expect(call.sessionId).toBe("post-compact-session");

expect(call.sessionFile).toBe("/tmp/post-compact.jsonl");

});

it("registers the admitted session id when the local session store is stale", async () => {

const realAgentEvents = await vi.importActual<typeof import("../../infra/agent-events.js")>(

"../../infra/agent-events.js",

);

realAgentEvents.resetAgentRunContextForTest();

const active = createReplyOperationForTest({

sessionKey: "main",

sessionId: "pre-compact-session",

resetTriggered: false,

});

active.setPhase("preflight_compacting");

let observedRunId: string | undefined;

runEmbeddedAgentMock.mockImplementationOnce(

async (params: { runId: string; sessionId?: string }) => {

observedRunId = params.runId;

expect(params.sessionId).toBe("post-compact-session");

return {

payloads: [],

meta: { agentMeta: { provider: "anthropic", model: "claude" } },

};

},

);

const sessionStore = {

main: {

sessionId: "pre-compact-session",

sessionFile: "/tmp/pre-compact.jsonl",

updatedAt: Date.now(),

},

};

const runner = createFollowupRunner({

typing: createMockTypingController(),

typingMode: "instant",

sessionEntry: sessionStore.main,

sessionStore,

sessionKey: "main",

defaultModel: "anthropic/claude",

});

const pending = runner(

createQueuedRun({

run: {

sessionId: "queued-stale-session",

sessionKey: "main",

provider: "anthropic",

model: "claude",

},

}),

);

await new Promise<void>((resolve) => setTimeout(resolve, 0));

active.updateSessionId("post-compact-session");

active.complete();

await pending;

expect(observedRunId).toBeDefined();

expect(realAgentEvents.getAgentRunContext(observedRunId ?? "")?.sessionId).toBe(

"post-compact-session",

);

realAgentEvents.resetAgentRunContextForTest();

});

});

async function normalizeComparablePath(filePath: string): Promise<string> {

provider: run.messageProvider,

}),

);

if (run.sessionKey) {

registerAgentRunContext(runId, {

sessionKey: run.sessionKey,

...(run.sessionId ? { sessionId: run.sessionId } : {}),

verboseLevel: run.verboseLevel,

isControlUiVisible: shouldSurfaceToControlUi,

});

}

let autoCompactionCount = 0;

let runResult: Awaited<ReturnType<typeof runEmbeddedAgent>>;

let fallbackProvider = run.provider;

isHeartbeat: opts?.isHeartbeat === true,

replyOperation,

});

if (run.sessionKey) {

const owningSessionId =

activeSessionEntry?.sessionId === run.sessionId

? activeSessionEntry.sessionId

: run.sessionId;

registerAgentRunContext(runId, {

sessionKey: run.sessionKey,

...(owningSessionId ? { sessionId: owningSessionId } : {}),

verboseLevel: run.verboseLevel,

isControlUiVisible: shouldSurfaceToControlUi,

});

}

let bootstrapPromptWarningSignaturesSeen = resolveBootstrapWarningSignaturesSeen(

activeSessionEntry?.systemPromptReport,

);

resetAgentRunContextForTest();

});

it("does not project stale pre-reset lifecycle events into session subscriber snapshots", () => {

vi.mocked(loadGatewaySessionRow).mockReturnValue({

key: "session-reset",

kind: "direct",

sessionId: "new-session",

updatedAt: 2_000,

status: "done",

startedAt: 1_000,

endedAt: 1_500,

runtimeMs: 500,

abortedLastRun: false,

});

const { broadcastToConnIds, sessionEventSubscribers, handler } = createHarness({

lifecycleErrorRetryGraceMs: 0,

});

sessionEventSubscribers.subscribe("conn-session");

handler({

runId: "old-run",

seq: 1,

stream: "lifecycle",

sessionKey: "session-reset",

sessionId: "old-session",

ts: 2_100,

data: {

phase: "start",

startedAt: 2_100,

},

});

handler({

runId: "old-run",

seq: 2,

stream: "lifecycle",

sessionKey: "session-reset",

sessionId: "old-session",

ts: 2_200,

data: {

phase: "error",

endedAt: 2_200,

error: "old run failed",

},

});

const sessionsChangedCalls = broadcastToConnIds.mock.calls.filter(

([event]) => event === "sessions.changed",

);

expect(sessionsChangedCalls).toHaveLength(2);

for (const [, payload] of sessionsChangedCalls) {

expectPayloadFields(payload, {

sessionKey: "session-reset",

sessionId: "new-session",

status: "done",

startedAt: 1_000,

endedAt: 1_500,

runtimeMs: 500,

updatedAt: 2_000,

abortedLastRun: false,

});

expectRecordFields(requireRecord(requireRecord(payload, "payload").session, "session"), {

sessionId: "new-session",

status: "done",

startedAt: 1_000,

endedAt: 1_500,

runtimeMs: 500,

});

}

resetAgentRunContextForTest();

});

it("clears tracked active runs before terminal sessions.changed broadcasts", () => {

vi.mocked(loadGatewaySessionRow).mockReturnValue({

key: "session-finished",

} from "./server-chat-state.js";

import { loadGatewaySessionRow } from "./server-chat.load-gateway-session-row.runtime.js";

import { persistGatewaySessionLifecycleEvent } from "./server-chat.persist-session-lifecycle.runtime.js";

import { deriveGatewaySessionLifecycleSnapshot } from "./session-lifecycle-state.js";

import {

deriveGatewaySessionLifecycleSnapshot,

isStaleLifecycleEventForSession,

} from "./session-lifecycle-state.js";

import { loadSessionEntry } from "./session-utils.js";

import { formatForLog } from "./ws-log.js";

) => {

const row = loadGatewaySessionRowForSnapshot(sessionKey, agentId ? { agentId } : undefined);

const omitUnscopedGlobalGoal = sessionKey === "global" && !agentId;

const lifecyclePatch = evt

? deriveGatewaySessionLifecycleSnapshot({

session: row

? {

updatedAt: row.updatedAt ?? undefined,

status: row.status,

startedAt: row.startedAt,

endedAt: row.endedAt,

runtimeMs: row.runtimeMs,

abortedLastRun: row.abortedLastRun,

}

: undefined,

event: evt,

})

: {};

const lifecyclePatch =

evt &&

!isStaleLifecycleEventForSession({

owningSessionId: evt.sessionId,

currentSessionId: row?.sessionId,

})

? deriveGatewaySessionLifecycleSnapshot({

session: row

? {

updatedAt: row.updatedAt ?? undefined,

status: row.status,

startedAt: row.startedAt,

endedAt: row.endedAt,

runtimeMs: row.runtimeMs,

abortedLastRun: row.abortedLastRun,

}

: undefined,

event: evt,

})

: {};

const session = row ? { ...row, ...lifecyclePatch } : undefined;

if (session && omitUnscopedGlobalGoal) {

delete session.goal;