Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
fix(provider-group): 换电脑期间不报错,组里都不能用才报错;自动续跑后收掉过期红点
Lizi882ffebcd4a3
diff --git a/apps/desktop/src/main/__tests__/messagePersistBroadcaster.test.ts b/apps/desktop/src/main/__tests__/messagePersistBroadcaster.test.tsindex d1a5b2c5d0..71338ddf1d 100644--- a/apps/desktop/src/main/__tests__/messagePersistBroadcaster.test.ts+++ b/apps/desktop/src/main/__tests__/messagePersistBroadcaster.test.ts@@ -97,6 +97,8 @@ import {flushOrphanToolResults,isSuccessfulCodexDoneEventData,onTurnErrorEvent,+ captureDeferredTurnError,+ persistDeferredTurnError,reserveTurnErrorPersistId,releaseReservedTurnErrorPersistId,whenTurnErrorPersisted,@@ -3444,6 +3446,72 @@ describe('onTurnErrorEvent — terminal error 持久化', () => {expect(createMessage).toHaveBeenCalledTimes(1);});+ describe('延后补落(供应商组换电脑期间先暂存的 error 行)', () => {+ it('按出错的时刻排序,不排到之后的消息后面', async () => {+ // 结算时才写:用户在这期间发的新消息必须仍排在它后面。+ const occurredAt = Date.parse('2026-10-11T08:00:00.000Z');+ const nowSpy = vi.spyOn(Date, 'now');+ nowSpy.mockReturnValue(occurredAt);+ const row = captureDeferredTurnError(SESSION, { message: '换电脑没成', reason: 'usage_limit' }, { uuid: 'failed-turn' });+ nowSpy.mockReturnValue(occurredAt + 60_000);+ try {+ persistDeferredTurnError(SESSION, row!);+ await flushWrites();+ } finally {+ nowSpy.mockRestore();+ }+ expect(createMessage).toHaveBeenCalledWith(+ SESSION,+ expect.objectContaining({+ role: 'error',+ content: { message: '换电脑没成', reason: 'usage_limit' },+ agentMeta: { uuid: 'failed-turn' },+ createdAt: occurredAt + 1,+ }),+ expect.objectContaining({ shouldBroadcast: expect.any(Function) }),+ );+ });++ it('不碰补落时正在进行的那一轮:不 flush 在飞正文,那一轮同样的错误照常落库', async () => {+ // 失败那一轮:暂存。+ noteTurnStarted(SESSION);+ const row = captureDeferredTurnError(SESSION, { message: 'Remote computer is offline' }, null);+ resetTurnPersistState(SESSION);+ // 用户中途接手:新的一轮正在输出。+ noteTurnStarted(SESSION);+ onAssistantTextEvent(SESSION, { text: 'half a reply', isFinal: false }, null);+ // 换电脑那一趟结束,补落旧的那条 error 行。+ persistDeferredTurnError(SESSION, row!);+ await flushWrites();+ // 只写了那条 error 行:新一轮输出到一半的正文没有被提前落库(否则重载后会拆成两行)。+ expect(vi.mocked(createMessage).mock.calls.map(([, body]) => (body as { role: string }).role)).toEqual(['error']);+ // 新的一轮随后同样连不上:它自己的 error 行不被当成重复,在飞正文这时才随它落库。+ expect(onTurnErrorEvent(SESSION, { message: 'Remote computer is offline' })).toBeTruthy();+ await flushWrites();+ const roles = vi.mocked(createMessage).mock.calls.map(([, body]) => (body as { role: string }).role);+ expect(roles).toEqual(['error', 'assistant', 'error']);+ });++ it('旧会话关闭清掉按会话的状态之后照样能补落', async () => {+ noteTurnStarted(SESSION);+ const row = captureDeferredTurnError(SESSION, { message: 'agent stopped' }, null);+ // 交接会关闭旧会话。+ clearSessionPersistState(SESSION);+ persistDeferredTurnError(SESSION, row!);+ await flushWrites();+ expect(createMessage).toHaveBeenCalledWith(+ SESSION,+ expect.objectContaining({ role: 'error', content: { message: 'agent stopped' } }),+ expect.anything(),+ );+ });++ it('没有错误文案时不取行', () => {+ expect(captureDeferredTurnError(SESSION, { reason: 'turn-failed' })).toBeNull();+ expect(captureDeferredTurnError(SESSION, null)).toBeNull();+ });+ });+it('/clear 在 error 事件之前发生时,createdAt 被 cap 在 clear 边界之下(不出现在清空后的会话中)', async () => {// 场景:turn 在 /clear 之前启动,/clear 后 terminal error 才到达。// noteTurnStarted 记录 turn 开始时刻(< clearBoundaryTs),使 onTurnErrorEventdiff --git a/apps/desktop/src/main/maker-ipc/__tests__/agent-input-coordinator.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/agent-input-coordinator.test.tsindex 4c351f82f1..581780268b 100644--- a/apps/desktop/src/main/maker-ipc/__tests__/agent-input-coordinator.test.ts+++ b/apps/desktop/src/main/maker-ipc/__tests__/agent-input-coordinator.test.ts@@ -1001,6 +1001,7 @@ function unsupportedChatBridgeImageError(feature = "input content part 'input_imfunction createHarness(opts?: {getRecoveryContextSnapshot?: (sessionId: string, userClientId: string) => Promise<RecoveryContextSnapshot>;+ providerGroupSwitchCandidate?: AgentInputCoordinatorDeps['providerGroupSwitchCandidate'];}) {let running = false;let liveRunningOverride: boolean | null | 'unknown' = null;@@ -1199,6 +1200,9 @@ function createHarness(opts?: {isResumableTurnErrorCandidate,onResumableTurnErrorDiscarded,onUsageLimitedTurnError,+ ...(opts?.providerGroupSwitchCandidate+ ? { providerGroupSwitchCandidate: opts.providerGroupSwitchCandidate }+ : {}),noteSessionClearBoundary,resolveSessionReferences,refreshAgentReferencesBeforeDispatch,@@ -13963,3 +13967,107 @@ describe('usage-limit wait (ordinary tasks)', () => {expect(h.coordinator.cancelUsageLimitWait(sid, candidate).usageLimitWait).toBeNull();});});++describe('provider group computer switch hold', () => {+ const LIMIT_SIGNALS = { sdkError: 'rate_limit', usageResetAt: 5_000_000 };+ const MESSAGE = "You've hit your session limit";+ const INFO = {+ reason: USAGE_LIMIT_RESET_AUTO_RESUME_REASON,+ attempt: 1,+ maxAttempts: 1,+ sessionTotal: 0,+ };++ async function failWhileSwitching(sid: string, cause: 'usage-limit' | null = 'usage-limit') {+ const candidate = vi.fn<NonNullable<AgentInputCoordinatorDeps['providerGroupSwitchCandidate']>>(+ () => cause,+ );+ const h = createHarness({ providerGroupSwitchCandidate: candidate });+ h.setHasAssistantProgressAfter(async () => true);+ h.coordinator.enqueue(sid, makeItem('q-first', 'original long task'));+ await flush();+ h.setRunning(false);+ h.coordinator.onTurnEvent(sid, 'error', MESSAGE, LIMIT_SIGNALS);+ await flush();+ const token = h.onUsageLimitedTurnError.mock.calls.at(-1)?.[3] as number;+ return { h, candidate, token };+ }++ it('shows "switching computer" instead of the error while the group tries the next computer', async () => {+ const sid = 'group-hold';+ const { h, candidate } = await failWhileSwitching(sid);+ expect(candidate).toHaveBeenCalledWith(+ sid,+ expect.objectContaining({ message: MESSAGE, ...LIMIT_SIGNALS }),+ expect.objectContaining({ clientId: 'q-first' }),+ );+ // 登记先于第一次投影:一帧红横幅都不出。+ expect(h.projections.every((projection) => projection.error === null)).toBe(true);+ const projection = latestProjection(h.projections);+ expect(projection.autoResumePending).toMatchObject({+ error: MESSAGE,+ groupSwitchPending: { cause: 'usage-limit' },+ });+ expect(projection.usageLimitWait).toBeNull();+ // 重试入口与限额候选仍绑定这次错误,换电脑的交接照常拿得到句柄。+ expect(projection.recovery?.kind).toBe('active-turn');+ expect(h.onUsageLimitedTurnError).toHaveBeenCalledTimes(1);+ expect(h.coordinator.getProviderGroupSwitchHoldId(sid)).toEqual(expect.any(Number));+ });++ it('surfaces the error once the switch gives up', async () => {+ const sid = 'group-hold-release';+ const { h, token } = await failWhileSwitching(sid);+ const holdId = h.coordinator.getProviderGroupSwitchHoldId(sid)!;+ expect(h.coordinator.releaseProviderGroupSwitchHold(sid, holdId + 1)).toBe(false);+ expect(latestProjection(h.projections).error).toBeNull();+ expect(h.coordinator.releaseProviderGroupSwitchHold(sid, holdId)).toBe(true);+ const projection = latestProjection(h.projections);+ expect(projection.error).toBe(MESSAGE);+ expect(projection.autoResumePending).toBeUndefined();+ expect(h.coordinator.getProviderGroupSwitchHoldId(sid)).toBeNull();+ // 交回额度重置后自动继续:仍能挂上等待。+ expect(h.coordinator.armUsageLimitWait(sid, token, 9_000_000)).toBe(true);+ expect(latestProjection(h.projections).usageLimitWait).toEqual({ resumeAt: 9_000_000 });+ });++ it('never shows the error when the task continues on another computer', async () => {+ const sid = 'group-hold-resumed';+ const { h, token } = await failWhileSwitching(sid);+ const holdId = h.coordinator.getProviderGroupSwitchHoldId(sid)!;+ const lease = h.coordinator.leaseUsageLimitRecovery(sid, token);+ expect(lease).not.toBeNull();+ // 交接关闭旧会话,再凭句柄挂上续跑。+ h.coordinator.onSessionClosed(sid);+ const continueToken = h.coordinator.rearmUsageLimitWait(sid, lease!, 1);+ expect(continueToken).toEqual(expect.any(Number));+ expect(latestProjection(h.projections).error).toBeNull();+ expect(await h.coordinator.continueAfterUsageLimitReset(sid, continueToken!, INFO)).toBe('resumed');+ await flush();+ expect(h.sendToAgent).toHaveBeenCalledTimes(2);+ expect(h.coordinator.getProviderGroupSwitchHoldId(sid)).toBeNull();+ // 迟到的结算碰不到已续上的这一轮。+ expect(h.coordinator.releaseProviderGroupSwitchHold(sid, holdId)).toBe(false);+ expect(h.projections.every((projection) => projection.error === null)).toBe(true);+ });++ it('keeps the normal error when the group will not switch', async () => {+ const sid = 'group-hold-none';+ const { h } = await failWhileSwitching(sid, null);+ expect(latestProjection(h.projections).error).toBe(MESSAGE);+ expect(latestProjection(h.projections).autoResumePending).toBeUndefined();+ expect(h.coordinator.getProviderGroupSwitchHoldId(sid)).toBeNull();+ });++ it('ends the hold when the user takes over', async () => {+ const sid = 'group-hold-user';+ const { h } = await failWhileSwitching(sid);+ const holdId = h.coordinator.getProviderGroupSwitchHoldId(sid)!;+ h.coordinator.enqueue(sid, makeItem('q-second', 'do something else'));+ await flush();+ expect(h.coordinator.getProviderGroupSwitchHoldId(sid)).toBeNull();+ expect(latestProjection(h.projections).autoResumePending?.groupSwitchPending).toBeUndefined();+ // 错误已不是当前状态:结算只清登记,不再弹横幅。+ expect(h.coordinator.releaseProviderGroupSwitchHold(sid, holdId)).toBe(false);+ });+});diff --git a/apps/desktop/src/main/maker-ipc/__tests__/sessionEventPipeline.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/sessionEventPipeline.test.tsindex d74347089c..4b0a5be2bf 100644--- a/apps/desktop/src/main/maker-ipc/__tests__/sessionEventPipeline.test.ts+++ b/apps/desktop/src/main/maker-ipc/__tests__/sessionEventPipeline.test.ts@@ -311,6 +311,7 @@ function harness() {onExternalTurnSettled: vi.fn(),isAutoResumePending: vi.fn(() => false),isAutoResumeDeferred: vi.fn(() => false),+ getProviderGroupSwitchHoldId: vi.fn((): number | null => null),getAutoResumeAttemptToken: vi.fn(() => 5),getAutoResumeDeferredOwner: vi.fn(() => null),},@@ -757,6 +758,36 @@ describe('production Session event pipeline', () => {},);+ it('holds the error row while a provider group switches computers instead of writing it', async () => {+ const h = harness();+ const stashProviderGroupHeldError = vi.fn(() => true);+ (h.deps as { stashProviderGroupHeldError?: unknown }).stashProviderGroupHeldError = stashProviderGroupHeldError;+ h.deps.agentInputCoordinatorHolder.getProviderGroupSwitchHoldId.mockReturnValue(3);+ const agentMeta = { uuid: 'failed-turn-uuid' };+ h.emit(event('error', { message: "You've hit your session limit", sdkError: 'rate_limit' }, { agentMeta } as Partial<AgentEvent>));+ expect(effects.fn('reserveTurnErrorPersistId')).not.toHaveBeenCalled();+ expect(effects.fn('onTurnErrorEvent')).not.toHaveBeenCalled();+ // 带上失败那一轮的身份:补落时不再读当时正在进行的那一轮。+ expect(stashProviderGroupHeldError).toHaveBeenCalledWith(+ 'task',+ 3,+ expect.objectContaining({ message: "You've hit your session limit" }),+ agentMeta,+ );+ // 补落发生在 turn 状态重置之后:先存一份 turn 开始时刻。+ expect(effects.fn('saveTurnStartedAtForDeferred')).toHaveBeenCalledTimes(1);+ await h.dispose();+ });++ it('writes a different error that arrives while a switch is held as usual', async () => {+ const h = harness();+ (h.deps as { stashProviderGroupHeldError?: unknown }).stashProviderGroupHeldError = vi.fn(() => false);+ h.deps.agentInputCoordinatorHolder.getProviderGroupSwitchHoldId.mockReturnValue(3);+ h.emit(event('error', { message: 'Something else broke', sdkError: 'api_error' }));+ expect(effects.fn('onTurnErrorEvent')).toHaveBeenCalledTimes(1);+ await h.dispose();+ });+it('keeps deferred error and its paired done out of Orca terminal handling and preserves the failure seal', async () => {const h = harness();h.deps.agentInputCoordinatorHolder.isAutoResumeDeferred.mockReturnValue(true);diff --git a/apps/desktop/src/main/maker-ipc/agent-input-coordinator.ts b/apps/desktop/src/main/maker-ipc/agent-input-coordinator.tsindex d9a6ea8458..182fb65d7d 100644--- a/apps/desktop/src/main/maker-ipc/agent-input-coordinator.ts+++ b/apps/desktop/src/main/maker-ipc/agent-input-coordinator.ts@@ -60,6 +60,7 @@ import type {AgentInputRecovery,AgentInputSessionReferenceContext,AgentInputToolLoopDetails,+ AutoResumeAgentSwitchCause,AutoResumeInfo,RecoveryCheckpoint,} from '../../shared/agentInputQueue.js';@@ -428,6 +429,17 @@ export interface AgentInputCoordinatorDeps {/** 绑定本次错误 recovery 的令牌;`armUsageLimitWait` 只认这个令牌。 */candidateToken: number,) => void;+ /**+ * **纯判定**:这条将交给 `onUsageLimitedTurnError` 的错误会不会先由供应商组试着换电脑+ * (docs/product-rules/provider-groups.md §6.1)。返回换电脑的原因时,这次错误照常成为当前状态+ * (重试入口、限额等待候选都绑定它),只是先不呈现:投影里不带 error,改带「正在换一台电脑继续」,+ * 直到 host 调 `releaseProviderGroupSwitchHold`,或续跑 / 用户接手换掉了这次错误。+ */+ providerGroupSwitchCandidate?: (+ sessionId: string,+ signals: InterruptedTurnErrorSignals,+ item: AgentInputQueuedMessage,+ ) => AutoResumeAgentSwitchCause | null;/*** **纯判定**:这条 terminal error 有没有可能被自愈接管(`isInterruptedTurnError`)。* 不消耗额度、不排期、无副作用。@@ -745,6 +757,17 @@ interface SessionInputState {token: number;recovery: NonNullable<AgentInputRecovery>;} | null;+ /**+ * 供应商组正在为这次错误换电脑(docs/product-rules/provider-groups.md §6.1):错误仍是当前状态,+ * 重试入口与限额等待候选照旧绑定它,只是投影里先不呈现(换成了就不出现,组里都不行才出来)。+ * 绑定登记时的 recovery:续跑、用户接手、清空换掉 recovery 即自然失效,不需要在每个入口单独撤。+ */+ providerGroupSwitchHold: {+ /** 每次登记唯一:host 暂存的 error 行与结算都按它对号,迟到的旧结算不会碰到下一次失败。 */+ id: number;+ recovery: NonNullable<AgentInputRecovery>;+ info: AutoResumeInfo;+ } | null;recovery: AgentInputRecovery;drainScheduled: boolean;drainWakeupGeneration: number;@@ -848,6 +871,7 @@ function createInitialInputState(autoResumePending: null,autoResumeAttemptToken: null,usageLimitWait: null,+ providerGroupSwitchHold: null,recovery: null,drainScheduled: false,drainWakeupGeneration: 0,@@ -889,6 +913,17 @@ function isUsageLimitWaitLive(state: SessionInputState, token?: number): booleanreturn state.usageLimitWait?.resumeAt != null && isUsageLimitCandidateCurrent(state, token);}+/** 换电脑期间先不呈现的那次错误仍是当前状态:登记时的 recovery 没被换掉、错误仍在、没有别的自愈接管。 */+function isProviderGroupSwitchHoldLive(state: SessionInputState): boolean {+ const hold = state.providerGroupSwitchHold;+ return (+ hold !== null &&+ hold.recovery === state.recovery &&+ state.error !== null &&+ state.autoResumePending === null+ );+}+function readSessionInstanceId(identity: object | null | undefined): string | null {if (!identity || typeof identity !== 'object') return null;const id = (identity as { instanceId?: unknown }).instanceId;@@ -1142,6 +1177,7 @@ export class AgentInputCoordinator {private readonly states = new Map<string, SessionInputState>();/** 账号限额等待计划的单调令牌(跨会话唯一,迟到的 host 定时器据此失效)。 */private usageLimitWaitSeq = 0;+ private providerGroupSwitchHoldSeq = 0;private readonly steerAbortControllers = new Map<string, Map<string, AbortController>>();/*** Stop clears visible steer markers before the provider promise necessarily settles. Retain@@ -3870,6 +3906,10 @@ export class AgentInputCoordinator {return;}}+ // 供应商组会先试着换电脑时,在 emit 之前登记先不呈现:不让用户先看到一帧红横幅。+ if (!takeover && outcome === 'kept' && active.item) {+ this.holdForProviderGroupSwitch(sessionId, state, active.item, message, signals);+ }this.emit(sessionId);if (!takeover && outcome === 'kept' && active.item) {this.notifyUsageLimitedTurnError(sessionId, active.item, message, signals);@@ -4257,14 +4297,19 @@ export class AgentInputCoordinator {private toProjection(sessionId: string, state: SessionInputState): AgentInputProjection {const pendingQueue = state.pendingQueue.map((item) => this.toProjectedItem(item));+ // 供应商组正在换电脑:错误先不呈现(没有红横幅、没有限额倒计时),聊天流里只有「正在换一台电脑继续」。+ const groupSwitchHeld = isProviderGroupSwitchHoldLive(state);+ const error = groupSwitchHeld ? null : state.error;// Draining removes the queue row before asynchronous preparation starts.// Keep the existing recovery projection until dispatch settles; derive it// from the active owner so cancellation/failure cannot leave a stale flag.const autoResumePending = state.autoResumePending ?? (- state.activeTurn?.item?.autoResume &&- state.activeTurn.dispatchLifecycle !== 'dispatched'- ? state.activeTurn.item.autoResumeInfo- : undefined+ groupSwitchHeld+ ? state.providerGroupSwitchHold!.info+ : state.activeTurn?.item?.autoResume &&+ state.activeTurn.dispatchLifecycle !== 'dispatched'+ ? state.activeTurn.item.autoResumeInfo+ : undefined);const recovery: AgentInputRecovery =state.recovery?.kind === 'active-turn'@@ -4289,12 +4334,12 @@ export class AgentInputCoordinator {queueInteractionLocks: [...state.queueInteractionLocks],queueEditLocks: [...state.queueEditLocks],queueAbortPending: state.queueAbortPending,- error: state.error,- ...(state.error && state.errorReason ? { errorReason: state.errorReason } : {}),- ...(state.error && state.toolLoop ? { toolLoop: state.toolLoop } : {}),+ error,+ ...(error && state.errorReason ? { errorReason: state.errorReason } : {}),+ ...(error && state.toolLoop ? { toolLoop: state.toolLoop } : {}),recovery,...(autoResumePending ? { autoResumePending } : {}),- usageLimitWait: isUsageLimitWaitLive(state)+ usageLimitWait: !groupSwitchHeld && isUsageLimitWaitLive(state)? { resumeAt: state.usageLimitWait!.resumeAt! }: null,errorRetryText: projectionRetryText(state.pendingQueue, state.recovery),@@ -6466,33 +6511,101 @@ export class AgentInputCoordinator {}}+ /** 这次终态错误会不会真的交给 `onUsageLimitedTurnError`(与 notifyUsageLimitedTurnError 同一判据)。 */+ private willNotifyUsageLimitedTurnError(+ state: SessionInputState,+ item: AgentInputQueuedMessage,+ ): boolean {+ // scheduler origin(含复用它的 Slack / X / Telegram Hook 消息)终态失败时本就不留+ // recovery、由各自 runner 收尾,没有可续的入口。共享任务访客的回合也不自动续:+ // 授权可能在等待期间被撤销,数小时后替访客重发原指令不安全,交给房主手动处理。+ return Boolean(+ this.deps.onUsageLimitedTurnError &&+ !isSchedulerOriginItem(item) &&+ !item.sharedTaskAuthor &&+ state.recovery?.kind === 'active-turn' &&+ state.error !== null,+ );+ }+private notifyUsageLimitedTurnError(sessionId: string,item: AgentInputQueuedMessage,message?: string,signals?: Omit<InterruptedTurnErrorSignals, 'message'>,): void {- // scheduler origin(含复用它的 Slack / X / Telegram Hook 消息)终态失败时本就不留- // recovery、由各自 runner 收尾,没有可续的入口。共享任务访客的回合也不自动续:- // 授权可能在等待期间被撤销,数小时后替访客重发原指令不安全,交给房主手动处理。- if (- !this.deps.onUsageLimitedTurnError ||- isSchedulerOriginItem(item) ||- item.sharedTaskAuthor- ) {- return;- }const state = this.states.get(sessionId);- if (!state || state.recovery?.kind !== 'active-turn' || state.error === null) return;+ if (!state || !this.willNotifyUsageLimitedTurnError(state, item)) return;const token = ++this.usageLimitWaitSeq;- state.usageLimitWait = { resumeAt: null, token, recovery: state.recovery };+ state.usageLimitWait = { resumeAt: null, token, recovery: state.recovery! };try {- this.deps.onUsageLimitedTurnError(sessionId, { ...(signals ?? {}), message }, item, token);+ this.deps.onUsageLimitedTurnError!(sessionId, { ...(signals ?? {}), message }, item, token);} catch (err) {log.warn('onUsageLimitedTurnError failed', { sessionId, error: errorMessage(err) });+ // 没人接手这次错误了:先不呈现的要立刻放出来。+ this.releaseProviderGroupSwitchHold(sessionId);}}+ /**+ * 终态错误交给 `onUsageLimitedTurnError` 之前(emit 之前):供应商组会先试着换电脑时登记先不呈现。+ * 只在确实会回调时登记,否则没有人放出来。+ */+ private holdForProviderGroupSwitch(+ sessionId: string,+ state: SessionInputState,+ item: AgentInputQueuedMessage,+ message?: string,+ signals?: Omit<InterruptedTurnErrorSignals, 'message'>,+ ): void {+ state.providerGroupSwitchHold = null;+ const candidate = this.deps.providerGroupSwitchCandidate;+ if (!candidate || !this.willNotifyUsageLimitedTurnError(state, item)) return;+ let cause: AutoResumeAgentSwitchCause | null = null;+ try {+ cause = candidate(sessionId, { ...(signals ?? {}), message }, item);+ } catch (err) {+ log.warn('providerGroupSwitchCandidate failed', { sessionId, error: errorMessage(err) });+ }+ if (!cause) return;+ state.providerGroupSwitchHold = {+ id: ++this.providerGroupSwitchHoldSeq,+ recovery: state.recovery!,+ info: {+ // 只用来让 renderer 认出随后到达的终态 event 是同一次失败的回声(不再点亮横幅),行内不显示它。+ ...(message ? { error: message } : {}),+ // 不是重连:次数都给 0,旧端按普通的「重新连接中」显示、不带次数。+ attempt: 0,+ maxAttempts: 0,+ sessionTotal: 0,+ groupSwitchPending: { cause },+ },+ };+ }++ /**+ * 这次错误正因供应商组换电脑而先不呈现时返回那次登记的 id(host 据此暂不落 error 行、不弹 Agent Island,+ * 并按 id 结算);没有返回 null。+ */+ getProviderGroupSwitchHoldId(sessionId: string): number | null {+ const state = this.states.get(sessionId);+ return state && isProviderGroupSwitchHoldLive(state) ? state.providerGroupSwitchHold!.id : null;+ }++ /**+ * 换电脑这一趟结束(没换成、交回原有处理,或已不再需要):撤掉那次先不呈现的登记(不传 id 时撤当前的)。+ * 错误仍是当前状态时投影随即带出红横幅,返回 true;已被续跑或用户接手换掉时只清登记,返回 false。+ */+ releaseProviderGroupSwitchHold(sessionId: string, id?: number): boolean {+ const state = this.states.get(sessionId);+ const hold = state?.providerGroupSwitchHold;+ if (!state || !hold || (id !== undefined && hold.id !== id)) return false;+ const live = isProviderGroupSwitchHoldLive(state);+ state.providerGroupSwitchHold = null;+ if (live) this.emit(sessionId);+ return live;+ }+/*** 普通任务撞上账号限额后挂等待计划:错误与手动重试照常保留,到 `resumeAt` 仍无人处理时* host 调 `continueAfterUsageLimitReset`。只认终态错误时下发的候选令牌、且那次错误的@@ -6940,16 +7053,27 @@ export class AgentInputCoordinator {return;}}- this.emit(sessionId);- if (+ const notifyUsageLimited =!deferredTakeover &&outcome === 'kept' &&active.item &&- terminalEvent.supersededByUser !== true- ) {+ terminalEvent.supersededByUser !== true;+ // 与 onTurnEvent 的 persisted 分支对称。这条时序下横幅在持久化期间已经出现过、error 行也已落库,+ // 这里至少让换电脑期间不再挂着横幅。+ if (notifyUsageLimited) {+ this.holdForProviderGroupSwitch(+ sessionId,+ state,+ active.item!,+ terminalEvent.message,+ terminalEvent.signals,+ );+ }+ this.emit(sessionId);+ if (notifyUsageLimited) {this.notifyUsageLimitedTurnError(sessionId,- active.item,+ active.item!,terminalEvent.message,terminalEvent.signals,);diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.tsindex d12b5a86e2..5ffecd957e 100644--- a/apps/desktop/src/main/maker-ipc/register.ts+++ b/apps/desktop/src/main/maker-ipc/register.ts@@ -52,7 +52,10 @@ import {type ProviderGroupService,type ProviderGroupSessionRow,type ProviderGroupStartContext,+ type ProviderGroupTurnErrorHooks,} from '../provider-group/service.js';+import { createProviderGroupHeldTurnErrors } from '../provider-group/heldTurnErrors.js';+import { classifyProviderGroupSwitchCause } from '../provider-group/switchCause.js';import { listProviderGroups, readProviderGroup } from '../provider-group/store.js';import {isRemoteProviderInvocationAllowed,@@ -640,6 +643,7 @@ import {} from '../maker-host/session-storage.js';import { libraryExtraDirSyncTargets } from './libraryExtraDirSyncTargets.js';import {+ captureDeferredTurnError,clearSessionPersistState,clearSessionThinkingSnapshots,consumeLastAssistantPersistId,@@ -660,10 +664,12 @@ import {sealAssistantBlockForLateFinal,markAutoResumeOutcome,onTurnErrorEvent,+ persistDeferredTurnError,prepareSyntheticToolEventForBroadcast,redactToolInputForUntrustedBoundary,resetTurnPersistState,saveTurnStartedAtForDeferred,+ type DeferredTurnErrorRow,} from '../messagePersistBroadcaster.js';import { ensureCcManagerInstalledOrInstall } from '../remote-ssh/cc-manager-install.js';import {@@ -1620,6 +1626,33 @@ const autoResumeBookkeeping = new AutoResumeBookkeeping({log: (message, fields) => log.debug(message, fields),});+/**+ * 供应商组自动换电脑期间先不呈现的那次失败(provider-group/heldTurnErrors.ts):error 行暂存在这里,换成了丢掉,+ * 没换成补落并放出横幅与 Agent Island 提醒。+ */+const providerGroupHeldErrors = createProviderGroupHeldTurnErrors<DeferredTurnErrorRow>({+ // 暂存那一刻(仍在失败那一轮里)取好补落要用的一切;补落只写这一行,不碰那时正在进行的一轮,+ // 按出错的时刻排序:换电脑途中用户发了新消息,补落的错误卡仍排在那条消息之前。+ capture: (sessionId, data, agentMeta) =>+ captureDeferredTurnError(+ sessionId,+ data as { message?: unknown; reason?: unknown; sdkError?: unknown; toolLoop?: unknown } | null,+ (agentMeta ?? null) as AgentMeta | null,+ ),+ persist: (sessionId, row) => {+ persistDeferredTurnError(sessionId, row);+ },+ surface: (sessionId, detail) => surfaceSuppressedAutoResumeErrorInAgentIsland(sessionId, detail),+ // holder 是可变绑定,必须懒读。+ releaseHold: (sessionId, holdId) =>+ agentInputCoordinatorHolder?.releaseProviderGroupSwitchHold(sessionId, holdId) ?? false,+ ownerKey: () => activeOwnerScopeKey(),+ log: (message, meta) => log.info(message, meta),+});++/** 换电脑这一趟久久没有结局(交接卡住等)时不再瞒着:先把错误放出来,换成了照常续跑。 */+const PROVIDER_GROUP_SWITCH_HOLD_MAX_MS = 3 * 60_000;+/*** Continuation-only auto-retry is scheduled against the current runtime* Session, but stall abort recovery, terminal-error drain, or a Codex@@ -4308,9 +4341,11 @@ function handleAgentIslandEventAfterBroadcast(return;}const terminalError = event.type === 'error' && isTerminalTurnErrorEvent(event);+ // 供应商组正在为这次失败换电脑:与中断自愈同样先不提醒,没换成时由 providerGroupHeldErrors 补上。const autoResumePendingOrDeferred =agentInputCoordinatorHolder?.isAutoResumePending(session.id) === true ||- agentInputCoordinatorHolder?.isAutoResumeDeferred(session.id) === true;+ agentInputCoordinatorHolder?.isAutoResumeDeferred(session.id) === true ||+ (agentInputCoordinatorHolder?.getProviderGroupSwitchHoldId(session.id) ?? null) !== null;const autoResumeOwnsError =autoResumePendingOrDeferred ||autoResumeBookkeeping.shouldSuppressAgentIslandError(session.id);@@ -5191,6 +5226,8 @@ const sessionEventDependencies: SessionEventDependencies = {get autoResumeBookkeeping() {return autoResumeBookkeeping;},+ stashProviderGroupHeldError: (sessionId, holdId, data, agentMeta) =>+ providerGroupHeldErrors.stash(sessionId, holdId, data, agentMeta),get pendingFailedTurnAssistantPersistId() {return pendingFailedTurnAssistantPersistId;},@@ -16498,10 +16535,45 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)// 两处必须同判据 —— 否则会出现"按住了却永远不接管"或"没按住却接管"的错配。isResumableTurnErrorCandidate: canRecoverTurn,// 被按住的 error 最终没接管 → 只补落 error 行(横幅 coordinator 自己设)。+ // 纯判定:供应商组会先试着换电脑时,这次错误先不呈现(provider-groups.md §6.1)。+ providerGroupSwitchCandidate: (sessionId, signals) =>+ providerGroupService?.mayHandleTurnError(sessionId, signals)+ ? classifyProviderGroupSwitchCause(signals)+ : null,onUsageLimitedTurnError: (sessionId, signals, _item, candidateToken) => {// 供应商组分配的任务先试自动换电脑,不换时由它交回额度重置后自动继续。- if (providerGroupService) providerGroupService.onTurnError(sessionId, signals, candidateToken);- else usageLimitAutoResume.onTurnError(sessionId, signals, candidateToken);+ if (!providerGroupService) {+ usageLimitAutoResume.onTurnError(sessionId, signals, candidateToken);+ return;+ }+ // 先不呈现的那次错误:换成了丢掉,不换了先放出来再交回原有处理;一直没有结局时到点放出来。+ const holdId = inputCoordinator.getProviderGroupSwitchHoldId(sessionId);+ let hooks: ProviderGroupTurnErrorHooks | undefined;+ let holdTimer: ReturnType<typeof setTimeout> | undefined;+ if (holdId !== null) {+ hooks = {+ beforeFallback: () => providerGroupHeldErrors.release(sessionId, holdId),+ resumed: () => providerGroupHeldErrors.discard(sessionId, holdId),+ };+ holdTimer = setTimeout(+ () => providerGroupHeldErrors.release(sessionId, holdId),+ PROVIDER_GROUP_SWITCH_HOLD_MAX_MS,+ );+ }+ void providerGroupService+ .onTurnError(sessionId, signals, candidateToken, hooks)+ .catch((error: unknown) => {+ log.warn('provider group: handling a failed turn did not complete', {+ sessionId,+ error: error instanceof Error ? error.message : String(error),+ });+ })+ .finally(() => {+ if (holdId === null) return;+ clearTimeout(holdTimer);+ // 用户中途接手、错误已被新的一轮换掉等:补落 error 行,错误已不是当前状态时不再呈现。+ providerGroupHeldErrors.release(sessionId, holdId);+ });},onResumableTurnErrorDiscarded: (sessionId: string,diff --git a/apps/desktop/src/main/maker-ipc/sessionEventDelivery.ts b/apps/desktop/src/main/maker-ipc/sessionEventDelivery.tsindex 68bb22599f..41392094ee 100644--- a/apps/desktop/src/main/maker-ipc/sessionEventDelivery.ts+++ b/apps/desktop/src/main/maker-ipc/sessionEventDelivery.ts@@ -23,7 +23,10 @@ export interface DeliverSessionEventDeps {readonly orcaTeamServiceForEvents: Pick<OrcaTeamService, 'captureWorkerTerminalTurn'> | null;readonly agentInputCoordinatorHolder: Pick<AgentInputCoordinator,- 'onExternalTurnSettled' | 'isAutoResumePending' | 'isAutoResumeDeferred'+ | 'onExternalTurnSettled'+ | 'isAutoResumePending'+ | 'isAutoResumeDeferred'+ | 'getProviderGroupSwitchHoldId'> | null;readonly overflowSuppressedBroadcasts: Map<string,@@ -97,6 +100,12 @@ export function deliverSessionEvent(event.type === 'error' &&isTerminalTurnErrorEvent(event) &&(isContextOverflowErrorData(event.data) || isOversizedHistoryErrorData(event.data));+ // 供应商组正在为这次失败换电脑:error 行先不落库(暂存,换成了就丢掉),同样不预留 persistId。+ // 协调器在 prepare 阶段同步登记,结算都是异步的,这里与 terminal 阶段看到的是同一次登记。+ const providerGroupHoldId =+ event.type === 'error' && isTerminalTurnErrorEvent(event)+ ? (deps.agentInputCoordinatorHolder?.getProviderGroupSwitchHoldId(session.id) ?? null)+ : null;if (event.type === 'error' &&isTerminalTurnErrorEvent(event) &&@@ -104,7 +113,8 @@ export function deliverSessionEvent(!isRemoteAuthRetry &&!isGatewayProxyTokenRecovery &&!autoResumeWouldSuppressPersist &&- !suppressOverflowBroadcast+ !suppressOverflowBroadcast &&+ providerGroupHoldId === null) {persistId = reserveTurnErrorPersistId(session.id,@@ -172,7 +182,7 @@ export function deliverSessionEvent(if (isTerminalTurnErrorEvent(event)) {deps.gitSnapshotCoordinator?.onTurnAbort(session.id);}- return { persistId, workerTerminalCapture };+ return { persistId, workerTerminalCapture, providerGroupHoldId };}export type SessionDeliveryResult = ReturnType<typeof deliverSessionEvent>;diff --git a/apps/desktop/src/main/maker-ipc/sessionEventTerminal.ts b/apps/desktop/src/main/maker-ipc/sessionEventTerminal.tsindex edca4e3966..617e08a4e9 100644--- a/apps/desktop/src/main/maker-ipc/sessionEventTerminal.ts+++ b/apps/desktop/src/main/maker-ipc/sessionEventTerminal.ts@@ -79,6 +79,17 @@ export interface FinishSessionTerminalEventDeps {| 'consumeFailedTurnCompletionTail'| 'hasSuppressedError'>;+ /**+ * 供应商组正在为这次失败换电脑(协调器登记了先不呈现):error 行改为暂存,换成了就丢掉,没换成再补落+ * (provider-group/heldTurnErrors.ts)。返回 false = 不是被暂存的那次失败,照常落库。+ * `agentMeta` 是失败那一轮的事件身份:补落时不再读当时正在进行的那一轮。+ */+ readonly stashProviderGroupHeldError?: (+ sessionId: string,+ holdId: number,+ data: unknown,+ agentMeta: unknown,+ ) => boolean;readonly productTurnUsageTargetTracker: Pick<ProductTurnUsageTargetTracker,'remember' | 'finish'@@ -136,7 +147,7 @@ export function finishSessionTerminalEvent(isRemoteAuthRetry,isGatewayProxyTokenRecovery,} = prepared;- const { persistId, workerTerminalCapture } = delivery;+ const { persistId, workerTerminalCapture, providerGroupHoldId } = delivery;const terminalOwner =event.type === 'done' || isTerminalTurnErrorEvent(event)? captureProductTurnFailureOwner(session, event, eventAgentMeta)@@ -347,16 +358,25 @@ export function finishSessionTerminalEvent(!isGatewayProxyTokenRecovery &&!autoResumeSuppressesPersist) {- onTurnErrorEvent(- session.id,- attributedEvent.data as {- message?: unknown;- reason?: unknown;- sdkError?: unknown;- } | null,- eventAgentMeta,- persistId,- );+ // 供应商组正在为这次失败换电脑:先不落库,换成了就丢掉,没换成再补落。登记期间到达的另一条不同错误+ // 不归这次暂存,照常落库。+ if (+ providerGroupHoldId !== null &&+ deps.stashProviderGroupHeldError?.(session.id, providerGroupHoldId, attributedEvent.data, eventAgentMeta) === true+ ) {+ if (persistId) releaseReservedTurnErrorPersistId(session.id, persistId);+ } else {+ onTurnErrorEvent(+ session.id,+ attributedEvent.data as {+ message?: unknown;+ reason?: unknown;+ sdkError?: unknown;+ } | null,+ eventAgentMeta,+ persistId,+ );+ }} else if (persistId) {releaseReservedTurnErrorPersistId(session.id, persistId);}@@ -391,10 +411,13 @@ export function finishSessionTerminalEvent(// renderer 会稍后调 persistTurnErrorDeferred IPC。在 resetTurnPersistState 清掉// _turnStartedAtBySession 之前保存一份,让 deferred 路径能正确做 /clear 竞态 cap。// 自愈压住 error 行时同理:补落发生在 resetTurnPersistState 之后(退避 3–20 秒,- // 或决策推迟的那一小段),不先存一份会让 /clear 竞态 cap 判错。+ // 或决策推迟的那一小段),不先存一份会让 /clear 竞态 cap 判错。供应商组换电脑暂存 error 行时同理。if (event.type === 'error' &&- (isRemoteAuthRetry || isGatewayProxyTokenRecovery || autoResumeSuppressesPersist)+ (isRemoteAuthRetry ||+ isGatewayProxyTokenRecovery ||+ autoResumeSuppressesPersist ||+ providerGroupHoldId !== null)) {saveTurnStartedAtForDeferred(session.id);}diff --git a/apps/desktop/src/main/messagePersistBroadcaster.ts b/apps/desktop/src/main/messagePersistBroadcaster.tsindex a7338aae65..2be06612c2 100644--- a/apps/desktop/src/main/messagePersistBroadcaster.ts+++ b/apps/desktop/src/main/messagePersistBroadcaster.ts@@ -2667,6 +2667,24 @@ export function onTurnErrorEvent(// 避免 Date.now() 落在 /clear 之后导致 error 行在清空后的历史中浮现。const blockCreatedAt = assistantBlocks.get(sessionId)?.createdAt;flushAssistantBlock(sessionId, agentMeta);+ enqueueTurnErrorRow(sessionId, persistId, {+ content: buildTurnErrorContent(sessionId, data, message),+ agentMeta: agentMeta ?? lastAgentMetaBySession.get(sessionId) ?? null,+ agentKind: getSessionDbAgentKind(sessionId) ?? undefined,+ orderedAt: capturedAt,+ turnStartedAt: turnStartedAtSnapshot,+ blockCreatedAt,+ });+ notePersistedMessage(sessionId, 'error', persistId);+ return persistId;+}++/** error 行 content:{ message, reason?, sdkError?, toolLoop?, providerId? },在入队前同步取值。 */+function buildTurnErrorContent(+ sessionId: string,+ data: { reason?: unknown; sdkError?: unknown; toolLoop?: unknown } | null | undefined,+ message: string,+): Record<string, unknown> {const content: Record<string, unknown> = { message };if (typeof data?.reason === 'string' && data.reason) content.reason = data.reason;if (typeof data?.sdkError === 'string' && data.sdkError) {@@ -2682,8 +2700,24 @@ export function onTurnErrorEvent(// 余额分类(fail-closed),与 live 路径「显式 providerId 才分类」同一判据。const providerIdAtError = getSessionProvider(sessionId);if (providerIdAtError) content.providerId = providerIdAtError;- const meta = agentMeta ?? lastAgentMetaBySession.get(sessionId) ?? null;- const dbAgentKindSnapshot = getSessionDbAgentKind(sessionId) ?? undefined;+ return content;+}++/** 入队写一条 error 行。除 blockCreatedAt 外的字段都是调用方在入队前同步取好的快照。 */+function enqueueTurnErrorRow(+ sessionId: string,+ persistId: string,+ row: {+ content: Record<string, unknown>;+ agentMeta: AgentMeta | null;+ agentKind: 'cc' | 'codex' | 'pi' | undefined;+ /** 行的排序时间上界(通常是错误到达的时刻)。 */+ orderedAt: number;+ turnStartedAt: number;+ blockCreatedAt?: number;+ },+): void {+ const { content, agentMeta: meta, agentKind: dbAgentKindSnapshot, orderedAt, turnStartedAt, blockCreatedAt } = row;enqueueTurnErrorWrite(sessionId, persistId, async (ownerScope) => {// 两个分支统一 +1:保证 error.createdAt 严格晚于本轮所有已入库行。// 注意:register.ts 在 flushAssistantBlock 之后调本函数,blockCreatedAt@@ -2691,25 +2725,24 @@ export function onTurnErrorEvent(// 返回本轮最后入库行的 createdAt,与 error 行同值会让 mobile 排序不可控// (mobile 无 rowid tie-breaker,同 createdAt 依赖 server 响应原始顺序)。// 统一 +1 确保 error 行始终排在本轮所有正文/工具行之后。- // Math.min(..., capturedAt):把异步查询结果的上界锁定在 onTurnErrorEvent 调用时刻,- // 防止写队列延迟消费时(用户已 /clear 并发了新消息)取到 post-clear 时间戳,- // 使 error.createdAt > clearedAt 从而出现在清空后的新会话历史里。+ // Math.min(..., orderedAt):把异步查询结果的上界锁定在 onTurnErrorEvent 调用时刻(延后补落时是错误+ // 实际发生的时刻),防止写队列延迟消费时(用户已 /clear 或发了新消息)取到之后的时间戳,+ // 使 error.createdAt > clearedAt 从而出现在清空后的新会话历史里,或排到用户新消息之后。const rawLatestTs =blockCreatedAt != null? blockCreatedAt: await latestMessageCreatedAt(sessionId);- const latestTs = rawLatestTs != null ? Math.min(rawLatestTs, capturedAt) : capturedAt;+ const latestTs = rawLatestTs != null ? Math.min(rawLatestTs, orderedAt) : orderedAt;// /clear 边界 cap:防止 pre-clear 旧 turn 的 error 行在清空后的新会话中浮现。- // 用 turnStartedAtSnapshot(入队前同步捕获,不受 resetTurnPersistState 影响)+ // 用 turnStartedAt(入队前同步捕获,不受 resetTurnPersistState 影响)// 判定 "stale pre-clear turn",而非 rawLatestTs(异步查询,write queue 延迟消费时可能返回// post-clear 新消息时间戳,导致误判竞态:旧 turn error 在 /clear 后且用户已发新消息后才入队,// rawLatestTs > clearBoundary → 跳过 cap → error.createdAt > clearedAt → 串入新会话)。- // turnStartedAtSnapshot <= clearBoundary:turn 在 /clear 之前启动 → stale → cap。- // turnStartedAtSnapshot > clearBoundary:turn 在 /clear 之后启动 → 新 turn → 不 cap。+ // turnStartedAt <= clearBoundary:turn 在 /clear 之前启动 → stale → cap。+ // turnStartedAt > clearBoundary:turn 在 /clear 之后启动 → 新 turn → 不 cap。// 无 noteTurnStarted:回退到 capturedAt 作保守锚,行为等价于// "error 事件到达时刻" 作 stale 判定(边缘 case,如 status:isRunning=true 未发的 agent)。const clearBoundary = clearBoundaryBySession.get(sessionId);- const turnStartedAt = turnStartedAtSnapshot;const createdAt =clearBoundary != null && turnStartedAt <= clearBoundary? Math.min(latestTs + 1, clearBoundary)@@ -2748,7 +2781,61 @@ export function onTurnErrorEvent(broadcastTap.tapWindowBroadcast('local-db:session:error-persisted', payload, ownerStamp);}});- notePersistedMessage(sessionId, 'error', persistId);+}++/**+ * 延后补落的 error 行(供应商组换电脑期间先暂存,provider-group/heldTurnErrors.ts):错误发生那一刻取好写库要用的+ * 一切——内容(含错误来源 provider)、agentMeta、agentKind、turn 开始时刻与出错时刻。+ *+ * 补落发生在之后任意时刻:那时任务可能已开始新的一轮(用户中途接手),旧会话也可能已在交接时关闭、按会话的+ * 持久化状态已清空,所以补落不能再读任何按会话的「当前一轮」状态。+ */+export interface DeferredTurnErrorRow {+ content: Record<string, unknown>;+ agentMeta: AgentMeta | null;+ agentKind: 'cc' | 'codex' | 'pi' | undefined;+ turnStartedAt: number;+ occurredAt: number;+}++/** 在失败那一轮里(错误到达时)同步调用,取好补落要用的 error 行;没有错误文案时返回 null。 */+export function captureDeferredTurnError(+ sessionId: string,+ data:+ | { message?: unknown; reason?: unknown; sdkError?: unknown; toolLoop?: unknown }+ | null+ | undefined,+ agentMeta: AgentMeta | null = null,+): DeferredTurnErrorRow | null {+ const message = typeof data?.message === 'string' ? redactSensitiveText(data.message) : '';+ if (!message) return null;+ const occurredAt = Date.now();+ return {+ content: buildTurnErrorContent(sessionId, data, message),+ agentMeta: agentMeta ?? lastAgentMetaBySession.get(sessionId) ?? null,+ agentKind: getSessionDbAgentKind(sessionId) ?? undefined,+ turnStartedAt:+ _turnStartedAtBySession.get(sessionId) ??+ _savedTurnStartedAtForDeferred.get(sessionId) ??+ occurredAt,+ occurredAt,+ };+}++/**+ * 补落 `captureDeferredTurnError` 取好的 error 行:只写这一行,不碰补落时正在进行的那一轮——不 flush 在飞正文+ * (失败那一轮的正文在终态边界已经落库)、不占用去重键(当前一轮同样的错误照常落库)、不改相邻行记录。+ * 行按出错的时刻排序:用户在这期间发的新消息仍排在它后面。返回行 id。+ */+export function persistDeferredTurnError(sessionId: string, row: DeferredTurnErrorRow): string {+ const persistId = createId();+ enqueueTurnErrorRow(sessionId, persistId, {+ content: row.content,+ agentMeta: row.agentMeta,+ agentKind: row.agentKind,+ orderedAt: Math.min(row.occurredAt, Date.now()),+ turnStartedAt: row.turnStartedAt,+ });return persistId;}diff --git a/apps/desktop/src/main/provider-group/__tests__/heldTurnErrors.test.ts b/apps/desktop/src/main/provider-group/__tests__/heldTurnErrors.test.tsnew file mode 100644index 0000000000..01b4ec4200--- /dev/null+++ b/apps/desktop/src/main/provider-group/__tests__/heldTurnErrors.test.ts@@ -0,0 +1,135 @@+/**+ * 自动换电脑期间先不呈现的那次失败(provider-groups.md §6.1):换成了不留痕迹,没换成补落并呈现,+ * 结算只认自己那次登记;补落的行在暂存那一刻就取好,换了账号不再写。+ */+import { describe, expect, it, vi } from 'vitest';++import { createProviderGroupHeldTurnErrors } from '../heldTurnErrors';++interface Row {+ message: string;+ agentMeta: unknown;+ capturedAt: number;+}++function harness(live = true) {+ let clock = 1_000;+ let owner = 'owner-a';+ const deps = {+ // 暂存那一刻取好的行:记下当时的时刻与失败那一轮的身份。+ capture: vi.fn((_sessionId: string, data: unknown, agentMeta: unknown): Row | null => {+ const message = (data as { message?: unknown } | null)?.message;+ return typeof message === 'string' && message ? { message, agentMeta, capturedAt: clock } : null;+ }),+ persist: vi.fn(),+ surface: vi.fn(),+ releaseHold: vi.fn(() => live),+ ownerKey: () => owner,+ log: vi.fn(),+ };+ return {+ deps,+ held: createProviderGroupHeldTurnErrors<Row>(deps),+ advance: (ms: number) => { clock += ms; },+ switchOwner: (next: string) => { owner = next; },+ };+}++const DATA = { message: "You've hit your session limit", reason: 'usage_limit', sdkError: 'rate_limit', extra: 1 };+const DETAIL = { message: "You've hit your session limit", reason: 'usage_limit', sdkError: 'rate_limit' };+const META = { uuid: 'failed-turn' };+const ROW: Row = { message: DATA.message, agentMeta: META, capturedAt: 1_000 };++describe('provider group held turn errors', () => {+ it('drops the error row when the task continued on another computer', () => {+ const { deps, held } = harness();+ expect(held.stash('s1', 1, DATA, META)).toBe(true);+ held.discard('s1', 1);+ expect(deps.releaseHold).toHaveBeenCalledWith('s1', 1);+ expect(deps.persist).not.toHaveBeenCalled();+ // 之后的结算(finally)什么都不做。+ held.release('s1', 1);+ expect(deps.persist).not.toHaveBeenCalled();+ expect(deps.surface).not.toHaveBeenCalled();+ });++ it('writes the row captured when the error happened and surfaces it when the switch gives up', () => {+ const { deps, held, advance } = harness(true);+ held.stash('s1', 1, DATA, META);+ // 换电脑花了一阵子:补落写的仍是出错那一刻取好的那一行(失败那一轮的身份与时刻)。+ advance(90_000);+ held.release('s1', 1);+ expect(deps.capture).toHaveBeenCalledTimes(1);+ expect(deps.persist).toHaveBeenCalledWith('s1', ROW);+ expect(deps.surface).toHaveBeenCalledWith('s1', DETAIL);+ // 重复结算无副作用。+ held.release('s1', 1);+ expect(deps.persist).toHaveBeenCalledTimes(1);+ });++ it('only writes the row when the error is no longer current (the user took over)', () => {+ const { deps, held } = harness(false);+ held.stash('s1', 1, DATA, META);+ held.release('s1', 1);+ expect(deps.persist).toHaveBeenCalledWith('s1', ROW);+ expect(deps.surface).not.toHaveBeenCalled();+ });++ it('does not write into another account after the user switched accounts', () => {+ const { deps, held, switchOwner } = harness(true);+ held.stash('s1', 1, DATA);+ switchOwner('owner-b');+ held.release('s1', 1);+ expect(deps.persist).not.toHaveBeenCalled();+ expect(deps.surface).not.toHaveBeenCalled();+ });++ it('keeps one row for a repeated terminal error and lets a different error through with its alert', () => {+ const { deps, held } = harness();+ expect(held.stash('s1', 1, DATA, META)).toBe(true);+ expect(held.stash('s1', 1, { ...DATA })).toBe(true);+ expect(deps.capture).toHaveBeenCalledTimes(1);+ // 同一次登记期间到达的另一条不同错误:不归这次暂存,调用方照常落库;换电脑期间被压下的 Agent Island 提醒+ // 在这里补上。暂存的那条不被覆盖。+ expect(held.stash('s1', 1, { message: 'Something else broke' })).toBe(false);+ expect(deps.surface).toHaveBeenCalledWith('s1', { message: 'Something else broke' });+ held.release('s1', 1);+ expect(deps.persist).toHaveBeenCalledTimes(1);+ expect(deps.persist).toHaveBeenCalledWith('s1', ROW);+ });++ it('writes nothing for an error without a message, but still holds and surfaces it', () => {+ const { deps, held } = harness();+ expect(held.stash('s1', 1, { reason: 'turn-failed' })).toBe(true);+ held.release('s1', 1);+ expect(deps.persist).not.toHaveBeenCalled();+ expect(deps.surface).toHaveBeenCalledWith('s1', { reason: 'turn-failed' });+ });++ it('never lets a late settlement touch a newer failure', () => {+ const { deps, held } = harness();+ held.stash('s1', 1, DATA);+ held.release('s1', 1);+ held.stash('s1', 2, { message: 'second' });+ held.discard('s1', 1);+ held.release('s1', 1);+ expect(deps.persist).toHaveBeenCalledTimes(1);+ held.release('s1', 2);+ expect(deps.persist).toHaveBeenLastCalledWith('s1', expect.objectContaining({ message: 'second' }));+ });++ it('leaves an earlier failure to its own settlement when a new one arrives first', () => {+ // 换成了、续跑那一轮又很快失败:新的一次先暂存,上一次随后以「换成了」结算,不留错误卡。+ const { deps, held } = harness();+ held.stash('s1', 1, DATA);+ held.stash('s1', 2, { message: 'second' });+ expect(deps.persist).not.toHaveBeenCalled();+ held.discard('s1', 1);+ held.release('s1', 1);+ expect(deps.persist).not.toHaveBeenCalled();+ // 新的这次没换成:照常补落。+ held.release('s1', 2);+ expect(deps.persist).toHaveBeenCalledTimes(1);+ expect(deps.persist).toHaveBeenCalledWith('s1', expect.objectContaining({ message: 'second' }));+ });+});diff --git a/apps/desktop/src/main/provider-group/__tests__/service.test.ts b/apps/desktop/src/main/provider-group/__tests__/service.test.tsindex f0ae7da2a6..4c09988c47 100644--- a/apps/desktop/src/main/provider-group/__tests__/service.test.ts+++ b/apps/desktop/src/main/provider-group/__tests__/service.test.ts@@ -649,3 +649,80 @@ describe('onTurnError for a shared user (the sharer’s group picks the computerexpect(h.deps.fallback).toHaveBeenCalledWith('s1', { sdkError: 'rate_limit' }, 4);});});++describe('no error while switching (mayHandleTurnError + hooks)', () => {+ const LIMIT = { sdkError: 'rate_limit' };++ it('predicts a switch only for bound tasks in a group that can still move them', () => {+ const h = harness();+ // 没归组、也没有分享者的凭证:照常先报错。+ expect(h.service.mayHandleTurnError('s1', LIMIT)).toBe(false);+ h.bindings.set('s1', { providerId: 'anthropic', memberKey: 'local', at: 1 });+ expect(h.service.mayHandleTurnError('s1', LIMIT)).toBe(true);+ // 换到哪台都一样的失败不换。+ expect(h.service.mayHandleTurnError('s1', { message: 'prompt is too long', sdkError: 'invalid_request' })).toBe(false);++ const off = harness({ autoSwitch: false });+ off.bindings.set('s1', { providerId: 'anthropic', memberKey: 'local', at: 1 });+ expect(off.service.mayHandleTurnError('s1', LIMIT)).toBe(false);++ // 组里只剩这一台电脑:换不了。+ const alone = harness({ members: [LOCAL] });+ alone.bindings.set('s1', { providerId: 'anthropic', memberKey: 'local', at: 1 });+ expect(alone.service.mayHandleTurnError('s1', LIMIT)).toBe(false);+ });++ it('predicts a switch for a shared task only with a fresh token from the group computer', () => {+ let clock = 0;+ const guestSwitch = createProviderGroupGuestSwitch(() => clock);+ const h = harness({ row: { agentDeviceId: 'share:share-from-alice', providerId: 'alice-anthropic' } });+ const service = createProviderGroupService({ ...h.deps, guestSwitch });+ expect(service.mayHandleTurnError('s1', LIMIT)).toBe(false);+ guestSwitch.offer('s1', 'token-aaaaaaaaaaaaaaaa');+ expect(service.mayHandleTurnError('s1', LIMIT)).toBe(true);+ // 只看不取:之后的换电脑仍拿得到凭证。+ expect(guestSwitch.claim('s1')).toBe(true);+ guestSwitch.offer('s1', 'token-bbbbbbbbbbbbbbbb');+ clock += PROVIDER_GROUP_SWITCH_OFFER_TTL_MS + 1;+ expect(service.mayHandleTurnError('s1', LIMIT)).toBe(false);+ });++ it('reports a successful switch and never hands back', async () => {+ const h = harness();+ h.bindings.set('s1', { providerId: 'anthropic', memberKey: 'local', at: 1 });+ const hooks = { beforeFallback: vi.fn(), resumed: vi.fn() };+ await h.service.onTurnError('s1', LIMIT, 7, hooks);+ expect(hooks.resumed).toHaveBeenCalledTimes(1);+ expect(hooks.beforeFallback).not.toHaveBeenCalled();+ expect(h.deps.fallback).not.toHaveBeenCalled();+ });++ it('lets the caller surface the error right before handing back to the existing handling', async () => {+ const order: string[] = [];+ const h = harness({ offline: [MINI.key, STUDIO.key] });+ h.bindings.set('s1', { providerId: 'anthropic', memberKey: 'local', at: 1 });+ h.deps.fallback.mockImplementation(() => { order.push('fallback'); });+ const hooks = { beforeFallback: vi.fn(() => { order.push('surface'); }), resumed: vi.fn() };+ // 组里没有别的电脑能接:全部试过才报错。+ await h.service.onTurnError('s1', LIMIT, 7, hooks);+ expect(order).toEqual(['surface', 'fallback']);+ expect(hooks.resumed).not.toHaveBeenCalled();++ // 不归组管的错误同样先放出来再交回。+ const plain = harness({ row: { providerId: 'openai' } });+ const plainHooks = { beforeFallback: vi.fn(), resumed: vi.fn() };+ await plain.service.onTurnError('s1', LIMIT, 1, plainHooks);+ expect(plainHooks.beforeFallback).toHaveBeenCalledTimes(1);+ expect(plain.deps.fallback).toHaveBeenCalledTimes(1);+ });++ it('does not report success when the continuation did not go through', async () => {+ const h = harness();+ h.bindings.set('s1', { providerId: 'anthropic', memberKey: 'local', at: 1 });+ h.deps.continueSession.mockResolvedValueOnce('no-progress' as never);+ const hooks = { beforeFallback: vi.fn(), resumed: vi.fn() };+ await h.service.onTurnError('s1', LIMIT, 7, hooks);+ expect(hooks.resumed).not.toHaveBeenCalled();+ expect(h.deps.cancelContinue).toHaveBeenCalledWith('s1', 99);+ });+});diff --git a/apps/desktop/src/main/provider-group/guestSwitch.ts b/apps/desktop/src/main/provider-group/guestSwitch.tsindex 2da2b527b1..2a317641fc 100644--- a/apps/desktop/src/main/provider-group/guestSwitch.ts+++ b/apps/desktop/src/main/provider-group/guestSwitch.ts@@ -21,6 +21,8 @@ const MAX_TRACKED_SESSIONS = 512;export interface ProviderGroupGuestSwitch {/** 组所在电脑发来凭证(任务的事件流里)。 */offer(sessionId: string, token: string): void;+ /** 只看不取:有没有还新鲜的凭证(终态错误那一刻判断要不要先不呈现这次错误)。 */+ hasOffer(sessionId: string): boolean;/** 这次错误要不要换一台:有新鲜的凭证则取走,登记给下一次打开,返回 true。 */claim(sessionId: string): boolean;/** 打开任务时带上的凭证(取走即用掉);没有返回 undefined。 */@@ -63,6 +65,11 @@ export function createProviderGroupGuestSwitch(now: () => number = Date.now): Pr}},+ hasOffer(sessionId) {+ const entry = offered.get(sessionId);+ return entry !== undefined && now() - entry.at <= PROVIDER_GROUP_SWITCH_OFFER_TTL_MS;+ },+claim(sessionId) {const entry = offered.get(sessionId);offered.delete(sessionId);diff --git a/apps/desktop/src/main/provider-group/heldTurnErrors.ts b/apps/desktop/src/main/provider-group/heldTurnErrors.tsnew file mode 100644index 0000000000..4d887add71--- /dev/null+++ b/apps/desktop/src/main/provider-group/heldTurnErrors.ts@@ -0,0 +1,125 @@+/**+ * 自动换电脑期间先不呈现的那次失败(docs/product-rules/provider-groups.md §6.1「换电脑期间不报错」)。+ *+ * 输入协调器在终态错误那一刻判断供应商组会先试着换电脑时,投影里先不带这次错误(没有红横幅),只显示+ * 「正在换一台电脑继续」;本该立刻落库的 error 行与 Agent Island 的错误提醒由 host 暂存在这里,按协调器那次+ * 登记的 id 对号结算:+ * - 换成了(续跑已发出):丢掉,历史里只留换电脑的活动行;+ * - 没换成、交回原有处理(组里都不能用、自动换电脑关着、交接失败等):先放出来——横幅、error 行、Agent Island;+ * - 这一趟以别的方式结束(用户中途接手、错误已被新的一轮换掉):补落 error 行,错误已不是当前状态时不再呈现。+ *+ * 补落的 error 行在暂存那一刻就取好写库要用的一切(`capture`):补落时任务可能已在跑新的一轮(用户中途接手),+ * 旧会话也可能已在交接时关闭,补落只写这一行,不碰那时正在进行的那一轮。行按出错的时刻排序:用户在换电脑途中+ * 发了新消息时,它仍排在那条消息之前。暂存时记下账号:结算时已换了账号就不再写(不往别的账号的数据里补行)。+ *+ * 暂存的必须有人结算,否则那次失败在历史里彻底消失;结算只认自己那次登记,迟到的旧结算碰不到下一次失败,+ * 新的一次登记也不会替还没结算的上一次做决定(上一次可能正要以「换成了」结算)。+ */++/** 暂存的失败详情(与 error 行 content 同形),用于判断重复与 Agent Island 提醒。 */+export interface HeldTurnErrorDetail {+ message?: string;+ reason?: string;+ sdkError?: string;+}++export interface ProviderGroupHeldTurnErrorsDeps<Row> {+ /**+ * 暂存那一刻取好补落要用的 error 行(内容、agentMeta、错误来源等);没有可写的内容时返回 null。+ * `agentMeta` 是失败那一轮的事件身份(没有时为 null)。+ */+ capture(sessionId: string, data: unknown, agentMeta: unknown): Row | null;+ /** 补落 `capture` 取好的那一行:只写这一行,不碰补落时正在进行的那一轮。 */+ persist(sessionId: string, row: Row): void;+ /** 错误确定要呈现:同步到聊天之外的错误表面(Agent Island)。 */+ surface(sessionId: string, detail: HeldTurnErrorDetail): void;+ /** 撤掉协调器那次「先不呈现」的登记;错误仍是当前状态时投影随即带出横幅,返回 true。 */+ releaseHold(sessionId: string, holdId: number): boolean;+ /** 当前登录账号的作用域键。 */+ ownerKey(): string;+ log?(message: string, meta?: Record<string, unknown>): void;+}++export interface ProviderGroupHeldTurnErrors {+ /**+ * 终态错误被先不呈现时,暂存本该立刻落库的 error 行。返回 false = 这不是被暂存的那次失败(同一次登记期间+ * 到达的另一条不同错误):调用方照常落库,这里替它补上换电脑期间被压下的 Agent Island 提醒。同一次失败的+ * 重复终态 error 返回 true(只留一行)。+ */+ stash(sessionId: string, holdId: number, data: unknown, agentMeta?: unknown): boolean;+ /** 换成了:这次失败不再落库、不再呈现。 */+ discard(sessionId: string, holdId: number): void;+ /** 不再换了:撤掉登记并补落;错误仍是当前状态时一并呈现。重复调用无副作用。 */+ release(sessionId: string, holdId: number): void;+}++interface HeldEntry<Row> {+ detail: HeldTurnErrorDetail;+ row: Row | null;+ owner: string;+}++function toDetail(data: unknown): HeldTurnErrorDetail {+ const d = (data ?? {}) as { message?: unknown; reason?: unknown; sdkError?: unknown };+ return {+ ...(typeof d.message === 'string' ? { message: d.message } : {}),+ ...(typeof d.reason === 'string' ? { reason: d.reason } : {}),+ ...(typeof d.sdkError === 'string' ? { sdkError: d.sdkError } : {}),+ };+}++export function createProviderGroupHeldTurnErrors<Row>(+ deps: ProviderGroupHeldTurnErrorsDeps<Row>,+): ProviderGroupHeldTurnErrors {+ /** sessionId → 登记 id → 暂存的那次失败。同一任务可能同时有两次还没结算(上一次正在以续跑收尾)。 */+ const held = new Map<string, Map<number, HeldEntry<Row>>>();++ function take(sessionId: string, holdId: number): HeldEntry<Row> | null {+ const entries = held.get(sessionId);+ const entry = entries?.get(holdId);+ if (!entries || !entry) return null;+ entries.delete(holdId);+ if (entries.size === 0) held.delete(sessionId);+ return entry;+ }++ /** 补落;暂存后已换了账号时不写。返回是否写了。 */+ function persist(sessionId: string, entry: HeldEntry<Row>): boolean {+ if (entry.owner !== deps.ownerKey()) {+ deps.log?.('provider group: dropped a held error row after the account changed', { sessionId });+ return false;+ }+ if (entry.row !== null) deps.persist(sessionId, entry.row);+ return true;+ }++ return {+ stash(sessionId, holdId, data, agentMeta) {+ const detail = toDetail(data);+ const entries = held.get(sessionId) ?? new Map<number, HeldEntry<Row>>();+ const previous = entries.get(holdId);+ if (previous) {+ // 同一次登记期间又来一条终态 error:同一次失败的重复就只留一行。不同的错误不归这次暂存:调用方照常落库,+ // 换电脑期间被压下的 Agent Island 提醒在这里补上。+ if (previous.detail.message === detail.message) return true;+ deps.surface(sessionId, detail);+ return false;+ }+ entries.set(holdId, { detail, row: deps.capture(sessionId, data, agentMeta ?? null), owner: deps.ownerKey() });+ held.set(sessionId, entries);+ return true;+ },++ discard(sessionId, holdId) {+ take(sessionId, holdId);+ deps.releaseHold(sessionId, holdId);+ },++ release(sessionId, holdId) {+ const live = deps.releaseHold(sessionId, holdId);+ const entry = take(sessionId, holdId);+ if (!entry) return;+ if (persist(sessionId, entry) && live) deps.surface(sessionId, entry.detail);+ },+ };+}diff --git a/apps/desktop/src/main/provider-group/service.ts b/apps/desktop/src/main/provider-group/service.tsindex a3c6ea6c57..652c7ded6d 100644--- a/apps/desktop/src/main/provider-group/service.ts+++ b/apps/desktop/src/main/provider-group/service.ts@@ -163,7 +163,7 @@ export interface ProviderGroupServiceDeps {/*** 分享的人这边的「需要换一台」凭证(guestSwitch.ts);不提供 = 分享来的供应商出错时一律交回原有处理。*/- guestSwitch?: Pick<ProviderGroupGuestSwitch, 'claim' | 'release' | 'drop'>;+ guestSwitch?: Pick<ProviderGroupGuestSwitch, 'hasOffer' | 'claim' | 'release' | 'drop'>;/** 这个任务现在是否正在运行一轮。 */isTurnRunning(sessionId: string): boolean;continueSession(@@ -187,8 +187,20 @@ export interface ProviderGroupService {assignBeforeStart(input: { sessionId: string; agentKind: AgentKind; model: string }): Promise<ProviderGroupStartContext | null>;/** 分配后 Agent 没能启动:换下一台,返回新的位置;不该换或没有下一台返回 null(调用方照常报错)。 */nextAfterStartFailure(context: ProviderGroupStartContext, error: unknown): Promise<ProviderGroupStartContext | null>;- /** 运行中的终态错误(输入协调器保留了重试入口)。 */- onTurnError(sessionId: string, signals: InterruptedTurnErrorSignals, token: number): void;+ /**+ * 纯判定(同步、无副作用):这次终态错误会不会先由本机制试着换电脑。为 true 时输入协调器先不呈现这次错误+ * (红横幅与错误卡):换成了就不出现,没换成再补出来(§6.1)。只看手上现成的:认得出的原因,加上已归组+ * (本机的组要开着自动换电脑、组里还有别的电脑;另一台电脑上的组交给随后的异步判断),或组所在电脑已发来+ * 「需要换一台」的凭证。出错时才纳入组的老任务这里认不出,照旧先报错再换。+ */+ mayHandleTurnError(sessionId: string, signals: InterruptedTurnErrorSignals): boolean;+ /** 运行中的终态错误(输入协调器保留了重试入口)。整个处理(换电脑、续跑或交回原有处理)结束时兑现。 */+ onTurnError(+ sessionId: string,+ signals: InterruptedTurnErrorSignals,+ token: number,+ hooks?: ProviderGroupTurnErrorHooks,+ ): Promise<void>;/*** 发送前:已归组的任务所在那台现在不能用(离线、分享暂停、供应商关掉、冷却中)时,先交接到组里下一台,* 这条消息直接发到新电脑。读不到状态或没有下一台时不动,照常发送。@@ -198,6 +210,14 @@ export interface ProviderGroupService {noteUserAction(sessionId: string): void;}+/** 一次终态错误的处理结局(调用方据此结算换电脑期间先不呈现的那次错误)。 */+export interface ProviderGroupTurnErrorHooks {+ /** 不换了,马上交回原有处理(报错与额度重置后自动继续):先把错误放出来。 */+ beforeFallback?(): void;+ /** 已换到另一台电脑并续上了这一轮。 */+ resumed?(): void;+}+/** 发送前检查组内电脑状态的上限:读不到就照常发送,不让一台卡住的电脑拖慢每次发送。 */export const PROVIDER_GROUP_BEFORE_SEND_TIMEOUT_MS = 3_000;@@ -543,6 +563,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Provsignals: InterruptedTurnErrorSignals,token: number,lease: object,+ hooks: ProviderGroupTurnErrorHooks | undefined,body: (isCurrent: () => boolean, handBack: () => void) => Promise<void>,): Promise<void> {const run = { superseded: false };@@ -552,6 +573,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Provconst isCurrent = () => !run.superseded && deps.isLeaseCurrent(sessionId, lease);const handBack = () => {if (!isCurrent()) return;+ hooks?.beforeFallback?.();const fallbackToken = deps.leaseRecovery(sessionId, token) ? token : deps.rearmContinue(sessionId, lease, null);if (fallbackToken !== null) deps.fallback(sessionId, signals, fallbackToken);};@@ -567,11 +589,16 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Prov}/** true = 已由本机制处理(含它自己交回原有处理);false = 不归它管,调用方照常交回。 */- async function failover(sessionId: string, signals: InterruptedTurnErrorSignals, token: number): Promise<boolean> {+ async function failover(+ sessionId: string,+ signals: InterruptedTurnErrorSignals,+ token: number,+ hooks: ProviderGroupTurnErrorHooks | undefined,+ ): Promise<boolean> {const cause = classifyProviderGroupSwitchCause(signals);if (!cause) return false;if (!deps.readBinding(sessionId) && !(await adoptOnFailure(sessionId))) {- return guestFailover(sessionId, signals, token, cause);+ return guestFailover(sessionId, signals, token, cause, hooks);}const bound = await loadBound(sessionId);if (!bound) return false;@@ -590,8 +617,8 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Provconst lease = deps.leaseRecovery(sessionId, token);if (!lease) return true;const boundRow = { ...row, model: row.model };- await withSwitchRun(sessionId, signals, token, lease, (isCurrent, handBack) => switchUntilSettled({- sessionId, signals, cause, binding, source, config, row: boundRow, current, lease, isCurrent, handBack,+ await withSwitchRun(sessionId, signals, token, lease, hooks, (isCurrent, handBack) => switchUntilSettled({+ sessionId, signals, cause, binding, source, config, row: boundRow, current, lease, isCurrent, handBack, hooks,}));return true;}@@ -607,6 +634,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Provsignals: InterruptedTurnErrorSignals,token: number,cause: ProviderGroupSwitchCause,+ hooks: ProviderGroupTurnErrorHooks | undefined,): Promise<boolean> {const guestSwitch = deps.guestSwitch;if (!guestSwitch) return false;@@ -621,7 +649,7 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Provreturn true;}const model = row.model;- await withSwitchRun(sessionId, signals, token, lease, async (isCurrent, handBack) => {+ await withSwitchRun(sessionId, signals, token, lease, hooks, async (isCurrent, handBack) => {try {// 位置仍是同一个分享:强制重新交接、新建会话,打开时带上凭证,由组所在电脑换一台。await deps.switchAgentLocation(sessionId, {@@ -647,7 +675,8 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): ProvsessionTotal: 0,groupSwitch: { cause },});- if (outcome !== 'resumed') deps.cancelContinue(sessionId, continueToken);+ if (outcome === 'resumed') hooks?.resumed?.();+ else deps.cancelContinue(sessionId, continueToken);});return true;}@@ -664,8 +693,9 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Provlease: object;isCurrent: () => boolean;handBack: () => void;+ hooks: ProviderGroupTurnErrorHooks | undefined;}): Promise<void> {- const { sessionId, signals, cause, binding, source, config, row, current, lease, isCurrent, handBack } = input;+ const { sessionId, signals, cause, binding, source, config, row, current, lease, isCurrent, handBack, hooks } = input;source.cool(binding.providerId, current.key, cause, deps.readResetAt(signals));source.invalidate(current);const tried = router.markTried(sessionId, current.key);@@ -734,7 +764,8 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): ProvsessionTotal: 0,agentSwitch: { from: fromLabel, to: pick.label, cause },});- if (outcome !== 'resumed') deps.cancelContinue(sessionId, continueToken);+ if (outcome === 'resumed') hooks?.resumed?.();+ else deps.cancelContinue(sessionId, continueToken);return;}}@@ -888,15 +919,29 @@ export function createProviderGroupService(deps: ProviderGroupServiceDeps): Provreturn { ...context, member: pick.member, route, overrideRoute: true };},- onTurnError(sessionId, signals, token) {- void failover(sessionId, signals, token)- .then((handled) => {- if (!handled) deps.fallback(sessionId, signals, token);- })- .catch((error) => {- deps.log.warn('provider group: automatic switch failed', { sessionId, error: errorText(error) });- deps.fallback(sessionId, signals, token);- });+ mayHandleTurnError(sessionId, signals) {+ if (!classifyProviderGroupSwitchCause(signals)) return false;+ const binding = deps.readBinding(sessionId);+ if (!binding) return deps.guestSwitch?.hasOffer(sessionId) === true;+ if (binding.groupDeviceId) return deps.remote !== undefined;+ const config = deps.readGroup(binding.providerId);+ const current = config?.members.find((m) => m.key === binding.memberKey);+ // 交接只在不同电脑之间进行(switchExclusion):组里没有别的电脑时换不了。+ return Boolean(+ config?.autoSwitch && current && config.members.some((m) => m.agentDeviceId !== current.agentDeviceId),+ );+ },++ async onTurnError(sessionId, signals, token, hooks) {+ let handled = false;+ try {+ handled = await failover(sessionId, signals, token, hooks);+ } catch (error) {+ deps.log.warn('provider group: automatic switch failed', { sessionId, error: errorText(error) });+ }+ if (handled) return;+ hooks?.beforeFallback?.();+ deps.fallback(sessionId, signals, token);},async beforeSend(sessionId) {diff --git a/apps/desktop/src/renderer/__tests__/makerChatStoreAutoResumeCard.test.ts b/apps/desktop/src/renderer/__tests__/makerChatStoreAutoResumeCard.test.tsindex 852f566c95..911bbdff38 100644--- a/apps/desktop/src/renderer/__tests__/makerChatStoreAutoResumeCard.test.ts+++ b/apps/desktop/src/renderer/__tests__/makerChatStoreAutoResumeCard.test.ts@@ -298,6 +298,22 @@ describe('applyInputProjection 自愈进行中提示', () => {});});+ it('供应商组换电脑期间任务仍算运行中,没换成时以错误结束(侧栏红点与失败通知照常)', () => {+ inputProjectionCb!(projection({+ autoResumePending: {+ error: "You've hit your session limit",+ attempt: 0,+ maxAttempts: 0,+ sessionTotal: 0,+ groupSwitchPending: { cause: 'usage-limit' },+ },+ }));+ expect(makerChatStore.getSnapshot(SID).error).toBeNull();+ expect(makerChatStore.getRunningSnapshot().get(SID)?.isRunning).toBe(true);+ inputProjectionCb!(projection({ error: "You've hit your session limit" }));+ expect(makerChatStore.getRunningSnapshot().get(SID)).toMatchObject({ isRunning: false, hasError: true });+ });+it('does not classify a normal Continue as recovery when it finishes before projection cleanup', () => {makerEventCb!({ sessionId: SID, event: { type: 'status', data: { isRunning: true } } });inputProjectionCb!(projection({ continuationInFlightClientId: 'manual-continue' }));@@ -1049,3 +1065,57 @@ describe('同一次中断事件的多次重连折叠成一行', () => {expect(rows.find((m) => m.clientId === 'r1')?.systemCardType).toBeUndefined();});});++describe('供应商组换电脑期间不报错(provider-groups.md §6.1)', () => {+ const LIMIT_MESSAGE = "You've hit your session limit · resets 12:40am";+ const switchingCard = (error = LIMIT_MESSAGE) => ({+ ...serverMessage({ clientId: PENDING_CARD_ID, content: '' }),+ systemCardType: 'auto-resume-pending' as const,+ systemCardData: { error, attempt: 0, maxAttempts: 0, sessionTotal: 0, groupSwitchPending: { cause: 'usage-limit' } },+ }) as ChatMessage;+ const terminalError = (source: 'claude-code' | 'pi', message = LIMIT_MESSAGE) => ({+ sessionId: SID,+ type: 'error' as const,+ source,+ data: { message, isTerminal: true },+ });++ it.each(['claude-code', 'pi'] as const)('%s 的终态错误回声不点亮横幅,也不撤掉「正在换一台电脑继续」', (source) => {+ const next = handleStreamEvent(+ { ...EMPTY_SESSION_STATE, messages: [switchingCard()] },+ terminalError(source),+ );+ expect(next.error).toBeNull();+ expect(next.messages.some((m) => m.clientId === PENDING_CARD_ID)).toBe(true);+ });++ it('换电脑期间到达的另一次错误照常报错', () => {+ const next = handleStreamEvent(+ { ...EMPTY_SESSION_STATE, messages: [switchingCard()] },+ terminalError('claude-code', 'Something else broke'),+ );+ expect(next.error).toBe('Something else broke');+ });++ it('不是换电脑的接管行不改变非 Codex 错误的呈现', () => {+ const plainCard = {+ ...serverMessage({ clientId: PENDING_CARD_ID, content: '' }),+ systemCardType: 'auto-resume-pending' as const,+ systemCardData: { ...PENDING_INFO, error: LIMIT_MESSAGE },+ } as ChatMessage;+ const next = handleStreamEvent({ ...EMPTY_SESSION_STATE, messages: [plainCard] }, terminalError('claude-code'));+ expect(next.error).toBe(LIMIT_MESSAGE);+ });++ it('输入框状态写「正在换一台电脑继续」所需的标记随进行中行带出', () => {+ const info = findActiveReconnect({+ messages: [switchingCard()],+ sessionRunning: false,+ continuationTurnClientId: null,+ projectionCapability: 'supported',+ });+ expect(info?.groupSwitchPending).toEqual({ cause: 'usage-limit' });+ // 不是重连:没有次数。+ expect(info?.attempt).toBeUndefined();+ });+});diff --git a/apps/desktop/src/renderer/__tests__/systemCardAutoResumeRow.test.tsx b/apps/desktop/src/renderer/__tests__/systemCardAutoResumeRow.test.tsxindex 7b2913f19f..117661c1ac 100644--- a/apps/desktop/src/renderer/__tests__/systemCardAutoResumeRow.test.tsx+++ b/apps/desktop/src/renderer/__tests__/systemCardAutoResumeRow.test.tsx@@ -115,6 +115,24 @@ describe('SystemCard auto-resume 行', () => {).toBeNull();});+ it('供应商组换电脑进行中 → 「正在换一台电脑继续」,不带先不呈现的原始错误', () => {+ render(+ <SystemCard+ cardType="auto-resume-pending"+ data={{+ error: "You've hit your session limit",+ attempt: 0,+ maxAttempts: 0,+ sessionTotal: 0,+ groupSwitchPending: { cause: 'usage-limit' },+ }}+ />,+ );+ expect(screen.getByText('chat.systemCard.autoResumePending.groupSwitch')).toBeTruthy();+ expect(screen.queryByText(/session limit/)).toBeNull();+ expect(screen.queryByText('chat.systemCard.autoResumePending.label')).toBeNull();+ });+it('已回填时 inFlight 不参与:终态优先,仍定格 ✓ / ✗', () => {render(<SystemCarddiff --git a/apps/desktop/src/renderer/__tests__/useSessionRunningStatusSilence.test.ts b/apps/desktop/src/renderer/__tests__/useSessionRunningStatusSilence.test.tsindex 87c3808925..80fb3c0285 100644--- a/apps/desktop/src/renderer/__tests__/useSessionRunningStatusSilence.test.ts+++ b/apps/desktop/src/renderer/__tests__/useSessionRunningStatusSilence.test.ts@@ -13,7 +13,7 @@ import {} from '@/lib/silencedSessionDoneStore';import { markSessionStarting, resetSessionStartingStoreForTests } from '@/lib/sessionStartingStore';import { useSessionRunningStatus } from '@/hooks/useSessionRunningStatus';-import { noteSessionTurnStartedForAlerts } from '@/hooks/usePendingAlertAttention';+import { noteSessionTurnStartedForAlerts, refreshPendingAlerts } from '@/hooks/usePendingAlertAttention';import {addSessionAttention,clearSessionAttention,@@ -69,6 +69,7 @@ vi.mock('@/lib/sessionAttentionStore', () => ({vi.mock('@/hooks/usePendingAlertAttention', () => ({noteSessionTurnStartedForAlerts: vi.fn(),+ refreshPendingAlerts: vi.fn(async () => {}),}));function status(isRunning: boolean, hasError = false, sideTask?: boolean): SessionStatusInfo {@@ -825,3 +826,77 @@ describe('useSessionRunningStatus silenced completion handling', () => {expect(onSessionDone).toHaveBeenCalledExactlyOnceWith('paused');});});++describe('useSessionRunningStatus stale error dot', () => {+ afterEach(() => {+ storeMock.snapshot = new Map();+ storeMock.listeners.clear();+ storeMock.terminalErrorSessions.clear();+ vi.clearAllMocks();+ vi.restoreAllMocks();+ vi.useRealTimers();+ });++ it('retires the error dot when the next turn finishes cleanly after the start missed it', async () => {+ vi.useFakeTimers();+ let kind: ReturnType<typeof getSessionAttentionKind>;+ vi.mocked(addSessionAttention).mockImplementation((_sessionId, next) => {+ kind = next;+ });+ vi.mocked(clearSessionAttention).mockImplementation(() => {+ kind = undefined;+ return true;+ });+ vi.mocked(getSessionAttentionKind).mockImplementation(() => kind);+ renderHook(() => useSessionRunningStatus(undefined));+ await emitSnapshot(new Map([['s', status(true)]]));+ storeMock.terminalErrorSessions.add('s');+ await emitSnapshot(new Map([['s', status(false, true)]]));+ expect(kind).toBe('error');++ // 自动续跑(换电脑后继续、额度恢复后继续)启动那一刻还读到旧错误:当时没收掉。+ await emitSnapshot(new Map([['s', status(true)]]));+ expect(kind).toBe('error');+ storeMock.terminalErrorSessions.clear();+ await emitSnapshot(new Map([['s', status(false)]]));+ expect(clearSessionAttention).toHaveBeenCalledWith('s', { intent: 'explicit' });+ // 派生账本重算:仍有未处置的错误尾行会重新点亮。+ expect(refreshPendingAlerts).toHaveBeenCalled();+ await act(async () => { await vi.advanceTimersByTimeAsync(1000); });+ expect(kind).toBe('done');+ });++ it('stops owning its dot once the user handled it, so a later dot from elsewhere stays', async () => {+ vi.useFakeTimers();+ let kind: ReturnType<typeof getSessionAttentionKind>;+ vi.mocked(addSessionAttention).mockImplementation((_sessionId, next) => {+ kind = next;+ });+ vi.mocked(getSessionAttentionKind).mockImplementation(() => kind);+ renderHook(() => useSessionRunningStatus(undefined));+ await emitSnapshot(new Map([['s', status(true)]]));+ storeMock.terminalErrorSessions.add('s');+ await emitSnapshot(new Map([['s', status(false, true)]]));+ // 用户关掉横幅:红点被处置。+ kind = undefined;+ storeMock.terminalErrorSessions.clear();+ await emitSnapshot(new Map([['s', status(true)]]));+ // 这一轮里别的来源(如 Make 卡片失败)点了红点,但这一轮本身正常结束。+ kind = 'error';+ vi.mocked(clearSessionAttention).mockClear();+ await emitSnapshot(new Map([['s', status(false)]]));+ expect(clearSessionAttention).not.toHaveBeenCalledWith('s', { intent: 'explicit' });+ });++ it('leaves an error dot it did not set to the pending-alert ledger', async () => {+ vi.useFakeTimers();+ vi.mocked(getSessionAttentionKind).mockReturnValue('error');+ renderHook(() => useSessionRunningStatus(undefined));+ storeMock.terminalErrorSessions.add('s');+ await emitSnapshot(new Map([['s', status(true)]]));+ storeMock.terminalErrorSessions.clear();+ await emitSnapshot(new Map([['s', status(false)]]));+ expect(clearSessionAttention).not.toHaveBeenCalledWith('s', { intent: 'explicit' });+ expect(refreshPendingAlerts).toHaveBeenCalled();+ });+});diff --git a/apps/desktop/src/renderer/components/chat/SystemCard.tsx b/apps/desktop/src/renderer/components/chat/SystemCard.tsxindex 214617d287..6a9d4234eb 100644--- a/apps/desktop/src/renderer/components/chat/SystemCard.tsx+++ b/apps/desktop/src/renderer/components/chat/SystemCard.tsx@@ -963,7 +963,9 @@ function AutoResumeActionRow({// - 已回填 → ✓ / ✗ 定格,`inFlight` 不参与(终态优先)const live = state === 'live' || (inFlight === true && info.outcome === undefined);const outcome = live ? undefined : info.outcome;- const label = info.agentSwitch+ const label = info.groupSwitchPending+ ? t('chat.systemCard.autoResumePending.groupSwitch')+ : info.agentSwitch? t(`chat.systemCard.autoResume.agentSwitch.${info.agentSwitch.cause}`, {from: info.agentSwitch.from,to: info.agentSwitch.to,@@ -984,8 +986,10 @@ function AutoResumeActionRow({: outcome === 'failed'? t('chat.systemCard.autoResume.labelFailed'): t('chat.systemCard.autoResume.labelNeutral');- const summary = summarizeInterruption(info.error);- const canExpand = Boolean(info.error) || hasProgress || showSessionTotal;+ // 供应商组正在换电脑时错误先不呈现:行内不带原始错误(它只用来认出终态 event 的回声)。+ const shownError = info.groupSwitchPending ? undefined : info.error;+ const summary = summarizeInterruption(shownError);+ const canExpand = Boolean(shownError) || hasProgress || showSessionTotal;return (<div className="flex flex-col"><buttondiff --git a/apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx b/apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsxindex 51e443412d..168ac80fea 100644--- a/apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx+++ b/apps/desktop/src/renderer/features/cc-agent/CCAgentSessionView.tsx@@ -2272,7 +2272,9 @@ export function CCAgentSessionView({[messages, agentStatus.isRunning, isStreaming, continuationTurnClientId, continuationInFlightProjectionCapability],);const reconnectStatus = activeReconnect- ? activeReconnect.attempt !== undefined && activeReconnect.maxAttempts !== undefined+ ? activeReconnect.groupSwitchPending+ ? t('chat.systemCard.autoResumePending.groupSwitch')+ : activeReconnect.attempt !== undefined && activeReconnect.maxAttempts !== undefined? t('chat.systemCard.autoResumePending.labelWithProgress', {attempt: activeReconnect.attempt,total: activeReconnect.maxAttempts,diff --git a/apps/desktop/src/renderer/hooks/useSessionRunningStatus.ts b/apps/desktop/src/renderer/hooks/useSessionRunningStatus.tsindex 63f7ba71dd..db9eeaefb7 100644--- a/apps/desktop/src/renderer/hooks/useSessionRunningStatus.ts+++ b/apps/desktop/src/renderer/hooks/useSessionRunningStatus.ts@@ -53,7 +53,10 @@ import {isSessionTerminalNotificationOwnedByScheduler,isSessionDoneSilenced,} from '@/lib/silencedSessionDoneStore';-import { noteSessionTurnStartedForAlerts } from '@/hooks/usePendingAlertAttention';+import {+ noteSessionTurnStartedForAlerts,+ refreshPendingAlerts,+} from '@/hooks/usePendingAlertAttention';import {ensureAgentIslandActivitySubscribed,isSessionCompletionHeldByAgentIsland,@@ -134,6 +137,9 @@ export function useSessionRunningStatus(// when pending states disappear and auto-clear notifications.const prevPendingRef = useRef(new Set<string>());+ /** 本 hook 因 turn 以错误结束而点的红点(新一轮正常结束时据此收掉过期的那颗)。 */+ const liveErrorMarkedRef = useRef(new Set<string>());+/*** Pending done-notifications waiting for a debounce window to expire.* 场景:用户排了队列,turn A done → main 会几十毫秒后自动 spawn turn B。@@ -169,10 +175,11 @@ export function useSessionRunningStatus(// hasSessionTerminalError 仍为 true 时不清(mivo 等 skipTurnReset 上升沿// 不拆横幅);派生账本另走 noteSessionTurnStartedForAlerts,只在仍认领// 错误尾行时重算,横幅已灭则差分熄灭红点。- if (- getSessionAttentionKind(sessionId) === 'error' &&- !makerChatStore.hasSessionTerminalError(sessionId)- ) {+ if (getSessionAttentionKind(sessionId) !== 'error') {+ // 本 hook 点的那颗已被处置(关横幅、重试等):不再认领,之后别的来源点的红点不归它收。+ liveErrorMarkedRef.current.delete(sessionId);+ } else if (!makerChatStore.hasSessionTerminalError(sessionId)) {+ liveErrorMarkedRef.current.delete(sessionId);clearSessionAttention(sessionId, { intent: 'explicit' });}noteSessionTurnStartedForAlerts(sessionId);@@ -228,6 +235,7 @@ export function useSessionRunningStatus(// 横幅就在眼前时列表同样亮点(2026-07 统一决策)。不能沿用「活跃会话不亮」// 的 done 语义。清除只能来自用户处置横幅或 pending-alerts 派生收敛。addSessionAttention(sessionId, 'error');+ liveErrorMarkedRef.current.add(sessionId);if (!notificationOwnedByScheduler) onSessionErrorRef.current?.(sessionId);continue;}@@ -240,6 +248,19 @@ export function useSessionRunningStatus(// retry. That idle gap is not completion, even if it lasts beyond debounce.if (makerChatStore.hasSessionRecoveryPending(sessionId)) continue;+ // 这一轮正常结束、错误已不在,上一次失败的红点却还亮着:新一轮启动那一刻可能还读到旧错误+ // (撞上限后自动换电脑、额度恢复后自动继续时尤其如此),当时没收掉,之后就再没人收。本 hook+ // 自己点的直接收;派生账本(错误尾行 / 中断)重算一次,仍有未处置的告警会重新点亮。+ if (+ getSessionAttentionKind(sessionId) === 'error' &&+ !makerChatStore.hasSessionTerminalError(sessionId)+ ) {+ if (liveErrorMarkedRef.current.delete(sessionId)) {+ clearSessionAttention(sessionId, { intent: 'explicit' });+ }+ void refreshPendingAlerts();+ }+// 正常 done:走 debounce。QUEUE_DEBOUNCE_MS 内若同 session 又变 running// (main 自动衔接下一条队列),上面的 "--- 1. Detect new turn starts ---"// 分支会 clearTimeout 取消这次。窗口过完仍是 not-running,才认为队列真的diff --git a/apps/desktop/src/renderer/i18n/locales/en/common.json b/apps/desktop/src/renderer/i18n/locales/en/common.jsonindex ed7df3a280..a6868fb96d 100644--- a/apps/desktop/src/renderer/i18n/locales/en/common.json+++ b/apps/desktop/src/renderer/i18n/locales/en/common.json@@ -10589,7 +10589,8 @@},"autoResumePending": {"label": "Reconnecting",- "labelWithProgress": "Reconnecting {{attempt}}/{{total}}"+ "labelWithProgress": "Reconnecting {{attempt}}/{{total}}",+ "groupSwitch": "Switching to another computer"},"agentSwitch": {"label": "Switched from {{from}} to {{to}}",diff --git a/apps/desktop/src/renderer/i18n/locales/ja/common.json b/apps/desktop/src/renderer/i18n/locales/ja/common.jsonindex d13a6bbde1..974fbec36f 100644--- a/apps/desktop/src/renderer/i18n/locales/ja/common.json+++ b/apps/desktop/src/renderer/i18n/locales/ja/common.json@@ -10565,7 +10565,8 @@},"autoResumePending": {"label": "再接続中",- "labelWithProgress": "再接続中 {{attempt}}/{{total}}"+ "labelWithProgress": "再接続中 {{attempt}}/{{total}}",+ "groupSwitch": "別のパソコンに切り替え中"},"agentSwitch": {"label": "{{from}} から {{to}} に切り替えました",diff --git a/apps/desktop/src/renderer/i18n/locales/ko/common.json b/apps/desktop/src/renderer/i18n/locales/ko/common.jsonindex 254dcd93d6..e09be47837 100644--- a/apps/desktop/src/renderer/i18n/locales/ko/common.json+++ b/apps/desktop/src/renderer/i18n/locales/ko/common.json@@ -10565,7 +10565,8 @@},"autoResumePending": {"label": "다시 연결하는 중",- "labelWithProgress": "다시 연결하는 중 {{attempt}}/{{total}}"+ "labelWithProgress": "다시 연결하는 중 {{attempt}}/{{total}}",+ "groupSwitch": "다른 컴퓨터로 전환하는 중"},"agentSwitch": {"label": "{{from}}에서 {{to}}(으)로 전환됨",diff --git a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.jsonindex a0fe6a0b58..f6a9a325a5 100644--- a/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json+++ b/apps/desktop/src/renderer/i18n/locales/zh-CN/common.json@@ -10565,7 +10565,8 @@},"autoResumePending": {"label": "重新连接中",- "labelWithProgress": "重新连接中 {{attempt}}/{{total}}"+ "labelWithProgress": "重新连接中 {{attempt}}/{{total}}",+ "groupSwitch": "正在换一台电脑继续"},"agentSwitch": {"label": "已从 {{from}} 切换到 {{to}}",diff --git a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.jsonindex b155c55fae..61a27bae67 100644--- a/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json+++ b/apps/desktop/src/renderer/i18n/locales/zh-TW/common.json@@ -10564,7 +10564,8 @@},"autoResumePending": {"label": "重新連線中",- "labelWithProgress": "重新連線中 {{attempt}}/{{total}}"+ "labelWithProgress": "重新連線中 {{attempt}}/{{total}}",+ "groupSwitch": "正在換一台電腦繼續"},"agentSwitch": {"label": "已從 {{from}} 切換到 {{to}}",diff --git a/apps/desktop/src/renderer/lib/autoResumePresentation.ts b/apps/desktop/src/renderer/lib/autoResumePresentation.tsindex 9daf259d43..cf69d147db 100644--- a/apps/desktop/src/renderer/lib/autoResumePresentation.ts+++ b/apps/desktop/src/renderer/lib/autoResumePresentation.ts@@ -13,6 +13,8 @@ export interface AutoResumeCardInfo {agentSwitch?: AutoResumeAgentSwitch;/** 分享者的供应商组替分享的人换了一台电脑后继续(不知道是哪台,不显示电脑名称)。 */groupSwitch?: AutoResumeGroupSwitch;+ /** 进行中:供应商组正在为这次失败换电脑(错误先不呈现)。 */+ groupSwitchPending?: AutoResumeGroupSwitch;error?: string;attempt?: number;maxAttempts?: number;@@ -39,6 +41,9 @@ export function readAutoResumeInfo(data?: Record<string, unknown>): AutoResumeCa...(data?.reason === USAGE_LIMIT_RESET_AUTO_RESUME_REASON ? { usageLimitReset: true } : {}),...(readAgentSwitch(data?.agentSwitch) ? { agentSwitch: readAgentSwitch(data?.agentSwitch)! } : {}),...(readGroupSwitch(data?.groupSwitch) ? { groupSwitch: readGroupSwitch(data?.groupSwitch)! } : {}),+ ...(readGroupSwitch(data?.groupSwitchPending)+ ? { groupSwitchPending: readGroupSwitch(data?.groupSwitchPending)! }+ : {}),...(typeof data?.error === 'string' && data.error.length > 0 ? { error: data.error } : {}),...(num(data?.attempt) !== undefined ? { attempt: num(data?.attempt) } : {}),...(num(data?.maxAttempts) !== undefined ? { maxAttempts: num(data?.maxAttempts) } : {}),diff --git a/apps/desktop/src/renderer/lib/makerChatStore.ts b/apps/desktop/src/renderer/lib/makerChatStore.tsindex 83e261a388..99a9f7ec4f 100644--- a/apps/desktop/src/renderer/lib/makerChatStore.ts+++ b/apps/desktop/src/renderer/lib/makerChatStore.ts@@ -4593,6 +4593,15 @@ function hasMatchingAutoResumePendingError(messages: ChatMessage[], data: unknow);}+/** 进行中行是「供应商组正在换电脑」:这次失败先不呈现,不论哪种 Agent(provider-groups.md §6.1)。 */+function hasProviderGroupSwitchPendingCard(messages: ChatMessage[]): boolean {+ return messages.some(+ (item) =>+ item.clientId === AUTO_RESUME_PENDING_CLIENT_ID &&+ Boolean(item.systemCardData?.groupSwitchPending),+ );+}+function applyInputProjection(projection: AgentInputProjection,opts: { supersedeQueries?: boolean } = {},@@ -6447,8 +6456,8 @@ export function handleStreamEvent(const finalized = finalizeStreamingInState(state);const derivedRetryText = deriveErrorRetryText(finalized);const suppressAutoResumeBroadcastError =- event.source === 'codex' &&- !isCodexUserActionableRetryError(event.data) &&+ ((event.source === 'codex' && !isCodexUserActionableRetryError(event.data)) ||+ hasProviderGroupSwitchPendingCard(finalized.messages)) &&hasMatchingAutoResumePendingError(finalized.messages, event.data);// main coordinator 在终止型 error 时**先**同步 emit projection(errorRetryText// = projectionRetryText 的权威 retry token,active-turn 恢复恒非空)再 broadcastdiff --git a/apps/desktop/src/shared/agentInputQueue.ts b/apps/desktop/src/shared/agentInputQueue.tsindex 5e2cdf7472..90a501f8a0 100644--- a/apps/desktop/src/shared/agentInputQueue.ts+++ b/apps/desktop/src/shared/agentInputQueue.ts@@ -214,6 +214,12 @@ export interface AutoResumeInfo {* 电脑继续」,不出现电脑名称(docs/product-rules/provider-groups.md §8)。旧端忽略该字段。*/groupSwitch?: AutoResumeGroupSwitch;+ /**+ * 只出现在投影的进行中行:供应商组正在为这次失败换电脑,错误先不呈现,行内显示「正在换一台电脑继续」+ * (provider-groups.md §6.1)。此时 attempt / maxAttempts / sessionTotal 都是 0(不是重连,不显示次数);+ * 旧端忽略该字段,显示成「重新连接中」。+ */+ groupSwitchPending?: AutoResumeGroupSwitch;}export interface AutoResumeGroupSwitch {diff --git a/apps/mobile/src/__tests__/autoResumePresentation.test.ts b/apps/mobile/src/__tests__/autoResumePresentation.test.tsindex 3ef07fe6dd..c6835e73fb 100644--- a/apps/mobile/src/__tests__/autoResumePresentation.test.ts+++ b/apps/mobile/src/__tests__/autoResumePresentation.test.ts@@ -34,6 +34,23 @@ describe('autoResumePresentation', () => {expect(isMobileAutoResumeRowInFlight({ ...args, projectionCapability: 'unknown' })).toBe(false);});+ it('shows a provider group switch as live without the held error or attempt counts', () => {+ const presentation = getMobileAutoResumePresentation({+ error: "You've hit your session limit",+ attempt: 0,+ maxAttempts: 0,+ sessionTotal: 0,+ groupSwitchPending: { cause: 'usage-limit' },+ live: true,+ });+ expect(presentation.state).toBe('live');+ expect(presentation.info.groupSwitchPending).toEqual({ cause: 'usage-limit' });+ expect(presentation.info.error).toBeUndefined();+ expect(presentation.summary).toBeUndefined();+ expect(presentation.hasProgress).toBe(false);+ expect(presentation.canExpand).toBe(false);+ });+it('lets terminal outcomes win over a stale in-flight signal', () => {expect(getMobileAutoResumePresentation({ ...info, outcome: 'succeeded' }, true).state).toBe('succeeded');expect(getMobileAutoResumePresentation({ ...info, outcome: 'failed' }, true).state).toBe('failed');diff --git a/apps/mobile/src/i18n/locales/en/message.json b/apps/mobile/src/i18n/locales/en/message.jsonindex 30352ae10d..91623593c7 100644--- a/apps/mobile/src/i18n/locales/en/message.json+++ b/apps/mobile/src/i18n/locales/en/message.json@@ -260,6 +260,7 @@"usageReset": "Usage reset, continued automatically","pending": "Reconnecting…","pendingWithProgress": "Reconnecting {{attempt}}/{{total}}…",+ "groupSwitchPending": "Switching to another computer…","details": "Attempt {{attempt}}/{{total}} · {{count}} reconnects in this session","detail": {"reason": "Interruption reason",diff --git a/apps/mobile/src/i18n/locales/ja/message.json b/apps/mobile/src/i18n/locales/ja/message.jsonindex fe2fc57354..fd473b8c29 100644--- a/apps/mobile/src/i18n/locales/ja/message.json+++ b/apps/mobile/src/i18n/locales/ja/message.json@@ -260,6 +260,7 @@"usageReset": "使用量が回復したため自動で続行しました","pending": "再接続中…","pendingWithProgress": "再接続中 {{attempt}}/{{total}}…",+ "groupSwitchPending": "別のパソコンに切り替え中…","details": "今回の再試行 {{attempt}}/{{total}} · このセッションでの再接続 {{count}} 回","detail": {"reason": "中断の理由",diff --git a/apps/mobile/src/i18n/locales/ko/message.json b/apps/mobile/src/i18n/locales/ko/message.jsonindex 4f03797bf2..b70464ce92 100644--- a/apps/mobile/src/i18n/locales/ko/message.json+++ b/apps/mobile/src/i18n/locales/ko/message.json@@ -260,6 +260,7 @@"usageReset": "사용량이 복구되어 자동으로 계속했습니다","pending": "다시 연결하는 중…","pendingWithProgress": "다시 연결하는 중 {{attempt}}/{{total}}…",+ "groupSwitchPending": "다른 컴퓨터로 전환하는 중…","details": "이번 재시도 {{attempt}}/{{total}} · 이 세션에서 재연결 {{count}}회","detail": {"reason": "중단 원인",diff --git a/apps/mobile/src/i18n/locales/zh-CN/message.json b/apps/mobile/src/i18n/locales/zh-CN/message.jsonindex bd6dd19bb8..37389b501e 100644--- a/apps/mobile/src/i18n/locales/zh-CN/message.json+++ b/apps/mobile/src/i18n/locales/zh-CN/message.json@@ -260,6 +260,7 @@"usageReset": "用量已恢复,已自动继续","pending": "重新连接中…","pendingWithProgress": "重新连接中 {{attempt}}/{{total}}…",+ "groupSwitchPending": "正在换一台电脑继续…","details": "本次重试 {{attempt}}/{{total}} · 本任务累计重连 {{count}} 次","detail": {"reason": "中断原因",diff --git a/apps/mobile/src/i18n/locales/zh-TW/message.json b/apps/mobile/src/i18n/locales/zh-TW/message.jsonindex 6fbb9abd27..22b93ee13c 100644--- a/apps/mobile/src/i18n/locales/zh-TW/message.json+++ b/apps/mobile/src/i18n/locales/zh-TW/message.json@@ -260,6 +260,7 @@"usageReset": "用量已恢復,已自動繼續","pending": "重新連線中…","pendingWithProgress": "重新連線中 {{attempt}}/{{total}}…",+ "groupSwitchPending": "正在換一台電腦繼續…","details": "本次重試 {{attempt}}/{{total}} · 本任務累計重連 {{count}} 次","detail": {"reason": "中斷原因",diff --git a/apps/mobile/src/session/MessageRenderer.tsx b/apps/mobile/src/session/MessageRenderer.tsxindex d06d54f97c..5de7204565 100644--- a/apps/mobile/src/session/MessageRenderer.tsx+++ b/apps/mobile/src/session/MessageRenderer.tsx@@ -5323,7 +5323,9 @@ function MobileAutoResumeActionRow({);}- const label = info.agentSwitch+ const label = info.groupSwitchPending+ ? t('message.systemCard.autoResume.groupSwitchPending')+ : info.agentSwitch? t(`message.systemCard.autoResume.agentSwitch.${info.agentSwitch.cause}`, {from: info.agentSwitch.from,to: info.agentSwitch.to,diff --git a/apps/mobile/src/session/autoResumePresentation.ts b/apps/mobile/src/session/autoResumePresentation.tsindex 72c8852881..545ea4a485 100644--- a/apps/mobile/src/session/autoResumePresentation.ts+++ b/apps/mobile/src/session/autoResumePresentation.ts@@ -41,6 +41,8 @@ export interface MobileAutoResumeInfo {agentSwitch?: MobileAutoResumeAgentSwitch;/** 分享的人这边的自动换电脑:活动行写「已自动换一台电脑继续」。 */groupSwitch?: MobileAutoResumeGroupSwitch;+ /** 进行中:供应商组正在为这次失败换电脑,错误先不呈现,写「正在换一台电脑继续」。 */+ groupSwitchPending?: MobileAutoResumeGroupSwitch;error?: string;attempt?: number;maxAttempts?: number;@@ -67,11 +69,16 @@ export function readMobileAutoResumeInfo(data?: Record<string, unknown>): Mobileconst sessionTotal = usageLimitReset ? undefined : number(data?.sessionTotal);const agentSwitch = readAgentSwitch(data?.agentSwitch);const groupSwitch = readGroupSwitch(data?.groupSwitch);+ const groupSwitchPending = readGroupSwitch(data?.groupSwitchPending);return {...(usageLimitReset ? { usageLimitReset: true } : {}),...(agentSwitch ? { agentSwitch } : {}),...(groupSwitch ? { groupSwitch } : {}),- ...(typeof data?.error === 'string' && data.error.trim() ? { error: data.error } : {}),+ ...(groupSwitchPending ? { groupSwitchPending } : {}),+ // 正在换电脑时错误先不呈现:行内不带原始错误。+ ...(!groupSwitchPending && typeof data?.error === 'string' && data.error.trim()+ ? { error: data.error }+ : {}),...(attempt !== undefined ? { attempt } : {}),...(maxAttempts !== undefined ? { maxAttempts } : {}),...(sessionTotal !== undefined ? { sessionTotal } : {}),diff --git a/apps/mobile/src/session/systemCard.ts b/apps/mobile/src/session/systemCard.tsindex 72b6ef29f6..c2708bb340 100644--- a/apps/mobile/src/session/systemCard.ts+++ b/apps/mobile/src/session/systemCard.ts@@ -183,14 +183,18 @@ function formatAutoResumeCard(data: Record<string, unknown> | undefined): Systemconst outcome = data?.outcome === 'succeeded' || data?.outcome === 'failed' ? data.outcome : undefined;const hasInterruptionContext = !!(data?.live === true || error || attempt || maxAttempts || sessionTotal || outcome);if (!hasInterruptionContext) return { title: i18n.t('message.systemCard.autoResume.separator'), rows: [] };+ // 供应商组正在换电脑:错误先不呈现,只写「正在换一台电脑继续」。+ const groupSwitchPending = data?.live === true && !!data.groupSwitchPending && typeof data.groupSwitchPending === 'object';const title = data?.live === true- ? attempt && maxAttempts+ ? groupSwitchPending+ ? i18n.t('message.systemCard.autoResume.groupSwitchPending')+ : attempt && maxAttempts? i18n.t('message.systemCard.autoResume.pendingWithProgress', { attempt, total: maxAttempts }): i18n.t('message.systemCard.autoResume.pending'): i18n.t(`message.systemCard.autoResume.${outcome ?? 'neutral'}`);const subtitle = attempt && maxAttempts && sessionTotal? i18n.t('message.systemCard.autoResume.details', { attempt, total: maxAttempts, count: sessionTotal }) : undefined;- return { title, ...(error ? { body: error } : {}), subtitle, rows: [] };+ return { title, ...(error && !groupSwitchPending ? { body: error } : {}), subtitle, rows: [] };}type AgentSwitchTranslate = (key: string, options?: Record<string, unknown>) => string;diff --git a/docs/dev-rules/protocol-compatibility.md b/docs/dev-rules/protocol-compatibility.mdindex ccf07fe020..90eed9a64b 100644--- a/docs/dev-rules/protocol-compatibility.md+++ b/docs/dev-rules/protocol-compatibility.md@@ -107,6 +107,12 @@ Claude Code 终态 error 事件可带 `usageResetAt`(unix ms)。服务端无不合法时照常显示 `usage-limit-reset` 的文案,旧客户端忽略该字段。P1 不改远程 Agent 协议:被分配到别的电脑的任务就是普通的远程 Agent 任务。分享的人这边的自动换电脑(P2c,2026-10-10)另加可选字段 `groupSwitch: { cause }`(不带电脑名称),Desktop 与 Mobile 显示「已自动换一台电脑继续」;旧客户端忽略,显示「用量已恢复,已自动继续」。+换电脑期间不报错(2026-10-10):被控端判断供应商组会先试着换电脑时,输入投影里先不带这次 `error`(也不带+`usageLimitWait`),改带 `autoResumePending`,其中新增可选字段 `groupSwitchPending: { cause }`,次数字段为 0、+`error` 只用于控制端认出随后的终态 event 是同一次失败的回声;新 Desktop 与 Mobile 据此显示「正在换一台电脑继续」,+并且不论哪种 Agent 都不再用这次终态 event 点亮横幅。换成了投影直接进入续跑;没换成投影恢复带 `error`。旧客户端忽略该+字段,按普通「重新连接中」显示(不带次数);旧 Desktop 控制端对 Claude Code / Pi 仍会被终态 event 短暂点亮横幅,+下一份投影即收回。只改投影内容,不新增 invoke 或推送通道,服务端无需改动。## Agent 跨设备历史发现与搜索diff --git a/docs/product-rules/provider-groups.md b/docs/product-rules/provider-groups.mdindex ed74b481f3..20624e7b9a 100644--- a/docs/product-rules/provider-groups.md+++ b/docs/product-rules/provider-groups.md@@ -6,6 +6,8 @@> 2026-10-10 用户确认:分享来的组内电脑按**本账号在那台实际跑着的任务数**统计(含不经组直接用的),见 §5。> 2026-10-10 用户确认:建组的电脑要看到组里每台在跑几个任务;本机与同账号电脑按**那台这个供应商实际在跑的任务总数**> 统计(含自己用的、不经组的与替分享的人跑的),见 §5。+> 2026-10-10 用户确认:**换电脑期间不报错**——组里还能换时不出错误卡、红色横幅与红点,只显示「正在换一台电脑继续」;+> 组里都不能用才报错,见 §6.1。> 实现进度见 §12:P1 已实现;P2 全部已实现:同账号直连与模型列表只显示组(P2a)、分享的人经组中转与启动阶段换电脑(P2b)、> 分享的人运行中换电脑与申请弹窗新说法(P2c);P3 未实现。> 交互设计稿见 [`docs/design-previews/provider-groups/index.html`](../design-previews/provider-groups/index.html)。@@ -176,6 +178,13 @@下一台:新建会话并带上交接上下文,然后继续这一轮——这一轮还没有产出就重发原消息,已经有产出就发续跑指令,与 [用量上限自动继续](usage-limit-auto-continue.md) 的续跑口径一致。消息流里显示一行活动记录「{原电脑} {原因},已换到 {新电脑} 继续」(受邀者那边写「已自动换一台电脑继续」,§8),不计为用户发送。+ - **换电脑期间不报错**(2026-10-10):这次失败会先试着换电脑时(已归组、自动换电脑开着、组里还有别的电脑;+ 受邀者那边是收到了「需要换一台」凭证),失败那一刻就不呈现:没有红色横幅、不写错误卡、不亮红点、Agent Island 不提醒,+ 消息流末尾只有一行「正在换一台电脑继续」,输入框上方的状态同样这样写。换成了,历史里只留上面那行换电脑的活动记录+ (原因在展开详情里);没换成(组里都不能用、交接失败、自动换电脑关着等),这时才补上错误卡与横幅,交回原有的报错与+ 额度重置后自动继续。换电脑途中用户亲自接手时,错误卡照常补进历史(按出错的时刻排在用户新消息之前),但不再弹横幅。+ 换电脑久久没有结局(3 分钟)时先把错误放出来,之后换成了照常续跑。出错时才纳入组的老任务(§6)判断不到,仍会先报错再换。+ 少见的时序例外:错误早于这一轮的用户消息落库完成到达时,错误卡与红点在判断之前已经出现,换电脑期间只是不再挂横幅。- 换过去之后任务固定在新电脑上,原电脑恢复后也不换回去(每换一次都要重新交接)。- **何时停止**:同一轮里每台组内电脑最多试一次;全部试过仍失败才报错,并提供换模型。其中有电脑是撞到用量上限的,按 [用量上限自动继续](usage-limit-auto-continue.md) 等恢复后自动继续