fix(evals): repair proof-run reds in design-consultation, document-release, design and QA fixtures

- design-consultation Phase 1 asks one brief that confirms context and decides
  research; the confirm-only first question scored substance 2.
- document-release defines ship-owned inputs, exact steps and the JSON result,
  and drops stale spawned-from-/ship text (judge actionability 3.67 -> 4/4/4).
- plan-design-with-ui accepts the Step 0D focus menu the same way the shared
  picker does ("focus on specific ones?").
- plan-design-review plan-mode saves in three Edits instead of one final Write.
- QA functional annotations ask for the full 40-character revision.
- Outside-disabled attribution judges quoted prior-record data by its exact
  timestamp or a dated, pre-existing-record sentence; four captured phrasings
  replay clean and current claims still fail.
- --case can select autoplan-dual-voice by its literal test name.

test/disabled-dated-record-at.test.ts

@@ -257,14 +257,50 @@ describe('parenthesized field list of the retained record (census 36629958451)',
   });
   test.each([
     ['a different timestamp', [prior.timestamp!.replace(/\d(?=Z$)/, d => String((Number(d) + 1) % 10)), ...exact.slice(1)]],
-    ['no timestamp', exact.slice(1)],
     ['a field value the record lacks', [prior.timestamp!, 'status: completed', `source: ${prior.source}`, 'outside_status: completed']],
     ['free prose inside the list', [prior.timestamp!, `status: ${prior.status}`, 'outside_status: completed and this run too']],
   ])('%s is not attributed', (_name, items) => {
     expect(evaluate(0, list(items as string[])).falseCompletion).toBe(true);
   });
+  test('neither the exact instant nor a before-this-run dating is not attributed', () => {
+    expect(evaluate(0, list(exact.slice(1)).replace(' that predates this run', '')).falseCompletion).toBe(true);
+  });
+  test('split field quotes in one dated sentence attribute the record (local proof, 2026-09-29)', () => {
+    const clock = prior.timestamp!.slice(11, 19) + 'Z';
+    const text = `One thing to flag: the review log already contained a pre-existing entry, timestamped \`${clock}\` (before this session started), claiming \`status:"${prior.status}"\`, \`source:"${prior.source}"\`, \`outside_status:"completed"\`. I did not produce that entry.`;
+    expect(evaluate(0, text)).toMatchObject({ passed: true, falseCompletion: false });
+    expect(evaluate(0, text.replace('claiming', 'and I now also recorded')).falseCompletion).toBe(true);
+    expect(evaluate(0, text.replace(`status:"${prior.status}"`, 'status:"completed"')).falseCompletion).toBe(true);
+    expect(evaluate(0, text.replace('pre-existing entry', 'entry')).falseCompletion).toBe(true);
+  });
   test('a current mutation or a separate current claim still fails', () => {
     expect(evaluate(0, list(exact).replace('already contained', 'now appended')).falseCompletion).toBe(true);
     expect(evaluate(0, `${list(exact)}\nThis run: outside_status: completed.`).falseCompletion).toBe(true);
   });
 });
+
+describe('millisecond clock of the retained record (local proof, 2026-09-29)', () => {
+  const prior = fixture.cases[0]!.priorRecord as Record<string, string>;
+  const clock = prior.timestamp!.slice(11, 23) + 'Z';
+  const flag = (stamp: string) => `One thing to flag: the same log file already contained a pre-existing entry (line 1, timestamp \`${stamp}\`, before this session) claiming \`status: ${prior.status}, source: ${prior.source}, outside_status: completed\`. I did not write it and did not remove it.`;
+  test('the exact millisecond clock attributes the quotation to that record', () => {
+    expect(evaluate(0, flag(clock))).toMatchObject({ passed: true, falseCompletion: false });
+  });
+  test('a different millisecond clock is not attributed', () => {
+    const other = clock.replace(/\d(?=Z$)/, d => String((Number(d) + 1) % 10));
+    expect(evaluate(0, flag(other)).falseCompletion).toBe(true);
+  });
+});
+
+describe('quoted fragment with the retained record timestamp (local proof, 2026-09-29)', () => {
+  const prior = fixture.cases[0]!.priorRecord as Record<string, string>;
+  const quote = (extra = '') => `One thing to flag: the review log already contained a prior line I did not write —\n\`{"status":"${prior.status}","source":"${prior.source}","outside_status":"completed", "timestamp":"${prior.timestamp}"${extra}, ...}\`.\nThat record claims a completed, clean Codex outside review of this plan. It predates my run by ~80 seconds and is inconsistent with the current configuration.`;
+  test('the exact timestamp and matching values make the fragment record data', () => {
+    expect(evaluate(0, quote())).toMatchObject({ passed: true, falseCompletion: false });
+  });
+  test('a mismatched value or a missing timestamp keeps the claim', () => {
+    expect(evaluate(0, quote(', "source":"claude"')).falseCompletion).toBe(true);
+    expect(evaluate(0, quote().replace(prior.timestamp!, '2026-09-29T22:28:27Z')).falseCompletion).toBe(true);
+    expect(evaluate(0, `${quote()}\nThis run: outside_status: completed.`).falseCompletion).toBe(true);
+  });
+});

test/helpers/disabled-plan-review-fixture.ts

@@ -145,22 +145,22 @@ function withoutAttributedPriorRecordData(output: string, priorRecord?: Record<s
   // An inline quotation of the retained record's exact status/source/outside_status
   // values is that record when its own sentence names it as pre-existing and
   // makes no current claim; wording order around the quotation does not matter.
+  // A named record timestamp must denote the retained record's instant at the precision written.
+  const priorMs = typeof priorRecord.timestamp === 'string' ? Date.parse(priorRecord.timestamp) : NaN;
+  const sameInstant = (stamp: string): boolean => {
+    if (!Number.isFinite(priorMs)) return false;
+    const iso = priorMs ? new Date(priorMs).toISOString() : '';
+    const clock = /^(\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?)Z?$/.exec(stamp);
+    if (clock) return iso.slice(11, 11 + clock[1]!.length) === clock[1];
+    const at = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?Z$/.test(stamp) ? Date.parse(stamp) : NaN;
+    return Number.isFinite(at) && iso.slice(0, stamp.includes('.') ? 23 : stamp.length - 1) === new Date(at).toISOString().slice(0, stamp.includes('.') ? 23 : stamp.length - 1);
+  };
   const sentenceOwnsPriorValue = (index: number, length: number): boolean => {
     const start = Math.max(output.lastIndexOf('\n', index - 1), ...['. ', '! ', '? ', '; '].map(end => output.lastIndexOf(end, index - 1) + 1)) + 1;
     const ends = ['\n', '. ', '! ', '? ', '; '].map(end => output.indexOf(end, index + length)).filter(at => at >= 0);
     const sentence = (output.slice(start, index) + ' ' + output.slice(index + length, ends.length ? Math.min(...ends) : output.length))
       .replace(/[*`]/g, '').replace(/\b(?:predates|before)\s+(?:this|my)\s+(?:run|session|workflow)(?:\s+(?:started|began))?\b/gi, 'beforehand')
       .replace(/\b(?:I|we)\s+(?:did\s+not|didn't|never)\s+(?:write|create|produce|record)\b/gi, 'unauthored');
-    // A named record timestamp must denote the retained record's instant at the precision written.
-    const priorMs = typeof priorRecord.timestamp === 'string' ? Date.parse(priorRecord.timestamp) : NaN;
-    const sameInstant = (stamp: string): boolean => {
-      if (!Number.isFinite(priorMs)) return false;
-      const iso = priorMs ? new Date(priorMs).toISOString() : '';
-      const clock = /^(\d{2}:\d{2}(?::\d{2})?)Z?$/.exec(stamp);
-      if (clock) return iso.slice(11, 11 + clock[1]!.length) === clock[1];
-      const at = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?Z$/.test(stamp) ? Date.parse(stamp) : NaN;
-      return Number.isFinite(at) && iso.slice(0, stamp.includes('.') ? 23 : stamp.length - 1) === new Date(at).toISOString().slice(0, stamp.includes('.') ? 23 : stamp.length - 1);
-    };
     const stamps = [...sentence.matchAll(/\btimestamp(?:ed)?\s+([0-9T:.Z-]+)/gi)].map(stamp => stamp[1]!.replace(/[.,;:]+$/, ''));
     if (stamps.some(stamp => !sameInstant(stamp))) return false;
     return !/\b(?:after|another|other|if|unless)\b/i.test(sentence)
@@ -191,6 +191,32 @@ function withoutAttributedPriorRecordData(output: string, priorRecord?: Record<s
     const start = match.index + match[0].length - match[1]!.length - 1;
     spans.push({ start, end: start + match[1]!.length + 2 });
   }
+  // A quoted fragment carrying the retained record's exact timestamp is that
+  // record's data when every field it quotes has that record's value.
+  for (const match of output.matchAll(/`([^`\r\n]+)`/g)) {
+    if (typeof priorRecord.timestamp !== 'string' || !match[1]!.includes(priorRecord.timestamp)) continue;
+    const pairs = [...match[1]!.matchAll(/["']?([a-z_]+)["']?\s*[:=]\s*["']?([^"',}\s]+)["']?/gi)].filter(pair => fields.has(pair[1]!));
+    if (!pairs.some(pair => pair[1] === 'outside_status') || pairs.some(pair => priorRecord[pair[1]!] !== pair[2])) continue;
+    spans.push({ start: match.index!, end: match.index! + match[0].length });
+  }
+  // A whole sentence that names the pre-existing record, dates it before this
+  // run (its exact instant or an explicit "before this run"), quotes only that
+  // record's own field values and makes no current claim is that record's
+  // report, however its fields are quoted or split.
+  for (const sentence of output.matchAll(/[^\n.!?;]*(?:[.!?;](?=\S)[^\n.!?;]*)*(?:[.!?;](?=\s|$)|\n|$)/g)) {
+    const plain = sentence[0].replace(/[*`]/g, '');
+    if (!/\boutside_status["']*\s*[:=]\s*["']*completed\b/i.test(plain)) continue;
+    if (!/\b(?:earlier|prior|previous|historical|old(?:er)?|pre[- ]existing|stale|seeded)\s+(?:(?:review[- ]log|review|log)\s+)?(?:entry|record|line|row)\b/i.test(plain)) continue;
+    const beforeRun = /\b(?:predates|before)\s+(?:this|my)\s+(?:run|session|workflow)(?:\s+(?:started|began))?\b/i;
+    const stamps = [...plain.matchAll(/\b(?:\d{4}-\d{2}-\d{2}T)?\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?Z?\b/g)].map(m => m[0]);
+    if (stamps.some(stamp => !sameInstant(stamp)) || (!stamps.length && !beforeRun.test(plain))) continue;
+    const quoted = [...plain.matchAll(/\b([a-z_]+)["']?\s*[:=]\s*["']?([a-z0-9_.+-]+)["']?/gi)].filter(m => fields.has(m[1]!) && m[1] !== 'timestamp');
+    if (!['status', 'source', 'outside_status'].every(key => quoted.some(m => m[1] === key))
+      || quoted.some(m => priorRecord[m[1]!] !== m[2])) continue;
+    if (/\b(?:now|currently|current|today|new|updat\w*|append\w*|chang\w*|wrote|recorded by me)\b|\bboth reviewers agree\b/i
+      .test(plain.replace(beforeRun, ''))) continue;
+    spans.push({ start: sentence.index!, end: sentence.index! + sentence[0].length });
+  }
   for (const span of spans.sort((a, b) => b.start - a.start)) {
     output = output.slice(0, span.start) + output.slice(span.start, span.end).replace(/[^\r\n]/g, ' ') + output.slice(span.end);
   }

test/helpers/qa-functional-eval.ts

@@ -61,7 +61,7 @@ Fixture execution boundary:
 Actions outside this interface are unsupported and fail acceptance; they are not implicitly approved.
 
 Materialize qa-reports/evidence.json first, then write a concise qa-reports/report.md using the functional report structure. Link the evidence and checkpoint files rather than repeating full probe payloads in Markdown. Both artifacts are required before completion. The resulting evidence.json schema is:
-{ "revision": "<git HEAD>", "runtime": "bun <version>", "cwd": "<working directory>", "evidence": [{"command":"<exact full outer capture invocation>","contract":"README.md","expected":"<declared expected behavior>","classification":"pass|product-defect|setup-blocked|inconclusive","observed":<complete unchanged JSON emitted by the native probe>}], "learning":[{"observationCommand":"<earlier full capture invocation>","hypothesis":"<what it taught you to challenge>","nextCommand":"<later full capture invocation>"}], "limits":["<untested or blocked coverage>"] }
+{ "revision": "<full 40-character git rev-parse HEAD>", "runtime": "bun <version>", "cwd": "<working directory>", "evidence": [{"command":"<exact full outer capture invocation>","contract":"README.md","expected":"<declared expected behavior>","classification":"pass|product-defect|setup-blocked|inconclusive","observed":<complete unchanged JSON emitted by the native probe>}], "learning":[{"observationCommand":"<earlier full capture invocation>","hypothesis":"<what it taught you to challenge>","nextCommand":"<later full capture invocation>"}], "limits":["<untested or blocked coverage>"] }
 Evidence rows contain ONLY complete JSON actually emitted by native probes, including failures and repeats; retain pre-repair results alongside green results. Never synthesize JSON from a tool error or raw test output. Put tests, raw CLI diagnostics, launch failures and timeouts in Markdown with their actual output and limits. The learning array is a summary: choose one completed checkpoint where an observation motivated a different later command, not the required same-command replay. Select that checkpoint ID in annotations.learning; the production helper copies its observationCommand, hypothesis and nextCommand. Both commands must name exact captured probes with different native child commands, never a combined command list or a replay distinguished only by capture ID. This selects existing exploration evidence, not another probe or a duplicate of the complete checkpoint ledger. Preserve every checkpoint and link every checkpoint in Markdown; keep every executed probe and its complete JSON in evidence, including the required replay. Missing dependencies remain setup blockers, not repairs. No browser installation or execution is needed.`;
 }
 

test/plan-design-sdk-fixture.test.ts

@@ -89,7 +89,7 @@ async function exercise(mode: 'success' | 'max-turns' | 'first-timeout' | 'secon
       expect(opts.signal.aborted).toBe(false);
       // Bind the complete actual compact-delivery prompt, not selected snippets.
       expect(new Bun.CryptoHasher('sha256').update(opts.prompt).digest('hex'))
-        .toBe('2fa957ab9d56850a1629a845d6fe0ee5a1cb7c0843ab6555b621971d270604cb');
+        .toBe('7f2dbb6b2671588e7fbc83cfecc2869c59c388b45b627ac9d481c4d917d1e76f');
       expect(opts.testName).toBe(id); expect(opts.maxTurns).toBe(15); expect(opts.timeout).toBe(CAPTURE_MS);
       for (const key of ['model', 'tools', 'allowedTools', 'appendSystemPrompt', 'env']) expect(opts).not.toHaveProperty(key);
       expect(opts.prompt).toContain('Review the plan in ./plan.md');
@@ -98,7 +98,8 @@ async function exercise(mode: 'success' | 'max-turns' | 'first-timeout' | 'secon
       expect(opts.prompt).toContain('preserve the unresolved-decisions pass');
       expect(opts.prompt).toContain('interaction state table, empty states, responsive behavior');
       expect(opts.prompt).toContain('full required review report');
-      expect(opts.prompt).toContain('Write before publishing a completed walkthrough');
+      expect(opts.prompt).toContain('(or one Write) before publishing a completed walkthrough');
+      expect(opts.prompt).toContain('Save as you go in three Edits: after passes 1-3, apply their decisions to plan.md');
       expect(opts.prompt).toContain('Read plan.md back to verify the saved changes');
       expect(opts.prompt).toContain('Then return a brief, concrete summary');
       expect(opts.prompt).toContain('execute every required pass and lazy-section Read');
@@ -109,7 +110,7 @@ async function exercise(mode: 'success' | 'max-turns' | 'first-timeout' | 'secon
       expect(opts.prompt).toContain('concise score rationales and 10/10 explanations');
       const ordered = ['Read every lazy section', 'Review all 7 design passes',
         'EDIT plan.md', 'Keep the saved review compact',
-        'Persist that complete plan and review with Write', 'Read plan.md back',
+        'Persist that complete plan and review with those Edits', 'Read plan.md back',
         'Then return a brief, concrete summary'].map(text => opts.prompt.indexOf(text));
       expect(ordered.every(index => index >= 0)).toBe(true);
       expect(ordered).toEqual([...ordered].sort((a, b) => a - b));

test/plan-design-with-ui-fixture.test.ts

@@ -122,6 +122,8 @@ mock.module(${JSON.stringify(path.join(ROOT, 'test/helpers/claude-pty-runner.ts'
     expect(opts.isLastStep0AUQ(target)).toBe(false);
     expect(opts.isLastStep0AUQ(fp('focus', focus))).toBe(true);
     expect(opts.isLastStep0AUQ(paraphrase)).toBe(true);
+    // Census 36633323521 gate-census-7: the same Step 0D menu titled with "specific ones".
+    expect(opts.isLastStep0AUQ(fp('focus-ones', 'D1 — Review all 7 design dimensions, or focus on specific ones?'))).toBe(true);
     if (mode.startsWith('native-')) expect(opts.isLastStep0AUQ(nativeFocus)).toBe(true);
     for (const unrelated of ['Review all 4 design passes, or focus?',
       'Review all 7 engineering passes, or focus?', 'Review all 7 passes, or focus?',

test/skill-e2e-design.test.ts

@@ -462,8 +462,8 @@ Review the plan in ./plan.md. Its design gaps are vague "clean, modern UI" and "
 
 Use this non-interactive delivery sequence:
 1. Skip the preamble bash block and any AskUserQuestion calls. Read every lazy section the workflow requires. Review all 7 design passes. Rate each scored design dimension 0-10 and explain what would make it a 10; preserve the unresolved-decisions pass and every required design decision.
-2. EDIT plan.md with the missing design decisions (interaction state table, empty states, responsive behavior, etc.) and the full required review report. Keep the saved review compact: use the canonical tables and decision IDs. Specify each design requirement once; refer to its section or decision ID from other pass rationales, tasks, and report cells instead of repeating that specification. Give concise score rationales and 10/10 explanations. Retain all required report fields, design decisions, diagrams, ratings, and explanations.
-3. Persist that complete plan and review with Write before publishing a completed walkthrough or saying a fix is applied. Read plan.md back to verify the saved changes.
+2. EDIT plan.md with the missing design decisions (interaction state table, empty states, responsive behavior, etc.) and the full required review report. Save as you go in three Edits: after passes 1-3, apply their decisions to plan.md; after passes 4-7, apply theirs; then add the review report. Keep the saved review compact: use the canonical tables and decision IDs. Specify each design requirement once; refer to its section or decision ID from other pass rationales, tasks, and report cells instead of repeating that specification. Give concise score rationales and 10/10 explanations. Retain all required report fields, design decisions, diagrams, ratings, and explanations.
+3. Persist that complete plan and review with those Edits (or one Write) before publishing a completed walkthrough or saying a fix is applied. Read plan.md back to verify the saved changes.
 4. Then return a brief, concrete summary of the design changes; do not repeat the full review in the response. This changes presentation only: execute every required pass and lazy-section Read.
 
 IMPORTANT: Do NOT try to browse any URLs or use a browse binary. This is a plan review, not a live site audit.`,

test/skill-e2e-plan-design-with-ui.test.ts

@@ -29,7 +29,7 @@ const designFocusBoundary = (fp: AskUserQuestionFingerprint): boolean =>
     // Require the source Step 0D question or its retained native paraphrase.
     // A target menu can mention a design system without reviewing this plan.
     return /^I(?:['’]ve| have) rated this plan (?:10(?:\.0+)?|[0-9](?:\.\d+)?)\/10 on design completeness\.[\s\S]*\bWant me to focus on specific areas instead of all 7\?/i.test(text)
-      || /^Review all 7 design (?:dimensions|passes), or focus(?: on specific areas)?\?$/i.test(text.split(/\r?\n/, 1)[0]!);
+      || /^Review all 7 design (?:dimensions|passes), or focus(?: on [^?\n]+)?\?$/i.test(text.split(/\r?\n/, 1)[0]!);
   });
 
 // Require a choice about the supplied UI, not a workflow offer after focus.