fix(runtime): validate canonical prefix anchors

Generated-by: Codex

Author: Astro-Han

packages/runtime/src/__tests__/context-diagnostics.test.ts

@@ -247,6 +247,34 @@ test('a failed call does not replace the last good snapshot', async () => {
   }
 });
 
+test('an identity-mismatched canonical event cannot become the latest request', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'maka-context-diagnostics-'));
+  try {
+    const writer = createSqliteAgentRunStore(root);
+    await writer.createRun(runHeader('run-1', 1));
+    await writer.appendEvent(
+      'session-1',
+      'run-1',
+      meteringEvent('run-1', 'attempt-1', 10, 'model-valid', 40, 200),
+    );
+    await writer.appendEvent(
+      'session-1',
+      'run-1',
+      meteringEvent('run-1', 'attempt-2', 20, 'model-mismatched', 40, 200, {
+        runId: 'another-run',
+      }),
+    );
+
+    const diagnostics = await readLatestContextDiagnostics(writer, 'session-1');
+
+    assert.equal(diagnostics.status, 'available');
+    if (diagnostics.status !== 'available') return;
+    assert.equal(diagnostics.modelId, 'model-valid');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
 test("a subagent's run never becomes the session's context", async () => {
   const root = await mkdtemp(join(tmpdir(), 'maka-context-diagnostics-'));
   try {
@@ -1138,7 +1166,7 @@ function meteringEvent(
   const turnId = `turn-${runId}`;
   return {
     type: 'model_call_attempt_recorded',
-    id: `metering-${attemptId}`,
+    id: attemptId,
     runId,
     sessionId: 'session-1',
     turnId,

packages/runtime/src/__tests__/semantic-prefix-continuity.test.ts

@@ -81,6 +81,58 @@ test('reports the first removed earlier segment', () => {
   });
 });
 
+test('reports the current segment at the first middle deletion', () => {
+  const previous = observation([
+    message(0, 'system'),
+    message(1, 'user-1'),
+    message(2, 'assistant-1'),
+  ]);
+  const current = observation([message(0, 'system'), message(2, 'assistant-1')]);
+
+  assert.deepEqual(deriveSemanticPrefixContinuity(current, previous), {
+    status: 'diverged',
+    previousSegmentCount: 3,
+    preservedSegmentCount: 1,
+    firstDivergentSegment: { kind: 'message', index: 2 },
+  });
+});
+
+test('reports an inserted segment as the first divergence', () => {
+  const previous = observation([message(0, 'system'), message(2, 'assistant-1')]);
+  const current = observation([
+    message(0, 'system'),
+    message(1, 'inserted-user'),
+    message(2, 'assistant-1'),
+  ]);
+
+  assert.deepEqual(deriveSemanticPrefixContinuity(current, previous), {
+    status: 'diverged',
+    previousSegmentCount: 2,
+    preservedSegmentCount: 1,
+    firstDivergentSegment: { kind: 'message', index: 1 },
+  });
+});
+
+test('reports the first moved segment after a reorder', () => {
+  const previous = observation([
+    message(0, 'system'),
+    message(1, 'user-1'),
+    message(2, 'assistant-1'),
+  ]);
+  const current = observation([
+    message(0, 'system'),
+    message(2, 'assistant-1'),
+    message(1, 'user-1'),
+  ]);
+
+  assert.deepEqual(deriveSemanticPrefixContinuity(current, previous), {
+    status: 'diverged',
+    previousSegmentCount: 3,
+    preservedSegmentCount: 1,
+    firstDivergentSegment: { kind: 'message', index: 2 },
+  });
+});
+
 test('uses the preceding physical retry as its durable baseline', async () => {
   const previous = attempt({ attemptId: 'attempt-0', attempt: 0 });
   const current = attempt({ attemptId: 'attempt-1', attempt: 1 });

packages/runtime/src/context-diagnostics.ts

@@ -42,6 +42,7 @@ import {
 } from './history-compact-checkpoint.js';
 import {
   deriveAttemptSemanticPrefixContinuity,
+  isCanonicalAttemptForRun,
   type SemanticPrefixContinuity,
 } from './semantic-prefix-continuity.js';
 
@@ -419,7 +420,13 @@ function meteringAnchor(event: AgentRunEvent, run: AgentRunHeader): MeteringAnch
   } catch {
     return undefined;
   }
-  if (attempt.callKind !== 'main' || attempt.status !== 'completed') return undefined;
+  if (
+    attempt.callKind !== 'main' ||
+    attempt.status !== 'completed' ||
+    !isCanonicalAttemptForRun(event, attempt, run)
+  ) {
+    return undefined;
+  }
   const composition = attempt.requestObservation
     ? foldPromptComposition(attempt.requestObservation.segments)
     : undefined;

packages/runtime/src/semantic-prefix-continuity.ts

@@ -23,7 +23,12 @@ import type {
   PreparedRequestObservationSegment,
 } from '@maka/core/model-call-attempt';
 import { decodeModelCallAttempt } from '@maka/core/model-call-attempt';
-import { isSessionInlineRun, type AgentRunHeader, type AgentRunStore } from '@maka/core/agent-run';
+import {
+  isSessionInlineRun,
+  type AgentRunEvent,
+  type AgentRunHeader,
+  type AgentRunStore,
+} from '@maka/core/agent-run';
 
 export type SemanticPrefixContinuity =
   | {
@@ -249,14 +254,7 @@ async function attemptsFor(store: PrefixStore, run: AgentRunHeader): Promise<Mod
     if (event.type !== 'model_call_attempt_recorded') continue;
     try {
       const attempt = decodeModelCallAttempt(event.data);
-      if (
-        attempt.callKind === 'main' &&
-        attempt.sessionId === run.sessionId &&
-        attempt.runId === run.runId &&
-        attempt.turnId === run.turnId &&
-        event.turnId === run.turnId &&
-        attempt.attemptId === event.id
-      ) {
+      if (attempt.callKind === 'main' && isCanonicalAttemptForRun(event, attempt, run)) {
         attempts.push(attempt);
       }
     } catch {
@@ -266,6 +264,22 @@ async function attemptsFor(store: PrefixStore, run: AgentRunHeader): Promise<Mod
   return attempts;
 }
 
+export function isCanonicalAttemptForRun(
+  event: AgentRunEvent,
+  attempt: ModelCallAttempt,
+  run: AgentRunHeader,
+): boolean {
+  return (
+    event.sessionId === run.sessionId &&
+    event.runId === run.runId &&
+    event.turnId === run.turnId &&
+    attempt.sessionId === run.sessionId &&
+    attempt.runId === run.runId &&
+    attempt.turnId === run.turnId &&
+    attempt.attemptId === event.id
+  );
+}
+
 function latestAttempt(
   run: AgentRunHeader,
   attempts: readonly ModelCallAttempt[],