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。

fix(sessions): address review on activity ordering

fmfsaisai810c80fc49ec
diff --git a/apps/desktop/src/main/goal-host/__tests__/controller.test.ts b/apps/desktop/src/main/goal-host/__tests__/controller.test.ts
index 068d1d7f0b..9f638399d7 100644
--- a/apps/desktop/src/main/goal-host/__tests__/controller.test.ts
+++ b/apps/desktop/src/main/goal-host/__tests__/controller.test.ts
@@ -308,11 +308,13 @@ class FakeSession implements SessionLike {
async send(
message: { type: 'user'; content: string } | string,
- opts?: { origin?: { kind?: string }; onDispatching?: () => void; signal?: AbortSignal },
+ opts?: { origin?: { kind?: string }; onDispatching?: () => void; onAccepted?: () => void | Promise<void>; signal?: AbortSignal },
): Promise<SessionSendResult> {
const content = typeof message === 'string' ? message : message.content;
this.sends.push({ content, originKind: opts?.origin?.kind });
opts?.onDispatching?.();
+ const accepted = opts?.onAccepted?.();
+ if (accepted) await accepted;
return { accepted: true };
}
@@ -413,6 +415,7 @@ function makeController(depOverrides: Partial<GoalControllerDeps> = {}) {
const notices: Array<{ sessionId: string; kind: string }> = [];
const userMessages: Array<{ sessionId: string; content: string; updated?: boolean }> = [];
const stopped = vi.fn();
+ const userDispatched = vi.fn();
// 可变:测试按需设置"账号是否受限 + resetAt"。
let accountLimit: AccountLimitInfo | null = null;
// 可变:模拟"会话已关闭 / 此刻 hydrate 不出来"(ensureSession 返回 undefined)。
@@ -425,6 +428,7 @@ function makeController(depOverrides: Partial<GoalControllerDeps> = {}) {
stopActiveGoalTurn: () => {},
emitStatus: (u) => updates.push(u),
onGoalStopped: stopped,
+ onGoalUserDispatched: userDispatched,
getDefaults: () => ({ ...DEFAULT_LIMITS }),
persistGoalSettingsOverride: (l) => persistedLimits.push(l),
logger: { info: () => {}, warn: () => {}, error: () => {} },
@@ -453,6 +457,7 @@ function makeController(depOverrides: Partial<GoalControllerDeps> = {}) {
notices,
userMessages,
stopped,
+ userDispatched,
setAccountLimit: (v: AccountLimitInfo | null) => {
accountLimit = v;
},
@@ -504,6 +509,21 @@ describe('GoalController', () => {
expect(h.stopped).toHaveBeenCalledTimes(1);
});
+ it('reports accepted manual starts and resumes, but not intermediate goal rounds', async () => {
+ try {
+ await startGoal(h);
+ expect(h.userDispatched).toHaveBeenCalledExactlyOnceWith('s1', 1000);
+ h.session.emitGoalTurn({ toolUse: true, verdictJson: '```json\n{"goal_status":"continue","reason":"wip"}\n```' });
+ await tick();
+ expect(h.session.sends).toHaveLength(2);
+ expect(h.userDispatched).toHaveBeenCalledTimes(1);
+ await h.controller.pauseGoal('s1');
+ await h.controller.resumeGoal('s1');
+ expect(h.session.sends).toHaveLength(3);
+ expect(h.userDispatched).toHaveBeenCalledTimes(2);
+ } finally { await h.controller.dispose(); }
+ });
+
// ── setGoal / updateGoal ──
it('blocks an unconfirmed dispatch without retrying duplicate Goal work', async () => {
const local = makeController();
@@ -518,6 +538,7 @@ describe('GoalController', () => {
await local.controller.setGoal({ sessionId: 's1', objective: 'finish the work' });
expect(local.session.send).toHaveBeenCalledTimes(1);
+ expect(local.userDispatched).not.toHaveBeenCalled();
expect(await local.storage.get('s1')).toMatchObject({
status: 'blocked',
turnsUsed: 0,
@@ -4618,6 +4639,7 @@ describe('GoalController', () => {
});
releaseEnsure();
await resumed;
+ expect(local.userDispatched).toHaveBeenCalledExactlyOnceWith('s1', 1000);
} finally {
releaseEnsure();
await local.controller.dispose();
diff --git a/apps/desktop/src/main/goal-host/controller.ts b/apps/desktop/src/main/goal-host/controller.ts
index b64a6a51ca..e22ae81c79 100644
--- a/apps/desktop/src/main/goal-host/controller.ts
+++ b/apps/desktop/src/main/goal-host/controller.ts
@@ -349,6 +349,7 @@ export function decideNextGoalState(prev: GoalCounters, outcome: TurnOutcome): G
// ── 每轮事件累计状态 ─────────────────────────────────────────────────────────
interface TurnAccumulator {
+ userDispatchPending: boolean;
/** 创建目标之前已在运行的轮次;只保存在本生命周期内,不计入目标裁决。 */
precedingTurn: { session: SessionLike; generation: number } | null;
text: string;
@@ -374,6 +375,7 @@ function freshTurn(
pendingCompletion: Promise<void> | null = null,
): TurnAccumulator {
return {
+ userDispatchPending: false,
precedingTurn: null,
text: '',
sawToolUse: false,
@@ -630,6 +632,7 @@ export class GoalController {
previousBoundary?.pendingPersistence ?? null,
previousBoundary?.pendingCompletion ?? null,
);
+ editBoundary.userDispatchPending = true;
this.turns.set(sessionId, editBoundary);
let editObjectivePersisted = false;
let updatedState: GoalState | null = null;
@@ -705,6 +708,7 @@ export class GoalController {
previousBoundary?.pendingPersistence ?? null,
previousBoundary?.pendingCompletion ?? null,
);
+ createBoundary.userDispatchPending = true;
createBoundary.precedingTurn = previousBoundary?.precedingTurn ?? null;
this.turns.set(sessionId, createBoundary);
let createdState: GoalState | null = null;
@@ -1341,6 +1345,7 @@ export class GoalController {
lookupBoundary.pendingPersistence,
lookupBoundary.pendingCompletion,
);
+ resumedBoundary.userDispatchPending = !opts?.auto;
this.turns.set(sessionId, resumedBoundary);
this.attachListener(sessionId);
this.emit(updated);
@@ -2544,11 +2549,18 @@ export class GoalController {
const outgoing = pendingHandoff
? prependHandoffToUserMessage({ type: 'user', content }, pendingHandoff)
: { type: 'user' as const, content };
+ const userDispatchAt = this.now();
+ const noteUserDispatched = () => {
+ if (!dispatchBoundary?.userDispatchPending) return;
+ dispatchBoundary.userDispatchPending = false;
+ this.deps.onGoalUserDispatched?.(sessionId, userDispatchAt);
+ };
const result = await session.send(
outgoing as { type: 'user'; content: string },
{
origin: { kind: 'goal', goalSessionId: sessionId },
planMode: false,
+ onAccepted: noteUserDispatched,
// Session.send 只在 vendor dispatch 前的最后一个同步边界调用它。不能等
// send Promise 返回后才登记:派发调用尚未返回时用户点清除,clearGoal 必须
// 已经知道这个 turn 属于目标模式,才能立即走 Stop 边界。
@@ -2565,6 +2577,7 @@ export class GoalController {
signal: dispatchAbortController.signal,
},
);
+ if (result.accepted) noteUserDispatched();
if (pendingHandoff && result.accepted) {
agentHandoffPending.consume(sessionId);
}
diff --git a/apps/desktop/src/main/goal-host/index.ts b/apps/desktop/src/main/goal-host/index.ts
index 6185c0dda2..5d86939362 100644
--- a/apps/desktop/src/main/goal-host/index.ts
+++ b/apps/desktop/src/main/goal-host/index.ts
@@ -78,6 +78,7 @@ export function startGoalController(deps: StartGoalControllerDeps): GoalControll
onUndispatchedUserTurn: deps.onUndispatchedUserTurn,
emitStatus: deps.broadcastStatus,
onGoalStopped: (sessionId, atMs) => { void touchSessionActivityInDb(sessionId, atMs); },
+ onGoalUserDispatched: (sessionId, atMs) => { void touchSessionActivityInDb(sessionId, atMs); },
// 护栏默认从 goal-settings-store 读(系统默认 + 用户 override,规则 20);新建 goal
// 时直接采用最新默认值。
getDefaults: () => readGoalSettings(),
diff --git a/apps/desktop/src/main/goal-host/types.ts b/apps/desktop/src/main/goal-host/types.ts
index 96d2516147..ae304ffd3a 100644
--- a/apps/desktop/src/main/goal-host/types.ts
+++ b/apps/desktop/src/main/goal-host/types.ts
@@ -200,6 +200,7 @@ export interface GoalControllerDeps {
/** 状态变化广播到 renderer(→ GOAL_STATUS_CHANGED);goal=null 表示已清除。 */
emitStatus(update: GoalStatusUpdate): void;
onGoalStopped?: (sessionId: string, atMs: number) => void;
+ onGoalUserDispatched?: (sessionId: string, atMs: number) => void;
/**
* 读当前"系统默认 + 用户 override"合并后的护栏默认(来自 goal-settings-store)。
* 新建 goal 时读取最新值(规则 20)。
diff --git a/apps/desktop/src/main/localDb/ipc/__tests__/sessionsUpdate.test.ts b/apps/desktop/src/main/localDb/ipc/__tests__/sessionsUpdate.test.ts
index 3d608985bf..5ad8cea17c 100644
--- a/apps/desktop/src/main/localDb/ipc/__tests__/sessionsUpdate.test.ts
+++ b/apps/desktop/src/main/localDb/ipc/__tests__/sessionsUpdate.test.ts
@@ -1067,15 +1067,18 @@ describe('local-db:sessions:update handler wiring', () => {
);
});
- it('persists handoffs monotonically without changing the last human send or metadata clock', async () => {
- const before = h.sqlite!.prepare('SELECT user_send_at, updated_at FROM sessions WHERE id = ?').get('codex-local');
+ it('advances the bounded-list clock monotonically on handoffs without changing the last human send', async () => {
+ const before = h.sqlite!.prepare('SELECT user_send_at FROM sessions WHERE id = ?').get('codex-local');
await touchSessionActivityInDb('codex-local', 1_786_500_050_000);
await touchSessionActivityInDb('codex-local', 1_786_500_040_000);
- expect(h.sqlite!.prepare('SELECT user_send_at, updated_at FROM sessions WHERE id = ?').get('codex-local')).toEqual(before);
- expect(h.sqlite!.prepare('SELECT last_activity_at FROM sessions WHERE id = ?').get('codex-local'))
- .toEqual({ last_activity_at: 1_786_500_050_000 });
+ expect(h.sqlite!.prepare('SELECT user_send_at FROM sessions WHERE id = ?').get('codex-local')).toEqual(before);
+ expect(h.sqlite!.prepare('SELECT last_activity_at, updated_at FROM sessions WHERE id = ?').get('codex-local'))
+ .toEqual({ last_activity_at: 1_786_500_050_000, updated_at: 1_786_500_050_000 });
expect(h.tapWindowBroadcast).toHaveBeenCalledWith('local-db:sessions:patched', expect.objectContaining({
- sessionId: 'codex-local', patch: { lastActivityAt: new Date(1_786_500_050_000).toISOString() },
+ sessionId: 'codex-local', patch: {
+ lastActivityAt: new Date(1_786_500_050_000).toISOString(),
+ updatedAt: new Date(1_786_500_050_000).toISOString(),
+ },
}));
await invokeUpdate('codex-local', { title: 'Renamed', status: 'archived' });
markSessionTurnEnded('codex-local');
diff --git a/apps/desktop/src/main/localDb/ipc/sessions.ts b/apps/desktop/src/main/localDb/ipc/sessions.ts
index f4f235bac0..1962819ca7 100644
--- a/apps/desktop/src/main/localDb/ipc/sessions.ts
+++ b/apps/desktop/src/main/localDb/ipc/sessions.ts
@@ -1150,7 +1150,10 @@ export async function touchSessionActivityInDb(
try {
const db = getDbClient().drizzle;
const updated = await db.update(sessions)
- .set({ lastActivityAt: sql`MAX(COALESCE(${sessions.lastActivityAt}, 0), ${atMs})` })
+ .set({
+ lastActivityAt: sql`MAX(COALESCE(${sessions.lastActivityAt}, 0), ${atMs})`,
+ updatedAt: sql`MAX(COALESCE(${sessions.updatedAt}, 0), ${atMs})`,
+ })
.where(and(
eq(sessions.id, id),
sql`COALESCE(${sessions.lastActivityAt}, 0) < ${atMs}`,
@@ -1158,10 +1161,11 @@ export async function touchSessionActivityInDb(
? sql`NOT EXISTS (SELECT 1 FROM session_goals WHERE session_id = ${id} AND status = 'active')`
: undefined,
))
- .returning({ lastActivityAt: sessions.lastActivityAt });
+ .returning({ lastActivityAt: sessions.lastActivityAt, updatedAt: sessions.updatedAt });
if (updated[0]?.lastActivityAt != null && isOwnerScopeCurrent(ownerScope)) {
broadcastSessionPatched(id, {
lastActivityAt: new Date(updated[0].lastActivityAt).toISOString(),
+ updatedAt: new Date(updated[0].updatedAt).toISOString(),
}, ownerScope);
}
} catch (error) {
diff --git a/apps/desktop/src/main/maker-ipc/__tests__/sessionEventPipeline.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/sessionEventPipeline.test.ts
index a19e7c572b..0fec530b8d 100644
--- a/apps/desktop/src/main/maker-ipc/__tests__/sessionEventPipeline.test.ts
+++ b/apps/desktop/src/main/maker-ipc/__tests__/sessionEventPipeline.test.ts
@@ -9,7 +9,7 @@ import { setMainLocale } from '../../i18n.js';
import { installSessionTurnObserver } from '../sessionTurnObserver.js';
import { onChannelTurn } from '../channelTurnSignal.js';
import { createSessionBindingLifecycle } from '../sessionBindingLifecycle.js';
-import { SessionTurnActivityTracker } from '../sessionTurnActivityTracker.js';
+import { SessionListActivityTracker, SessionTurnActivityTracker } from '../sessionTurnActivityTracker.js';
import { ProductTurnWallClockTracker, ProductTurnUsageTargetTracker } from '../turnWallClock.js';
import { ClaudeOutputLagTimingGuard } from '../../usage/modelUsageDelta.js';
import { createWorkerTurnStartSequencer } from '../workerTurnStartSequencer.js';
@@ -264,6 +264,7 @@ function harness() {
turnStallMs: 0,
});
const activity = new SessionTurnActivityTracker();
+ const listActivity = new SessionListActivityTracker(effects.fn('list-activity'));
const deps = {
onPluginTaskTerminal: vi.fn(),
onSuccessfulProductTurn: vi.fn(async () => {}),
@@ -302,6 +303,7 @@ function harness() {
pendingFailedTurnAssistantPersistId: new Map<string, string>(),
silentStopAutoResumeGuard: { noteTurnStarted: vi.fn() },
sessionTurnActivityTracker: activity,
+ sessionListActivityTracker: listActivity,
productTurnWallClockTracker: new ProductTurnWallClockTracker(),
productTurnUsageTargetTracker: new ProductTurnUsageTargetTracker(),
advanceSessionTurnBoundaryGeneration: vi.fn(() => 1),
@@ -378,6 +380,7 @@ function harness() {
emit,
dispose: async () => {
activity.deleteSession('task');
+ listActivity.deleteSession('task');
await session.close();
},
};
@@ -426,6 +429,75 @@ function ordered(...names: string[]) {
}
describe('production Session event pipeline', () => {
+ it.each([false, true])('records a paired terminal once at the first signal (done first: %s)', async doneFirst => {
+ const current = harness();
+ try {
+ current.emit(event('status', { isRunning: true }));
+ vi.setSystemTime(10_000);
+ current.emit(doneFirst ? event('done') : event('status', { isRunning: false }));
+ await microtasks();
+ vi.setSystemTime(10_100);
+ current.emit(doneFirst ? event('status', { isRunning: false }) : event('done'));
+ await vi.advanceTimersByTimeAsync(0);
+ expect(current.deps.noteSessionListActivity).toHaveBeenCalledExactlyOnceWith('task', 10_000);
+ } finally { await current.dispose(); }
+ });
+
+ it.each([false, true])('settles silent-stop activity only after the continuation decision (resume: %s)', async continued => {
+ const current = harness();
+ current.deps.handleSilentStopTurnEnd.mockImplementation(async () => {
+ if (continued) current.deps.sessionListActivityTracker.captureContinuation('task')();
+ else current.deps.sessionListActivityTracker.commit('task');
+ });
+ try {
+ current.emit(event('status', { isRunning: true }));
+ vi.setSystemTime(20_000);
+ current.emit(event('status', { isRunning: false }));
+ await microtasks();
+ vi.setSystemTime(20_100);
+ current.emit(event('done', { silentStop: true }, { source: 'claude-code' }));
+ await vi.advanceTimersByTimeAsync(0);
+ expect(current.deps.noteSessionListActivity).not.toHaveBeenCalled();
+ await vi.advanceTimersByTimeAsync(1_500);
+ if (continued) {
+ expect(current.deps.noteSessionListActivity).not.toHaveBeenCalled();
+ current.emit(event('status', { isRunning: true }));
+ current.emit(event('done'));
+ expect(current.deps.noteSessionListActivity).toHaveBeenCalledExactlyOnceWith('task', 21_600);
+ } else {
+ expect(current.deps.noteSessionListActivity).toHaveBeenCalledExactlyOnceWith('task', 20_000);
+ }
+ } finally { await current.dispose(); }
+ });
+
+ it('distinguishes a new generation that terminates without a running status', async () => {
+ const current = harness();
+ try {
+ current.emit(event('done', {}, { sessionTurnGeneration: 1 }));
+ current.emit(event('done', {}, { sessionTurnGeneration: 1 }));
+ expect(current.deps.noteSessionListActivity).toHaveBeenCalledTimes(1);
+ current.emit(event('error', {}, { sessionTurnGeneration: 2 }));
+ expect(current.deps.noteSessionListActivity).toHaveBeenCalledTimes(2);
+ } finally { await current.dispose(); }
+ });
+
+ it('commits a status-only stop once and cancels its fallback when the runtime closes', async () => {
+ const current = harness();
+ try {
+ current.emit(event('status', { isRunning: true }));
+ vi.setSystemTime(30_000);
+ current.emit(event('status', { isRunning: false }));
+ await vi.advanceTimersByTimeAsync(0);
+ current.emit(event('status', { isRunning: false }));
+ expect(current.deps.noteSessionListActivity).toHaveBeenCalledExactlyOnceWith('task', 30_000);
+ current.emit(event('status', { isRunning: true }));
+ current.emit(event('status', { isRunning: false }));
+ await current.dispose();
+ await vi.advanceTimersByTimeAsync(0);
+ expect(current.deps.noteSessionListActivity).toHaveBeenCalledTimes(1);
+ } finally { await current.dispose(); }
+ });
+
it('ignores idle status without a turn and an interrupted turn reserved for automatic continuation', async () => {
const current = harness();
try {
@@ -446,7 +518,8 @@ describe('production Session event pipeline', () => {
expect(current.deps.noteSessionListActivity).not.toHaveBeenCalled();
current.emit(event(terminal, terminal === 'status' ? { isRunning: false } : {}));
await microtasks();
- expect(current.deps.noteSessionListActivity).toHaveBeenCalledWith('task');
+ await vi.advanceTimersByTimeAsync(0);
+ expect(current.deps.noteSessionListActivity).toHaveBeenCalledWith('task', expect.any(Number));
current.deps.noteSessionListActivity.mockClear();
current.emit(event('status', { isRunning: true }, { turnOrigin: { kind: 'goal' } }));
current.emit(event(terminal, terminal === 'status' ? { isRunning: false } : {}, { turnOrigin: { kind: 'goal' } }));
diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.ts
index 0e2e6e8e75..575596dc6c 100644
--- a/apps/desktop/src/main/maker-ipc/register.ts
+++ b/apps/desktop/src/main/maker-ipc/register.ts
@@ -1364,6 +1364,7 @@ import {
isSessionTurnDispatchBoundaryBusy,
isTerminalTurnErrorEvent,
SessionTurnActivityTracker,
+ SessionListActivityTracker,
} from './sessionTurnActivityTracker.js';
import { SilentStopTurnLeaseGate, SessionTurnLeaseTracker } from './sessionTurnLease.js';
import { ProductTurnUsageTargetTracker, ProductTurnWallClockTracker } from './turnWallClock.js';
@@ -1998,6 +1999,7 @@ function settleDeferredProductTurnFailure(sessionId: string): void {
sessionId,
isCurrentProductTurnFailureOwner,
(owner) => {
+ sessionListActivityTracker.commit(sessionId);
void interruptProductTurn(sessionId, owner).catch(() =>
log.warn('Could not interrupt product turn follow-up'));
},
@@ -4606,6 +4608,9 @@ function resolveSwitchedSessionVendorOptions(sessionId: string): Record<string,
}
let gitSnapshotCoordinator: GitSnapshotCoordinator | null = null;
const sessionTurnActivityTracker = new SessionTurnActivityTracker();
+const sessionListActivityTracker = new SessionListActivityTracker((sessionId, atMs) => {
+ void touchSessionActivityInDb(sessionId, atMs, true);
+});
let providerGroupLeaseReporter: ProviderGroupLeaseReporter | null = null;
const reviewRunOwner: ReviewRunOwner = { instanceId: randomUUID(), processId: process.pid };
const sessionTurnLeaseTracker = new SessionTurnLeaseTracker({
@@ -5687,6 +5692,7 @@ async function settleSilentStopDone(
return;
}
void finalizeTurnChangeSet(sessionId, null, 'complete');
+ sessionListActivityTracker.commit(sessionId);
productTurnWallClockTracker.clear(sessionId);
productTurnUsageTargetTracker.clear(sessionId);
sessionTurnActivityTracker.scheduleIdleAfterTerminalBroadcast(sessionId);
@@ -5763,6 +5769,7 @@ async function handleSilentStopTurnEnd(
}
const decision = silentStopAutoResumeGuard.onSilentStop(session.id, doneAt);
if (decision.action === 'resume') {
+ const discardEndedActivity = sessionListActivityTracker.captureContinuation(session.id);
// 续跑绕过 send 事务:generation 的绑定/失败回滚接线集中在 binding 对象
// (bindSilentStopContinuationGeneration,见该文件头)。漏掉任一半边会让
// 协调器残留的 activeTurn 与续跑的真实 done 永久失配,输入边界卡在忙
@@ -5790,6 +5797,7 @@ async function handleSilentStopTurnEnd(
// silentStopContinuationBinding.ts 文件头。
...binding.sendOpts,
onAccepted: async () => {
+ discardEndedActivity();
await createDbMessage(session.id, {
clientId,
role: 'user',
@@ -5971,6 +5979,7 @@ const sessionBindings = createSessionBindingLifecycle<WiredSession, WiredSession
finalizeSessionClose(context.closedDirectAbortBoundary !== null, {
clearTurnState: () => {
sessionTurnActivityTracker.deleteSession(session.id);
+ sessionListActivityTracker.deleteSession(session.id);
sessionTurnBoundaryGenerationById.delete(session.id);
markSessionTurnEnded(session.id);
},
@@ -6210,9 +6219,7 @@ const sessionEventDependencies: SessionEventDependencies = {
get markTurnEndedAfterPersistDrain() {
return markTurnEndedAfterPersistDrain;
},
- noteSessionListActivity: (sessionId: string) => {
- void touchSessionActivityInDb(sessionId, Date.now(), true);
- },
+ sessionListActivityTracker,
get contextOverflowRolloverHolder() {
return contextOverflowRolloverHolder;
},
@@ -19197,6 +19204,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)
});
}
sessionTurnActivityTracker.deleteSession(sessionId);
+ sessionListActivityTracker.deleteSession(sessionId);
void sessionTurnLeaseTracker.markTurnEnded(sessionId);
notifyGoalIdleAfterTurnSettled(sessionId);
try {
diff --git a/apps/desktop/src/main/maker-ipc/sessionEventDelivery.ts b/apps/desktop/src/main/maker-ipc/sessionEventDelivery.ts
index 8bc59dedb5..36d97fa933 100644
--- a/apps/desktop/src/main/maker-ipc/sessionEventDelivery.ts
+++ b/apps/desktop/src/main/maker-ipc/sessionEventDelivery.ts
@@ -15,12 +15,13 @@ import { DeferredCodexRestartService } from './deferredCodexRestart.js';
import {
isTerminalTurnErrorEvent,
SessionTurnActivityTracker,
+ SessionListActivityTracker,
} from './sessionTurnActivityTracker.js';
import type { PreparedSessionEvent } from './sessionEventPreparation.js';
import type { SessionStreamResult } from './sessionEventStream.js';
import { isSessionErrorSuppressed } from './sessionErrorSuppression.js';
export interface DeliverSessionEventDeps {
- readonly noteSessionListActivity: (sessionId: string) => void;
+ readonly sessionListActivityTracker: SessionListActivityTracker;
readonly attemptBotCompactRuntimeRefresh: (session: Session, reason: string) => void;
readonly orcaTeamServiceForEvents: Pick<OrcaTeamService, 'captureWorkerTerminalTurn'> | null;
readonly agentInputCoordinatorHolder: Pick<
@@ -186,11 +187,15 @@ export function deliverSessionEvent(
// status:isRunning=false 即逻辑 turn 结束(可重试 error 不发这个信号)。
deps.markTurnEndedAfterPersistDrain(session.id);
if (
- wasInTurn && event.turnOrigin?.kind !== 'goal' &&
- !deps.agentInputCoordinatorHolder?.isAutoResumePending(session.id) &&
- !deps.agentInputCoordinatorHolder?.isAutoResumeDeferred(session.id)
+ wasInTurn && event.turnOrigin?.kind !== 'goal'
) {
- deps.noteSessionListActivity(session.id);
+ deps.sessionListActivityTracker.end(session.id, {
+ identity: event.sessionTurnGeneration === undefined ? undefined
+ : `${event.sessionInstanceId ?? session.instanceId}:${event.sessionTurnGeneration}`,
+ statusOnly: true,
+ hold: deps.agentInputCoordinatorHolder?.isAutoResumePending(session.id) ||
+ deps.agentInputCoordinatorHolder?.isAutoResumeDeferred(session.id),
+ });
}
noteClaudeSessionTurnState(session.id, false);
}
diff --git a/apps/desktop/src/main/maker-ipc/sessionEventPreparation.ts b/apps/desktop/src/main/maker-ipc/sessionEventPreparation.ts
index 2a77e4a244..59c0fef61c 100644
--- a/apps/desktop/src/main/maker-ipc/sessionEventPreparation.ts
+++ b/apps/desktop/src/main/maker-ipc/sessionEventPreparation.ts
@@ -38,6 +38,7 @@ import { consumeClaudeOpusPlanMismatch } from '../maker-host/claude-gateway-erro
import {
isTerminalTurnErrorEvent,
SessionTurnActivityTracker,
+ type SessionListActivityTracker,
} from './sessionTurnActivityTracker.js';
import { SilentStopTurnLeaseGate } from './sessionTurnLease.js';
import { ProductTurnUsageTargetTracker, ProductTurnWallClockTracker } from './turnWallClock.js';
@@ -64,6 +65,7 @@ interface DismissedInteraction {
}
export interface PrepareSessionEventDeps {
+ readonly sessionListActivityTracker: SessionListActivityTracker;
readonly botCompactRuntimeRefreshCoordinator: Pick<BotCompactRuntimeRefreshCoordinator, 'noteBoundary'>;
readonly isFencedStaleSessionTerminal: (sessionId: string, event: AgentEvent) => boolean;
readonly log: Pick<ReturnType<typeof createLogger>, 'debug' | 'warn'>;
@@ -350,6 +352,11 @@ export function prepareSessionEvent(
clearPending: typeof event.turnAttemptToken === 'number',
});
const wasInTurn = deps.sessionTurnActivityTracker.isSessionInTurn(session.id);
+ if (!wasInTurn || event.sessionTurnGeneration !== undefined) {
+ deps.sessionListActivityTracker.start(session.id, event.sessionTurnGeneration === undefined
+ ? undefined
+ : `${event.sessionInstanceId ?? session.instanceId}:${event.sessionTurnGeneration}`);
+ }
if (!wasInTurn && event.source === 'claude-code') {
const startedProductTurn = deps.productTurnWallClockTracker.start(session.id);
if (startedProductTurn) deps.productTurnUsageTargetTracker.clear(session.id);
diff --git a/apps/desktop/src/main/maker-ipc/sessionEventTerminal.ts b/apps/desktop/src/main/maker-ipc/sessionEventTerminal.ts
index ff09037396..5c9cd92b55 100644
--- a/apps/desktop/src/main/maker-ipc/sessionEventTerminal.ts
+++ b/apps/desktop/src/main/maker-ipc/sessionEventTerminal.ts
@@ -40,7 +40,7 @@ import {
isOversizedHistoryErrorData,
isUnsupportedRequestOptionErrorData,
} from './contextOverflowRollover.js';
-import { isTerminalTurnErrorEvent } from './sessionTurnActivityTracker.js';
+import { isTerminalTurnErrorEvent, type SessionListActivityTracker } from './sessionTurnActivityTracker.js';
import { botGroupRuntimeFailureCode } from './botGroupRuntimeFailure.js';
import { ProductTurnUsageTargetTracker } from './turnWallClock.js';
import { createWorkerTurnStartSequencer } from './workerTurnStartSequencer.js';
@@ -60,7 +60,7 @@ import {
type ProductTurnFailureOwner,
} from './productTurnFailureOwner.js';
export interface FinishSessionTerminalEventDeps {
- readonly noteSessionListActivity: (sessionId: string) => void;
+ readonly sessionListActivityTracker: SessionListActivityTracker;
readonly onPluginTaskTerminal?: (sessionId: string, execution: { instanceId: string; generation: number }, outcome: 'completed' | 'failed' | 'cancelled' | 'interrupted', outputMessageId?: string) => void;
readonly onSuccessfulProductTurn?: (
sessionId: string,
@@ -545,12 +545,16 @@ export function finishSessionTerminalEvent(
if (!isContinuationBoundary) {
deps.markTurnEndedAfterPersistDrain(session.id);
if (
- event.turnScope !== 'background' && event.turnOrigin?.kind !== 'goal' &&
- !autoResumeSuppressesPersist && !recoveryOwnsUnsuccessfulBoundary &&
- !deps.agentInputCoordinatorHolder?.isAutoResumePending(session.id) &&
- !deps.agentInputCoordinatorHolder?.isAutoResumeDeferred(session.id)
+ event.turnScope !== 'background' && event.turnOrigin?.kind !== 'goal'
) {
- deps.noteSessionListActivity(session.id);
+ deps.sessionListActivityTracker.end(session.id, {
+ identity: event.sessionTurnGeneration === undefined ? undefined
+ : `${event.sessionInstanceId ?? session.instanceId}:${event.sessionTurnGeneration}`,
+ hold: autoResumeSuppressesPersist || recoveryOwnsUnsuccessfulBoundary ||
+ deps.agentInputCoordinatorHolder?.isAutoResumePending(session.id) ||
+ deps.agentInputCoordinatorHolder?.isAutoResumeDeferred(session.id) ||
+ (event.type === 'done' && (event.data as { silentStop?: boolean } | null)?.silentStop === true),
+ });
}
// 逻辑 turn 结束:跨段存活的计划行引用到此回收(continuation boundary
// 上必须保留,否则最终 done 找不到计划行 → 无章无失败印记 → 胶囊永久
diff --git a/apps/desktop/src/main/maker-ipc/sessionTurnActivityTracker.ts b/apps/desktop/src/main/maker-ipc/sessionTurnActivityTracker.ts
index e419586d9a..96fd9f14d4 100644
--- a/apps/desktop/src/main/maker-ipc/sessionTurnActivityTracker.ts
+++ b/apps/desktop/src/main/maker-ipc/sessionTurnActivityTracker.ts
@@ -2,6 +2,68 @@ import { isTerminalAgentErrorEvent, type AgentEvent } from '@cindy/maker-core';
export const TURN_IDLE_THROTTLE_RESTORE_GRACE_MS = 1_000;
+export class SessionListActivityTracker {
+ private readonly turns = new Map<string, {
+ identity?: string;
+ endedAt?: number;
+ settled: boolean;
+ held: boolean;
+ flush?: ReturnType<typeof setImmediate>;
+ }>();
+
+ constructor(private readonly write: (sessionId: string, atMs: number) => void) {}
+
+ start(sessionId: string, identity?: string): void {
+ if (identity && this.turns.get(sessionId)?.identity === identity) return;
+ this.deleteSession(sessionId);
+ this.turns.set(sessionId, { identity, settled: false, held: false });
+ }
+
+ end(sessionId: string, options: { statusOnly?: boolean; hold?: boolean; identity?: string } = {}): void {
+ if (!this.turns.has(sessionId) ||
+ (options.identity && this.turns.get(sessionId)?.identity !== options.identity)) {
+ this.start(sessionId, options.identity);
+ }
+ const turn = this.turns.get(sessionId)!;
+ if (turn.settled) return;
+ turn.endedAt ??= Date.now();
+ turn.held ||= options.hold === true;
+ if (turn.held) return;
+ if (!options.statusOnly) {
+ this.commit(sessionId);
+ } else if (!turn.flush) {
+ // 同批 status(false) / done 可跨 async iterator 微任务;等当前事件批次结束,
+ // 让 silentStop 有机会接管。不是固定毫秒延时,新轮次或关闭会取消此兜底。
+ turn.flush = setImmediate(() => {
+ turn.flush = undefined;
+ if (this.turns.get(sessionId) === turn && !turn.held) this.commit(sessionId);
+ });
+ }
+ }
+
+ commit(sessionId: string): void {
+ const turn = this.turns.get(sessionId);
+ if (!turn || turn.settled) return;
+ if (turn.flush) clearImmediate(turn.flush);
+ turn.flush = undefined;
+ turn.settled = true;
+ if (turn.endedAt !== undefined) this.write(sessionId, turn.endedAt);
+ }
+
+ captureContinuation(sessionId: string): () => void {
+ const turn = this.turns.get(sessionId);
+ return () => {
+ if (this.turns.get(sessionId) === turn) this.deleteSession(sessionId);
+ };
+ }
+
+ deleteSession(sessionId: string): void {
+ const turn = this.turns.get(sessionId);
+ if (turn?.flush) clearImmediate(turn.flush);
+ this.turns.delete(sessionId);
+ }
+}
+
/**
* 维护 desktop 对「逻辑 turn」和「前台恢复 keepalive」的本地视图。
*
diff --git a/docs/product-rules/sidebar-redesign-plan.md b/docs/product-rules/sidebar-redesign-plan.md
index 25805db2de..727493fa0b 100644
--- a/docs/product-rules/sidebar-redesign-plan.md
+++ b/docs/product-rules/sidebar-redesign-plan.md
@@ -176,7 +176,7 @@ Cindy Make 分组固定在主列表顶部,不参与普通条目的优先级、
旧「手动排序」不再是任务排序的第三档。它排的是项目行,不是任务,和按时间/优先级互斥会让用户以为能拖单条任务。现拆成下一节的「项目排序」,可与任务排序叠加。存量 `sortBy=manual` 静默迁移为 `sortBy=recency` + `projectOrder=custom`。
-最近活动遵循「换手才更新」(2026-10-24 用户裁决,对齐主流产品):用户发送、继续或重试,其他任务/Orca/插件/定时任务交来输入并开始一轮,以及正常完成、终止型错误或逻辑轮次转为空闲时更新。目标模式的中间轮次不更新;整个目标完成、暂停、清除或停下待处理时更新一次。自动续跑开始、流式输出、工具调用、标题/模型/权限修改、归档/取消归档、进程关闭或回收、忽略中断、退出冻结与 compact 等内部动作不更新;可以识别为马上自动续跑的中断收尾也跳过。
+最近活动遵循「换手才更新」(2026-10-24 用户裁决,对齐主流产品):用户发送、继续或重试,其他任务/Orca/插件/定时任务交来输入并开始一轮,以及正常完成、终止型错误或逻辑轮次转为空闲时更新。同一逻辑轮次的结束只更新一次,使用首次结束信号的时间。目标模式在用户开始或恢复目标并成功派发、以及整个目标完成、暂停、清除或停下待处理时各更新一次;自动恢复与中间轮次不更新。silentStop 等自动续跑在决定续跑时不更新;决定不续跑时按原结束时间更新一次。自动续跑开始、流式输出、工具调用、标题/模型/权限修改、归档/取消归档、进程关闭或回收、忽略中断、退出冻结与 compact 等内部动作不更新。
这与主流产品按最新交接排列的方向一致:Codex 的 [recencyAt](https://github.com/openai/codex/pull/27910) 在新轮次开始时推进,独立于普通字段修改;其 Last updated 排序也关注回复完成。被其他线程调用却不上浮及防跳动快照造成顺序过时,分别见 [#36634](https://github.com/openai/codex/issues/36634) 与 [#36300](https://github.com/openai/codex/issues/36300)。微信、Slack、Telegram 的消息列表以最后一条消息为常见参照;这里采用交接边界,而不是流式片段逐条重排。本次不处理等待用户确认权限或回答问题,不清理定时任务既有 `userSendAt` 写入,也不改变 IM `/sessions` 和 Work Louder 的顺序。