Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

merge: 同步主干并保留官方 bot 默认路由跟随

Dash1fa665ed0eae
diff --cc apps/desktop/src/main/hook-control/__tests__/session-runner.test.ts
index 679a6eb0d8,54b2287ef2..d95c0877a6
--- a/apps/desktop/src/main/hook-control/__tests__/session-runner.test.ts
+++ b/apps/desktop/src/main/hook-control/__tests__/session-runner.test.ts
@@@ -471,149 -477,6 +492,178 @@@ beforeEach(() =>
h.listMessagesForAgentHandoff.mockResolvedValue([]);
});
+describe('hook task model selection on next send', () => {
+ it('runs default following under the send lock before reading metadata', async () => {
+ const readMeta = fakeMaker.getSessionMeta.getMockImplementation()!;
+ h.acquirePendingAgentSwitch.mockImplementationOnce(async (id, sync) => {
+ expect(id).toBe('sess-new');
+ await sync();
+ return () => {};
+ });
+ fakeMaker.getSessionMeta.mockImplementationOnce(async () => {
+ expect(h.syncDefaultRoute).toHaveBeenCalledWith('sess-new');
+ return readMeta();
+ });
+ await createMakerHookSessionRunner({ log }).run(baseReq({ isNew: false }));
+ });
+
+ it('uses current local workspace defaults instead of stale dispatch model hints', async () => {
+ h.useActualDefaults = true;
+ const providers = [connectedProvider('xd', [catalogModel('test-model')])];
+ h.getWorkspacePref.mockReturnValue({
+ channel: 'telegram', teamId: null, workspace: 'repo',
+ agentKind: 'claude-code', model: 'test-model', effort: 'high', permissionMode: null,
+ });
+ await createMakerHookSessionRunner({ log }).run(baseReq({
+ isNew: false, model: 'stale-model', workspaceAlias: 'repo',
+ source: { im: 'telegram', userText: 'hello' },
+ }));
+ const policy = h.followPolicy.mock.calls[0][0];
+ const target = await policy.resolveTarget(providers);
+ expect(target).toMatchObject({ agentKind: 'claude-code', model: 'test-model', providerId: 'xd' });
+ expect(target.fingerprint).toBe(policy.fingerprint());
+ expect(h.getWorkspacePref).toHaveBeenCalledWith('telegram', null, 'repo');
+ expect(h.readImDefaultSettings).toHaveBeenCalledWith(undefined);
+ });
+
+ it.each([false, true])('records new official tasks with their creation defaults (createOnly=%s)', async (createOnly) => {
+ const outcome = await createMakerHookSessionRunner({ log }).run(baseReq({
+ createOnly, source: { im: 'telegram', userText: 'hello' },
+ }));
+ expect(outcome.status).toBe('ok');
+ expect(h.writeDefaultRecord).toHaveBeenCalledWith('sess-new', expect.stringContaining('hook'));
+ expect(h.acquirePendingAgentSwitch).not.toHaveBeenCalled();
+ });
+
+ it.each(['telegram', 'slack', 'x'])('preserves %s dispatch defaults until workspace migration completes', async (channel) => {
+ h.useActualDefaults = true;
+ h.isWorkspacePrefsMigrated.mockReturnValue(false);
+ h.readImDefaultSettings.mockReturnValue({
+ agentKind: 'claude-code',
+ agents: { 'claude-code': { providerId: null, model: 'global-model', effort: 'high' } },
+ });
+ const providers = [connectedProvider('xd', [catalogModel('test-model'), catalogModel('global-model')])];
+ h.listProviders.mockResolvedValue(providers);
+ const req = baseReq({
+ agentKind: 'claude-code', model: 'test-model', effort: 'high',
+ workspaceAlias: 'repo', source: { im: channel, userText: 'hello' },
+ });
+ const runner = createMakerHookSessionRunner({ log });
+ expect((await runner.run({ ...req, createOnly: true })).status).toBe('ok');
+ const creationFingerprint = h.writeDefaultRecord.mock.calls[0][1];
+ await runner.run({ ...req, isNew: false });
+ const policy = h.followPolicy.mock.calls[0][0];
+ expect(policy.fingerprint()).toBe(creationFingerprint);
+ expect(await policy.resolveTarget(providers)).toMatchObject({
+ model: 'test-model', providerId: 'xd', fingerprint: creationFingerprint,
+ });
+
+ // 迁移后,缺省本机目录偏好表示继承全局,不再消费旧服务端值。
+ h.isWorkspacePrefsMigrated.mockReturnValue(true);
+ expect(await policy.resolveTarget(providers)).toMatchObject({ model: 'global-model' });
+ });
+
+ it('keeps the current route when the task workspace alias is unknown', async () => {
+ await createMakerHookSessionRunner({ log }).run(baseReq({
+ isNew: false, source: { im: 'telegram', userText: 'hello' },
+ }));
+ const policy = h.followPolicy.mock.calls[0][0];
+ expect(policy.ownsRow({})).toBe(false);
+ });
+
++ it.each(['workspace', 'global'])('tracks changes to the %s default execution device', async (scope) => {
++ h.useActualDefaults = true;
++ h.readRemoteRoute.mockResolvedValue({ model: catalogModel('test-model') });
++ const selectDevice = (agentDeviceId: string) => {
++ if (scope === 'workspace') {
++ h.getWorkspaceProviderSource.mockReturnValue('owner-provider');
++ h.agentDeviceId = agentDeviceId;
++ } else {
++ h.readImDefaultSettings.mockReturnValue({
++ agentKind: 'claude-code', agents: {
++ 'claude-code': { providerId: 'owner-provider', model: 'test-model', effort: 'high', agentDeviceId },
++ },
++ });
++ }
++ };
++ selectDevice('share:owner');
++ const runner = createMakerHookSessionRunner({ log });
++ const req = baseReq({ workspaceAlias: 'chat', source: { im: 'telegram' } });
++ expect((await runner.run({ ...req, createOnly: true })).status).toBe('ok');
++ const creationFingerprint = h.writeDefaultRecord.mock.calls[0][1];
++ await runner.run({ ...req, isNew: false });
++ const policy = h.followPolicy.mock.calls[0][0];
++ expect(policy.fingerprint()).toBe(creationFingerprint);
++ expect(await policy.resolveTarget([])).toMatchObject({ agentDeviceId: 'share:owner', fingerprint: creationFingerprint });
++ selectDevice('share:other');
++ expect(policy.fingerprint()).not.toBe(creationFingerprint);
++ expect(await policy.resolveTarget([])).toMatchObject({ agentDeviceId: 'share:other', fingerprint: policy.fingerprint() });
++ });
++
+ it.each(['claude-code', 'codex'] as const)('applies the selected %s route before reading metadata and sending', async (agentKind) => {
+ let applied = false;
+ const release = vi.fn();
+ h.acquirePendingAgentSwitch.mockImplementationOnce(async () => {
+ applied = true;
+ return release;
+ });
+ fakeMaker.getSessionMeta.mockImplementationOnce(async () => {
+ expect(applied).toBe(true);
+ return { workDir: 'D:/repo', model: 'selected-model', sdkSessionId: 'selected-sdk',
+ agentKind, permissionMode: undefined } as never;
+ });
+ const selected = makeFakeSession('sess-new');
+ const send = selected.send.getMockImplementation()!;
+ selected.send.mockImplementation(async (...args) => {
+ expect(release).not.toHaveBeenCalled();
+ return send(...args);
+ });
+ fakeMaker.createSession.mockImplementationOnce(async (opts) => {
+ expect(opts).toMatchObject({ agentKind, model: 'selected-model' });
+ return selected;
+ });
+
+ const result = await createMakerHookSessionRunner({ log }).run(baseReq({ isNew: false }));
+ expect(result.status).toBe('ok');
+ expect(selected.send).toHaveBeenCalledOnce();
+ expect(release).toHaveBeenCalledOnce();
+ });
+
+ it('releases the send lock before waiting for the model to finish', async () => {
+ const release = vi.fn();
+ h.acquirePendingAgentSwitch.mockResolvedValueOnce(release);
+ const session = makeFakeSession('sess-new');
+ session.send.mockResolvedValue({ accepted: true });
+ fakeMaker.createSession.mockResolvedValueOnce(session);
+ const run = createMakerHookSessionRunner({ log }).run(baseReq({ isNew: false }));
+ await vi.waitFor(() => expect(release).toHaveBeenCalledOnce());
+ h.eventCbs.get('sess-new')!({ type: 'done', data: null });
+ expect((await run).status).toBe('ok');
+ expect(release).toHaveBeenCalledOnce();
+ });
+
+ it.each(['create', 'directory', 'send'] as const)('releases the send lock on %s failure', async (stage) => {
+ const release = vi.fn();
+ h.acquirePendingAgentSwitch.mockResolvedValueOnce(release);
+ const session = makeFakeSession('sess-new');
+ if (stage === 'create') fakeMaker.createSession.mockRejectedValueOnce(new Error('create failed'));
+ else fakeMaker.createSession.mockResolvedValueOnce(session);
+ if (stage === 'send') session.send.mockRejectedValueOnce(new Error('send failed'));
+ const result = await createMakerHookSessionRunner({ log }).run(baseReq({
+ isNew: false, ...(stage === 'directory' ? { isDirAuthorized: () => false } : {}),
+ }));
+ expect(result.status).toBe('error');
+ expect(release).toHaveBeenCalledOnce();
+ });
+
+ it('does not send with the old model when applying the choice fails', async () => {
+ h.acquirePendingAgentSwitch.mockRejectedValueOnce(new Error('selection failed'));
+ await expect(createMakerHookSessionRunner({ log }).run(baseReq({ isNew: false })))
+ .rejects.toThrow('selection failed');
+ expect(fakeMaker.createSession).not.toHaveBeenCalled();
+ });
+});
+
describe('hook session 精确接管边界', () => {
it.each([false, true])('keeps post-terminal recovery bound to the exact Pi instance (replaced=%s)', async (replaced) => {
let terminal!: () => void;
diff --cc apps/desktop/src/main/hook-control/defaultRouteFollow.ts
index f1d601916a,0000000000..ee344c75aa
mode 100644,000000..100644
--- a/apps/desktop/src/main/hook-control/defaultRouteFollow.ts
+++ b/apps/desktop/src/main/hook-control/defaultRouteFollow.ts
@@@ -1,43 -1,0 +1,45 @@@
+import { and, eq, isNull } from 'drizzle-orm';
+
+import { dbToMakerAgentKind } from '../../shared/agentKindConversion.js';
+import { getDbClient } from '../localDb/client/current';
+import { sessions } from '../localDb/schema';
+import { buildImDefaultRouteRecord, parseImDefaultRouteRecord } from '../im/shared/channelDefaultRoute.js';
+import type { SessionRouteRow } from '../im/shared/channelDefaultRouteSync.js';
+
+/** 只跟随有创建记录的官方任务;历史任务和被接管的桌面任务不按值猜测。 */
+export function isHookDefaultRouteRow(row: SessionRouteRow): boolean {
+ const record = parseImDefaultRouteRecord(row.imDefaultRoute);
+ return row.status === 'active' && !row.remoteHostId && !row.orcaRole && !!row.model
+ && !row.imBotContextId && !row.feishuBotAppId
+ && record?.fp.startsWith('["hook",') === true;
+}
+
+/** 新任务记录实际落地路由;同值手动选择留下的记录也不能覆盖。 */
+export async function writeHookDefaultRouteRecord(sessionId: string, fingerprint: string): Promise<void> {
+ const db = getDbClient();
+ const [row] = await db.drizzle
+ .select({
+ agentKind: sessions.agentKind,
+ model: sessions.model,
+ providerId: sessions.providerId,
++ agentDeviceId: sessions.agentDeviceId,
+ effort: sessions.effort,
+ imDefaultRoute: sessions.imDefaultRoute,
+ })
+ .from(sessions)
+ .where(eq(sessions.id, sessionId))
+ .limit(1);
+ if (!row?.model || row.imDefaultRoute !== null) return;
+ await db.drizzle
+ .update(sessions)
+ .set({
+ imDefaultRoute: buildImDefaultRouteRecord(fingerprint, {
+ agentKind: dbToMakerAgentKind(row.agentKind),
+ model: row.model,
+ providerId: row.providerId?.trim() || null,
++ agentDeviceId: row.agentDeviceId ?? null,
+ effort: row.effort ?? null,
+ }),
+ })
+ .where(and(eq(sessions.id, sessionId), isNull(sessions.imDefaultRoute)));
+}
diff --cc apps/desktop/src/main/hook-control/session-runner.ts
index c407d3d7bf,c03fd86aaf..aa4fdde11e
--- a/apps/desktop/src/main/hook-control/session-runner.ts
+++ b/apps/desktop/src/main/hook-control/session-runner.ts
@@@ -171,58 -168,6 +173,60 @@@ function mainOwnedChannelOrigin(value:
/** 路由不可用时附在错误后的恢复指引(渠道回帖与 request ledger 都看得到)。 */
const ROUTE_RESELECT_HINT = '。请在 设置 → IM 机器人 中为这个渠道的工作目录重新选择模型。';
+type HookDispatchOverrides = {
+ agentKind: string | null;
+ model: string | null;
+ effort: string | null;
+ permissionMode: string | null;
+};
+type HookWorkspaceCtx = { alias: string | undefined; teamId: string | null };
+
+/**
+ * 新任务路由取值链的全部输入(同步读本机文件, 不碰供应商目录): 目录偏好合并后的
+ * 显式值、目录来源偏好、IM 默认设置。resolveNewSessionConfig 与「跟随默认」的指纹
+ * 共用这一份, 免得两边对「默认由什么决定」各说各话。
+ */
+function hookDefaultInputs(
+ overrides: HookDispatchOverrides,
+ sourceIm: string | null | undefined,
+ workspaceCtx: HookWorkspaceCtx | undefined,
+) {
+ const prefsChannel: HookPrefsChannel | null =
+ sourceIm === 'telegram' || sourceIm === 'x' || sourceIm === 'slack' ? sourceIm : null;
+ const workspaceAlias = workspaceCtx?.alias;
+ const localPref =
+ prefsChannel !== null && workspaceAlias
+ ? getWorkspacePref(prefsChannel, workspaceCtx.teamId, workspaceAlias)
+ : null;
+ const mergedOverrides = resolveWorkspacePrefOverrides(
+ localPref,
+ overrides,
+ prefsChannel !== null && workspaceAlias !== undefined && isWorkspacePrefsMigrated(prefsChannel),
+ );
+ // 目录级来源偏好(纯本地, 用户在工作目录映射行显式选的来源)优先于草稿默认来源。
- const workdirProviderId =
++ const workdirRoute =
+ prefsChannel !== null && workspaceAlias
- ? getWorkspaceProviderSource(prefsChannel, workspaceCtx.teamId, workspaceAlias)
++ ? getWorkspaceProviderRoute(prefsChannel, workspaceCtx.teamId, workspaceAlias)
+ : null;
++ const workdirProviderId = workdirRoute?.providerId ?? null;
+ // 官方 Telegram hook 与个人 Bot 是两个独立入口。个人 Bot 使用
+ // channel='telegram';官方群继续读取 global,避免任一设置卡静默
+ // 改写另一入口的新会话路由。
+ const imDefaults = readImDefaultSettings(sourceIm === 'slack' ? 'slack' : undefined);
- return { channel: prefsChannel, mergedOverrides, workdirProviderId, imDefaults };
++ return { channel: prefsChannel, mergedOverrides, workdirProviderId, workdirRoute, imDefaults };
+}
+
+/**
+ * 官方 hook 任务的「默认设置指纹」: 取值链输入任一变化(目录偏好、目录来源、IM 默认)
+ * 才需要重新解析。权限档不在内 —— 它不跟随(与个人渠道同口径)。
+ */
+function hookDefaultsFingerprint(inputs: ReturnType<typeof hookDefaultInputs>): string {
- const { channel, mergedOverrides, workdirProviderId, imDefaults } = inputs;
++ const { channel, mergedOverrides, workdirProviderId, workdirRoute, imDefaults } = inputs;
+ return JSON.stringify(['hook', channel, mergedOverrides.agentKind, mergedOverrides.model,
- mergedOverrides.effort, workdirProviderId, fingerprintImDefaultSettings(imDefaults)]);
++ mergedOverrides.effort, workdirProviderId, fingerprintImDefaultSettings(imDefaults),
++ ...(workdirRoute?.agentDeviceId ? [workdirRoute.agentDeviceId] : [])]);
+}
+
/**
* 新会话 agent/model/effort/permissionMode/providerId 合成: IM provider 按目录偏好
* (dispatch options)优先, 缺省落桌面端 IM 新会话默认值(草稿, 建 session 那
@@@ -248,7 -195,49 +252,35 @@@ async function resolveNewSessionConfig
);
}
- const { channel, mergedOverrides, workdirProviderId, imDefaults } = inputs;
- const prefsChannel: HookPrefsChannel | null =
- sourceIm === 'telegram' || sourceIm === 'x' || sourceIm === 'slack' ? sourceIm : null;
- const workspaceAlias = workspaceCtx?.alias;
- const localPref =
- prefsChannel !== null && workspaceAlias
- ? getWorkspacePref(prefsChannel, workspaceCtx.teamId, workspaceAlias)
- : null;
- const mergedOverrides = resolveWorkspacePrefOverrides(
- localPref,
- overrides,
- prefsChannel !== null && workspaceAlias !== undefined && isWorkspacePrefsMigrated(prefsChannel),
- );
-
- const workdirRoute = prefsChannel && workspaceAlias
- ? getWorkspaceProviderRoute(prefsChannel, workspaceCtx.teamId, workspaceAlias) : null;
- const defaults = readImDefaultSettings(sourceIm === 'slack' ? 'slack' : undefined);
++ const { channel, mergedOverrides, workdirProviderId, workdirRoute, imDefaults } = inputs;
++ const defaults = imDefaults;
+ const requestedAgent = mergedOverrides.agentKind === 'claude-code' || mergedOverrides.agentKind === 'codex' || mergedOverrides.agentKind === 'pi'
+ ? mergedOverrides.agentKind : defaults.agentKind;
+ const defaultRoute = defaults.agents[requestedAgent];
+ const agentDeviceId = workdirRoute ? workdirRoute.agentDeviceId : defaultRoute.agentDeviceId;
+ if (agentDeviceId) {
+ const providerId = workdirRoute?.providerId ?? defaultRoute.providerId;
+ const requestedModel = mergedOverrides.model ?? defaultRoute.model;
+ const { model } = await readImRemoteProviderRoute({ agentDeviceId, agentKind: requestedAgent, providerId, model: requestedModel });
+ const permissionModes = mergedOverrides.permissionMode !== null
+ ? await readImRemotePermissionModes(agentDeviceId, requestedAgent) : [];
+ // 远端能力只用于确认支持,不是权限强弱的权威。不能把对方的首项当作“最严档”,
+ // 也不能让未知档位进入本机执行器;显式选择必须原样保留,否则拒绝启动。
+ const requestedPermissionMode = mergedOverrides.permissionMode;
+ if (requestedPermissionMode !== null && (
+ !isImDefaultPermissionMode(requestedPermissionMode) ||
+ !permissionModes.includes(requestedPermissionMode)
+ )) {
+ throw new Error('Selected permission mode is unavailable for the remote agent' + ROUTE_RESELECT_HINT);
+ }
+ const remote = resolveHookSessionConfig({
+ readDefaults: () => defaults,
+ getModels: () => [model],
+ getPermissionModes: () => requestedPermissionMode === null ? [] : [requestedPermissionMode],
+ log,
+ }, { ...mergedOverrides, agentKind: requestedAgent, model: requestedModel });
- return { ...remote, agentDeviceId, providerId };
++ return { ...remote, agentDeviceId, providerId, fingerprint };
+ }
const resolved = resolveHookSessionConfig(
{
diff --cc apps/desktop/src/main/im/shared/__tests__/channelDefaultRouteSync.test.ts
index 5562b667c3,8c3bb5d7bc..76def5f744
--- a/apps/desktop/src/main/im/shared/__tests__/channelDefaultRouteSync.test.ts
+++ b/apps/desktop/src/main/im/shared/__tests__/channelDefaultRouteSync.test.ts
@@@ -780,71 -794,3 +795,83 @@@ describe('createSession', () =>
expect((await rowOf(created.id)).imDefaultRoute).toBe('kept');
});
});
+
+
+describe('official bot follows defaults without an extra control', () => {
+ const hookFp = JSON.stringify(['hook', 'telegram', 'old-default']);
+ const nextHookFp = JSON.stringify(['hook', 'telegram', 'new-default']);
+ beforeEach(() => {
+ mocks.fingerprint.mockReturnValue(nextHookFp);
+ mocks.resolveDefaults.mockResolvedValue({ ...NEW, fingerprint: nextHookFp });
+ });
+ const hookRecord = buildImDefaultRouteRecord(hookFp, OLD);
+ async function officialFollower() {
+ const { isHookDefaultRouteRow } = await import('../../../hook-control/defaultRouteFollow');
+ return createDefaultRouteFollower({
+ label: 'hook', ownsRow: isHookDefaultRouteRow,
+ fingerprint: mocks.fingerprint, resolveTarget: mocks.resolveDefaults,
+ isRouteUsable: async () => true,
+ });
+ }
+
+ it('records a new official task and follows on its next message, preserving Fast and permissions', async () => {
+ const { writeHookDefaultRouteRecord } = await import('../../../hook-control/defaultRouteFollow');
+ await insertTask('official', OLD, { source: 'telegram', marker: false, record: null, fastMode: true });
+ await writeHookDefaultRouteRecord('official', hookFp);
+ await (await officialFollower()).syncUnderLock('official');
- expect(mocks.applyRoute).toHaveBeenCalledWith('official', { ...NEW, fastMode: true }, 'claude-code');
++ expect(mocks.applyRoute).toHaveBeenCalledWith('official', { ...NEW, agentDeviceId: null, fastMode: true }, 'claude-code');
+ expect((await rowOf('official')).permissionMode).toBe('auto');
+ expect(parseImDefaultRouteRecord((await rowOf('official')).imDefaultRoute)?.fp).toBe(nextHookFp);
+ mocks.fingerprint.mockReturnValue(hookFp);
+ mocks.resolveDefaults.mockResolvedValue({ ...OLD, fingerprint: hookFp });
+ await (await officialFollower()).syncUnderLock('official');
+ expect((await rowOf('official')).model).toBe(OLD.model);
+ });
+
+ it('a same-value manual selection permanently stops following; a new task follows again', async () => {
+ const { writeHookDefaultRouteRecord } = await import('../../../hook-control/defaultRouteFollow');
+ await insertTask('official', OLD, { source: 'telegram', marker: false, record: hookRecord });
+ await markImSessionManualRouteOverride('official');
+ await writeHookDefaultRouteRecord('official', hookFp);
+ await (await officialFollower()).syncUnderLock('official');
+ expect(mocks.applyRoute).not.toHaveBeenCalled();
+ expect(parseImDefaultRouteRecord((await rowOf('official')).imDefaultRoute)?.manual).toBe(true);
+ await insertTask('new-task', OLD, { source: 'telegram', marker: false, record: null });
+ await writeHookDefaultRouteRecord('new-task', hookFp);
+ await (await officialFollower()).syncUnderLock('new-task');
+ expect(mocks.applyRoute).toHaveBeenCalledTimes(1);
+ expect((await rowOf('official')).model).toBe(OLD.model);
+ });
+
++ it('records the actual remote device and follows device changes without treating them as manual choices', async () => {
++ const { writeHookDefaultRouteRecord } = await import('../../../hook-control/defaultRouteFollow');
++ const remote = { ...OLD, agentDeviceId: 'share:owner' };
++ await insertTask('official', remote, { source: 'telegram', marker: false, record: null });
++ await writeHookDefaultRouteRecord('official', hookFp);
++ expect(parseImDefaultRouteRecord((await rowOf('official')).imDefaultRoute)?.route).toMatchObject(remote);
++ mocks.resolveDefaults.mockResolvedValue({ ...remote, agentDeviceId: 'share:other', fingerprint: nextHookFp });
++ await (await officialFollower()).syncUnderLock('official');
++ expect(mocks.applyRoute).toHaveBeenCalledWith('official', { ...remote, agentDeviceId: 'share:other', fastMode: false }, 'claude-code');
++ expect((await rowOf('official')).agentDeviceId).toBe('share:other');
++ });
++
+ it('does not claim historical official tasks, personal bot tasks, or remote tasks', async () => {
+ await insertTask('historical', OLD, { source: 'telegram', marker: false, record: null });
+ await insertTask('personal', OLD, { source: 'telegram' });
+ await insertTask('remote', OLD, { source: 'telegram', marker: false, remoteHostId: 'other' });
+ await insertTask('rotated-personal', OLD, { source: 'telegram', marker: false });
+ const follower = await officialFollower();
+ for (const id of ['historical', 'personal', 'remote', 'rotated-personal']) await follower.syncUnderLock(id);
+ expect(mocks.applyRoute).not.toHaveBeenCalled();
+ expect(mocks.resolveDefaults).not.toHaveBeenCalled();
+ });
+
+ it('defers a busy follow switch so generic pending application cannot interrupt it', async () => {
+ await insertTask('official', OLD, { source: 'telegram', marker: false, record: hookRecord });
+ mocks.applyRoute.mockResolvedValue('staged');
+ mocks.readPendingRoute.mockReturnValue({ ...NEW, rev: 7 });
+ mocks.readPendingRoute.mockReturnValueOnce(undefined);
+ expect(await (await officialFollower()).syncUnderLock('official')).toBe(true);
+ expect(parseImDefaultRouteRecord((await rowOf('official')).imDefaultRoute)?.pendingRev).toBe(7);
+ });
+});
diff --cc apps/desktop/src/main/im/shared/channelDefaultRouteSync.ts
index e5e5317d05,e78c3e83dd..056961d3c2
--- a/apps/desktop/src/main/im/shared/channelDefaultRouteSync.ts
+++ b/apps/desktop/src/main/im/shared/channelDefaultRouteSync.ts
@@@ -67,7 -67,8 +67,8 @@@ export interface ImChannelDefaultRouteS
syncBeforeWiring(sessionId: string): Promise<void>;
}
-interface SessionRouteRow {
+export interface SessionRouteRow {
+ agentDeviceId?: string | null;
source: string | null;
status: string;
remoteHostId: string | null;