fix: keep turn ids above the wire-wide max and fold cold transcripts over the active branch (#3922)

* fix(agent-core-v2): floor the human turn clock at the wire-wide max on engine journal reset

* fix(kap-server): fold the cold transcript snapshot over the restorable branch chain

* fix(agent-core-v2): advance the human turn clock when a turn starts

* fix(kap-server): split reused wire turn ids in the live transcript projector

* fix(kap-server): adopt the completed cold tip for mid-turn attach events

Continuation deltas after a lazy transcript attach belong on the last
cold turn, not a newly split export id.

Author: sailist

.changeset/cold-rebuild-turn-id.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Fix new messages occasionally landing at an old position in the conversation after resuming a session.

packages/agent-core-v2/src/agent/loop/machine/engine.ts

@@ -28,7 +28,7 @@ import type { Actor, Subscription } from '#human/xstate2';
 
 import { createMachineRequester, type MachineRequester, type MachineRequesterGateDecision } from './requester';
 import { createMachineTools, type MachineTools, type ToolResultExtras } from './tools';
-import { seededStoreJournal } from './storeJournal';
+import { appendedStoreJournal, seededStoreJournal } from './storeJournal';
 
 export type { PromptGateVerdict };
 
@@ -619,9 +619,8 @@ export function engineJournal(base: SyncStoreJournal | undefined, initialTurnId:
     if (initialTurnId <= 0) return memoryJournal();
     return seedRecords([turnEnded({ turnId: initialTurnId - 1, outcome: 'done' })]);
   }
-  if (initialTurnId <= 0 || base.readSync().length > 0) return base;
-  return seededStoreJournal(
-    base,
-    seedRecords([turnEnded({ turnId: initialTurnId - 1, outcome: 'done' })]).readSync(),
-  );
+  if (initialTurnId <= 0) return base;
+  const seed = seedRecords([turnEnded({ turnId: initialTurnId - 1, outcome: 'done' })]).readSync();
+  if (base.readSync().length === 0) return seededStoreJournal(base, seed);
+  return appendedStoreJournal(base, seed);
 }

packages/agent-core-v2/src/agent/loop/machine/storeJournal.ts

@@ -86,3 +86,33 @@ export function seededStoreJournal(
     settled: () => base.settled(),
   };
 }
+
+export function appendedStoreJournal(
+  base: SyncStoreJournal,
+  seed: readonly JournalRecord[],
+): SyncStoreJournal {
+  let appended = 0;
+  const baseCount = base.nextSeq();
+  const trailing = seed.map((record, index) => ({
+    ...record,
+    branch: base.ref.branch,
+    seq: baseCount + index,
+  }));
+  return {
+    get ref() {
+      return base.ref;
+    },
+    append: async (input) => {
+      const entry = await base.append(input);
+      appended += 1;
+      return entry;
+    },
+    read: async function* () {
+      for (const record of base.readSync()) yield record;
+      for (const record of trailing) yield record;
+    },
+    readSync: () => [...base.readSync(), ...trailing],
+    nextSeq: () => baseCount + trailing.length + appended,
+    settled: () => base.settled(),
+  };
+}

packages/agent-core-v2/src/human/agent/slices.ts

@@ -119,11 +119,12 @@ export const turnIndexSlice = createSlice({
   reducers: {
     [turnStarted.type]: (draft, event: TurnStarted, ctx) => {
       draft.turns.push({ turnId: event.turnId, start: ctx.ref });
+      if (event.turnId >= draft.nextTurnId) draft.nextTurnId = event.turnId + 1;
     },
     [turnEnded.type]: (draft, event: TurnEnded, ctx) => {
       const entry = draft.turns.findLast((turn) => turn.turnId === event.turnId);
       if (entry !== undefined) entry.end = ctx.ref;
-      draft.nextTurnId = event.turnId + 1;
+      if (event.turnId >= draft.nextTurnId) draft.nextTurnId = event.turnId + 1;
     },
   },
 });

packages/agent-core-v2/src/human/test/session/stores.test.ts

@@ -217,6 +217,19 @@ describe('SessionStores reopen', () => {
     expect(restoredMain.getState().turnIndex.nextTurnId).toBe(3);
 
     actor2.stop();
+
+    await restoredMain.dispatch(turnStarted({ turnId: 3 }));
+    await restored.stores.flush();
+
+    const crashed = await reopen(restored);
+    const crashedMain = await crashed.stores.open('main');
+    expect(crashedMain.getState().turnIndex.nextTurnId).toBe(4);
+
+    const actor3 = startAgent(crashedMain);
+    await runTurn(actor3, crashedMain, 'after-crash', 8);
+    expect(crashedMain.getState().turnIndex.turns.at(-1)?.turnId).toBe(4);
+
+    actor3.stop();
   });
 });
 

packages/agent-core-v2/test/agent/undo/undo.test.ts

@@ -355,17 +355,17 @@ describe('AgentConversationUndoService', () => {
 
     expect(ctx.agentState.get(turnKey).nextTurnId).toBe(2);
 
-    await expect(runTurn(ctx, 'u3')).resolves.toBe(1);
+    await expect(runTurn(ctx, 'u3')).resolves.toBe(2);
 
     const persisted = await ctx.persistedWireRecords();
     expect(
       persisted.filter((record) => record.type === 'turn.prompt').map((record) => record['turnId']),
-    ).toEqual([0, 1, 1]);
+    ).toEqual([0, 1, 2]);
     expect(
       persisted
         .filter((record) => record.type === 'agent.turn.started')
         .map((record) => record['turnId']),
-    ).toEqual([0, 1, 1]);
+    ).toEqual([0, 1, 2]);
 
     const resumed = createTestAgent(
       { autoConfigure: false, persistence: new InMemoryWireRecordPersistence(persisted) },
@@ -375,14 +375,14 @@ describe('AgentConversationUndoService', () => {
     try {
       resumed.get(IAgentContextMemoryService);
       await resumed.restorePersisted();
-      expect(resumed.agentState.get(turnKey).nextTurnId).toBe(2);
-      await expect(runTurn(resumed, 'u4')).resolves.toBe(2);
+      expect(resumed.agentState.get(turnKey).nextTurnId).toBe(3);
+      await expect(runTurn(resumed, 'u4')).resolves.toBe(3);
       const repersisted = await resumed.persistedWireRecords();
       expect(
         repersisted
           .filter((record) => record.type === 'agent.turn.started')
           .map((record) => record['turnId']),
-      ).toEqual([0, 1, 1, 2]);
+      ).toEqual([0, 1, 2, 3]);
     } finally {
       await resumed.dispose();
     }

packages/kap-server/src/services/transcript/coreBinding.ts

@@ -32,6 +32,7 @@ export interface TranscriptBindingLogger {
 
 export interface TranscriptBinding extends IDisposable {
   seedPendingInteractions(agentId?: string): void;
+  syncFromStore(agentId: string): void;
 }
 
 export function bindSessionTranscript(
@@ -106,6 +107,13 @@ export function bindSessionTranscript(
           return agentHandle === undefined ? [] : legacyApprovalsOf(agentHandle);
         },
         turn: (turnId) => store.getAgent(agentId)?.getTurn(turnId),
+        maxOrdinal: () => {
+          let max = -1;
+          for (const item of store.getAgent(agentId)?.getItems() ?? []) {
+            if (item.kind === 'turn' && item.ordinal > max) max = item.ordinal;
+          }
+          return max;
+        },
         prompt: (promptId) => store.getAgent(agentId)?.getPrompt(promptId),
         resolvePlanRevisionKey: (key) =>
           agents.handleOf(agentId)?.accessor.get(IAgentScopeContext).scope(key) ?? key,
@@ -287,6 +295,9 @@ export function bindSessionTranscript(
 
   return {
     seedPendingInteractions,
+    syncFromStore: (agentId) => {
+      projectors.get(agentId)?.syncFromStore();
+    },
     dispose: () => {
       for (const d of disposables) d.dispose();
       for (const list of agentDisposables.values()) {