@haposoft/cafekit 0.18.2 → 0.18.4

package/bin/__tests__/develop-contract.test.js

@@ -36,13 +36,12 @@ const PROCESS_FIRST_AGENTS = [
   'deployer.md',
 ].map((name) => path.join(PACKAGE_ROOT, 'src/claude/agents', name));
 const PROVENANCE = path.join(PACKAGE_ROOT, '../../docs/provenance.md');
-const SPECS_USAGE_GUIDE = path.join(PACKAGE_ROOT, '../../docs/specs-usage-guide.md');
 const RUNTIME_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-policy-runtime-'));
-const RUNTIME_SPEC = path.join(RUNTIME_ROOT, 'specs', 'demo', 'spec.json');
+const RUNTIME_SPEC = path.join(RUNTIME_ROOT, 'specs', 'demo', 'plan.md');
 fs.mkdirSync(path.dirname(RUNTIME_SPEC), { recursive: true });
 fs.mkdirSync(path.join(RUNTIME_ROOT, 'src'), { recursive: true });
 fs.writeFileSync(path.join(RUNTIME_ROOT, 'src', 'app.js'), 'runtime fixture\n');
-fs.writeFileSync(RUNTIME_SPEC, JSON.stringify({ status: 'in_progress', feature_name: 'demo', task_registry: {} }));
+fs.writeFileSync(RUNTIME_SPEC, '# Demo\nSpecs-Contract: process-first-ready-v1\n');
 for (const args of [['init', '-q'], ['config', 'user.email', 'cafekit@example.invalid'], ['config', 'user.name', 'CafeKit Test'], ['add', '-A'], ['commit', '-qm', 'fixture']]) {
   const result = spawnSync('git', ['-C', RUNTIME_ROOT, ...args], { encoding: 'utf8' });
   assert.equal(result.status, 0, result.stderr);
@@ -94,37 +93,7 @@ function installClaude(root) {
   });
 }
 
-function markdownLegacyRegions(content) {
-  const headings = [];
-  const primaryLines = [];
-  const legacyLines = [];
-  const hierarchy = [];
-
-  for (const [index, line] of content.split('\n').entries()) {
-    const heading = line.match(/^(#{1,6})\s+(.+?)\s*$/);
-    if (heading) {
-      const level = heading[1].length;
-      while (hierarchy.at(-1)?.level >= level) hierarchy.pop();
-      const entry = { level, text: heading[2], line: index + 1 };
-      hierarchy.push(entry);
-      headings.push(entry);
-    }
-
-    const target = hierarchy.some(({ text }) => /legacy/i.test(text))
-      ? legacyLines
-      : primaryLines;
-    target.push({ line: index + 1, text: line });
-  }
-
-  return {
-    headings,
-    primary: primaryLines.map(({ text }) => text).join('\n'),
-    legacy: legacyLines.map(({ text }) => text).join('\n'),
-    primaryLines,
-  };
-}
-
-function assertVocabularyIsLegacyOnly(filePath, regions) {
+function assertNoLegacyVocabulary(filePath, content) {
   const vocabulary = [
     ['v2.1', /\bv2\.1\b/i],
     ['spec.json', /\bspec\.json\b/i],
@@ -140,16 +109,12 @@ function assertVocabularyIsLegacyOnly(filePath, regions) {
     ['lane', /\blane\b/i],
   ];
   const violations = [];
-  for (const { line, text } of regions.primaryLines) {
+  for (const [index, text] of content.split('\n').entries()) {
     for (const [term, pattern] of vocabulary) {
-      if (pattern.test(text)) violations.push(`${line}:${term}`);
+      if (pattern.test(text)) violations.push(`${index + 1}:${term}`);
     }
   }
-  assert.deepEqual(
-    violations,
-    [],
-    `${path.relative(PACKAGE_ROOT, filePath)} has v2.1 vocabulary outside a Legacy heading`,
-  );
+  assert.deepEqual(violations, [], `${path.relative(PACKAGE_ROOT, filePath)} teaches a retired packet vocabulary`);
 }
 
 function canonicalReceipt(command = 'pnpm test', extra = '') {
@@ -160,16 +125,8 @@ function read(filePath) {
   return fs.readFileSync(filePath, 'utf8');
 }
 
-function manifestAgents() {
-  const manifest = JSON.parse(read(path.join(PACKAGE_ROOT, 'src/claude/migration-manifest.json')));
-  return manifest.agents.required.map((fileName) => path.basename(fileName, path.extname(fileName)));
-}
-
 test('CLI rejects flash and parallel before any mutation', () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-policy-cli-'));
-  const statePath = path.join(root, 'state.json');
-  fs.writeFileSync(statePath, '{"status":"in_progress"}\n');
-  const before = fs.readFileSync(statePath, 'utf8');
   try {
     const result = spawnSync(process.execPath, [POLICY_PATH, '--flash', '--parallel', '--json'], {
       cwd: root,
@@ -180,7 +137,6 @@ test('CLI rejects flash and parallel before any mutation', () => {
     assert.equal(payload.ok, false);
     assert.equal(payload.failFast, true);
     assert.match(payload.message, /incompatible/);
-    assert.equal(fs.readFileSync(statePath, 'utf8'), before);
   } finally {
     fs.rmSync(root, { recursive: true, force: true });
   }
@@ -190,12 +146,9 @@ test('develop flags retain their process-v3 contracts', () => {
   const develop = read(DEVELOP);
   assert.match(develop, /node \.claude\/scripts\/workflow-policy\.cjs --flash --parallel --json/);
   assert.match(develop, /exits `2` before a task edit, receipt, worktree, subagent, or commit/i);
-  assert.match(develop, /--notes` is opt-in/i);
-  assert.match(develop, /implementation-notes-template\.html/);
-  assert.match(develop, /Never create it by default/i);
-  assert.match(develop, /--parallel \[N\][\s\S]*parallel-waves\.md[\s\S]*isolated worktrees[\s\S]*one controller writer/i);
-  assert.match(develop, /--flash[\s\S]*Status: in_progress[\s\S]*FLASH_UNVERIFIED[\s\S]*awaiting \/cf:test <feature>/i);
-  assert.match(develop, /FLASH_UNVERIFIED[\s\S]*do not unblock dependents[\s\S]*sync-finalize path/i);
+  assert.match(develop, /--parallel \[N\][\s\S]*parallel-waves\.md[\s\S]*one controller writer/i);
+  assert.match(develop, /--flash[\s\S]*Status: in_progress[\s\S]*FLASH_UNVERIFIED/);
+  assert.match(develop, /FLASH_UNVERIFIED[\s\S]*do not unblock dependents/i);
 });
 
 test('review and sync skills keep the verdict vocabulary and the sync-finalize path', () => {
@@ -210,32 +163,22 @@ test('review and sync skills keep the verdict vocabulary and the sync-finalize p
 
 test('Develop names the process-first packet as its only authority', () => {
   const develop = read(DEVELOP);
-  const regions = markdownLegacyRegions(develop);
-  assert.doesNotMatch(develop, /DO NOT write implementation code until an approved spec exists/i);
-  assert.doesNotMatch(regions.primary, /planning_depth|assurance_level|execution_tier|\blane\b/i);
-  assert.doesNotMatch(develop, /## Legacy workflow compatibility|Also supports existing legacy Specs packets/);
-  assert.match(regions.primary, /specs\/<feature>\/plan\.md[\s\S]*task-NN-\*\.md/i);
-  assert.match(regions.primary, /one unblocked task at a time/i);
-  assert.match(regions.primary, /Verification Plan/);
-  assert.match(regions.primary, /inline Receipt/i);
-  assert.doesNotMatch(develop, /D2\[Step 3/);
-  assert.match(develop, /--notes.*opt-in/i);
-  assert.doesNotMatch(develop, /--no-notes/);
-  assert.doesNotMatch(develop, /planner|implementer|test-runner|code-auditor|docs-keeper/i);
+  assertNoLegacyVocabulary(DEVELOP, develop);
+  assert.doesNotMatch(develop, /Legacy workflow compatibility|existing legacy Specs packets/i);
+  assert.match(develop, /specs\/<feature>\/plan\.md[\s\S]*task-NN-\*\.md/i);
+  assert.match(develop, /one unblocked task at a time/i);
+  assert.match(develop, /Verification Plan/);
+  assert.match(develop, /inline Receipt/i);
 });
 
-test('Specs primary output is a flat process-first packet with isolated legacy compatibility', () => {
+test('Specs primary output is a flat process-first packet with no legacy packet vocabulary', () => {
   const specs = read(SPECS);
-  const regions = markdownLegacyRegions(specs);
-  const legacyHeadings = regions.headings.filter(({ text }) => /legacy/i.test(text));
-  assert.equal(legacyHeadings.length, 0);
-  assert.match(regions.primary, /specs\/<feature>\/[\s\S]*plan\.md[\s\S]*task-01-<slug>\.md[\s\S]*task-02-<slug>\.md/i);
-  assert.match(regions.primary, /Task files are flat beside `plan\.md`/i);
-  assert.match(regions.primary, /one task at a time/i);
-  assert.match(regions.primary, /inline `## Receipt`/i);
-  assert.match(regions.primary, /GATE-SCOPE[\s\S]*GATE-REVIEW[\s\S]*GATE-DONE/i);
-  assert.doesNotMatch(specs, /installed legacy adapters?/i);
-  assertVocabularyIsLegacyOnly(SPECS, regions);
+  assertNoLegacyVocabulary(SPECS, specs);
+  assert.doesNotMatch(specs, /^#{1,6}\s.*legacy/im);
+  assert.match(specs, /specs\/<feature>\/[\s\S]*plan\.md[\s\S]*task-01-<slug>\.md[\s\S]*task-02-<slug>\.md/i);
+  assert.match(specs, /Task files are flat beside `plan\.md`/i);
+  assert.match(specs, /inline `## Receipt`/i);
+  assert.match(specs, /GATE-SCOPE[\s\S]*GATE-REVIEW[\s\S]*GATE-DONE/i);
 });
 
 test('core execution agents default to process-first state and carry no legacy adapter', () => {
@@ -248,75 +191,66 @@ test('core execution agents default to process-first state and carry no legacy a
   }
 
   const implementer = read(PROCESS_FIRST_AGENTS[0]);
-  assert.match(implementer, /Under every dispatch mode[\s\S]{0,160}do NOT edit[\s\S]{0,80}`plan\.md`[\s\S]{0,80}`Status:`[\s\S]{0,80}`## Receipt`/i);
+  assert.match(implementer, /do NOT edit[\s\S]{0,80}`plan\.md`[\s\S]{0,80}`Status:`[\s\S]{0,80}`## Receipt`/i);
   assert.match(implementer, /controller/i);
-  assert.match(implementer, /process-first work[\s\S]{0,100}Ownership\s+boundary\./i);
-
-  const auditor = read(PROCESS_FIRST_AGENTS[2]);
-  assert.match(auditor, /accepted GATE-SCOPE\/GATE-REVIEW decisions/i);
-  assert.doesNotMatch(auditor, /CAFEKIT_SEMANTIC_REVIEW_ATTESTATION/);
-
-  const docsKeeper = read(PROCESS_FIRST_AGENTS[3]);
-  assert.match(docsKeeper, /never[\s\S]{0,80}invent or write Status, Receipt, approval, or execution proof/i);
-
+  assert.match(read(PROCESS_FIRST_AGENTS[2]), /GATE-SCOPE\/GATE-REVIEW/);
+  assert.match(read(PROCESS_FIRST_AGENTS[3]), /never[\s\S]{0,80}Status, Receipt/i);
   const deployer = read(PROCESS_FIRST_AGENTS[4]);
-  assert.match(deployer, /current final inline Receipt/i);
-  assert.match(deployer, /GATE-DONE\/release authorization/i);
+  assert.match(deployer, /GATE-DONE/);
   assert.match(deployer, /does not write process-first Status\/Receipt/i);
 });
 
-test('R7 Develop and Sync surfaces teach process-v3 and isolate hierarchical Legacy sections', () => {
-  const surfaces = [
-    ['develop', DEVELOP, 0],
-    ['parallel waves', PARALLEL_WAVES, 0],
-    ['sync', SYNC_SKILL, 0],
-    ['sync protocols', SYNC_PROTOCOLS, 0],
-  ];
-  const regionsByName = new Map();
-
-  for (const [name, filePath, expectedLegacy] of surfaces) {
-    const regions = markdownLegacyRegions(read(filePath));
-    const legacyHeadings = regions.headings.filter(({ text }) => /legacy/i.test(text));
-    assert.equal(legacyHeadings.length, expectedLegacy, `${name} must have exactly ${expectedLegacy} Legacy heading(s)`);
-    assert.match(regions.primary, /inline (?:`## )?Receipts?/i, `${name} must teach inline Receipts`);
-    if (expectedLegacy === 1) {
-      assert.match(regions.legacy, /spec\.json/i, `${name} must retain the spec.json adapter`);
-      assert.match(regions.legacy, /task_registry/i, `${name} must retain task_registry compatibility`);
-    }
-    assertVocabularyIsLegacyOnly(filePath, regions);
-    regionsByName.set(name, regions);
+test('Develop and Sync surfaces teach the flat process-first packet and no legacy vocabulary', () => {
+  for (const [name, filePath] of [
+    ['develop', DEVELOP], ['parallel waves', PARALLEL_WAVES], ['sync', SYNC_SKILL], ['sync protocols', SYNC_PROTOCOLS],
+  ]) {
+    const content = read(filePath);
+    assert.doesNotMatch(content, /^#{1,6}\s.*legacy/im, `${name} must have no Legacy section`);
+    assert.match(content, /inline (?:`## )?Receipts?/i, `${name} must teach inline Receipts`);
+    assertNoLegacyVocabulary(filePath, content);
   }
+  assert.match(read(DEVELOP), /`specs\/<feature>\/plan\.md` plus flat `task-NN-\*\.md`/i);
+  assert.match(read(SYNC_SKILL), /<task-NN-slug\.md>/i);
+  assert.match(read(SYNC_SKILL), /sync-finalize/i);
+  assert.match(read(PARALLEL_WAVES), /one file has one writer per wave/i);
+  assert.match(read(PARALLEL_WAVES), /writes inline Receipts and Status one task at a time/i);
+  assert.match(read(SYNC_PROTOCOLS), /`plan\.md` and flat `task-\*\.md` files/i);
+});
 
-  const develop = regionsByName.get('develop').primary;
-  assert.match(develop, /`specs\/<feature>\/plan\.md` plus flat `task-NN-\*\.md`/i);
-  assert.match(develop, /one unblocked task at a time/i);
-  assert.match(develop, /Outcome and Acceptance/i);
-  assert.match(develop, /Verification Plan/);
-  assert.match(develop, /final inline `## Receipt`/i);
-
-  const sync = regionsByName.get('sync').primary;
-  assert.match(sync, /<task-NN-slug\.md>/i);
-  assert.match(sync, /specs\/<feature>\/task-\*\.md` beside `plan\.md`/i);
-  assert.match(sync, /Acceptance[\s\S]*Verification Plan/i);
-  assert.match(sync, /current inline Receipt/i);
-
-  const waves = regionsByName.get('parallel waves').primary;
-  assert.match(waves, /dependencies from the plan table and each task/i);
-  assert.match(waves, /acceptance, proof command/i);
-  assert.match(waves, /one file has one writer per wave/i);
-  assert.match(waves, /writes inline Receipts and Status one task at a time/i);
-
-  const protocols = regionsByName.get('sync protocols').primary;
-  assert.match(protocols, /`plan\.md` and flat `task-\*\.md` files/i);
-  assert.match(protocols, /acceptance IDs/i);
-  assert.match(protocols, /current inline Receipt/i);
-  assert.match(regionsByName.get('sync').primary, /sync-finalize/i);
+test('develop and sync carry symptom-first gotchas', () => {
+  // The section runs from its heading to the next level-two heading or the end of the file.
+  const gotchas = (filePath) => {
+    const content = read(filePath);
+    const name = path.basename(path.dirname(filePath));
+    assert.equal((content.match(/^## Gotchas$/gm) || []).length, 1, `${name} must have exactly one Gotchas section`);
+    const body = content.slice(content.indexOf('\n## Gotchas\n') + 1);
+    const next = body.indexOf('\n## ', 1);
+    return next === -1 ? body : body.slice(0, next);
+  };
+
+  const develop = gotchas(DEVELOP);
+  assert.match(develop, /command_identity/);
+  assert.match(develop, /last top-level `- Command:`/);
+  assert.match(develop, /\bprovenance\b/);
+  assert.match(develop, /outside the specs root/);
+  assert.match(develop, /specs\/_shared\/active-feature\.json/);
+  assert.match(develop, /explicit_not_found/);
+
+  const sync = gotchas(SYNC_SKILL);
+  assert.match(sync, /committed copy/);
+  assert.match(sync, /\/cf:sync rebind/);
+
+  // A bulleted Receipt is accepted by the parser, so that trap must not come back.
+  for (const [name, section] of [['develop', develop], ['sync', sync]]) {
+    assert.doesNotMatch(section, /list marker|bullet/i, `${name} gotchas must not list the fixed bulleted-Receipt trap`);
+    assert.doesNotMatch(section, /\b(MUST|NEVER)\b/, `${name} gotchas must not shout`);
+  }
 });
 
 test('Develop process-first source contract preserves selection, recovery, final-Head, parallel, and Flash boundaries', () => {
-  const develop = markdownLegacyRegions(read(DEVELOP)).primary;
+  const develop = read(DEVELOP);
   const quality = read(GATE);
-  const waves = markdownLegacyRegions(read(PARALLEL_WAVES)).primary;
+  const waves = read(PARALLEL_WAVES);
   const dispatch = read(path.join(path.dirname(PARALLEL_WAVES), 'subagent-patterns.md'));
 
   for (const clause of [
@@ -325,13 +259,10 @@ test('Develop process-first source contract preserves selection, recovery, final
     /More than one `in_progress`/i,
     /For an interrupted `in_progress` task/i,
     /only the controller writes Status or Receipt/i,
-    /do not research, replan, or add a routine user gate/i,
   ]) assert.match(develop, clause);
   assert.match(quality, /consecutive Head captures are identical/i);
   assert.match(quality, /skip, skipped, todo, cancel, canceled, cancelled/i);
-  assert.match(quality, /exact command, current Head, required proof level, oracle/i);
   assert.match(waves, /every commit[\s\S]*complete changed tree/i);
-  assert.match(waves, /handoff metadata cannot substitute/i);
   assert.match(develop, /later explicit non-Flash invocation may recover/i);
   assert.match(dispatch, /controller alone writes Status and inline Receipt/i);
 
@@ -398,34 +329,11 @@ test('Develop process-first source contract preserves selection, recovery, final
   }
 });
 
-test('Claude installed Develop preserves plan-native execution and references', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-claude-develop-'));
-  try {
-    const result = installClaude(root);
-    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
-    const sourceRoot = path.dirname(DEVELOP);
-    const installedRoot = path.join(root, '.claude/skills/develop');
-    for (const relative of ['SKILL.md', ...DEVELOP_REFERENCES.map((name) => `references/${name}`)]) {
-      assert.equal(
-        fs.readFileSync(path.join(installedRoot, relative), 'utf8'),
-        fs.readFileSync(path.join(sourceRoot, relative), 'utf8'),
-        `Claude Develop projection drifted: ${relative}`,
-      );
-    }
-    assert.equal(fs.existsSync(path.join(root, '.agents/skills/develop')), false);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
 test('Test process-first handoff preserves proof ownership and side-effect boundaries', () => {
   const skill = read(TEST_SKILL);
   const strategy = read(path.join(TEST_SOURCE_ROOT, 'references/execution-strategy.md'));
   const runner = read(TEST_RUNNER);
   const review = read(CODE_REVIEW_SKILL);
-  const developConsumers = [read(DEVELOP), read(GATE), read(path.join(
-    path.dirname(PARALLEL_WAVES), 'subagent-patterns.md',
-  ))].join('\n');
 
   const exactKeys = [
     'schema_version', 'target', 'verdict', 'command', 'exit', 'counts',
@@ -433,24 +341,9 @@ test('Test process-first handoff preserves proof ownership and side-effect bound
     'artifacts', 'branches', 'raw_output', 'redactions', 'payload_sha256',
   ];
   for (const key of exactKeys) assert.match(strategy, new RegExp(`\\b${key}\\b`));
-  const developHandoffFields = new Map([
-    ['command', /Verification handoff separately contains the fresh command/i],
-    ['exit', /fresh command, exit/i],
-    ['branches', /named probes/i],
-    ['counts', /counts, output/i],
-    ['raw_output', /counts, output/i],
-    ['provenance', /observed Head/i],
-    ['reachability', /runtime reachability/i],
-    ['proof_level', /required proof level/i],
-  ]);
-  for (const [field, sourceClause] of developHandoffFields) {
-    assert.match(developConsumers, sourceClause, `Develop must currently consume ${field}`);
-    assert.ok(exactKeys.includes(field), `test-proof-v1 must preserve Develop field ${field}`);
-  }
   assert.match(runner, /Emit only `schema_version: "test-proof-v1"`/);
   assert.match(runner, /sole writer of[\s\S]*Status and inline Receipt/i);
   assert.match(review, /consume only the controller-validated[\s\S]*`test-proof-v1`[\s\S]*handoff/i);
-  assert.match(review, /Never create or search for a separate[\s\S]*process-first receipt/i);
   assert.doesNotMatch([skill, strategy, runner].join('\n'), /npm\s+install|inject-auth\.js|--cookies\s|Bearer eyJ/);
 
   const stable = (value) => {
@@ -534,18 +427,24 @@ test('Test process-first handoff preserves proof ownership and side-effect bound
   assert.equal(fs.existsSync(externalTemp), false, 'Test-owned external temp must be cleaned');
 });
 
-test('Claude installed Test preserves plan-native proof and references', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-claude-test-proof-'));
+test('Claude installed Develop and Test preserve plan-native execution, proof and references', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-claude-develop-test-'));
   try {
     const result = installClaude(root);
     assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
-    const installedRoot = path.join(root, '.claude/skills/test');
-    for (const relative of ['SKILL.md', ...TEST_REFERENCES.map((name) => `references/${name}`)]) {
-      assert.equal(
-        fs.readFileSync(path.join(installedRoot, relative), 'utf8'),
-        fs.readFileSync(path.join(TEST_SOURCE_ROOT, relative), 'utf8'),
-        `Claude Test projection drifted: ${relative}`,
-      );
+    const projections = [
+      ['develop', path.dirname(DEVELOP), DEVELOP_REFERENCES],
+      ['test', TEST_SOURCE_ROOT, TEST_REFERENCES],
+    ];
+    for (const [name, sourceRoot, references] of projections) {
+      for (const relative of ['SKILL.md', ...references.map((ref) => `references/${ref}`)]) {
+        assert.equal(
+          fs.readFileSync(path.join(root, '.claude/skills', name, relative), 'utf8'),
+          fs.readFileSync(path.join(sourceRoot, relative), 'utf8'),
+          `Claude ${name} projection drifted: ${relative}`,
+        );
+      }
+      assert.equal(fs.existsSync(path.join(root, '.agents/skills', name)), false);
     }
     const installedRunner = fs.readFileSync(path.join(root, '.claude/agents/test-runner.md'), 'utf8');
     assert.equal(installedRunner, fs.readFileSync(TEST_RUNNER, 'utf8'));
@@ -553,27 +452,11 @@ test('Claude installed Test preserves plan-native proof and references', () => {
     const installedReview = fs.readFileSync(path.join(root, '.claude/skills/code-review/SKILL.md'), 'utf8');
     assert.equal(installedReview, fs.readFileSync(CODE_REVIEW_SKILL, 'utf8'));
     assert.match(installedReview, /controller-validated `test-proof-v1`/);
-    assert.match(installedReview, /For proof consumption, this skill's `## Execution-proof boundary` is\s+authoritative/i);
-    assert.equal(fs.existsSync(path.join(root, '.agents/skills/test')), false);
   } finally {
     fs.rmSync(root, { recursive: true, force: true });
   }
 });
 
-test('specs-usage-guide documents Test proof handoff without timing claims', () => {
-  const guide = read(SPECS_USAGE_GUIDE);
-  const section = guide.split('## Test proof handoff')[1]?.split('### Receipt canonical')[0] || '';
-  assert.match(section, /`test-proof-v1`/);
-  assert.match(section, /Test không ghi `Status:` hay inline[\s\S]*Develop controller là writer duy nhất/i);
-  assert.match(section, /tracked\/untracked\/ignored drift/i);
-  assert.match(section, /HTTPS\/localhost origin[\s\S]*fresh consent/i);
-  assert.match(section, /chỉ nằm trong `## Receipt` inline/i);
-  assert.match(section, /không phải benchmark thời gian/i);
-  assert.match(section, /không chứng minh live adherence/i);
-  assert.doesNotMatch(section, /\b\d+(?:\.\d+)?\s*(?:ms|milliseconds?|seconds?|minutes?)\b/i);
-  assert.doesNotMatch(section, /\[(?:LIVE_)?VERIFIED\]/i);
-});
-
 test('first-run cache bypass is blocked - canonical receipt required even without cache', () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-first-run-'));
   const claude = path.join(root, '.claude');
@@ -696,13 +579,13 @@ test('runtime provenance derives exact Git evidence, CLI context, and stale/forg
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-provenance-adversarial-'));
   const specsRoot = path.join(root, 'specs');
   const featureRoot = path.join(specsRoot, 'demo');
-  const specFile = path.join(featureRoot, 'spec.json');
+  const specFile = path.join(featureRoot, 'plan.md');
   const sourceFile = path.join(root, 'src', 'app.js');
   const renameSource = path.join(root, 'src', 'rename-old.js');
   const renameTarget = path.join(root, 'src', 'rename-new.js');
   fs.mkdirSync(path.dirname(sourceFile), { recursive: true });
   fs.mkdirSync(featureRoot, { recursive: true });
-  fs.writeFileSync(specFile, JSON.stringify({ status: 'in_progress', feature_name: 'demo', task_registry: {} }));
+  fs.writeFileSync(specFile, '# Demo\n');
   fs.writeFileSync(sourceFile, 'original source\n');
   fs.writeFileSync(renameSource, 'rename source\n');
   fs.writeFileSync(path.join(root, '.gitignore'), 'ignored-secret.env\nnode_modules/\n.cache/\n');
@@ -734,13 +617,8 @@ test('runtime provenance derives exact Git evidence, CLI context, and stale/forg
       'valid-shaped arbitrary SHA values must not bind',
     );
 
-    fs.writeFileSync(specFile, JSON.stringify({
-      status: 'in_progress',
-      feature_name: 'demo',
-      task_registry: {},
-      receipt_refresh: true,
-    }));
-    const specCommit = spawnSync('git', ['-C', root, 'add', 'specs/demo/spec.json'], { encoding: 'utf8' });
+    fs.writeFileSync(specFile, '# Demo\n\nrefreshed\n');
+    const specCommit = spawnSync('git', ['-C', root, 'add', 'specs/demo/plan.md'], { encoding: 'utf8' });
     assert.equal(specCommit.status, 0, specCommit.stderr);
     const commitReceipt = spawnSync('git', ['-C', root, 'commit', '-qm', 'refresh spec receipt'], { encoding: 'utf8' });
     assert.equal(commitReceipt.status, 0, commitReceipt.stderr);
@@ -826,9 +704,9 @@ test('runtime provenance derives exact Git evidence, CLI context, and stale/forg
   }
 
   const nonGit = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-provenance-non-git-'));
-  const nonGitSpec = path.join(nonGit, 'specs', 'demo', 'spec.json');
+  const nonGitSpec = path.join(nonGit, 'specs', 'demo', 'plan.md');
   fs.mkdirSync(path.dirname(nonGitSpec), { recursive: true });
-  fs.writeFileSync(nonGitSpec, JSON.stringify({ status: 'in_progress', feature_name: 'demo' }));
+  fs.writeFileSync(nonGitSpec, '# Demo\n');
   try {
     const blocked = spawnSync(process.execPath, [
       path.join(PACKAGE_ROOT, 'src/claude/scripts/provenance.cjs'), '--json',
@@ -846,15 +724,15 @@ test('runtime provenance chooses a deterministic root when all history is Specs-
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-provenance-multi-root-'));
   const specsRoot = path.join(root, 'specs');
   const featureRoot = path.join(specsRoot, 'demo');
-  const specFile = path.join(featureRoot, 'spec.json');
+  const specFile = path.join(featureRoot, 'plan.md');
   try {
     fs.mkdirSync(featureRoot, { recursive: true });
-    fs.writeFileSync(specFile, JSON.stringify({ status: 'in_progress', feature_name: 'demo', task_registry: {} }));
+    fs.writeFileSync(specFile, '# Demo\n');
     for (const args of [
       ['init', '-q', '-b', 'first-root'],
       ['config', 'user.email', 'cafekit@example.invalid'],
       ['config', 'user.name', 'CafeKit Test'],
-      ['add', 'specs/demo/spec.json'],
+      ['add', 'specs/demo/plan.md'],
       ['commit', '-qm', 'first specs root'],
       ['checkout', '--orphan', 'unrelated-specs'],
       ['rm', '-qrf', '.'],
@@ -862,10 +740,10 @@ test('runtime provenance chooses a deterministic root when all history is Specs-
       const result = spawnSync('git', ['-C', root, ...args], { encoding: 'utf8' });
       assert.equal(result.status, 0, result.stderr);
     }
-    const unrelatedSpec = path.join(specsRoot, 'unrelated', 'spec.json');
+    const unrelatedSpec = path.join(specsRoot, 'unrelated', 'plan.md');
     fs.mkdirSync(path.dirname(unrelatedSpec), { recursive: true });
-    fs.writeFileSync(unrelatedSpec, JSON.stringify({ status: 'in_progress', feature_name: 'unrelated', task_registry: {} }));
-    let result = spawnSync('git', ['-C', root, 'add', 'specs/unrelated/spec.json'], { encoding: 'utf8' });
+    fs.writeFileSync(unrelatedSpec, '# Unrelated\n');
+    let result = spawnSync('git', ['-C', root, 'add', 'specs/unrelated/plan.md'], { encoding: 'utf8' });
     assert.equal(result.status, 0, result.stderr);
     result = spawnSync('git', ['-C', root, 'commit', '-qm', 'second specs root'], { encoding: 'utf8' });
     assert.equal(result.status, 0, result.stderr);
@@ -889,56 +767,26 @@ test('runtime provenance chooses a deterministic root when all history is Specs-
 });
 
 test('parallel waves require immutable provenance receipts and safe recovery', () => {
-  const waves = markdownLegacyRegions(read(PARALLEL_WAVES)).primary;
-  assert.match(waves, /only for explicit parallel execution/i);
-  assert.match(waves, /isolated worktree support[\s\S]*fall back to the sequential loop/i);
+  const waves = read(PARALLEL_WAVES);
   assert.match(waves, /Clamp `--parallel N` to 1\.\.5; default to 3/i);
   assert.match(waves, /clean destination[\s\S]*base_sha[\s\S]*incompatible bases/i);
-  assert.match(waves, /consent for worker commits and controller cherry-picks/i);
   for (const field of ['base_sha', 'head_sha', 'branch', 'worktree_path', 'commit_range']) {
     assert.match(waves, new RegExp(`\\b${field}\\b`));
   }
-  assert.match(waves, /git rev-list --reverse <base_sha>\.\.<head_sha>/i);
-  assert.match(waves, /git diff --name-status <base_sha>\.\.<head_sha>/i);
-  assert.match(waves, /code\/spec repair[\s\S]*new commit/i);
-  assert.match(waves, /dependencies from the plan table and each task/i);
-  for (const sharedSurface of ['registry', 'lockfile', 'manifest', 'generated output', 'migration', 'export barrel']) {
-    assert.match(waves, new RegExp(sharedSurface, 'i'));
-  }
   assert.match(waves, /One file has one writer per wave/i);
   assert.match(waves, /only the controller writes state\/proof/i);
   assert.match(waves, /commit only with user authorization/i);
-  assert.match(waves, /blocked or failed worker keeps[\s\S]*worktree and branch/i);
   assert.match(waves, /Never[\s\S]*force-delete[\s\S]*merge success or explicit discard authorization/i);
-  assert.match(waves, /git cherry-pick <next-worker-commit>/i);
   assert.match(waves, /On conflict, abort the pick[\s\S]*retain its branch\/worktree/i);
   assert.match(waves, /cleanup_authorization: merged-release/i);
-  assert.match(waves, /affected integration|final.*integration/i);
-  for (const category of ['baseline', 'environment', 'spec', 'code']) {
-    assert.match(waves, new RegExp(`\\b${category}\\b`));
-  }
   assert.match(waves, /Do not blind-retry/i);
 });
 
-test('provenance ledger defines reuse contract and source anchors', () => {
+test('provenance ledger forbids copied source text and the shipped runtime carries none', () => {
   assert.equal(fs.existsSync(PROVENANCE), true);
   const provenance = read(PROVENANCE);
-  assert.match(provenance, /\bidea\b/);
   assert.match(provenance, /\bclean-room\b/);
-  assert.match(provenance, /copied-text.*never valid|never valid.*copied-text/i);
   assert.match(provenance, /never copy source text verbatim/i);
-  for (const column of ['Pattern', 'Source anchor', 'Reuse type', 'CafeKit destination', 'Evidence/status']) {
-    assert.match(provenance, new RegExp(`\\b${column.replace('/', '\\/')}\\b`, 'i'));
-  }
-  assert.match(provenance, /AgentKit|cafekit-ref/);
-  assert.match(provenance, /before implementation/i);
-  // H1 remediation: distinguish survey vs verified implementation, fail unsupported claims
-  assert.match(provenance, /external survey|not committed/i);
-  assert.match(provenance, /survey only|not used|No borrowed text recorded/i);
-  assert.match(provenance, /Source anchor.*plans\//);
-  assert.match(provenance, /Evidence\/status/i);
-  assert.match(provenance, /grep -r.*cafekit-ref/i);
-  assert.doesNotMatch(provenance, /AgentKit T1.*implemented as direct source/i);
   // shipped runtime must not contain cafekit-ref/AgentKit verbatim (only ledger/plans may)
   const shippedHits = spawnSync('grep', ['-rn', 'cafekit-ref', 'packages/spec/src', '--include=*.md', '--include=*.cjs', '--include=*.ts'], { encoding: 'utf8' });
   const agentKitHits = spawnSync('grep', ['-rn', 'AgentKit', 'packages/spec/src', '--include=*.md', '--include=*.cjs', '--include=*.ts'], { encoding: 'utf8' });
@@ -946,628 +794,6 @@ test('provenance ledger defines reuse contract and source anchors', () => {
   assert.equal(agentKitHits.stdout.trim(), '', 'shipped runtime must not contain AgentKit verbatim');
 });
 
-const BENCHMARK_SCRIPT = path.join(PACKAGE_ROOT, 'scripts/benchmark-workflow.mjs');
-const BENCHMARK_CORPUS_SCHEMA = path.join(PACKAGE_ROOT, 'benchmarks/corpus.schema.json');
-const BENCHMARK_CONFIG_EXAMPLE = path.join(PACKAGE_ROOT, 'benchmarks/benchmark-config.example.json');
-const BENCHMARK_RUBRIC = path.join(PACKAGE_ROOT, 'benchmarks/rubric.md');
-const BENCHMARK_DOCS = path.join(PACKAGE_ROOT, '../../docs/benchmark-workflow.md');
-
-function canonicalBenchmark(value) {
-  if (Array.isArray(value)) return `[${value.map(canonicalBenchmark).join(',')}]`;
-  if (value && typeof value === 'object') return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalBenchmark(value[key])}`).join(',')}}`;
-  return JSON.stringify(value);
-}
-
-function benchmarkHash(value) {
-  const crypto = require('node:crypto');
-  return `sha256:${crypto.createHash('sha256').update(canonicalBenchmark(value)).digest('hex')}`;
-}
-
-function benchmarkRawHash(value) {
-  return `sha256:${crypto.createHash('sha256').update(value).digest('hex')}`;
-}
-
-function writeBenchmarkConfig(file, config) {
-  const frozen = { ...config };
-  delete frozen.config_sha256;
-  frozen.config_sha256 = benchmarkHash(frozen);
-  fs.writeFileSync(file, JSON.stringify(frozen));
-}
-
-function makeBenchmarkFixture(root) {
-  const corpus = {
-    schema_version: 'b1.v1', status: 'frozen', corpus_id: 'fixture-only-corpus',
-    tasks: [
-      { task_id: 'fixture-direct', lane: 'Direct', prompt: 'fixture-only reversible task', repo_sample: 'fixture-repo', acceptance: { criteria: ['fixture criterion'] }, risk: { level: 'low' } },
-      { task_id: 'fixture-critical', lane: 'Critical', prompt: 'fixture-only negative control', repo_sample: 'fixture-repo', acceptance: { criteria: ['fixture contract'] }, risk: { level: 'high', reasons: ['fixture negative control'] } },
-    ],
-  };
-  const corpusSha = benchmarkHash(corpus);
-  const common = {
-    schema_version: 'b1.v1', status: 'frozen', experiment_id: 'fixture-only-experiment',
-    model: { name: 'fixture-model', version: 'fixture-version' }, reasoning_effort: 'fixture',
-    repo: { identifier: 'fixture-repo', commit: 'abc1234567890', clean_initial_tree_sha: benchmarkHash('fixture-clean-tree') },
-    permissions_fingerprint: benchmarkHash('fixture-permissions'), tool_availability_fingerprint: benchmarkHash('fixture-tools'),
-    corpus_sha256: corpusSha, repeat_policy: { repeats_per_task: 2, context_isolated: true },
-    input_usd_per_1k: 1, output_usd_per_1k: 2,
-  };
-  const configs = ['baseline', 'treatment'].map((arm) => {
-    const config = { ...common, arm };
-    config.config_sha256 = benchmarkHash(config);
-    return config;
-  });
-  const artifactRef = 'fixture-artifact.bin';
-  const artifactBytes = Buffer.from('fixture-only benchmark artifact\n');
-  fs.writeFileSync(path.join(root, artifactRef), artifactBytes);
-  const artifactSha = benchmarkRawHash(artifactBytes);
-  const receipts = [];
-  for (const config of configs) for (const task of corpus.tasks) for (const repeat of [1, 2]) {
-    const treatment = config.arm === 'treatment';
-    const critical = task.lane === 'Critical';
-    const wall = critical ? 300 : (treatment ? 50 : 100) * repeat;
-    const input = (treatment ? 100 : 200) * repeat;
-    const output = (treatment ? 50 : 100) * repeat;
-    receipts.push({
-      task_id: task.task_id, lane: task.lane, arm: config.arm, repeat,
-      model: config.model, reasoning_effort: config.reasoning_effort,
-      repo_commit: config.repo.commit, clean_initial_tree_sha: config.repo.clean_initial_tree_sha,
-      permissions_fingerprint: config.permissions_fingerprint, tool_availability_fingerprint: config.tool_availability_fingerprint,
-      corpus_sha256: config.corpus_sha256, config_sha256: config.config_sha256,
-      wall_ms: wall, input_tokens: input, output_tokens: output, context_loaded_tokens: 500,
-      tool_calls: 2, subagent_calls: critical ? 1 : 0, correctness: true, regression: false,
-      unsupported_completion_claim: false, user_corrections: 0, useful_reviewer_findings: 1,
-      false_positive_reviewer_findings: 0,
-      evidence: { artifact_ref: artifactRef, artifact_sha256: artifactSha, command: 'fixture-only command' },
-    });
-  }
-  const paths = { corpus: path.join(root, 'corpus.json'), receipts: path.join(root, 'receipts.json') };
-  fs.writeFileSync(paths.corpus, JSON.stringify(corpus));
-  fs.writeFileSync(paths.receipts, JSON.stringify({ receipts }));
-  paths.configs = configs.map((config, index) => {
-    const file = path.join(root, `${config.arm}-${index}.json`);
-    fs.writeFileSync(file, JSON.stringify(config));
-    return file;
-  });
-  return paths;
-}
-
-test('B1 benchmark artifacts expose bounded CLI contract', () => {
-  for (const file of [BENCHMARK_SCRIPT, BENCHMARK_CORPUS_SCHEMA, BENCHMARK_CONFIG_EXAMPLE, BENCHMARK_RUBRIC, BENCHMARK_DOCS]) assert.equal(fs.existsSync(file), true, file);
-  assert.match(read(BENCHMARK_DOCS), /live baseline.*treatment.*pending/i);
-  assert.match(read(BENCHMARK_DOCS), /`npm test`.*workflow correctness/i);
-  assert.match(read(BENCHMARK_CONFIG_EXAMPLE), /TEMPLATE ONLY|example.template/i);
-  assert.match(read(BENCHMARK_RUBRIC), /Direct/);
-  assert.match(read(BENCHMARK_RUBRIC), /Standard/);
-  assert.match(read(BENCHMARK_RUBRIC), /Critical/);
-});
-
-test('B1 validator rejects missing freeze fields and accepts fixture-only corpus', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-b1-validation-'));
-  const fixture = makeBenchmarkFixture(root);
-  try {
-    assert.equal(JSON.parse(read(fixture.corpus)).status, 'frozen');
-    const valid = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--config', fixture.configs[1], '--receipts', fixture.receipts], { encoding: 'utf8' });
-    assert.equal(valid.status, 0, `${valid.stdout}\n${valid.stderr}`);
-    assert.equal(JSON.parse(valid.stdout).status, 'valid');
-    const invalidConfig = JSON.parse(read(fixture.configs[0]));
-    delete invalidConfig.clean_initial_tree_sha;
-    delete invalidConfig.config_sha256;
-    const invalidPath = path.join(root, 'missing-freeze.json');
-    fs.writeFileSync(invalidPath, JSON.stringify(invalidConfig));
-    const invalid = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', fixture.corpus, '--config', invalidPath], { encoding: 'utf8' });
-    assert.equal(invalid.status, 2);
-    assert.match(invalid.stderr, /missing or placeholder freeze field/);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('B1 validator fails closed for templates, prompts, parity, and artifacts', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-b1-integrity-'));
-  const fixture = makeBenchmarkFixture(root);
-  try {
-    const templateCorpus = JSON.parse(read(fixture.corpus));
-    templateCorpus.status = 'example_template';
-    const templatePath = path.join(root, 'template-corpus.json');
-    fs.writeFileSync(templatePath, JSON.stringify(templateCorpus));
-    const template = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', templatePath, '--config', fixture.configs[0], '--config', fixture.configs[1], '--receipts', fixture.receipts], { encoding: 'utf8' });
-    assert.equal(template.status, 2);
-    assert.match(template.stderr, /example_template.*receipt validation.*live summary/);
-
-    const placeholderCorpus = JSON.parse(read(fixture.corpus));
-    placeholderCorpus.tasks[0].prompt = '{{replace_me}}';
-    const placeholderPath = path.join(root, 'placeholder-corpus.json');
-    fs.writeFileSync(placeholderPath, JSON.stringify(placeholderCorpus));
-    const placeholder = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', placeholderPath, '--config', fixture.configs[0]], { encoding: 'utf8' });
-    assert.equal(placeholder.status, 2);
-    assert.match(placeholder.stderr, /tasks\[0\]\.prompt.*missing or placeholder/);
-
-    const emptyPromptWithHashCorpus = JSON.parse(read(fixture.corpus));
-    emptyPromptWithHashCorpus.tasks[0].prompt = '';
-    emptyPromptWithHashCorpus.tasks[0].prompt_sha256 = `sha256:${'1'.repeat(64)}`;
-    const emptyPromptWithHashPath = path.join(root, 'empty-prompt-with-hash-corpus.json');
-    fs.writeFileSync(emptyPromptWithHashPath, JSON.stringify(emptyPromptWithHashCorpus));
-    const emptyPromptWithHash = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', emptyPromptWithHashPath, '--config', fixture.configs[0]], { encoding: 'utf8' });
-    assert.equal(emptyPromptWithHash.status, 2);
-    assert.match(emptyPromptWithHash.stderr, /tasks\[0\]: exactly one of prompt or prompt_sha256 required/);
-
-    const treatment = JSON.parse(read(fixture.configs[1]));
-    treatment.experiment_id = 'different-experiment';
-    const parityPath = path.join(root, 'parity-treatment.json');
-    writeBenchmarkConfig(parityPath, treatment);
-    const parity = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--config', parityPath], { encoding: 'utf8' });
-    assert.equal(parity.status, 2);
-    assert.match(parity.stderr, /differ only by arm/);
-
-    const receipts = JSON.parse(read(fixture.receipts));
-    const missingArtifactHash = JSON.parse(read(fixture.receipts));
-    delete missingArtifactHash.receipts[0].evidence.artifact_sha256;
-    const missingArtifactHashPath = path.join(root, 'missing-artifact-hash.json');
-    fs.writeFileSync(missingArtifactHashPath, JSON.stringify(missingArtifactHash));
-    const missingHash = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--config', fixture.configs[1], '--receipts', missingArtifactHashPath], { encoding: 'utf8' });
-    assert.equal(missingHash.status, 2);
-    assert.match(missingHash.stderr, /evidence\.artifact_sha256.*missing or placeholder/);
-
-    receipts.receipts[0].evidence.artifact_sha256 = benchmarkRawHash(Buffer.from('wrong artifact'));
-    const wrongHashPath = path.join(root, 'wrong-artifact-hash.json');
-    fs.writeFileSync(wrongHashPath, JSON.stringify(receipts));
-    const wrongHash = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--config', fixture.configs[1], '--receipts', wrongHashPath], { encoding: 'utf8' });
-    assert.equal(wrongHash.status, 2);
-    assert.match(wrongHash.stderr, /artifact_sha256.*raw-byte hash mismatch/);
-
-    receipts.receipts[0].evidence.artifact_ref = 'https://example.invalid/artifact.json';
-    const uriPath = path.join(root, 'uri-artifact.json');
-    fs.writeFileSync(uriPath, JSON.stringify(receipts));
-    const uri = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--config', fixture.configs[1], '--receipts', uriPath], { encoding: 'utf8' });
-    assert.equal(uri.status, 2);
-    assert.match(uri.stderr, /artifact_ref.*relative local file.*URI/);
-
-    const outsideArtifact = path.join(path.dirname(root), `${path.basename(root)}-outside.bin`);
-    fs.writeFileSync(outsideArtifact, Buffer.from('outside receipt bundle'));
-    const traversalReceipts = JSON.parse(read(fixture.receipts));
-    traversalReceipts.receipts[0].evidence.artifact_ref = path.relative(root, outsideArtifact);
-    traversalReceipts.receipts[0].evidence.artifact_sha256 = benchmarkRawHash(fs.readFileSync(outsideArtifact));
-    const traversalPath = path.join(root, 'traversal-artifact.json');
-    fs.writeFileSync(traversalPath, JSON.stringify(traversalReceipts));
-    const traversal = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--config', fixture.configs[1], '--receipts', traversalPath], { encoding: 'utf8' });
-    assert.equal(traversal.status, 2);
-    assert.match(traversal.stderr, /artifact_ref.*path escapes receipt bundle directory/);
-    fs.rmSync(outsideArtifact, { force: true });
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('B1 summary groups fixture-only receipts by arm/lane with deterministic quantiles', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-b1-summary-'));
-  const fixture = makeBenchmarkFixture(root);
-  try {
-    const result = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'summarize', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--config', fixture.configs[1], '--receipts', fixture.receipts], { encoding: 'utf8' });
-    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
-    const summary = JSON.parse(result.stdout);
-    assert.equal(summary.status, 'ready');
-    assert.equal(summary.groups.baseline.Direct.metrics.wall_ms.median, 150);
-    assert.equal(summary.groups.baseline.Direct.metrics.wall_ms.p25, 125);
-    assert.equal(summary.groups.baseline.Direct.metrics.wall_ms.p75, 175);
-    assert.equal(summary.groups.treatment.Direct.quality_rates.correctness, 1);
-    assert.equal(summary.rollout_recommendation.gates.Critical.pass, true);
-
-    const countAggregation = JSON.parse(read(fixture.receipts));
-    const countedReceipt = countAggregation.receipts.find((item) => item.arm === 'baseline' && item.lane === 'Direct' && item.repeat === 1);
-    countedReceipt.user_corrections = 2;
-    countedReceipt.useful_reviewer_findings = 3;
-    countedReceipt.false_positive_reviewer_findings = 4;
-    const countAggregationPath = path.join(root, 'count-aggregation.json');
-    fs.writeFileSync(countAggregationPath, JSON.stringify(countAggregation));
-    const countAggregationResult = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'summarize', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--config', fixture.configs[1], '--receipts', countAggregationPath], { encoding: 'utf8' });
-    assert.equal(countAggregationResult.status, 0, `${countAggregationResult.stdout}\n${countAggregationResult.stderr}`);
-    const countAggregationSummary = JSON.parse(countAggregationResult.stdout);
-    assert.equal(countAggregationSummary.groups.baseline.Direct.quality_rates.user_correction_rate, 1);
-    assert.equal(countAggregationSummary.groups.baseline.Direct.quality_rates.useful_reviewer_finding_rate, 2);
-    assert.equal(countAggregationSummary.groups.baseline.Direct.quality_rates.false_positive_reviewer_finding_rate, 2);
-
-    const degraded = JSON.parse(read(fixture.receipts));
-    for (const receipt of degraded.receipts.filter((item) => item.arm === 'treatment')) {
-      receipt.useful_reviewer_findings = 0;
-      receipt.false_positive_reviewer_findings = 1;
-    }
-    const degradedPath = path.join(root, 'degraded-review-quality.json');
-    fs.writeFileSync(degradedPath, JSON.stringify(degraded));
-    const degradedResult = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'summarize', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--config', fixture.configs[1], '--receipts', degradedPath], { encoding: 'utf8' });
-    assert.equal(degradedResult.status, 0, `${degradedResult.stdout}\n${degradedResult.stderr}`);
-    const degradedSummary = JSON.parse(degradedResult.stdout);
-    assert.equal(degradedSummary.status, 'not-ready');
-    assert.equal(degradedSummary.rollout_recommendation.gates.Critical.quality_pass, false);
-    assert.equal(degradedSummary.rollout_recommendation.gates.Critical.pass, false);
-
-    const lowRiskQualityFailure = JSON.parse(read(fixture.receipts));
-    for (const receipt of lowRiskQualityFailure.receipts.filter((item) => item.lane === 'Direct')) receipt.correctness = false;
-    const lowRiskQualityFailurePath = path.join(root, 'low-risk-quality-failure.json');
-    fs.writeFileSync(lowRiskQualityFailurePath, JSON.stringify(lowRiskQualityFailure));
-    const lowRiskQualityFailureResult = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'summarize', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--config', fixture.configs[1], '--receipts', lowRiskQualityFailurePath], { encoding: 'utf8' });
-    assert.equal(lowRiskQualityFailureResult.status, 0, `${lowRiskQualityFailureResult.stdout}\n${lowRiskQualityFailureResult.stderr}`);
-    const lowRiskQualityFailureSummary = JSON.parse(lowRiskQualityFailureResult.stdout);
-    assert.equal(lowRiskQualityFailureSummary.rollout_recommendation.gates.Direct.quality_pass, false);
-    assert.equal(lowRiskQualityFailureSummary.rollout_recommendation.gates.Direct.pass, false);
-    assert.equal(lowRiskQualityFailureSummary.rollout_recommendation.gates.Critical.pass, true);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('B1 rollout rejects incomplete fixture-only lane/repeat matrices', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-b1-completeness-'));
-  const fixture = makeBenchmarkFixture(root);
-  try {
-    const payload = JSON.parse(read(fixture.receipts));
-    const completeReceipts = payload.receipts;
-    const partialPath = path.join(root, 'partial.json');
-    fs.writeFileSync(partialPath, JSON.stringify({ receipts: completeReceipts.filter((receipt) => !(receipt.arm === 'treatment' && receipt.lane === 'Direct' && receipt.repeat === 1)) }));
-    const partial = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'summarize', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--config', fixture.configs[1], '--receipts', partialPath], { encoding: 'utf8' });
-    assert.equal(partial.status, 0, `${partial.stdout}\n${partial.stderr}`);
-    const partialSummary = JSON.parse(partial.stdout);
-    assert.equal(partialSummary.status, 'not-ready');
-    assert.equal(partialSummary.rollout_recommendation.gates.Direct.treatment_matrix.complete, false);
-    const incompleteValidation = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--config', fixture.configs[1], '--receipts', partialPath], { encoding: 'utf8' });
-    assert.equal(incompleteValidation.status, 2);
-    assert.match(incompleteValidation.stderr, /incomplete receipt matrix.*treatment\/Direct\/fixture-direct\/1/);
-
-    const missingLanePath = path.join(root, 'missing-lane.json');
-    fs.writeFileSync(missingLanePath, JSON.stringify({ receipts: completeReceipts.filter((receipt) => !(receipt.arm === 'treatment' && receipt.lane === 'Critical')) }));
-    const missingLane = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'summarize', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--config', fixture.configs[1], '--receipts', missingLanePath], { encoding: 'utf8' });
-    assert.equal(missingLane.status, 0, `${missingLane.stdout}\n${missingLane.stderr}`);
-    const missingLaneSummary = JSON.parse(missingLane.stdout);
-    assert.equal(missingLaneSummary.status, 'not-ready');
-    assert.equal(missingLaneSummary.rollout_recommendation.gates.Critical.treatment_matrix.complete, false);
-
-    const outOfRange = JSON.parse(JSON.stringify(completeReceipts));
-    outOfRange[0].repeat = 3;
-    const outOfRangePath = path.join(root, 'out-of-range.json');
-    fs.writeFileSync(outOfRangePath, JSON.stringify({ receipts: outOfRange }));
-    const invalidRepeat = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--config', fixture.configs[1], '--receipts', outOfRangePath], { encoding: 'utf8' });
-    assert.equal(invalidRepeat.status, 2);
-    assert.match(invalidRepeat.stderr, /exceeds repeat_policy/);
-
-    const duplicateArm = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--config', fixture.configs[0]], { encoding: 'utf8' });
-    assert.equal(duplicateArm.status, 2);
-    assert.match(duplicateArm.stderr, /duplicate arm/);
-
-    const invalidCorpus = JSON.parse(read(fixture.corpus));
-    delete invalidCorpus.corpus_id;
-    const invalidCorpusPath = path.join(root, 'missing-corpus-id.json');
-    fs.writeFileSync(invalidCorpusPath, JSON.stringify(invalidCorpus));
-    const missingCorpusId = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', invalidCorpusPath, '--config', fixture.configs[0]], { encoding: 'utf8' });
-    assert.equal(missingCorpusId.status, 2);
-    assert.match(missingCorpusId.stderr, /corpus_id.*missing or placeholder/);
-
-    const invalidCost = JSON.parse(read(fixture.configs[0]));
-    invalidCost.input_usd_per_1k = 'not-a-rate';
-    const invalidCostPath = path.join(root, 'invalid-cost.json');
-    fs.writeFileSync(invalidCostPath, JSON.stringify(invalidCost));
-    const invalidCostResult = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', fixture.corpus, '--config', invalidCostPath], { encoding: 'utf8' });
-    assert.equal(invalidCostResult.status, 2);
-    assert.match(invalidCostResult.stderr, /config\.input_usd_per_1k.*non-negative number/);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('B1 summary marks no receipts exploratory instead of claiming a run', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-b1-empty-'));
-  const fixture = makeBenchmarkFixture(root);
-  try {
-    const result = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'summarize', '--corpus', fixture.corpus, '--config', fixture.configs[0]], { encoding: 'utf8' });
-    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
-    const summary = JSON.parse(result.stdout);
-    assert.equal(summary.status, 'exploratory/no-live-runs');
-    assert.equal(summary.live_runs, false);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('B1 run requires explicit runner contract and rejects placeholders/shell strings', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-b1-run-runner-'));
-  const fixture = makeBenchmarkFixture(root);
-  try {
-    // Missing runner
-    const missing = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'run', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--out', path.join(root, 'out-missing')], { encoding: 'utf8' });
-    assert.equal(missing.status, 2);
-    assert.match(missing.stderr, /runner contract is required/);
-    assert.match(missing.stderr, /explicit command array/);
-
-    // Placeholder runner (command contains placeholder)
-    const placeholderRunner = path.join(root, 'placeholder-runner.json');
-    fs.writeFileSync(placeholderRunner, JSON.stringify({ schema_version: 'b1.v1', command: ['node', '{{replace_me}}'] }));
-    const placeholder = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'run', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--runner', placeholderRunner, '--out', path.join(root, 'out-placeholder')], { encoding: 'utf8' });
-    assert.equal(placeholder.status, 2);
-    assert.match(placeholder.stderr, /missing or placeholder freeze field/);
-
-    // Shell string forbidden (command as string)
-    const shellRunner = path.join(root, 'shell-runner.json');
-    fs.writeFileSync(shellRunner, JSON.stringify({ schema_version: 'b1.v1', command: 'node runner.mjs' }));
-    const shell = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'run', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--runner', shellRunner, '--out', path.join(root, 'out-shell')], { encoding: 'utf8' });
-    assert.equal(shell.status, 2);
-    assert.match(shell.stderr, /explicit argv|shell string is forbidden/);
-
-    // Missing out/receipts
-    const minimalRunner = path.join(root, 'minimal-runner.json');
-    fs.writeFileSync(minimalRunner, JSON.stringify({ schema_version: 'b1.v1', command: ['node', '-e', 'process.exit(0)'] }));
-    const noOut = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'run', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--runner', minimalRunner], { encoding: 'utf8' });
-    assert.equal(noOut.status, 2);
-    assert.match(noOut.stderr, /output is required/);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('B1 run executes via explicit argv, captures wall_ms/artifact, and remains honest no-live-runs without execution', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-b1-run-execute-'));
-  const fixture = makeBenchmarkFixture(root);
-  try {
-    // Honest no-live-runs: summarize without receipts must stay exploratory
-    const noLive = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'summarize', '--corpus', fixture.corpus, '--config', fixture.configs[0]], { encoding: 'utf8' });
-    assert.equal(noLive.status, 0);
-    const noLiveSummary = JSON.parse(noLive.stdout);
-    assert.equal(noLiveSummary.status, 'exploratory/no-live-runs');
-    assert.equal(noLiveSummary.live_runs, false);
-    assert.equal(noLiveSummary.rollout_recommendation.status, 'exploratory');
-    // Also validate without receipts is valid_no_receipts, not fabricated success
-    const validNoReceipts = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', fixture.corpus, '--config', fixture.configs[0]], { encoding: 'utf8' });
-    assert.equal(validNoReceipts.status, 0);
-    assert.equal(JSON.parse(validNoReceipts.stdout).status, 'valid_no_receipts');
-
-    // Create minimal deterministic runner that writes artifact and emits metrics JSON
-    const runnerScript = path.join(root, 'runner.mjs');
-    fs.writeFileSync(runnerScript, `
-import fs from 'node:fs';
-import path from 'node:path';
-let input='';
-process.stdin.on('data', c=>input+=c);
-process.stdin.on('end', ()=>{
-  const payload=JSON.parse(input);
-  fs.mkdirSync(path.dirname(payload.artifact_path), {recursive:true});
-  fs.writeFileSync(payload.artifact_path, 'artifact:'+payload.task_id+'/'+payload.repeat+'\\n');
-  const out={input_tokens:100, output_tokens:50, context_loaded_tokens:500, tool_calls:2, subagent_calls:0, correctness:true, regression:false, unsupported_completion_claim:false, user_corrections:0, useful_reviewer_findings:1, false_positive_reviewer_findings:0};
-  process.stdout.write(JSON.stringify(out));
-});
-`);
-    const runnerJson = path.join(root, 'runner.json');
-    fs.writeFileSync(runnerJson, JSON.stringify({ schema_version: 'b1.v1', command: ['node', runnerScript] }));
-    const outDir = path.join(root, 'out-live');
-    const run = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'run', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--runner', runnerJson, '--out', outDir], { encoding: 'utf8' });
-    assert.equal(run.status, 0, `${run.stdout}\n${run.stderr}`);
-    const runResult = JSON.parse(run.stdout);
-    assert.equal(runResult.status, 'executed');
-    assert.equal(runResult.live_runs, true);
-    assert.ok(fs.existsSync(path.join(outDir, 'receipts.json')), 'receipts.json must be written');
-    // Receipts must be consumable by existing validate/summarize path
-    const receipts = JSON.parse(fs.readFileSync(path.join(outDir, 'receipts.json'), 'utf8'));
-    assert.ok(Array.isArray(receipts.receipts) || Array.isArray(receipts));
-    const validate = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--receipts', path.join(outDir, 'receipts.json')], { encoding: 'utf8' });
-    assert.equal(validate.status, 0, `${validate.stdout}\n${validate.stderr}`);
-    assert.equal(JSON.parse(validate.stdout).status, 'valid');
-    // Ensure receipts capture wall_ms, command, artifact hash and are frozen
-    const firstReceipt = (receipts.receipts || receipts)[0];
-    assert.ok(typeof firstReceipt.wall_ms === 'number' && firstReceipt.wall_ms >= 0, 'wall_ms captured');
-    assert.ok(typeof firstReceipt.evidence.command === 'string' && firstReceipt.evidence.command.includes('node'), 'command captured');
-    assert.match(firstReceipt.evidence.artifact_sha256, /^sha256:[0-9a-f]{64}$/);
-    assert.equal(firstReceipt.corpus_sha256, JSON.parse(fs.readFileSync(fixture.corpus, 'utf8')).corpus_sha256 || runResult.corpus_sha256 || firstReceipt.corpus_sha256);
-    // Artifact file must exist and hash must match raw bytes
-    const artifactPath = path.join(outDir, firstReceipt.evidence.artifact_ref);
-    assert.ok(fs.existsSync(artifactPath), 'artifact file must exist inside bundle');
-    const bytes = fs.readFileSync(artifactPath);
-    const expectedHash = `sha256:${crypto.createHash('sha256').update(bytes).digest('hex')}`;
-    assert.equal(firstReceipt.evidence.artifact_sha256, expectedHash);
-    // Ensure no secrets leakage: receipts must not contain env secrets (check that known secret pattern not in file)
-    const receiptsText = fs.readFileSync(path.join(outDir, 'receipts.json'), 'utf8');
-    assert.doesNotMatch(receiptsText, /OPENAI_API_KEY|AWS_SECRET|GITHUB_TOKEN/);
-    // Ensure artifact_ref is relative and does not escape
-    assert.doesNotMatch(firstReceipt.evidence.artifact_ref, /^\//);
-    assert.doesNotMatch(firstReceipt.evidence.artifact_ref, /^\.\./);
-    assert.doesNotMatch(firstReceipt.evidence.artifact_ref, /^https?:/);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('B1 run rejects mismatched corpus hash, artifact escape, and partial matrices fail-closed', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-b1-run-safety-'));
-  const fixture = makeBenchmarkFixture(root);
-  try {
-    const runnerScript = path.join(root, 'safe-runner.mjs');
-    fs.writeFileSync(runnerScript, `
-import fs from 'node:fs';
-import path from 'node:path';
-let input='';
-process.stdin.on('data', c=>input+=c);
-process.stdin.on('end', ()=>{
-  const payload=JSON.parse(input);
-  fs.mkdirSync(path.dirname(payload.artifact_path), {recursive:true});
-  fs.writeFileSync(payload.artifact_path, 'ok');
-  const out={input_tokens:100, output_tokens:50, context_loaded_tokens:500, tool_calls:2, subagent_calls:0, correctness:true, regression:false, unsupported_completion_claim:false, user_corrections:0, useful_reviewer_findings:1, false_positive_reviewer_findings:0};
-  process.stdout.write(JSON.stringify(out));
-});
-`);
-    const runnerJson = path.join(root, 'runner.json');
-    fs.writeFileSync(runnerJson, JSON.stringify({ schema_version: 'b1.v1', command: ['node', runnerScript] }));
-
-    // Mismatched corpus_sha256 in config must be rejected before execution
-    const badCorpus = JSON.parse(fs.readFileSync(fixture.corpus, 'utf8'));
-    badCorpus.corpus_id = 'tampered-id';
-    const badCorpusPath = path.join(root, 'bad-corpus.json');
-    fs.writeFileSync(badCorpusPath, JSON.stringify(badCorpus));
-    const mismatch = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'run', '--corpus', badCorpusPath, '--config', fixture.configs[0], '--runner', runnerJson, '--out', path.join(root, 'out-mismatch')], { encoding: 'utf8' });
-    assert.equal(mismatch.status, 2);
-    assert.match(mismatch.stderr, /corpus_sha256.*does not match corpus|freeze hash mismatch/);
-
-    // Artifact escape via validator: craft receipt with traversal artifact_ref and expect reject
-    const traversalReceipts = JSON.parse(fs.readFileSync(fixture.receipts, 'utf8'));
-    const outsideArtifact = path.join(path.dirname(root), 'outside.bin');
-    fs.writeFileSync(outsideArtifact, Buffer.from('outside'));
-    traversalReceipts.receipts[0].evidence.artifact_ref = path.relative(root, outsideArtifact);
-    traversalReceipts.receipts[0].evidence.artifact_sha256 = `sha256:${crypto.createHash('sha256').update(fs.readFileSync(outsideArtifact)).digest('hex')}`;
-    const traversalPath = path.join(root, 'traversal.json');
-    fs.writeFileSync(traversalPath, JSON.stringify(traversalReceipts));
-    const traversal = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--config', fixture.configs[1], '--receipts', traversalPath], { encoding: 'utf8' });
-    assert.equal(traversal.status, 2);
-    assert.match(traversal.stderr, /path escapes receipt bundle directory/);
-    fs.rmSync(outsideArtifact, { force: true });
-
-    // Partial matrix: run with runner that fails on one task/repeat must not be reported as valid success
-    // Simulate by creating a runner that exits non-zero for one specific task
-    const flakyRunner = path.join(root, 'flaky-runner.mjs');
-    fs.writeFileSync(flakyRunner, `
-import fs from 'node:fs';
-import path from 'node:path';
-let input='';
-process.stdin.on('data', c=>input+=c);
-process.stdin.on('end', ()=>{
-  const payload=JSON.parse(input);
-  if (payload.task_id==='fixture-direct' && payload.repeat===1 && payload.arm==='baseline') process.exit(7);
-  fs.mkdirSync(path.dirname(payload.artifact_path), {recursive:true});
-  fs.writeFileSync(payload.artifact_path, 'ok');
-  const out={input_tokens:100, output_tokens:50, context_loaded_tokens:500, tool_calls:2, subagent_calls:0, correctness:true, regression:false, unsupported_completion_claim:false, user_corrections:0, useful_reviewer_findings:1, false_positive_reviewer_findings:0};
-  process.stdout.write(JSON.stringify(out));
-});
-`);
-    const flakyJson = path.join(root, 'flaky.json');
-    fs.writeFileSync(flakyJson, JSON.stringify({ schema_version: 'b1.v1', command: ['node', flakyRunner] }));
-    const flakyOut = path.join(root, 'out-flaky');
-    const flakyRun = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'run', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--runner', flakyJson, '--out', flakyOut], { encoding: 'utf8' });
-    assert.equal(flakyRun.status, 2);
-    assert.match(flakyRun.stderr, /runner exited non-zero|no receipt fabricated/);
-    // No valid live success should be claimed from partial run
-    if (fs.existsSync(path.join(flakyOut, 'receipts.json'))) {
-      const maybeReceipts = JSON.parse(fs.readFileSync(path.join(flakyOut, 'receipts.json'), 'utf8'));
-      if (maybeReceipts.receipts) {
-        const incompleteValidate = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'validate', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--receipts', path.join(flakyOut, 'receipts.json')], { encoding: 'utf8' });
-        assert.equal(incompleteValidate.status, 2);
-        assert.match(incompleteValidate.stderr, /incomplete receipt matrix|runner exited/);
-      }
-    }
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('B1 runner secret safety: command argv with secret-like assignment/flag is fail-closed and stderr is redacted', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-b1-secret-'));
-  const fixture = makeBenchmarkFixture(root);
-  try {
-    // Helper runner that would succeed if not blocked
-    const okRunnerScript = path.join(root, 'ok.mjs');
-    fs.writeFileSync(okRunnerScript, `
-import fs from 'node:fs';
-import path from 'node:path';
-let input='';
-process.stdin.on('data', c=>input+=c);
-process.stdin.on('end', ()=>{
-  const p=JSON.parse(input);
-  fs.mkdirSync(path.dirname(p.artifact_path), {recursive:true});
-  fs.writeFileSync(p.artifact_path,'ok');
-  process.stdout.write(JSON.stringify({input_tokens:1,output_tokens:1,context_loaded_tokens:1,tool_calls:0,subagent_calls:0,correctness:true,regression:false,unsupported_completion_claim:false,user_corrections:0,useful_reviewer_findings:0,false_positive_reviewer_findings:0}));
-});
-`);
-    // Secret-like argv must be rejected fail-closed, value not shown, keep shell:false
-    const cases = [
-      { desc: 'env assignment', command: ['node', okRunnerScript, 'OPENAI_API_KEY=sk-1234567890abcdefghij123456'] },
-      { desc: 'flag equals', command: ['node', okRunnerScript, '--api-key=sk-1234567890abcdefghij123456'] },
-      { desc: 'flag spaced', command: ['node', okRunnerScript, '--api-key', 'sk-1234567890abcdefghij123456'] },
-      { desc: 'password', command: ['node', okRunnerScript, '--password=supersecret1234'] },
-      { desc: 'jwt', command: ['node', okRunnerScript, '--jwt-secret=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9abcdefghij'] },
-      { desc: 'github token', command: ['node', okRunnerScript, 'GITHUB_TOKEN=ghp_1234567890abcdefghijklmnopqrstuv'] },
-    ];
-    for (const c of cases) {
-      const runnerJson = path.join(root, `runner-${c.desc.replace(/\s+/g,'-')}.json`);
-      fs.writeFileSync(runnerJson, JSON.stringify({ schema_version: 'b1.v1', command: c.command }));
-      const out = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'run', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--runner', runnerJson, '--out', path.join(root, `out-${c.desc}`)], { encoding: 'utf8' });
-      assert.equal(out.status, 2, `case ${c.desc} should be blocked`);
-      assert.match(out.stderr, /secret-like assignment\/flag is forbidden/);
-      assert.match(out.stderr, /Value not shown/);
-      // Must not leak secret value in error or evidence
-      assert.doesNotMatch(out.stderr, /sk-1234567890/);
-      assert.doesNotMatch(out.stderr, /supersecret/);
-      assert.doesNotMatch(out.stderr, /ghp_/);
-      assert.doesNotMatch(out.stderr, /eyJhbGci/);
-      // Also ensure stderr snippet does not contain raw secret if leaked via stderr
-      // (the runner never executed, so no stderr from runner, just validation error)
-    }
-
-    // Safe names must NOT be flagged (no false positive)
-    const safeCases = [
-      ['node', okRunnerScript, '--tokenizer', 'bert-base'],
-      ['node', okRunnerScript, '--api-key-file', '/tmp/keyfile'],
-      ['node', okRunnerScript, '--token-path', '/tmp/token'],
-      ['node', okRunnerScript, '--password-hint', 'my hint'],
-      ['node', okRunnerScript, '--password-label', 'label'],
-    ];
-    for (const [idx, command] of safeCases.entries()) {
-      const runnerJson = path.join(root, `safe-${idx}.json`);
-      fs.writeFileSync(runnerJson, JSON.stringify({ schema_version: 'b1.v1', command }));
-      const out = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'run', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--runner', runnerJson, '--out', path.join(root, `out-safe-${idx}`)], { encoding: 'utf8' });
-      // Should not be blocked for secret-like; it should either succeed or fail for other reasons but not secret-like
-      assert.doesNotMatch(out.stderr, /secret-like assignment\/flag is forbidden/, `safe case ${command.join(' ')} must not be flagged`);
-      assert.equal(out.status, 0, `safe case ${command.join(' ')} should execute (got ${out.stderr})`);
-      // Clean out for next
-      fs.rmSync(path.join(root, `out-safe-${idx}`), { recursive: true, force: true });
-    }
-
-    // Stderr redaction: runner that exits non-zero and leaks secret in stderr must have [REDACTED] and not raw secret
-    const leakyRunner = path.join(root, 'leaky.mjs');
-    fs.writeFileSync(leakyRunner, `
-import fs from 'node:fs';
-let input='';
-process.stdin.on('data', c=>input+=c);
-process.stdin.on('end', ()=>{
-  console.error('failed to connect with OPENAI_API_KEY=sk-1234567890abcdefghijklmnopqrstuv and token ghp_1234567890abcdefghijklmnopqrstuv');
-  console.error('also password supersecret1234 and jwt eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9abcdefghij');
-  process.exit(2);
-});
-`);
-    const leakyJson = path.join(root, 'leaky.json');
-    fs.writeFileSync(leakyJson, JSON.stringify({ schema_version: 'b1.v1', command: ['node', leakyRunner] }));
-    const leakyOut = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'run', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--runner', leakyJson, '--out', path.join(root, 'out-leaky')], { encoding: 'utf8' });
-    assert.equal(leakyOut.status, 2);
-    assert.match(leakyOut.stderr, /runner exited non-zero/);
-    assert.match(leakyOut.stderr, /\[REDACTED\]/);
-    assert.doesNotMatch(leakyOut.stderr, /sk-1234567890/);
-    assert.doesNotMatch(leakyOut.stderr, /ghp_1234567890/);
-    assert.doesNotMatch(leakyOut.stderr, /supersecret/);
-    assert.doesNotMatch(leakyOut.stderr, /eyJhbGci/);
-    // Ensure no receipt was fabricated
-    assert.equal(fs.existsSync(path.join(root, 'out-leaky', 'receipts.json')), false, 'no receipt should be fabricated on stderr secret leak');
-
-    // Also test that evidence.command never contains secret when runner would have been allowed (it is blocked, so no evidence)
-    // For a runner that does not contain secret, evidence should contain the safe command
-    const safeRunnerForEvidence = path.join(root, 'evidence.mjs');
-    fs.writeFileSync(safeRunnerForEvidence, `
-import fs from 'node:fs';
-import path from 'node:path';
-let input='';
-process.stdin.on('data', c=>input+=c);
-process.stdin.on('end', ()=>{
-  const p=JSON.parse(input);
-  fs.mkdirSync(path.dirname(p.artifact_path),{recursive:true});
-  fs.writeFileSync(p.artifact_path,'evidence');
-  process.stdout.write(JSON.stringify({input_tokens:1,output_tokens:1,context_loaded_tokens:1,tool_calls:0,subagent_calls:0,correctness:true,regression:false,unsupported_completion_claim:false,user_corrections:0,useful_reviewer_findings:0,false_positive_reviewer_findings:0}));
-});
-`);
-    const evidenceRunnerJson = path.join(root, 'evidence.json');
-    fs.writeFileSync(evidenceRunnerJson, JSON.stringify({ schema_version: 'b1.v1', command: ['node', safeRunnerForEvidence, '--verbose'] }));
-    const evidenceOut = path.join(root, 'out-evidence');
-    const evidenceRun = spawnSync(process.execPath, [BENCHMARK_SCRIPT, 'run', '--corpus', fixture.corpus, '--config', fixture.configs[0], '--runner', evidenceRunnerJson, '--out', evidenceOut], { encoding: 'utf8' });
-    assert.equal(evidenceRun.status, 0);
-    const evidenceReceipts = JSON.parse(fs.readFileSync(path.join(evidenceOut, 'receipts.json'), 'utf8'));
-    const ev = (evidenceReceipts.receipts || evidenceReceipts)[0].evidence;
-    assert.match(ev.command, /node/);
-    assert.doesNotMatch(ev.command, /sk-|ghp_|eyJ/);
-    assert.doesNotMatch(JSON.stringify(evidenceReceipts), /OPENAI_API_KEY/);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
 // ── P0 regressions ──────────────────────────────────────────────────────
 test('P0 receipt fail-closed: Exit 1/-1/abc/conflict/empty command rejected', () => {
   const base = 'Verification: PASS\nCommand: pnpm test\nBase: 0123456789abcdef0123456789abcdef01234567\nHead: 89abcdef0123456789abcdef0123456789abcdef\n';