test: fold per-incident replay series into their detector owners (D)

Twelve detector families move into one owner test each: 73 incident files
become describe blocks in ceo-section-loading-fixture (stale-fill race),
model-overlays, coverage-audit-evidence, autoplan-phase-observer,
native-auto-decide, outside-voice-evidence, eng-first-review,
plan-count-completion, plan-count-file-permission, ceo-mode-option,
plan-scope-selection and plan-count-prerequisite. Each block keeps its original
code and fixture, so every case still runs; only tests asserting the incident
file's own touchfile registration are dropped (41). Touchfile lists that named
an incident now name its owner.

test/plan-count-prerequisite.test.ts

@@ -0,0 +1,252 @@
+/**
+ * Native prerequisite and navigation picks (planCountPrerequisitePick) over captured calls.
+ */
+import { describe } from 'bun:test';
+import { expect } from 'bun:test';
+import { test } from 'bun:test';
+import { capturePlanCountQuestion } from './helpers/claude-pty-runner';
+import { nativePlanCallFingerprint } from './helpers/claude-pty-runner';
+import { planCountPrerequisitePick } from './helpers/claude-pty-runner';
+import { planCountQuestionInput } from './helpers/claude-pty-runner';
+import type { NativePlanQuestionCall } from './helpers/plan-count-transcript';
+import prerequisite_plan_count_navigation_r from './fixtures/dx-prerequisite-r-call.json';
+import callFixture_plan_count_prerequisite_n from './fixtures/ceo-prerequisite-n-call.json';
+import engPrerequisite77_plan_count_prerequisite_n from './fixtures/eng-prerequisite-77.json';
+
+describe('plan-count-navigation-r', () => {
+const prerequisite = prerequisite_plan_count_navigation_r;
+function pending(source: NativePlanQuestionCall): NativePlanQuestionCall {
+  const call = structuredClone(source);
+  call.answered = false;
+  delete call.answers;
+  delete call.unansweredQuestionIndices;
+  delete call.answeredAt;
+  return call;
+}
+function frame(call: NativePlanQuestionCall) {
+  const q = call.questions[0]!;
+  const visible = `☐ ${q.header}\n${q.question}\n${q.options.map((o, i) => `${i ? ' ' : '❯'} ${i + 1}. ${o.label}`).join('\n')}\nEnter to select · ↑/↓ to navigate · Esc to cancel`;
+  const active = capturePlanCountQuestion(visible, new Set(), 0, true, call)!;
+  return { visible, active, routing: nativePlanCallFingerprint(call, 0, true) };
+}
+
+describe('captured R planning navigation', () => {
+  test('DX declines its optional office-hours detour using the full native option meaning', () => {
+    const call = pending(prerequisite as NativePlanQuestionCall);
+    const { visible, active, routing } = frame(call);
+    expect(active.nativeCall).toBe(call);
+    expect(prerequisite.answers[prerequisite.questions[0]!.question]).toBe(prerequisite.questions[0]!.options[0]!.label);
+    const pick = planCountPrerequisitePick(routing, active) ?? 1;
+    expect(pick).toBe(2);
+    expect(planCountQuestionInput(visible, active, pick)).toBe('2');
+  });
+  test('short prerequisite labels require the current native question and affirmative review action', () => {
+    for (const change of [
+      (c: NativePlanQuestionCall) => { c.questions[0]!.options[1]!.description = ''; },
+      (c: NativePlanQuestionCall) => { c.questions[0]!.options[1]!.description = 'Do not proceed with standard DX POLISH review.'; },
+      (c: NativePlanQuestionCall) => { c.questions[0]!.options[1]!.description = 'Accept the finding and proceed with standard DX POLISH review.'; },
+      (c: NativePlanQuestionCall) => { c.questions[0]!.options[1]!.description = 'Accept this security finding. Proceed with standard DX POLISH review.'; },
+      (c: NativePlanQuestionCall) => { c.questions[0]!.options[1]!.description = 'Proceed with standard DX POLISH review after running /office-hours first.'; },
+      (c: NativePlanQuestionCall) => { c.questions[0]!.options[1]!.description = 'Proceed with standard DX POLISH review? No, run /office-hours first.'; },
+      (c: NativePlanQuestionCall) => { c.questions[0]!.options[1]!.description = 'Proceed with standard DX POLISH review. Accept the security risk.'; },
+      (c: NativePlanQuestionCall) => { c.questions[0]!.options[1]!.description = 'Plan scope is already precise. Proceed with standard DX POLISH review if the tests pass.'; },
+      (c: NativePlanQuestionCall) => { c.questions[0]!.options.push({ label: 'Accept this security finding' }); },
+      (c: NativePlanQuestionCall) => { c.questions[0]!.multiSelect = true; },
+      (c: NativePlanQuestionCall) => { c.questions.push(structuredClone(c.questions[0]!)); },
+      (c: NativePlanQuestionCall) => { c.answered = true; },
+      (c: NativePlanQuestionCall) => { c.failed = true; },
+    ]) {
+      const call = pending(prerequisite as NativePlanQuestionCall);
+      change(call);
+      const fp = nativePlanCallFingerprint(call, 0, true);
+      expect(planCountPrerequisitePick(fp)).toBeNull();
+    }
+    const call = pending(prerequisite as NativePlanQuestionCall);
+    const { active, routing, visible } = frame(call);
+    expect(planCountPrerequisitePick(routing, { ...active, preReview: false })).toBeNull();
+    expect(planCountPrerequisitePick(routing, { ...active, signature: 'stale:question' })).toBeNull();
+    expect(planCountPrerequisitePick(routing, { ...active, nativeQuestionIndex: 1 })).toBeNull();
+    expect(planCountPrerequisitePick(routing, { ...active, options: active.options.slice().reverse() })).toBeNull();
+    const visibleOnly = capturePlanCountQuestion(visible, new Set(), 0, true)!;
+    expect(visibleOnly.nativeCall).toBeUndefined();
+    expect(planCountPrerequisitePick(routing, visibleOnly)).toBeNull();
+    call.questions[0]!.options.reverse();
+    const reordered = frame(call);
+    expect(planCountPrerequisitePick(reordered.routing, reordered.active)).toBe(1);
+  });
+
+  test('a bare short label uses its bound unconditional review meaning', () => {
+    const call = pending(prerequisite as NativePlanQuestionCall);call.questions[0]!.options[1]!.label='Skip';
+    const {active,routing}=frame(call);expect(planCountPrerequisitePick(routing,active)).toBe(2);
+  });
+
+  test('short labels allow only a benign plan-scope premise plus the unconditional review action', () => {
+    for (const description of ['Proceed with standard review.', 'Proceed with standard DX review', 'The plan is clear. Proceed with standard DX POLISH review.', 'Plan scope is already precise. Proceed with standard DX POLISH review.']) {
+      const call = pending(prerequisite as NativePlanQuestionCall);
+      call.questions[0]!.options[1]!.description = description;
+      const { active, routing } = frame(call);
+      expect(planCountPrerequisitePick(routing, active)).toBe(2);
+    }
+  });
+});
+});
+
+describe('plan-count-prerequisite-n', () => {
+const callFixture = callFixture_plan_count_prerequisite_n;
+const engPrerequisite77 = engPrerequisite77_plan_count_prerequisite_n;
+const call = () => structuredClone(callFixture);
+
+describe('native prerequisite review-now offer', () => {
+  test('the captured CEO offer keeps the supplied plan instead of starting office hours', () => {
+    const fp = nativePlanCallFingerprint(call(), 0, true);
+    expect(planCountPrerequisitePick(fp)).toBe(2);
+    expect(planCountPrerequisitePick({ ...fp, preReview: false })).toBeNull();
+  });
+
+  test('the visible offer works before metadata arrives and follows reordered choices', () => {
+    for (const reverse of [false, true]) {
+      const native = call();
+      if (reverse) native.questions[0]!.options.reverse();
+      const q = native.questions[0]!;
+      const screen = ['☐ Prerequisite', q.question.split('\n\n')[0],
+        `❯ 1. ${q.options[0]!.label}`, `  2. ${q.options[1]!.label}`,
+        '  3. Type something.', '  4. Chat about this',
+        'Enter to select · ↑/↓ to navigate · Esc to cancel'].join('\n');
+      const fp = capturePlanCountQuestion(screen, new Set(), 0, true)!;
+      expect(fp).not.toBeNull();
+      expect(planCountPrerequisitePick(fp)).toBe(reverse ? 1 : 2);
+    }
+  });
+
+  test('the extra wording does not authorize skipping a finding or mixed decision', () => {
+    const fp = nativePlanCallFingerprint(call(), 0, true);
+    for (const skip of ['Skip', 'Skip — review now and ignore security', 'Skip — review now or delete the plan']) {
+      expect(planCountPrerequisitePick({ ...fp, options: [fp.options[0]!, { index: 2, label: skip }] })).toBeNull();
+    }
+    expect(planCountPrerequisitePick({ ...fp, promptSnippet: 'Should we skip this SQL injection finding?' })).toBeNull();
+    expect(planCountPrerequisitePick({ ...fp, options: [...fp.options, { index: 3, label: 'Fix SQL injection' }] })).toBeNull();
+    expect(planCountPrerequisitePick({ ...fp, options: [fp.options[0]!, { ...fp.options[1]!, index: 1 }] })).toBeNull();
+    expect(planCountPrerequisitePick({ ...fp, options: [{ index: 1, label: 'Run /office-hours first and rewrite the API' }, fp.options[1]!] })).toBeNull();
+    for (const mutate of [
+      (c: any) => { c.failed = true; },
+      (c: any) => { c.questions[0].multiSelect = true; },
+      (c: any) => { c.questions.push(structuredClone(c.questions[0])); },
+    ]) {
+      const native = call(); mutate(native);
+      expect(planCountPrerequisitePick(nativePlanCallFingerprint(native, 0, true))).toBeNull();
+    }
+  });
+});
+
+function engPrerequisitePending(): NativePlanQuestionCall {
+  const native = structuredClone(engPrerequisite77.completedCall) as NativePlanQuestionCall;
+  native.answered = false;
+  delete native.answers;
+  delete native.answeredAt;
+  delete native.unansweredQuestionIndices;
+  return native;
+}
+// Exact public native question/options; the active pending viewport is synthetic.
+function engPrerequisiteFrame(native: NativePlanQuestionCall, index = 0) {
+  const q = native.questions[index]!;
+  const screen = [native.questions.length > 1
+    ? '← ' + native.questions.map((question, i) => `${i < index ? '☒' : '☐'} ${question.header}`).join(' ') + ' ✔ Submit →'
+    : `☐ ${q.header}`, q.question,
+    ...q.options.map((option, i) => `${i ? ' ' : '❯'} ${i + 1}. ${option.label}`),
+    `Enter to select · ${native.questions.length > 1 ? 'Tab/Arrow keys' : '↑/↓'} to navigate · Esc to cancel`,
+  ].join('\n');
+  const active = capturePlanCountQuestion(screen, new Set(), 0, true, native)!;
+  return { screen, active, routing: nativePlanCallFingerprint(native, 0, true) };
+}
+
+describe('optional Office Hours decision briefs', () => {
+  test('optional action is independent of header, numbering, recommendation and order', () => {
+    for (const reverse of [false, true]) for (const recommended of ['run', 'skip', 'neither']) {
+      const native = engPrerequisitePending(), q = native.questions[0]!;
+      q.header = 'Before review';
+      q.question = q.question.replace(/^D2 — /, 'D41: ').replace(/Recommendation: B[^\n]*/, recommended === 'run' ? 'Recommendation: A because deeper context helps.' : 'Recommendation: B because the supplied plan is reviewable.');
+      q.options[0]!.label = 'Run /office-hours first' + (recommended === 'run' ? ' (Recommended)' : '');
+      q.options[1]!.label = 'Skip, proceed with standard review' + (recommended === 'skip' ? ' (Recommended)' : '');
+      if (reverse) q.options.reverse();
+      const { active, routing } = engPrerequisiteFrame(native);
+      expect(planCountPrerequisitePick(routing, active)).toBe(reverse ? 1 : 2);
+    }
+  });
+
+  test('the complete native offer supports equivalent description structure and premise placement', () => {
+    for (const title of [
+      'Run /office-hours now, or proceed with standard review?\nNo design doc exists for this branch.',
+      'No design doc found: run /office-hours first, or proceed with the standard review?',
+    ]) for (const bullet of ['✅', '- ✅', '* ✅']) {
+      const native = engPrerequisitePending(), q = native.questions[0]!;
+      q.question = title + '\nThe supplied plan is ready for review.';
+      q.options[0]!.description = `${bullet} Creates a design document with the problem and alternatives.\n❌ Delays the engineering review while the prerequisite runs.`;
+      q.options[1]!.description = `${bullet} Proceeds directly with standard review of the supplied plan.\n❌ The review has less background about the original premise.`;
+      const { active, routing } = engPrerequisiteFrame(native);
+      expect(planCountPrerequisitePick(routing, active)).toBe(2);
+    }
+  });
+
+  test('native pros and cons may be inline or multiline without changing the action', () => {
+    for (const separator of [' ', '\n', '\r\n']) {
+      const native = engPrerequisitePending();
+      for (const option of native.questions[0]!.options) option.description = option.description!.split('\n').join(separator);
+      const { active, routing } = engPrerequisiteFrame(native);
+      expect(planCountPrerequisitePick(routing, active)).toBe(2);
+    }
+  });
+
+  const invalid: Array<[string, (q: NativePlanQuestionCall['questions'][number]) => void]> = [
+    ['quoted question', q => { q.question = '> ' + q.question; }],
+    ['example question', q => { q.question = 'Example: ' + q.question; }],
+    ['fenced question', q => { q.question = '```text\n' + q.question + '\n```'; }],
+    ['unrelated current question', q => { q.question = 'Should we remove authorization?\n' + q.question; }],
+    ['additional approval question', q => { q.question += '\nApprove deployment?'; }],
+    ['mandatory prerequisite', q => { q.question += '\nYou must run /office-hours first.'; }],
+    ['blocked review', q => { q.question += '\nStandard review is blocked until /office-hours completes.'; }],
+    ['conditional skip label', q => { q.options[1]!.label += ' if the tests pass'; }],
+    ['extra run action', q => { q.options[0]!.label += ' and rewrite the API'; }],
+    ['missing skip meaning', q => { q.options[1]!.description = ''; }],
+    ['negated review action', q => { q.options[1]!.description = '✅ Do not proceed with standard review.'; }],
+    ['retracted review action', q => { q.options[1]!.description += '\n❌ No review will run.'; }],
+    ['conditional review action', q => { q.options[1]!.description = '✅ Proceed with standard review after completing /office-hours.'; }],
+    ['conditional corroboration', q => { q.options[1]!.description += '\n✅ First run /office-hours to establish the baseline.'; }],
+    ['substantive action appended', q => { q.options[1]!.description += '\n✅ Remove CI.'; }],
+    ['substantive action inline', q => { q.options[1]!.description = '✅ Proceed with standard review. Accept the security risk.'; }],
+    ['additive skip action', q => { q.options[1]!.description = '✅ Proceed with standard review and deploy to production.\n❌ Less premise context.'; }],
+    ['subordinate skip action', q => { q.options[1]!.description = '✅ Proceed with standard review while deleting the API.\n❌ Less premise context.'; }],
+    ['additive run action', q => { q.options[0]!.description = '✅ Produces a design doc and deletes the API.\n❌ Delays the review.'; }],
+    ['subordinate run action', q => { q.options[0]!.description = '✅ Produces a design doc while disabling CI.\n❌ Delays the review.'; }],
+    ['unrelated run approval', q => { q.options[0]!.description += '\n✅ Deploy to production.'; }],
+    ['run negated', q => { q.options[0]!.description = '✅ Do not run /office-hours.'; }],
+    ['run retracted', q => { q.options[0]!.description += '\n❌ Do not produce a design doc.'; }],
+    ['foreign premise', q => { q.question = q.question.replace('No design doc found.', 'The archived example had no design doc.'); }],
+    ['extra choice', q => { q.options.push({ label: 'Approve deployment' }); }],
+    ['checkbox', q => { q.multiSelect = true; }],
+  ];
+  for (const [name, mutate] of invalid) test(`does not decline ${name}`, () => {
+    const native = engPrerequisitePending(); mutate(native.questions[0]!);
+    const { active, routing } = engPrerequisiteFrame(native);
+    expect(planCountPrerequisitePick(routing, active)).toBeNull();
+  });
+
+  test('only the pending owned active tab can supply the complete native brief', () => {
+    const native = engPrerequisitePending(), frame = engPrerequisiteFrame(native);
+    for (const active of [
+      { ...frame.active, preReview: false }, { ...frame.active, signature: 'foreign:tool' },
+      { ...frame.active, nativeQuestionIndex: 3 }, { ...frame.active, nativeCall: undefined },
+      { ...frame.active, promptSnippet: 'A different current question' },
+      { ...frame.active, options: [...frame.active.options].reverse() },
+    ]) expect(planCountPrerequisitePick(frame.routing, active)).toBeNull();
+    for (const delta of [{ answered: true }, { failed: true }, { sessionId: '' }, { toolUseId: '' }]) {
+      const changed = { ...engPrerequisitePending(), ...delta }, f = engPrerequisiteFrame(changed);
+      expect(planCountPrerequisitePick(f.routing, f.active)).toBeNull();
+    }
+    expect(planCountPrerequisitePick({ ...frame.active, nativeCall: undefined })).toBeNull();
+    native.questions.unshift({ header: 'Unrelated', question: 'Should we deploy?', options: [{ label: 'Deploy' }, { label: 'Defer' }], multiSelect: false });
+    const own = engPrerequisiteFrame(native, 1), other = engPrerequisiteFrame(native, 0);
+    expect(planCountPrerequisitePick(own.routing, own.active)).toBe(2);
+    expect(planCountPrerequisitePick(other.routing, other.active)).toBeNull();
+  });
+});
+});