larkup 0.4.12 → 0.4.14

package/.next/standalone/apps/web/lib/chat/tool-context.test.ts

@@ -0,0 +1,978 @@
+import { describe, expect, it } from 'vitest';
+import {
+  compactToolContextForModel,
+  collectAnswerLevelMediaStatements,
+  collectObservedSubjectLedger,
+  containsAnswerLevelMediaEvidence,
+  collectQuestionMatchedDirectClaims,
+  recoverEmptyUIMessageStream,
+  formatDirectObservationAnswer,
+  formatParticipantInventory,
+  formatExhaustiveMediaAnswer,
+  formatLocatedObservedSubjectAnswer,
+  formatObservedAppearanceAnswer,
+  formatOutcomeMediaAnswer,
+  mediaClaimNeedsCorroboration,
+  withFinalAnswerNudge,
+} from './tool-context';
+
+function toolResultMessage(toolName: string, output: unknown) {
+  return {
+    role: 'tool',
+    content: [{ type: 'tool-result', toolName, output }],
+  };
+}
+
+async function transformedChunks(chunks: any[], fallback = 'A visible fallback answer.') {
+  const source = new ReadableStream<any>({
+    start(controller) {
+      chunks.forEach((chunk) => controller.enqueue(chunk));
+      controller.close();
+    },
+  });
+  const reader = source.pipeThrough(recoverEmptyUIMessageStream(fallback)()).getReader();
+  const output: any[] = [];
+  for (;;) {
+    const next = await reader.read();
+    if (next.done) return output;
+    output.push(next.value);
+  }
+}
+
+describe('recoverEmptyUIMessageStream', () => {
+  it('inserts visible text before a normal finish', async () => {
+    const chunks = await transformedChunks([
+      { type: 'start-step' },
+      { type: 'finish-step' },
+      { type: 'finish' },
+    ]);
+
+    const finishIndex = chunks.findIndex((chunk) => chunk.type === 'finish');
+    const fallbackIndex = chunks.findIndex(
+      (chunk) => chunk.type === 'text-delta' && chunk.delta === 'A visible fallback answer.',
+    );
+    expect(fallbackIndex).toBeGreaterThan(-1);
+    expect(fallbackIndex).toBeLessThan(finishIndex);
+  });
+
+  it('forwards finish-step immediately so multi-step generation cannot deadlock', async () => {
+    const chunks = await transformedChunks([{ type: 'start-step' }, { type: 'finish-step' }]);
+    expect(chunks[1]).toEqual({ type: 'finish-step' });
+  });
+
+  it('turns a sanitized stream error into ordinary assistant text', async () => {
+    const chunks = await transformedChunks([
+      { type: 'error', errorText: 'The provider is temporarily unavailable.' },
+    ]);
+    expect(chunks.some((chunk) => chunk.type === 'error')).toBe(false);
+    expect(chunks).toContainEqual(
+      expect.objectContaining({
+        type: 'text-delta',
+        delta: 'The provider is temporarily unavailable.',
+      }),
+    );
+  });
+
+  it('also inserts visible text when a provider closes without a terminal chunk', async () => {
+    const chunks = await transformedChunks([{ type: 'start-step' }, { type: 'finish-step' }]);
+    expect(chunks).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ type: 'text-delta', delta: 'A visible fallback answer.' }),
+      ]),
+    );
+    expect(chunks.filter((chunk) => chunk.type === 'text-delta')).toHaveLength(1);
+  });
+
+  it('does not add fallback text when the model already answered', async () => {
+    const chunks = await transformedChunks([
+      { type: 'start-step' },
+      { type: 'text-delta', id: 'answer', delta: 'The actual answer.' },
+      { type: 'finish-step' },
+      { type: 'finish' },
+    ]);
+    expect(chunks.filter((chunk) => chunk.type === 'text-delta')).toEqual([
+      expect.objectContaining({ delta: 'The actual answer.' }),
+    ]);
+  });
+});
+
+describe('collectAnswerLevelMediaStatements', () => {
+  it('keeps a verified chronological trail available when the answer stream closes empty', () => {
+    expect(
+      collectAnswerLevelMediaStatements({
+        videoEvidence: {
+          success: true,
+          claimVerification: { status: 'established-by-trail', directlyEstablished: false },
+          evidence: [
+            { payload: { text: 'Reconciled state: Alpha 2, Beta 3' } },
+            { payload: { text: 'Reconciled state: Alpha 4, Beta 7' } },
+          ],
+        },
+      }),
+    ).toEqual(['Alpha 2, Beta 3', 'Alpha 4, Beta 7']);
+  });
+
+  it('does not turn an unverified locator into fallback answer text', () => {
+    expect(
+      collectAnswerLevelMediaStatements({
+        success: true,
+        claimVerification: { status: 'needs-corroboration' },
+        evidence: [{ payload: { text: 'An unrelated nearby scene.' } }],
+      }),
+    ).toEqual([]);
+  });
+
+  it('does not promote a partial source observation when a scan is complete', () => {
+    expect(
+      collectAnswerLevelMediaStatements({
+        success: true,
+        claimVerification: { status: 'directly-established' },
+        evidence: [
+          {
+            payload: {
+              text: 'Observed context (not a complete answer): Three people are visible.\nClaim verdict: partial',
+            },
+          },
+        ],
+      }),
+    ).toEqual([]);
+  });
+});
+
+describe('collectObservedSubjectLedger', () => {
+  it('keeps the source-wide recurrence ledger when a local direct observation also answered', () => {
+    expect(
+      collectObservedSubjectLedger({
+        videoEvidence: {
+          success: true,
+          claimVerification: { status: 'directly-established' },
+          directObservation: { readings: [{ found: 'The requested moment is established.' }] },
+          observedSubjects: [
+            {
+              identity: 'grey-haired person in a purple checkered shirt',
+              identityBasis: 'source-described',
+              appearances: [
+                { startSecs: 55.022, endSecs: 55.022 },
+                { startSecs: 895.022, endSecs: 895.022 },
+              ],
+            },
+          ],
+        },
+      }),
+    ).toEqual([
+      'Reconciled visible subject: grey-haired person in a purple checkered shirt\n' +
+        'Identity basis: source-described\n' +
+        'Observed appearances: 55.022-55.022s; 895.022-895.022s',
+    ]);
+  });
+
+  it('does not expose a ledger attached to an unverified media result', () => {
+    expect(
+      collectObservedSubjectLedger({
+        success: true,
+        claimVerification: { status: 'needs-corroboration' },
+        observedSubjects: [
+          {
+            identity: 'unverified subject',
+            identityBasis: 'source-described',
+            appearances: [{ startSecs: 10, endSecs: 20 }],
+          },
+        ],
+      }),
+    ).toEqual([]);
+  });
+});
+
+describe('formatLocatedObservedSubjectAnswer', () => {
+  it('does not attach a remote proper name to an unnamed subject at the requested position', () => {
+    expect(
+      formatLocatedObservedSubjectAnswer({
+        success: true,
+        claimVerification: { status: 'directly-established' },
+        investigation: {
+          directive: {
+            scope: 'temporal',
+            goal: 'trace',
+            recordSet: 'observed',
+            timeRange: { startSecs: 840, endSecs: 900 },
+          },
+        },
+        evidence: [
+          {
+            payload: {
+              text:
+                'A grey-haired person speaks into a microphone.\n' +
+                'Visible subject: {"identity":"grey-haired person in a purple checkered shirt","identityBasis":"source-described","startMs":830000,"endMs":858028}',
+            },
+          },
+        ],
+        observedSubjects: [
+          {
+            identity: 'Brian Cox',
+            identityBasis: 'source-named',
+            appearances: [{ startSecs: 58, endSecs: 64 }],
+          },
+          {
+            identity: 'grey-haired person in a purple checkered shirt',
+            identityBasis: 'source-described',
+            appearances: [{ startSecs: 830, endSecs: 858.028 }],
+          },
+        ],
+      }),
+    ).toBe(
+      'I saw grey-haired person in a purple checkered shirt at 13:50–14:18. ' +
+        'This is a source-described identification, so I cannot safely equate it with a separately named appearance. ' +
+        'The recorded interval for this exact description: 13:50–14:18.',
+    );
+  });
+
+  it('keeps a point observation at the exact range boundary and includes its direct claim', () => {
+    expect(
+      formatLocatedObservedSubjectAnswer({
+        success: true,
+        claimVerification: { status: 'directly-established' },
+        investigation: {
+          directive: {
+            scope: 'temporal',
+            goal: 'trace',
+            recordSet: 'observed',
+            timeRange: { startSecs: 840, endSecs: 900 },
+          },
+        },
+        evidence: [
+          {
+            payload: {
+              text:
+                'A presenter delivers a sponsor segment.\n' +
+                'Visible subject: {"identity":"Presenter in plaid shirt","identityBasis":"unresolved","startMs":840000,"endMs":840000}\n' +
+                'Claim answer: At 14:00, an unnamed presenter in a plaid shirt delivers a sponsor segment.',
+            },
+          },
+          {
+            payload: {
+              text:
+                'A grey-haired presenter continues speaking.\n' +
+                'Visible subject: {"identity":"Presenter with grey hair","identityBasis":"source-described","startMs":886352,"endMs":886352}',
+            },
+          },
+        ],
+        observedSubjects: [
+          {
+            identity: 'Presenter in plaid shirt',
+            identityBasis: 'unresolved',
+            appearances: [{ startSecs: 840, endSecs: 840 }],
+          },
+          {
+            identity: 'Presenter with grey hair',
+            identityBasis: 'source-described',
+            appearances: [
+              { startSecs: 820.086, endSecs: 820.086 },
+              { startSecs: 886.352, endSecs: 886.352 },
+            ],
+          },
+        ],
+      }),
+    ).toBe(
+      'At 14:00, an unnamed presenter in a plaid shirt delivers a sponsor segment. ' +
+        'I saw Presenter in plaid shirt at 14:00–14:00. ' +
+        'This is an unresolved identification, so I cannot safely equate it with a separately named appearance. ' +
+        'The recorded interval for this exact description: 14:00. ' +
+        'The source also uses separate visible-subject labels: Presenter with grey hair (source-described) at 13:40, 14:46. ' +
+        'It does not establish that those labels are the same identity.',
+    );
+  });
+});
+
+describe('formatObservedAppearanceAnswer', () => {
+  it('preserves every repeated protocol-backed appearance without inferring continuity', () => {
+    expect(
+      formatObservedAppearanceAnswer({
+        videoEvidence: {
+          success: true,
+          claimVerification: { status: 'directly-established' },
+          evidence: [
+            {
+              payload: {
+                text:
+                  'Reconciled visible subject: grey-haired person in a purple checkered shirt\n' +
+                  'Identity basis: source-described\n' +
+                  'Observed appearances: 55.022-55.022s; 895.022-895.022s',
+              },
+            },
+          ],
+        },
+      }),
+    ).toBe(
+      'I saw grey-haired person in a purple checkered shirt at 00:55.022 and 14:55.022. These are separate observed moments, not continuous visibility.',
+    );
+  });
+
+  it('does not turn a single observed moment into a recurrence answer', () => {
+    expect(
+      formatObservedAppearanceAnswer({
+        success: true,
+        claimVerification: { status: 'directly-established' },
+        evidence: [
+          {
+            payload: {
+              text:
+                'Reconciled visible subject: blue bird\n' +
+                'Identity basis: source-described\n' +
+                'Observed appearances: 12.000-15.000s',
+            },
+          },
+        ],
+      }),
+    ).toBeUndefined();
+  });
+
+  it('leaves a multi-subject source result to the grounded prose renderer', () => {
+    expect(
+      formatObservedAppearanceAnswer({
+        success: true,
+        claimVerification: { status: 'directly-established' },
+        evidence: [
+          {
+            payload: {
+              text:
+                'Reconciled visible subject: blue bird\n' +
+                'Identity basis: source-described\n' +
+                'Observed appearances: 12.000-15.000s; 30.000-35.000s',
+            },
+          },
+          {
+            payload: {
+              text:
+                'Reconciled visible subject: red fox\n' +
+                'Identity basis: source-described\n' +
+                'Observed appearances: 18.000-20.000s; 45.000-50.000s',
+            },
+          },
+        ],
+      }),
+    ).toBeUndefined();
+  });
+});
+
+describe('formatOutcomeMediaAnswer', () => {
+  it('answers from the latest verified state instead of dumping the whole trail', () => {
+    const answer = formatOutcomeMediaAnswer(
+      {
+        videoEvidence: {
+          success: true,
+          claimVerification: { status: 'established-by-trail' },
+          temporalContext: {
+            readings: [
+              { atSecs: 100, text: 'Reconciled state: Alpha=1200, Beta=900' },
+              { atSecs: 590, text: 'Reconciled state: Final result: Alpha=1200, Beta=1400' },
+            ],
+          },
+        },
+      },
+      { scope: 'temporal', goal: 'trace' },
+    );
+
+    expect(answer).toBe('Beta won, 1400–1200 over Alpha.');
+  });
+
+  it('does not synthesize numeric states for a non-outcome question', () => {
+    expect(
+      formatOutcomeMediaAnswer(
+        {
+          success: true,
+          claimVerification: { status: 'established-by-trail' },
+          temporalContext: {
+            readings: [{ atSecs: 10, text: 'Reconciled state: Alpha=1, Beta=2' }],
+          },
+        },
+        { scope: 'focused', goal: 'answer' },
+      ),
+    ).toBeUndefined();
+  });
+
+  it('preserves the team-to-score binding from a quoted Arabic scoreboard', () => {
+    expect(
+      formatOutcomeMediaAnswer(
+        {
+          success: true,
+          claimVerification: { status: 'established-by-trail' },
+          temporalContext: {
+            readings: [
+              {
+                atSecs: 750.64,
+                text: "On screen: 'الزمالك المصري 2 - 1 الهلال السعودي' — score remains 2-1",
+              },
+            ],
+          },
+        },
+        { scope: 'temporal', goal: 'trace' },
+      ),
+    ).toBe('الزمالك المصري won, 2–1 over الهلال السعودي.');
+  });
+});
+
+describe('formatDirectObservationAnswer', () => {
+  it('returns the strongest verified bounded reading without another model pass', () => {
+    expect(
+      formatDirectObservationAnswer({
+        videoEvidence: {
+          success: true,
+          claimVerification: { status: 'directly-established' },
+          directObservation: {
+            readings: [
+              {
+                found: 'A partial description.',
+                confidence: 'medium',
+                settlesQuestion: true,
+              },
+              {
+                found: 'All four people are described separately and clearly.',
+                confidence: 'high',
+                settlesQuestion: true,
+              },
+            ],
+          },
+        },
+      }),
+    ).toBe('All four people are described separately and clearly.');
+  });
+
+  it('removes social-handle clutter from a positional group-appearance answer', () => {
+    expect(
+      formatDirectObservationAnswer(
+        {
+          success: true,
+          claimVerification: { status: 'directly-established' },
+          directObservation: {
+            readings: [
+              {
+                found:
+                  'From left to right: one wears green, one white-red, one gray, and one white. The first is identified as @unproven.',
+                confidence: 'high',
+                settlesQuestion: true,
+              },
+            ],
+          },
+        },
+        'what was each person wearing?',
+      ),
+    ).toBe('From left to right: one wears green, one white-red, one gray, and one white.');
+  });
+
+  it('does not surface an upstream partial-observation marker as a final answer', () => {
+    expect(
+      formatDirectObservationAnswer({
+        success: true,
+        claimVerification: { status: 'directly-established' },
+        directObservation: {
+          readings: [
+            {
+              found: 'Observed context (not a complete answer): Three people are visible.',
+              confidence: 'high',
+              settlesQuestion: true,
+            },
+          ],
+        },
+      }),
+    ).toBeUndefined();
+  });
+});
+
+describe('formatParticipantInventory', () => {
+  it('renders verified aggregate participants as a compact timestamped table', () => {
+    expect(
+      formatParticipantInventory(
+        {
+          videoEvidence: {
+            success: true,
+            claimVerification: { status: 'directly-established' },
+            evidence: [
+              {
+                timeRange: { startSecs: 150 },
+                payload: {
+                  text: 'Reconciled participant: Zizo — contestant shown on the scoreboard',
+                },
+              },
+              {
+                timeRange: { startSecs: 180 },
+                text: 'Reconciled participant: Ramez — contestant seated on the left',
+              },
+            ],
+          },
+        },
+        'Create a table of every team member by name.',
+      ),
+    ).toBe(
+      '| Participant | Description | Timestamp |\n| --- | --- | --- |\n| Zizo | contestant shown on the scoreboard | [2:30] |\n| Ramez | contestant seated on the left | [3:00] |',
+    );
+  });
+
+  it('does not turn ordinary visual descriptions into an identity table', () => {
+    expect(
+      formatParticipantInventory(
+        {
+          success: true,
+          claimVerification: { status: 'directly-established' },
+          evidence: [{ payload: { text: 'A participant wears a black shirt.' } }],
+        },
+        'List every team member by name.',
+      ),
+    ).toBeUndefined();
+  });
+});
+
+describe('formatExhaustiveMediaAnswer', () => {
+  it('returns every verified item chronologically without a model context limit', () => {
+    const evidence = Array.from({ length: 320 }, (_, index) => ({
+      timeRange: { startSecs: (319 - index) * 30, endSecs: (319 - index) * 30 + 10 },
+      payload: { text: `Source question (spoken): Question ${319 - index}` },
+    }));
+    const answer = formatExhaustiveMediaAnswer(
+      {
+        videoEvidence: {
+          success: true,
+          claimVerification: { status: 'directly-established' },
+          continuation: { exhaustive: true, hasMore: false },
+          evidence,
+        },
+      },
+      'list every question',
+    );
+    expect(answer?.match(/^- \[/gm)).toHaveLength(320);
+    expect(answer).toContain('- [0:00] Question 0');
+    expect(answer).toContain('- [2:39:30] Question 319');
+    expect(answer?.indexOf('Question 0')).toBeLessThan(answer!.indexOf('Question 319'));
+  });
+
+  it('refuses to present an incomplete or unverified inventory as complete', () => {
+    expect(
+      formatExhaustiveMediaAnswer(
+        {
+          success: true,
+          claimVerification: { status: 'needs-corroboration' },
+          continuation: { exhaustive: true, hasMore: false },
+          evidence: [{ payload: { text: 'Source item: one result' } }],
+        },
+        'list everything',
+      ),
+    ).toBeUndefined();
+  });
+
+  it('leaves an exhaustive outcome investigation for concise answer synthesis', () => {
+    const evidence = Array.from({ length: 60 }, (_, index) => ({
+      timeRange: { startSecs: index * 60 },
+      payload: { text: `Reconciled state: Spain ${index + 1}, Argentina 0` },
+    }));
+
+    expect(
+      formatExhaustiveMediaAnswer(
+        {
+          success: true,
+          claimVerification: { status: 'directly-established' },
+          investigation: { directive: { scope: 'source', goal: 'synthesize' } },
+          continuation: { exhaustive: true, hasMore: false },
+          evidence,
+        },
+        'Who won the match?',
+      ),
+    ).toBeUndefined();
+  });
+
+  it('renders an indexed partial structured inventory without asking a model to fill the gaps', () => {
+    const answer = formatExhaustiveMediaAnswer(
+      {
+        success: true,
+        inventory: {
+          recordSet: 'source-questions',
+          coverage: { complete: false, reason: 'One source window was not inventoried.' },
+        },
+        columns: ['Timestamp', 'Content', 'Answer'],
+        rows: [
+          {
+            id: 'question-1',
+            Timestamp: '0:12',
+            Content: 'What changed?',
+            Answer: 'The total rose.',
+          },
+          { id: 'question-2', Timestamp: '0:42', Content: 'Why?', Answer: 'A new entry arrived.' },
+        ],
+        continuation: { exhaustive: true, hasMore: false },
+      },
+      'list every question and answer',
+    );
+
+    expect(answer).toBe(
+      'I completed a scan of 2 indexed source-questions records. The table above contains every matching record currently available, but it is not a guarantee of complete source coverage: One source window was not inventoried.',
+    );
+  });
+
+  it('renders the compact verified Question records returned by the evidence tool', () => {
+    const answer = formatExhaustiveMediaAnswer(
+      {
+        success: true,
+        claimVerification: { status: 'directly-established' },
+        continuation: { exhaustive: true, hasMore: false },
+        evidence: [
+          {
+            timeRange: { startSecs: 12 },
+            payload: { text: 'Question: Who scored?\nContext: Opening round' },
+          },
+          {
+            timeRange: { startSecs: 42 },
+            payload: { text: 'Question: Which team won?\nAnswer: Blue' },
+          },
+        ],
+      },
+      'list every question',
+    );
+
+    expect(answer).toBe(
+      'Here is the complete list in chronological order:\n\n' +
+        '- [0:12] Who scored?\n' +
+        '- [0:42] Which team won?',
+    );
+  });
+
+  it('renders a grounded question-and-respondent table without model synthesis', () => {
+    const answer = formatExhaustiveMediaAnswer(
+      {
+        success: true,
+        claimVerification: { status: 'directly-established' },
+        continuation: { exhaustive: true, hasMore: false },
+        evidence: [
+          {
+            timeRange: { startSecs: 12 },
+            payload: {
+              text: 'Source question (spoken): Who scored?\nSource answer: Blue\nSource respondent: Dana',
+            },
+          },
+        ],
+      },
+      'make a table with every question and who answered it',
+    );
+
+    expect(answer).toBe(
+      '| Question | Answered by | Answer |\n' +
+        '| --- | --- | --- |\n' +
+        '| [0:12] Who scored? | Dana | Blue |',
+    );
+  });
+
+  it('renders legacy source prompts without matching the user language or vocabulary', () => {
+    const answer = formatExhaustiveMediaAnswer(
+      {
+        success: true,
+        claimVerification: { status: 'directly-established' },
+        continuation: { exhaustive: true, hasMore: false },
+        evidence: [
+          {
+            timeRange: { startSecs: 12 },
+            payload: { text: 'Source question (visible, primary): One?' },
+          },
+          {
+            timeRange: { startSecs: 42 },
+            payload: { text: 'Source question (spoken, primary): Two?' },
+          },
+        ],
+      },
+      'كم سؤال موجود؟',
+    );
+
+    expect(answer).toBe(
+      'Here is the complete list in chronological order:\n\n' + '- [0:12] One?\n' + '- [0:42] Two?',
+    );
+  });
+
+  it('leaves a small ordinary timeline for natural answer synthesis', () => {
+    expect(
+      formatExhaustiveMediaAnswer(
+        {
+          success: true,
+          claimVerification: { status: 'directly-established' },
+          continuation: { exhaustive: true, hasMore: false },
+          evidence: [
+            {
+              timeRange: { startSecs: 10 },
+              payload: { text: 'Reconciled state: Left 2, right 4' },
+            },
+          ],
+        },
+        'list the states',
+      ),
+    ).toBeUndefined();
+  });
+});
+
+describe('compactToolContextForModel', () => {
+  it('preserves the evidence-first videoEvidence field on a searchKnowledgeBase result', () => {
+    // Regression: compaction only kept {query, hits}, silently dropping the
+    // embedded video investigation the evidence-first shortcut relies on --
+    // the model's next step then had nothing to answer a video question
+    // from (observed live as a completely empty final chat response, even
+    // though the video had been found correctly).
+    const videoEvidence = { success: true, mediaAssetId: 'asset-1', citations: ['clip-1'] };
+    const [message] = compactToolContextForModel([
+      toolResultMessage('searchKnowledgeBase', {
+        query: 'what crashed',
+        hits: [{ documentId: 'd1', title: 't1', text: 'x'.repeat(2000) }],
+        videoEvidence,
+      }),
+    ]);
+    const output = (message.content[0] as any).output;
+    expect(output.videoEvidence).toEqual(videoEvidence);
+  });
+
+  it('bounds a broad media investigation without discarding its temporal evidence', () => {
+    const evidence = Array.from({ length: 60 }, (_, index) => ({
+      id: `e-${index}`,
+      modality: 'visual',
+      timeRange: { startSecs: index * 60, endSecs: index * 60 + 20 },
+      payload: 'x'.repeat(2_000),
+      confidence: { score: 0.9 },
+    }));
+    const [message] = compactToolContextForModel([
+      toolResultMessage('searchKnowledgeBase', {
+        query: 'whole lecture',
+        hits: [],
+        videoEvidence: {
+          success: true,
+          mediaAssetId: 'asset-1',
+          claimVerification: { directlyEstablished: true },
+          investigation: { answerPath: 'rag', broadCoverage: true },
+          evidence,
+        },
+      }),
+    ]);
+
+    const output = (message.content[0] as any).output.videoEvidence;
+    expect(output.evidence).toHaveLength(48);
+    expect(output.evidence[0].payload).toHaveLength(700);
+    expect(output.claimVerification.directlyEstablished).toBe(true);
+  });
+
+  it('preserves bounded direct re-watch readings and temporal trajectory', () => {
+    const [message] = compactToolContextForModel([
+      toolResultMessage('queryVideoEvidence', {
+        success: true,
+        mediaAssetId: 'asset-1',
+        evidence: [],
+        directObservation: {
+          rule: 'Answer from these readings.',
+          readings: [
+            {
+              range: { startSecs: 10, endSecs: 20 },
+              at: '0:10',
+              found: 'The left person wears orange.',
+              read: ['ORANGE'],
+              confidence: 'high',
+            },
+          ],
+        },
+        temporalContext: {
+          rule: 'Read the states as one trajectory.',
+          readings: [{ atSecs: 10, text: 'Reconciled state: 2 and 3.' }],
+        },
+      }),
+    ]);
+    const output = (message.content[0] as any).output;
+    expect(output.directObservation.readings[0].found).toContain('orange');
+    expect(output.temporalContext.readings).toEqual([
+      { atSecs: 10, text: 'Reconciled state: 2 and 3.' },
+    ]);
+  });
+
+  it('keeps a larger bounded chronological account for an exhaustive video request', () => {
+    const evidence = Array.from({ length: 120 }, (_, index) => ({
+      id: `e-${index}`,
+      modality: 'computed',
+      timeRange: { startSecs: index * 30, endSecs: index * 30 + 10 },
+      payload: `${index}: ${'detail '.repeat(100)}`,
+    }));
+    const [message] = compactToolContextForModel([
+      toolResultMessage('searchKnowledgeBase', {
+        query: 'list everything',
+        hits: [],
+        videoEvidence: {
+          success: true,
+          mediaAssetId: 'asset-1',
+          continuation: { exhaustive: true, hasMore: false, totalItems: 120 },
+          evidence,
+        },
+      }),
+    ]);
+
+    const output = (message.content[0] as any).output.videoEvidence;
+    expect(output.evidence).toHaveLength(120);
+    expect(output.evidence[0].payload).toHaveLength(260);
+    expect(output.continuation).toMatchObject({ exhaustive: true, hasMore: false });
+  });
+
+  it('still bounds hits and truncates long text as before', () => {
+    const manyHits = Array.from({ length: 10 }, (_, i) => ({
+      documentId: `d${i}`,
+      title: `t${i}`,
+      text: 'x'.repeat(5_000),
+    }));
+    const [message] = compactToolContextForModel([
+      toolResultMessage('searchKnowledgeBase', { query: 'q', hits: manyHits }),
+    ]);
+    const output = (message.content[0] as any).output;
+    expect(output.hits).toHaveLength(4);
+    expect(output.hits[0].text.length).toBe(1_200);
+    expect(output.videoEvidence).toBeUndefined();
+  });
+
+  it('leaves messages without array content untouched', () => {
+    const message = { role: 'user', content: 'plain text' };
+    expect(compactToolContextForModel([message])).toEqual([message]);
+  });
+
+  it('still compacts queryTabularData results as before', () => {
+    const rows = Array.from({ length: 100 }, (_, i) => ({ id: i }));
+    const [message] = compactToolContextForModel([
+      toolResultMessage('queryTabularData', { columns: ['id'], rows, totalRows: 100 }),
+    ]);
+    const output = (message.content[0] as any).output;
+    expect(output.rows).toHaveLength(50);
+  });
+
+  it('keeps bounded local PDF page evidence for the visual-analysis step', () => {
+    const [message] = compactToolContextForModel([
+      toolResultMessage('inspectPdfPages', {
+        success: true,
+        documentId: 'pdf-1',
+        title: 'source.pdf',
+        totalPages: 30,
+        pages: Array.from({ length: 5 }, (_, index) => ({
+          pageNumber: index + 1,
+          text: 'x'.repeat(5_000),
+          previewUrl: `/api/pdf-page?documentId=pdf-1&page=${index + 1}`,
+        })),
+      }),
+    ]);
+    const output = (message.content[0] as any).output;
+    expect(output.documentId).toBe('pdf-1');
+    expect(output.pages).toHaveLength(3);
+    expect(output.pages[0].text).toHaveLength(1_600);
+  });
+
+  it('retains bounded PDF page evidence attached to a deterministic search', () => {
+    const [message] = compactToolContextForModel([
+      toolResultMessage('searchKnowledgeBase', {
+        query: 'What does Figure 5.1 show?',
+        hits: [{ documentId: 'pdf-1', title: 'source.pdf', url: '/api/uploads/source.pdf' }],
+        pdfInspection: {
+          success: true,
+          documentId: 'pdf-1',
+          pages: [{ pageNumber: 27, text: 'x'.repeat(5_000) }],
+        },
+        pdfVisualAnalysis: {
+          success: true,
+          documentId: 'pdf-1',
+          pages: [{ pageNumber: 27, analysis: 'a'.repeat(5_000) }],
+        },
+      }),
+    ]);
+    const output = (message.content[0] as any).output;
+    expect(output.pdfInspection.pages[0].pageNumber).toBe(27);
+    expect(output.pdfInspection.pages[0].text).toHaveLength(1_600);
+    expect(output.pdfVisualAnalysis.pages[0].analysis).toHaveLength(3_000);
+  });
+});
+
+describe('collectQuestionMatchedDirectClaims', () => {
+  const evidence = {
+    evidence: [
+      {
+        payload:
+          'Claim question: who won the round\nClaim verdict: direct\nClaim answer: The second side won.',
+      },
+    ],
+  };
+
+  it('returns a direct claim for the same question', () => {
+    expect(collectQuestionMatchedDirectClaims(evidence, 'which side won the round')).toEqual([
+      'The second side won.',
+    ]);
+  });
+
+  it('does not leak an old answer into a different follow-up', () => {
+    expect(collectQuestionMatchedDirectClaims(evidence, 'what was each person wearing')).toEqual(
+      [],
+    );
+  });
+});
+
+describe('withFinalAnswerNudge', () => {
+  it('appends one explicit user message instructing the model to answer now', () => {
+    // Regression: removing every tool for the final-answer step
+    // (activeTools: [], toolChoice: 'none') wasn't reliable signal on its
+    // own for every model -- reproduced live with a reasoning-tagged model
+    // (Claude Sonnet 4.6) on a real, evidence-heavy video question: it
+    // finished with zero tool calls AND zero text, leaving the chat turn
+    // silently empty despite citations already having rendered from the
+    // tool result. The explicit nudge fixed it, confirmed by re-running the
+    // exact same live request afterward.
+    const original = [{ role: 'user', content: 'original question' }];
+    const nudged = withFinalAnswerNudge(original);
+
+    expect(nudged).toHaveLength(2);
+    expect(nudged[0]).toBe(original[0]);
+    expect(nudged[1].role).toBe('user');
+    expect(nudged[1].content[0].text).toMatch(/answer.*now/i);
+  });
+
+  it('does not mutate the input array', () => {
+    const original = [{ role: 'user', content: 'q' }];
+    withFinalAnswerNudge(original);
+    expect(original).toHaveLength(1);
+  });
+});
+
+describe('mediaClaimNeedsCorroboration', () => {
+  it('accepts a conclusion established by a chronological evidence trail', () => {
+    expect(
+      mediaClaimNeedsCorroboration({
+        status: 'established-by-trail',
+        directlyEstablished: false,
+      }),
+    ).toBe(false);
+  });
+
+  it('keeps genuinely unresolved and legacy evidence behind the gate', () => {
+    expect(
+      mediaClaimNeedsCorroboration({
+        status: 'needs-corroboration',
+        directlyEstablished: false,
+      }),
+    ).toBe(true);
+    expect(mediaClaimNeedsCorroboration({ directlyEstablished: false })).toBe(true);
+  });
+});
+
+describe('containsAnswerLevelMediaEvidence', () => {
+  it('accepts a chronological trail even though no single observation is direct', () => {
+    expect(
+      containsAnswerLevelMediaEvidence({
+        videoEvidence: {
+          success: true,
+          claimVerification: {
+            status: 'established-by-trail',
+            directlyEstablished: false,
+          },
+          evidence: [{ payload: 'state one' }, { payload: 'state two' }],
+        },
+      }),
+    ).toBe(true);
+  });
+
+  it('does not promote evidence that still requires corroboration', () => {
+    expect(
+      containsAnswerLevelMediaEvidence({
+        success: true,
+        claimVerification: { status: 'needs-corroboration' },
+        evidence: [{ payload: 'candidate only' }],
+      }),
+    ).toBe(false);
+  });
+});