@pi-unipi/background-tasks 2.6.3 → 2.9.0

package/src/__tests__/fusion-evaluation.test.ts

@@ -1,315 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  assertMergerFindingCoverage,
-  boundedEvaluationErrors,
-  parseFusionEvaluation,
-  parseFusionValidationCandidateReport,
-  recoverFencedFusionValidationCandidateReport,
-  renderValidatedFusionValidationReport,
-  validateFusionEvaluation,
-  validateFusionFindingAccounting,
-} from '../fusion/evaluation.js';
-import {
-  FUSION_EVALUATION_SCHEMA_VERSION,
-  FUSION_VALIDATE_CANDIDATE_SCHEMA_VERSION,
-  FusionError,
-  type FusionValidationFindingAccounting,
-} from '../fusion/types.js';
-
-function validEvaluation(): Record<string, unknown> {
-  return {
-    schema_version: FUSION_EVALUATION_SCHEMA_VERSION,
-    candidate_assessments: [
-      {
-        candidate_id: 'A',
-        summary: 'solid',
-        strengths: ['clear'],
-        limitations: ['brief'],
-        useful_contributions: ['structure'],
-        risks: ['misses edge case'],
-      },
-      {
-        candidate_id: 'B',
-        summary: 'detailed',
-        strengths: ['coverage'],
-        limitations: ['wordy'],
-        useful_contributions: ['tests'],
-        risks: ['overstates'],
-      },
-      {
-        candidate_id: 'C',
-        summary: 'balanced',
-        strengths: ['tradeoffs'],
-        limitations: ['few examples'],
-        useful_contributions: ['risk list'],
-        risks: ['needs cleanup'],
-      },
-    ],
-    agreements: ['all address the request'],
-    conflicts: [
-      {
-        topic: 'scope',
-        positions: [
-          { candidate_id: 'A', position: 'small' },
-          { candidate_id: 'B', position: 'broad' },
-        ],
-        resolution: 'use the smallest complete scope',
-      },
-    ],
-    synthesis_plan: {
-      must_include: [{ candidate_id: 'C', contribution: 'risk list' }],
-      must_resolve: ['scope'],
-      must_avoid: ['unsupported claims'],
-    },
-  };
-}
-
-function singletonAccounting(): FusionValidationFindingAccounting {
-  return {
-    findings: [
-      {
-        id: 'A-F001',
-        candidate_id: 'A',
-        severity: 'high',
-        location: 'src/fusion.ts:12',
-        evidence: 'read line 12',
-        impact: 'breaks workflow',
-        summary: 'workflow bug',
-      },
-    ],
-    decisions: [
-      {
-        source_id: 'A-F001',
-        disposition: 'include',
-        rationale: 'candidate A: A-F001 is supported by evidence',
-        group_id: 'G001',
-      },
-    ],
-    groups: [
-      {
-        group_id: 'G001',
-        source_ids: ['A-F001'],
-        severity: 'high',
-        location: 'src/fusion.ts:12',
-        evidence: 'read line 12',
-        impact: 'breaks workflow',
-        summary: 'workflow bug',
-        rationale: 'the evidence supports inclusion',
-      },
-    ],
-  };
-}
-
-void describe('fusion evaluation schema', () => {
-  void it('accepts a closed valid evaluation object', () => {
-    const parsed = parseFusionEvaluation(JSON.stringify(validEvaluation()));
-    assert.equal(parsed.schema_version, FUSION_EVALUATION_SCHEMA_VERSION);
-    assert.deepEqual(
-      parsed.candidate_assessments.map((entry) => entry.candidate_id),
-      ['A', 'B', 'C'],
-    );
-  });
-
-  void it('rejects wrappers and invalid JSON without substring extraction', () => {
-    assert.throws(() => parseFusionEvaluation('```json\n{}\n```'), /JSON only/);
-    assert.throws(
-      () => parseFusionEvaluation(`${JSON.stringify(validEvaluation())}\nprose`),
-      /JSON only/,
-    );
-  });
-
-  void it('rejects unknown fields, duplicate IDs, and blank strings', () => {
-    const withExtra = validEvaluation();
-    withExtra['winner'] = 'A';
-    const extra = validateFusionEvaluation(withExtra);
-    assert.equal(extra.ok, false);
-    if (!extra.ok) assert.match(extra.errors.join('\n'), /unknown key winner/);
-
-    const duplicate = validEvaluation();
-    const assessments = duplicate['candidate_assessments'];
-    assert.ok(Array.isArray(assessments));
-    const first = assessments[0];
-    assert.ok(typeof first === 'object' && first !== null && !Array.isArray(first));
-    Reflect.set(first, 'candidate_id', 'B');
-    const duplicateResult = validateFusionEvaluation(duplicate);
-    assert.equal(duplicateResult.ok, false);
-    if (!duplicateResult.ok) assert.match(duplicateResult.errors.join('\n'), /unique/);
-
-    const blank = validEvaluation();
-    blank['agreements'] = ['   '];
-    const blankResult = validateFusionEvaluation(blank);
-    assert.equal(blankResult.ok, false);
-    if (!blankResult.ok) assert.match(blankResult.errors.join('\n'), /non-blank/);
-  });
-
-  void it('requires conflict positions from distinct candidates without duplicate IDs', () => {
-    const invalid = validEvaluation();
-    invalid['conflicts'] = [
-      {
-        topic: 'scope',
-        positions: [
-          { candidate_id: 'A', position: 'small' },
-          { candidate_id: 'A', position: 'also small' },
-        ],
-        resolution: 'compare real disagreement',
-      },
-    ];
-    const result = validateFusionEvaluation(invalid);
-    assert.equal(result.ok, false);
-    if (!result.ok) assert.match(result.errors.join('\n'), /two distinct|unique/);
-
-    const duplicateWithTwoIds = validEvaluation();
-    duplicateWithTwoIds['conflicts'] = [
-      {
-        topic: 'scope',
-        positions: [
-          { candidate_id: 'A', position: 'small' },
-          { candidate_id: 'A', position: 'duplicate small' },
-          { candidate_id: 'B', position: 'broad' },
-        ],
-        resolution: 'compare real disagreement',
-      },
-    ];
-    const duplicateResult = validateFusionEvaluation(duplicateWithTwoIds);
-    assert.equal(duplicateResult.ok, false);
-    if (!duplicateResult.ok) assert.match(duplicateResult.errors.join('\n'), /unique/);
-  });
-
-  void it('keeps validation parsing strict while narrowly recovering one audited JSON fence', () => {
-    const report = JSON.stringify({
-      schema_version: FUSION_VALIDATE_CANDIDATE_SCHEMA_VERSION,
-      findings: [],
-      verified: ['read src/file.ts'],
-      limitations: [],
-    });
-    assert.throws(
-      () => parseFusionValidationCandidateReport(`\`\`\`json\n${report}\n\`\`\``, 'A'),
-      /structured JSON only/,
-    );
-    const recovered = recoverFencedFusionValidationCandidateReport(
-      `Validation complete.\n\n\`\`\`json\n${report}\n\`\`\``,
-      'A',
-    );
-    assert.ok(recovered);
-    assert.equal(recovered.normalization, 'prose_then_markdown_json_fence');
-    assert.equal(recovered.response, report);
-    assert.deepEqual(recovered.report.verified, ['read src/file.ts']);
-    assert.equal(
-      recoverFencedFusionValidationCandidateReport(
-        `\`\`\`json\n${report}\n\`\`\`\ntrailing prose`,
-        'A',
-      ),
-      undefined,
-    );
-  });
-
-  void it('validates validation finding singleton, duplicate, and exclusion contracts', () => {
-    const singleton = singletonAccounting();
-    assert.deepEqual(validateFusionFindingAccounting(singleton), []);
-    const rendered = renderValidatedFusionValidationReport(singleton);
-    assert.match(rendered, /# Validation report/);
-    assert.match(rendered, /workflow bug/);
-    assert.doesNotMatch(rendered, /A-F001|candidate A/i, 'rendered rationale must not expose source ids or candidate labels');
-
-    const duplicateDecision: FusionValidationFindingAccounting = {
-      ...singleton,
-      decisions: [singleton.decisions[0]!, { ...singleton.decisions[0]!, rationale: 'duplicate' }],
-    };
-    assert.match(validateFusionFindingAccounting(duplicateDecision).join('\n'), /accounted more than once/);
-
-    const includeWithoutGroup: FusionValidationFindingAccounting = {
-      ...singleton,
-      decisions: [{ source_id: 'A-F001', disposition: 'include', rationale: 'supported' }],
-    };
-    assert.match(validateFusionFindingAccounting(includeWithoutGroup).join('\n'), /group_id required/);
-
-    const excludedWithGroup: FusionValidationFindingAccounting = {
-      ...singleton,
-      decisions: [
-        { source_id: 'A-F001', disposition: 'exclude', rationale: 'duplicate of stronger finding', group_id: 'G001' },
-      ],
-    };
-    assert.match(validateFusionFindingAccounting(excludedWithGroup).join('\n'), /group_id must be omitted/);
-
-    const excluded: FusionValidationFindingAccounting = {
-      ...singleton,
-      decisions: [{ source_id: 'A-F001', disposition: 'exclude', rationale: 'candidate A: not supported' }],
-      groups: [],
-    };
-    assert.deepEqual(validateFusionFindingAccounting(excluded), []);
-    const excludedReport = renderValidatedFusionValidationReport(excluded);
-    assert.match(excludedReport, /No included findings/);
-    assert.match(excludedReport, /Excluded source findings/);
-    assert.doesNotMatch(excludedReport, /candidate A|A-F001/i);
-  });
-
-  void it('merges distinct duplicate source findings into one resolved group', () => {
-    const singleton = singletonAccounting();
-    const duplicate: FusionValidationFindingAccounting = {
-      findings: [
-        ...singleton.findings,
-        {
-          ...singleton.findings[0]!,
-          id: 'B-F001',
-          candidate_id: 'B',
-          severity: 'minor',
-          evidence: 'independent read of line 12',
-        },
-      ],
-      decisions: [
-        { source_id: 'A-F001', disposition: 'include', rationale: 'supported', group_id: 'G001' },
-        { source_id: 'B-F001', disposition: 'include', rationale: 'same defect', group_id: 'G001' },
-      ],
-      groups: [
-        {
-          ...singleton.groups[0]!,
-          source_ids: ['A-F001', 'B-F001'],
-          severity: 'high',
-          evidence: 'both reviewers independently read line 12',
-          rationale: 'same location and failure mechanism; high severity has stronger support',
-        },
-      ],
-    };
-    assert.deepEqual(validateFusionFindingAccounting(duplicate), []);
-    const rendered = renderValidatedFusionValidationReport(duplicate);
-    assert.equal((rendered.match(/### high: workflow bug/gu) ?? []).length, 1);
-    assert.doesNotMatch(rendered, /### minor:/u);
-  });
-
-  void it('rejects validation merger dropped and invented group IDs', () => {
-    const singleton = singletonAccounting();
-    assert.doesNotThrow(() => assertMergerFindingCoverage(singleton, ['G001']));
-    assert.throws(
-      () => assertMergerFindingCoverage(singleton, []),
-      /merger dropped included group G001/,
-    );
-    assert.throws(
-      () => assertMergerFindingCoverage(singleton, ['G001', 'G999']),
-      /invented or revived group G999/,
-    );
-  });
-
-  void it('bounds validation errors for repair prompts and user-facing failures', () => {
-    const errors = Array.from(
-      { length: 200 },
-      (_, index) => `error-${String(index)}-${'x'.repeat(800)}`,
-    );
-    const bounded = boundedEvaluationErrors(errors);
-    assert.ok(bounded.length < errors.length);
-    assert.ok(bounded.join('').length < 4300);
-    assert.match(bounded.at(-1) ?? '', /omitted/);
-  });
-
-  void it('throws a typed error for invalid parsed content', () => {
-    assert.throws(
-      () =>
-        parseFusionEvaluation(JSON.stringify({ schema_version: FUSION_EVALUATION_SCHEMA_VERSION })),
-      (error: unknown) => {
-        assert.ok(error instanceof FusionError);
-        assert.equal(error.code, 'evaluation_invalid');
-        return true;
-      },
-    );
-  });
-});

package/src/__tests__/fusion-extraction-equivalence.test.ts

@@ -1,58 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { buildFusionCleanTaskCanonicalInput } from '../fusion/clean-context.js';
-import { buildFusionCanonicalInput } from '../fusion/context.js';
-import { canonicalJson } from '../attested-pi-run.js';
-import { sessionWith, userMessage } from './helpers/fusion-canonical.js';
-
-void describe('fusion v5 context boundaries', () => {
-  void it('keeps reason as the only workflow that projects parent conversation', () => {
-    const sessionManager = sessionWith([userMessage('visible parent text')]);
-    const built = buildFusionCanonicalInput({ cwd: '/repo', sessionManager, getSystemPrompt: () => 'parent system' }, { source: 'tool', request: 'reason about this', toolName: 'fusion_reason' });
-    assert.equal(built.input.workflow, 'reason');
-    assert.equal(built.input.context?.kind, 'session_projection');
-    assert.match(built.serialized, /visible parent text/);
-    assert.match(built.serialized, /parent system/);
-  });
-
-  void it('clean canonical input is byte-identical across unrelated parent sessions with same request and cwd', () => {
-    const parentSentinel = 'PARENT-SESSION-SENTINEL-never-forward';
-    const unrelatedLeft = sessionWith([userMessage(`left ${parentSentinel}`)]);
-    const unrelatedRight = sessionWith([userMessage(`right ${parentSentinel}`)]);
-    assert.notDeepEqual(unrelatedLeft.getEntries(), unrelatedRight.getEntries());
-
-    const requests = {
-      investigate: canonicalJson({ objective: 'inspect', background: [], deliverable: 'answer', scope: [], constraints: [] }),
-      research: canonicalJson({ objective: 'research', background: [], deliverable: 'answer', scope: [], constraints: [], sources: [{ url: 'https://example.com/a', purpose: 'unit' }] }),
-      validate: canonicalJson({ objective: 'validate', background: [], changeSummary: 'changed', scope: ['src'], acceptanceCriteria: ['works'], verification: { status: 'not_run', evidence: [], reason: 'unit' }, knownLimitations: [], exclusions: [] }),
-    } as const;
-
-    for (const [workflow, request] of Object.entries(requests) as Array<[keyof typeof requests, string]>) {
-      const declaredSources = workflow === 'research'
-        ? [{ url: 'https://example.com/a', purpose: 'unit' }]
-        : [];
-      const left = buildFusionCleanTaskCanonicalInput({ cwd: '/repo', source: 'tool', workflow, request, declaredSources });
-      const right = buildFusionCleanTaskCanonicalInput({ cwd: '/repo', source: 'tool', workflow, request, declaredSources });
-      assert.equal(left.serialized, right.serialized, workflow);
-      assert.equal(left.input.context.kind, 'clean_task');
-      assert.equal('system_prompt' in left.input, false);
-      assert.equal('conversation_projection' in left.input, false);
-      assert.equal('ledger' in left, false);
-      assert.doesNotMatch(left.serialized, new RegExp(parentSentinel));
-    }
-  });
-
-  void it('refuses old parent-session projection fallback before touching throwing clean accessors', () => {
-    const throwingParent = {
-      get cwd(): never { throw new Error('clean workflow touched parent cwd'); },
-      get sessionManager(): never { throw new Error('clean workflow touched parent session'); },
-      getSystemPrompt(): never { throw new Error('clean workflow touched parent system prompt'); },
-    };
-    for (const workflow of ['investigate', 'research', 'validate'] as const) {
-      assert.throws(
-        () => buildFusionCanonicalInput(throwingParent as never, { source: 'tool', request: 'clean', workflow }),
-        /parent session projection is available only to the reason workflow/,
-      );
-    }
-  });
-});

package/src/__tests__/fusion-golden-bytes.test.ts

@@ -1,35 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFile } from 'node:fs/promises';
-import { createHash } from 'node:crypto';
-import { buildFusionCleanTaskCanonicalInput } from '../fusion/clean-context.js';
-import { canonicalJson } from '../attested-pi-run.js';
-
-async function fixture(path: string | URL): Promise<unknown> {
-  return JSON.parse(await readFile(path, 'utf8')) as unknown;
-}
-
-void describe('fusion historical and v5 canonical fixtures', () => {
-  void it('keeps historical v4 golden fixtures explicitly historical', async () => {
-    const brainstorm = await fixture(new URL('../fixtures/fusion-golden-bytes.json', import.meta.url));
-    const validate = await fixture(new URL('../fixtures/fusion-validate-golden-bytes.json', import.meta.url));
-    assert.equal(typeof brainstorm, 'object');
-    assert.equal(typeof validate, 'object');
-    const bytes = await readFile(new URL('../fixtures/fusion-golden-bytes.json', import.meta.url));
-    assert.equal(createHash('sha256').update(bytes).digest('hex').length, 64);
-  });
-
-  void it('pins a reviewed v5 clean canonical input shape without parent context', () => {
-    const built = buildFusionCleanTaskCanonicalInput({
-      cwd: '/repo',
-      source: 'tool',
-      workflow: 'investigate',
-      request: canonicalJson({ objective: 'o', background: [], deliverable: 'd', scope: [], constraints: [] }),
-    });
-    assert.equal(built.input.schema_version, 'pi-background-tasks.fusion-input.v5');
-    assert.equal(built.input.context.kind, 'clean_task');
-    assert.equal('system_prompt' in built.input, false);
-    assert.equal('conversation_projection' in built.input, false);
-    assert.equal(built.serialized, canonicalJson(built.input));
-  });
-});

package/src/__tests__/fusion-high-cardinality.test.ts

@@ -1,192 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { canonicalJson } from '../attested-pi-run.js';
-import { FusionBudget } from '../fusion/budget.js';
-import {
-  FUSION_COMMAND_CONTEXT_POLICY_ID,
-  type ResolvedFusionModel,
-  type ResolvedFusionModels,
-} from '../fusion/types.js';
-import {
-  buildFrom,
-  omissionEntries,
-  projectedText,
-  type ExpandedFusionOmissionEntry,
-} from './helpers/fusion-canonical.js';
-import { buildHighCardinalitySession } from './helpers/fusion-high-cardinality.js';
-
-/**
- * Regression coverage for the production incident in which omission receipts
- * grew to 43% of a 290 KB projected prompt (340 runs over 1,465 omitted
- * events). Existing fixtures used a few very large tool results and therefore
- * could not reproduce it: the cost came from receipt cardinality, not payload
- * size.
- */
-function resolved(qualifiedId: string, contextWindow: number): ResolvedFusionModel {
-  const slash = qualifiedId.indexOf('/');
-  return {
-    selection: '$current',
-    source: 'current',
-    provider: qualifiedId.slice(0, slash),
-    model: qualifiedId.slice(slash + 1),
-    qualifiedId,
-    thinkingLevel: 'high',
-    contextWindow,
-    maxOutputTokens: 32_768,
-  };
-}
-
-function codexModels(): ResolvedFusionModels {
-  return {
-    candidates: [
-      resolved('openai-codex/gpt-5.6-sol', 272_000),
-      resolved('openai-codex/gpt-5.6-terra', 272_000),
-      resolved('openai-codex/gpt-5.5', 272_000),
-    ],
-    evaluator: resolved('openai-codex/gpt-5.6-sol', 272_000),
-    merger: resolved('openai-codex/gpt-5.6-sol', 272_000),
-  };
-}
-
-void describe('fusion high-cardinality tool activity', () => {
-  void it('keeps receipt metadata small when omitted events are numerous and short', () => {
-    const session = buildHighCardinalitySession();
-    const built = buildFrom(session.messages, { source: 'tool', request: 'summarize' });
-    const projection = built.input.conversation_projection;
-    const receipts = omissionEntries(built.input);
-
-    // One receipt per retained-text separated run, and every event ledgered.
-    assert.equal(receipts.length, session.expectedRuns);
-    assert.equal(built.ledger.entries.length, session.expectedLedgerEvents);
-    assert.equal(projection.accounting.omitted_run_count, session.expectedRuns);
-    assert.equal(projection.accounting.omitted_event_count, session.expectedLedgerEvents);
-
-    // Per-receipt cost is the quantity that regressed: the incident averaged
-    // 356 bytes per receipt because each carried a run hash, ledger indices,
-    // and a per-kind byte map. Pin the compact cost directly, since the ratio
-    // to total payload depends on how much visible text a fixture happens to
-    // contain and is therefore not a stable signal.
-    const receiptBytes = projection.accounting.omission_receipt_utf8_bytes;
-    const perReceipt = receiptBytes / receipts.length;
-    assert.ok(
-      perReceipt < 140,
-      `each receipt must stay compact, saw ${perReceipt.toFixed(1)} bytes`,
-    );
-
-    // Receipt metadata must never exceed the conversational text it annotates.
-    const visibleBytes =
-      projection.accounting.included_user_text_bytes +
-      projection.accounting.included_assistant_text_bytes;
-    assert.ok(
-      receiptBytes < visibleBytes,
-      `receipts (${String(receiptBytes)} B) must not outweigh visible text (${String(visibleBytes)} B)`,
-    );
-  });
-
-  void it('emits only the compact model-facing receipt tuple', () => {
-    const session = buildHighCardinalitySession({ runs: 8 });
-    const built = buildFrom(session.messages, { source: 'tool', request: 'r' });
-    const compactReceipts = built.input.conversation_projection.entries.filter(
-      (entry) => entry[0] === 'o',
-    );
-    assert.equal(compactReceipts.length, session.expectedRuns);
-    for (const receipt of compactReceipts) {
-      assert.equal(receipt.length, 4);
-      assert.equal(receipt[0], 'o');
-      const span = receipt[1];
-      assert.equal(span.length, 2);
-      assert.ok(span[0] <= span[1]);
-      assert.ok(Number.isSafeInteger(receipt[2]) && receipt[2] >= 0);
-      const counts = receipt[3];
-      assert.equal(counts.length, 3);
-      for (const value of counts) {
-        assert.ok(Number.isSafeInteger(value) && value >= 0, 'tuple counts must be non-negative');
-      }
-    }
-    for (const receipt of omissionEntries(built.input)) {
-      assert.deepEqual(Object.keys(receipt).sort(), ['at', 'bytes', 'counts', 'kind']);
-    }
-    // Retired coordinates and hashes must not reappear in the prompt bytes.
-    for (const banned of [
-      'ledger_run_sha256',
-      'ledger_index_first',
-      'ledger_index_last',
-      'source_ordinal_first',
-      'payload_bytes',
-    ]) {
-      assert.doesNotMatch(built.serialized, new RegExp(banned), banned);
-    }
-  });
-
-  void it('reconciles every receipt against the ledger it summarizes', () => {
-    const session = buildHighCardinalitySession({ runs: 12 });
-    const built = buildFrom(session.messages, { source: 'tool', request: 'r' });
-    const map = built.ledger.projection_map;
-
-    // Every ledger row is represented exactly once.
-    const covered = new Set<number>();
-    for (const entry of map) {
-      for (let i = entry.ledger_index_first; i <= entry.ledger_index_last; i++) {
-        assert.equal(covered.has(i), false, `ledger row ${String(i)} mapped twice`);
-        covered.add(i);
-      }
-    }
-    assert.equal(covered.size, built.ledger.entries.length);
-
-    // Receipt byte totals recompute exactly from the mapped ledger rows.
-    const receipts = omissionEntries(built.input);
-    const receiptMaps = map.filter((entry) => entry.entry_kind === 'omitted_activity');
-    assert.equal(receiptMaps.length, receipts.length);
-    for (const [index, entry] of receiptMaps.entries()) {
-      const rows = built.ledger.entries.slice(
-        entry.ledger_index_first,
-        entry.ledger_index_last + 1,
-      );
-      const expected = rows
-        .filter((row) => row.kind !== 'tool_result_image')
-        .reduce((total, row) => total + row.payload_bytes, 0);
-      const receipt = receipts[index];
-      assert.ok(receipt);
-      assert.equal(receipt.bytes, expected, `receipt ${String(index)} byte total mismatch`);
-    }
-  });
-
-  void it('preserves all conversational text and forwards no tool payload', () => {
-    const session = buildHighCardinalitySession({ runs: 20 });
-    const built = buildFrom(session.messages, { source: 'tool', request: 'r' });
-    const text = projectedText(built.input);
-    for (let run = 0; run < 20; run++) {
-      assert.match(text, new RegExp(`USER-TURN-${String(run)} `));
-      assert.match(text, new RegExp(`ASSISTANT-TURN-${String(run)} `));
-    }
-    // Payload and thinking sentinels never reach the prompt.
-    assert.doesNotMatch(built.serialized, /g{50}/);
-    assert.doesNotMatch(built.serialized, /z{50}/);
-    assert.doesNotMatch(built.serialized, /k{50}/);
-  });
-
-  void it('keeps input-only workflow preflight inside a real route budget', () => {
-    const session = buildHighCardinalitySession();
-    const built = buildFrom(session.messages, { source: 'tool', request: 'summarize' });
-    const budget = new FusionBudget(codexModels(), FUSION_COMMAND_CONTEXT_POLICY_ID);
-    const plan = budget.plan(built.input);
-    assert.equal(plan.blockers.length, 0);
-    for (const stage of plan.stages) {
-      assert.ok(
-        stage.input_only_input_tokens_upper_bound <= stage.allowed_input_tokens,
-        `${stage.budget_stage} input must fit the limiting route, saw ${String(stage.input_only_input_tokens_upper_bound)} of ${String(stage.allowed_input_tokens)}`,
-      );
-    }
-    assert.equal(plan.warnings.some((entry) => entry.warning_kind === 'worst_case_reservation'), true);
-  });
-
-  void it('produces byte-identical output for repeated construction', () => {
-    const session = buildHighCardinalitySession({ runs: 30 });
-    const first = buildFrom(session.messages, { source: 'tool', request: 'same' });
-    const second = buildFrom(session.messages, { source: 'tool', request: 'same' });
-    assert.equal(first.serialized, second.serialized);
-    assert.equal(canonicalJson(first.ledger), canonicalJson(second.ledger));
-    const receipts: readonly ExpandedFusionOmissionEntry[] = omissionEntries(first.input);
-    assert.equal(receipts.length, session.expectedRuns);
-  });
-});