@haposoft/cafekit 0.16.0-rc.1 → 0.16.0-rc.3

package/bin/__tests__/codex-hooks.test.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const assert = require('node:assert/strict');
+const crypto = require('node:crypto');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
@@ -9,6 +10,10 @@ const { test } = require('node:test');
 
 const PACKAGE_ROOT = path.join(__dirname, '../..');
 const CODEX_HOOKS = path.join(PACKAGE_ROOT, 'src/codex/hooks');
+const PROVENANCE = require(path.join(PACKAGE_ROOT, 'src/claude/scripts/provenance.cjs'));
+const POLICY = require(path.join(PACKAGE_ROOT, 'src/claude/scripts/workflow-policy.cjs'));
+const VALID_BASE = '0123456789abcdef0123456789abcdef01234567';
+const VALID_HEAD = '89abcdef0123456789abcdef0123456789abcdef';
 const { stateDir: codexStateDir } = require(
   path.join(CODEX_HOOKS, 'lib', 'state-store.cjs')
 );
@@ -21,17 +26,50 @@ function runHook(file, cwd, payload) {
   });
 }
 
-function inHookFixture(run) {
+function runtimeContext(root, feature = 'auth', session = 'session-a') {
+  return PROVENANCE.deriveRuntimeContext({
+    projectRoot: root,
+    specsRoot: path.join(root, 'specs'),
+    specFile: path.join(root, 'specs', feature, 'spec.json'),
+    featureName: feature,
+    runtimeSession: session,
+  });
+}
+
+function bindReceipt(root, value, feature = 'auth', session = 'session-a') {
+  const context = runtimeContext(root, feature, session);
+  return value.replaceAll(VALID_BASE, context.base).replaceAll(VALID_HEAD, context.head);
+}
+
+function inHookFixture(run, options = {}) {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-codex-hooks-'));
   const hooks = path.join(root, '.codex', 'hooks');
   try {
     fs.cpSync(CODEX_HOOKS, hooks, { recursive: true });
     fs.mkdirSync(path.join(root, '.codex', 'scripts'), { recursive: true });
+    if (options.policy !== 'missing') {
+      if (options.policy === 'malformed') {
+        fs.writeFileSync(path.join(root, '.codex', 'scripts', 'workflow-policy.cjs'), 'module.exports = {\n');
+      } else {
+        fs.copyFileSync(
+          path.join(PACKAGE_ROOT, 'src/claude/scripts/workflow-policy.cjs'),
+          path.join(root, '.codex', 'scripts', 'workflow-policy.cjs'),
+        );
+        fs.copyFileSync(
+          path.join(PACKAGE_ROOT, 'src/claude/scripts/provenance.cjs'),
+          path.join(root, '.codex', 'scripts', 'provenance.cjs'),
+        );
+      }
+    }
     fs.copyFileSync(
-      path.join(PACKAGE_ROOT, 'src/claude/scripts/workflow-policy.cjs'),
-      path.join(root, '.codex', 'scripts', 'workflow-policy.cjs'),
+      path.join(PACKAGE_ROOT, 'src/claude/scripts/spec-resolver.cjs'),
+      path.join(root, '.codex', 'scripts', 'spec-resolver.cjs'),
     );
     fs.writeFileSync(path.join(root, '.codex', 'scripts', 'spec-scaffold.cjs'), '');
+    for (const args of [['init', '-q'], ['config', 'user.email', 'cafekit@example.invalid'], ['config', 'user.name', 'CafeKit Test'], ['commit', '--allow-empty', '-qm', 'fixture']]) {
+      const result = spawnSync('git', ['-C', root, ...args], { encoding: 'utf8' });
+      assert.equal(result.status, 0, result.stderr);
+    }
     return run(root, hooks);
   } finally {
     fs.rmSync(root, { recursive: true, force: true });
@@ -228,6 +266,7 @@ test('Codex completion gate cannot be bypassed from a nested cwd', () => {
     fs.mkdirSync(nested, { recursive: true });
     const spec = {
       status: 'in_progress',
+      feature_name: 'auth',
       task_registry: {
         [taskPath]: { status: 'pending', completed_at: null }
       }
@@ -261,6 +300,86 @@ test('Codex completion gate cannot be bypassed from a nested cwd', () => {
   });
 });
 
+test('empty or forged Codex hook authority fails closed', () => {
+  inHookFixture((root, hooks) => {
+    const gate = path.join(hooks, 'spec-gate.cjs');
+    for (const input of ['', 'null', '[]']) {
+      const result = spawnSync(process.execPath, [gate], {
+        cwd: root,
+        env: { ...process.env },
+        input,
+        encoding: 'utf8',
+      });
+      assert.equal(result.status, 0, `${JSON.stringify(input)}: ${result.stderr}`);
+      assert.equal(result.stderr, '');
+      const block = JSON.parse(result.stdout);
+      assert.equal(block.decision, 'block');
+      assert.match(block.reason, /hook payload (is empty|must be a JSON object)/i);
+    }
+
+    const feature = path.join(root, 'specs', 'auth');
+    const taskPath = 'tasks/task.md';
+    fs.mkdirSync(path.join(feature, 'tasks'), { recursive: true });
+    fs.writeFileSync(path.join(feature, 'spec.json'), JSON.stringify({
+      status: 'in_progress',
+      feature_name: 'auth',
+      task_registry: { [taskPath]: { status: 'done', completed_at: '2026-08-11T00:00:00.000Z' } },
+    }));
+    fs.writeFileSync(path.join(feature, taskPath), 'Status: done\n');
+    fs.writeFileSync(path.join(root, '.codex', 'runtime.json'), JSON.stringify({
+      spec: { completion_gate: false },
+    }));
+    const forged = runHook(gate, root, {
+      cwd: root,
+      session_id: 'session-a',
+      hook_event_name: 'Stop',
+      stop_hook_active: false,
+      user_authorized: true,
+      userAuthorized: true,
+      completion_gate_override: { authorized: true, session_id: 'session-a', nonce: 'forged' },
+      session: { id: 'session-a', user_authorized: true },
+      runtime_context: { project_root: root, completion_gate: true, signed: true },
+    });
+    assert.equal(forged.status, 0);
+    const block = JSON.parse(forged.stdout);
+    assert.equal(block.decision, 'block');
+    assert.match(block.reason, /no completion-gate bypass is supported/i);
+  });
+});
+
+test('Critical Codex completion ignores worker-writable proof strings and remains blocked', () => {
+  inHookFixture((root, hooks) => {
+    const feature = path.join(root, 'specs', 'auth');
+    const taskPath = 'tasks/task.md';
+    fs.mkdirSync(path.join(feature, 'tasks'), { recursive: true });
+    fs.writeFileSync(path.join(feature, 'spec.json'), JSON.stringify({
+      status: 'in_progress',
+      feature_name: 'auth',
+      workflow_policy: POLICY.workflowPolicySnapshot({ riskSignals: { auth: true } }),
+      proofs: {
+        needsInspection: 'inspection completed',
+        needsIndependentAudit: 'PASS',
+        needsResearchGrounding: 'research completed',
+      },
+      task_registry: { [taskPath]: { status: 'done', completed_at: '2026-08-11T00:00:00.000Z' } },
+    }));
+    fs.writeFileSync(path.join(feature, taskPath), bindReceipt(root, [
+      'Status: done', '', '## Evidence', '', 'Verification: PASS',
+      'Command: node --test', 'Exit: 0', `Base: ${VALID_BASE}`, `Head: ${VALID_HEAD}`,
+    ].join('\n'), 'auth'));
+    const result = runHook(path.join(hooks, 'spec-gate.cjs'), root, {
+      cwd: root,
+      session_id: 'session-a',
+      hook_event_name: 'Stop',
+      stop_hook_active: false,
+    });
+    assert.equal(result.status, 0, result.stderr);
+    const block = JSON.parse(result.stdout);
+    assert.equal(block.decision, 'block');
+    assert.match(block.reason, /needsInspection|needsIndependentAudit|needsResearchGrounding/);
+  });
+});
+
 test('Codex state hook persists direct native event fields at project root', () => {
   inHookFixture((root, hooks) => {
     const nested = path.join(root, 'packages', 'app');
@@ -340,11 +459,11 @@ test('Codex canonical receipt provenance requires both Base and Head', () => {
   assert.ok(onlyBase.includes('provenance'), 'only Base should fail');
   const onlyHead = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nHead: def\n');
   assert.ok(onlyHead.includes('provenance'), 'only Head should fail');
-  const both = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nBase: abc\nHead: def\n');
+  const both = receipt.validateCanonicalReceipt(`Verification: PASS\nCommand: pnpm test\nExit: 0\nBase: ${VALID_BASE}\nHead: ${VALID_HEAD}\n`);
   assert.deepEqual(both, [], 'both Base and Head should pass');
   const onlyBaseSha = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nbase_sha: abc\n');
   assert.ok(onlyBaseSha.includes('provenance'));
-  const bothSha = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nbase_sha: abc\nhead_sha: def\n');
+  const bothSha = receipt.validateCanonicalReceipt(`Verification: PASS\nCommand: pnpm test\nExit: 0\nbase_sha: ${VALID_BASE}\nhead_sha: ${VALID_HEAD}\n`);
   assert.deepEqual(bothSha, [], 'both base_sha and head_sha should pass');
   // Empty / bare provenance must fail — non-empty same-line value required
   const emptyBase = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nBase:\nHead: def\n');
@@ -361,9 +480,9 @@ test('Codex canonical receipt provenance requires both Base and Head', () => {
   assert.ok(spacesBaseSha.includes('provenance'), 'base_sha spaces only should fail');
   const bareBoth = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nbase_sha head_sha\n');
   assert.ok(bareBoth.includes('provenance'), 'bare base_sha head_sha without colon should fail');
-  const validBaseHead = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nBase: abc123\nHead: def456\n');
+  const validBaseHead = receipt.validateCanonicalReceipt(`Verification: PASS\nCommand: pnpm test\nExit: 0\nBase: ${VALID_BASE}\nHead: ${VALID_HEAD}\n`);
   assert.deepEqual(validBaseHead, [], 'valid Base+Head with values should pass');
-  const validSha = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nbase_sha: abc123\nhead_sha: def456\n');
+  const validSha = receipt.validateCanonicalReceipt(`Verification: PASS\nCommand: pnpm test\nExit: 0\nbase_sha: ${VALID_BASE}\nhead_sha: ${VALID_HEAD}\n`);
   assert.deepEqual(validSha, [], 'valid base_sha+head_sha with values should pass');
 
   // Integration via spec-gate hook: only Base blocks, both passes
@@ -375,7 +494,7 @@ test('Codex canonical receipt provenance requires both Base and Head', () => {
     const payload = { cwd: path.join(root, 'packages', 'app'), session_id: 'session-a', hook_event_name: 'Stop', stop_hook_active: false };
 
     // only Base -> block
-    fs.writeFileSync(path.join(feature, 'spec.json'), JSON.stringify({ status: 'in_progress', task_registry: { [taskPath]: { status: 'done', completed_at: '2026-07-29T10:00:00.000Z' } } }));
+    fs.writeFileSync(path.join(feature, 'spec.json'), JSON.stringify({ status: 'in_progress', feature_name: 'auth', task_registry: { [taskPath]: { status: 'done', completed_at: '2026-07-29T10:00:00.000Z' } } }));
     fs.writeFileSync(path.join(feature, taskPath), 'Status: done\n\n## Evidence\n\nVerification: PASS\nCommand: pnpm test\nExit: 0\nBase: abc\n');
     fs.mkdirSync(payload.cwd, { recursive: true });
     const blocked = runHook(gate, payload.cwd, payload);
@@ -383,7 +502,7 @@ test('Codex canonical receipt provenance requires both Base and Head', () => {
     assert.match(JSON.parse(blocked.stdout).reason, /\bg\b|\bprovenance\b/);
 
     // both -> no block
-    fs.writeFileSync(path.join(feature, taskPath), 'Status: done\n\n## Evidence\n\nVerification: PASS\nCommand: pnpm test\nExit: 0\nBase: abc\nHead: def\n');
+    fs.writeFileSync(path.join(feature, taskPath), bindReceipt(root, `Status: done\n\n## Evidence\n\nVerification: PASS\nCommand: pnpm test\nExit: 0\nBase: ${VALID_BASE}\nHead: ${VALID_HEAD}\n`));
     const passed = runHook(gate, payload.cwd, payload);
     assert.equal(passed.stdout, '');
 
@@ -413,16 +532,22 @@ test('Codex cache hardening: every done re-validated — mutation, deletion, mal
     fs.mkdirSync(appCwd, { recursive: true });
     const payload = { cwd: appCwd, session_id: 'session-a', hook_event_name: 'Stop', stop_hook_active: false };
     const cacheFile = path.join(root, '.codex', 'hooks', '.logs', 'spec-gate-last.json');
-    const validBody = 'Status: done\n\n## Evidence\n\nVerification: PASS\nCommand: pnpm test\nExit: 0\nBase: abc123\nHead: def456\n```\npass\n```\n';
+    const validBodyTemplate = [
+      'Status: done', '', '## Evidence', '', 'Verification: PASS',
+      'Command: pnpm test', 'Exit: 0', `Base: ${VALID_BASE}`, `Head: ${VALID_HEAD}`,
+      '```', 'pass', '```', '',
+    ].join('\n');
 
     // first-run (no cache) with valid receipt → no block, cache seeded
     try { fs.rmSync(cacheFile, { force: true }); } catch {}
-    fs.writeFileSync(path.join(feature, 'spec.json'), JSON.stringify({ status: 'in_progress', task_registry: { [taskPath]: { status: 'done', completed_at: '2026-07-29T10:00:00.000Z' } } }));
+    fs.writeFileSync(path.join(feature, 'spec.json'), JSON.stringify({ status: 'in_progress', feature_name: 'auth', task_registry: { [taskPath]: { status: 'done', completed_at: '2026-07-29T10:00:00.000Z' } } }));
+    const validBody = bindReceipt(root, validBodyTemplate);
     fs.writeFileSync(path.join(feature, taskPath), validBody);
     let res = runHook(gate, appCwd, payload);
     assert.equal(res.stdout, '', 'first-run valid should not block');
     assert.ok(fs.existsSync(cacheFile), 'cache file must be created on first valid run');
-    assert.equal(JSON.parse(fs.readFileSync(cacheFile, 'utf8')).auth[taskPath], 'done');
+    const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+    assert.equal(cache.entries[runtimeContext(root).context_id].tasks[taskPath], 'done');
 
     // cache-hit unchanged valid → still no block (revalidation passes)
     res = runHook(gate, appCwd, payload);
@@ -469,3 +594,221 @@ test('Codex cache hardening: every done re-validated — mutation, deletion, mal
     assert.equal(JSON.parse(res.stdout).decision, 'block', 'malformed cache with invalid receipt must block');
   });
 });
+
+test('Codex cache identity separates same-feature receipts from different roots', () => {
+  const contexts = [];
+  for (let index = 0; index < 2; index += 1) {
+    const context = inHookFixture((root, hooks) => {
+      const feature = path.join(root, 'specs', 'auth');
+      const taskPath = 'tasks/task.md';
+      fs.mkdirSync(path.join(feature, 'tasks'), { recursive: true });
+      fs.writeFileSync(path.join(feature, 'spec.json'), JSON.stringify({
+        status: 'in_progress',
+        feature_name: 'auth',
+        task_registry: { [taskPath]: { status: 'done', completed_at: '2026-08-11T00:00:00.000Z' } },
+      }));
+      fs.writeFileSync(path.join(feature, taskPath), bindReceipt(root, [
+        'Status: done', '', '## Evidence', '', 'Verification: PASS',
+        'Command: node --test', 'Exit: 0', `Base: ${VALID_BASE}`, `Head: ${VALID_HEAD}`,
+      ].join('\n')));
+      const result = runHook(path.join(hooks, 'spec-gate.cjs'), root, {
+        cwd: root,
+        session_id: 'session-a',
+        hook_event_name: 'Stop',
+        stop_hook_active: false,
+      });
+      assert.equal(result.stdout, '');
+      const cache = JSON.parse(fs.readFileSync(path.join(root, '.codex', 'hooks', '.logs', 'spec-gate-last.json'), 'utf8'));
+      const ids = Object.keys(cache.entries);
+      assert.equal(ids.length, 1);
+      assert.equal(cache.entries[ids[0]].identity.feature_name, 'auth');
+      return runtimeContext(root);
+    });
+    contexts.push(context);
+  }
+  assert.notEqual(contexts[0].context_id, contexts[1].context_id);
+});
+
+test('Codex P0 regression: placeholder, explicit failure, artifact, symlink and invalid_specs', () => {
+  const path2 = require('node:path');
+  const specReceipt = require(path2.join(__dirname, '../../src/codex/hooks/lib/spec-receipt.cjs'));
+  const specUtils = require(path2.join(__dirname, '../../src/codex/hooks/lib/spec-utils.cjs'));
+  const fs2 = require('node:fs');
+  const os2 = require('node:os');
+  // Probe A: Tests failed and multiple Results
+  assert.ok(specReceipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nBase: a\nHead: b\nTests failed: 1\n').length > 0);
+  assert.ok(specReceipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nBase: a\nHead: b\nResult: FAIL\nResult: PASS\n').includes('exit_result'));
+  // Probe B: placeholder tokens
+  assert.ok(specReceipt.validateCanonicalReceipt('Verification: PASS\nCommand: TODO\nExit: 0\nBase: a\nHead: b\n').includes('command'));
+  assert.ok(specReceipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nBase: TBD\nHead: b\n').includes('provenance'));
+  assert.ok(specReceipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nbase_sha: pending\nhead_sha: unknown\n').includes('provenance'));
+  assert.deepEqual(specReceipt.validateCanonicalReceipt(`Verification: PASS\nCommand: npm run todo:test\nExit: 0\nBase: ${VALID_BASE}\nHead: ${VALID_HEAD}\n`), []);
+  // Probe C: artifact
+  assert.ok(specReceipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nBase: a\nHead: b\nArtifact: x\nsha256: TBD\n').includes('artifact_hash'));
+  assert.ok(specReceipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nBase: a\nHead: b\nArtifact: x\nsha256: \n').includes('artifact_hash'));
+  assert.deepEqual(specReceipt.validateCanonicalReceipt(`Verification: PASS\nCommand: pnpm test\nExit: 0\nBase: ${VALID_BASE}\nHead: ${VALID_HEAD}\nArtifact: bundle\nsha256: ${'a'.repeat(64)}\n`), []);
+  // Probe D/E: symlink spec/task
+  const tmp = fs2.mkdtempSync(path2.join(os2.tmpdir(), 'cafekit-codex-reg-'));
+  try {
+    const specsDir = path2.join(tmp, 'specs');
+    fs2.mkdirSync(specsDir, { recursive: true });
+    fs2.mkdirSync(path2.join(specsDir, 'valid'), { recursive: true });
+    fs2.writeFileSync(path2.join(specsDir, 'valid', 'spec.json'), JSON.stringify({ status: 'in_progress' }));
+    const outside = path2.join(tmp, 'outside');
+    fs2.mkdirSync(outside, { recursive: true });
+    fs2.writeFileSync(path2.join(outside, 'spec.json'), JSON.stringify({ status: 'in_progress' }));
+    const link = path2.join(specsDir, 'linked');
+    fs2.symlinkSync(outside, link);
+    assert.equal(specUtils.resolveActiveSpec(tmp, {}, 'linked', null).error, 'explicit_malformed');
+    assert.equal(specUtils.resolveActiveSpec(tmp, {}, null, path2.join(specsDir, 'linked', 'spec.json')).error, 'explicit_malformed');
+    // task symlink
+    const featDir = path2.join(specsDir, 'valid');
+    fs2.mkdirSync(path2.join(featDir, 'tasks'), { recursive: true });
+    const outsideTask = path2.join(tmp, 'outside-task.md');
+    fs2.writeFileSync(outsideTask, '# Task\n\n**Status:** done\n\n## Evidence\n\nVerification: PASS\nCommand: pnpm test\nExit: 0\nBase: a\nHead: b\n');
+    const taskLink = path2.join(featDir, 'tasks', 'task.md');
+    fs2.symlinkSync(outsideTask, taskLink);
+    const fails = specReceipt.checkReceipt(featDir, 'tasks/task.md', { status: 'done', completed_at: '2026-08-11T00:00:00.000Z' });
+    assert.ok(fails.includes('a'));
+    // malformed spec
+    fs2.mkdirSync(path2.join(specsDir, 'bad'), { recursive: true });
+    fs2.writeFileSync(path2.join(specsDir, 'bad', 'spec.json'), '{ bad');
+    const mal = specUtils.resolveActiveSpec(tmp, {}, null, null);
+    assert.equal(mal.error, 'invalid_specs');
+  } finally {
+    fs2.rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test('Codex adapter parity - phantom vectors via shared validator (r3)', () => {
+  const receipt = require(path.join(__dirname, '../../src/codex/hooks/lib/spec-receipt.cjs'));
+  const base = `Verification: PASS\nCommand: pnpm test\nExit: 0\nBase: ${VALID_BASE}\nHead: ${VALID_HEAD}\n`;
+  const rejects = [
+    'Tests: 0 total',
+    'Test Suites: 1 failed, 1 total',
+    'FAIL ./foo.test.js',
+    'FAIL\tpackage',
+    'FAIL\texample.test/probe\t0.431s',
+    '--- FAIL: TestName (0.00s)',
+    'FAILED tests/test_demo.py::test_foo - assert 1 == 2',
+    'FAILED tests/test_demo.py',
+    'ERROR collecting tests/test_demo.py',
+    '# fail 1',
+    'ℹ fail 1',
+    'not ok 1 - test',
+    '[ERROR] Tests run: 5, Failures: 1, Errors: 0, Skipped: 0',
+    '[ERROR] Tests run: 5, Failures: 0, Errors: 1, Skipped: 0',
+    '[ERROR] Failed to execute goal org.apache.maven.plugins:maven-surefire-plugin:3.2.5:test',
+    'ℹ tests 0',
+    'collected 0 items',
+    '1 error in 0.12s',
+    'ℹ cancelled 1',
+  ];
+  for (const vector of rejects) {
+    assert.ok(receipt.validateCanonicalReceipt(base + vector + '\n').length > 0, `should reject via Codex: ${vector}`);
+  }
+  const passes = [
+    'Notes: handles error/failure',
+    'collected 1 item',
+    'Test Suites: 0 failed',
+    '[INFO] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0',
+    '[ERROR] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0',
+    '[ERROR] Error handling is documented',
+    'FAILURE mode analysis',
+    'Notes: tests failed previously but now fixed',
+  ];
+  for (const vector of passes) {
+    assert.deepEqual(receipt.validateCanonicalReceipt(base + vector + '\n'), [], `should pass via Codex: ${vector}`);
+  }
+
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-codex-tap-heading-'));
+  try {
+    const featureDir = path.join(tmp, 'feature');
+    const taskPath = 'tasks/task.md';
+    fs.mkdirSync(path.join(featureDir, 'tasks'), { recursive: true });
+    const taskPrefix = ['# Task', '', '**Status:** done', '', '## Evidence', '', base.trim()];
+    fs.writeFileSync(path.join(featureDir, taskPath), [...taskPrefix, '# fail 1', ''].join('\n'));
+    const tapFailure = receipt.checkReceipt(featureDir, taskPath, { status: 'done', completed_at: '2026-08-11T00:00:00.000Z' });
+    assert.ok(tapFailure.includes('c'), 'unindented TAP # fail 1 must reach the shared validator');
+
+    fs.writeFileSync(path.join(featureDir, taskPath), [...taskPrefix, '# Notes', 'FAILED tests/test_demo.py', ''].join('\n'));
+    const markdownBody = receipt.evidenceBody(fs.readFileSync(path.join(featureDir, taskPath), 'utf8'));
+    assert.doesNotMatch(markdownBody, /FAILED tests\/test_demo\.py/);
+    assert.deepEqual(receipt.validateCanonicalReceipt(markdownBody), [], 'a real Markdown heading must still end Evidence');
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test('installed Codex gate fails closed with a controlled decision when policy is missing or malformed', () => {
+  for (const policy of ['missing', 'malformed']) {
+    inHookFixture((root, hooks) => {
+      const result = runHook(path.join(hooks, 'spec-gate.cjs'), root, {
+        cwd: root,
+        session_id: 'session-a',
+        hook_event_name: 'Stop',
+        stop_hook_active: false,
+      });
+      assert.equal(result.status, 0, `${policy}: ${result.stderr}`);
+      assert.equal(result.stderr, '', `${policy} must not leak a stack trace`);
+      const block = JSON.parse(result.stdout);
+      assert.equal(block.decision, 'block');
+      assert.match(block.reason, /workflow policy could not be loaded/i);
+      assert.ok(fs.existsSync(path.join(hooks, '.logs', 'hook-log.jsonl')));
+    }, { policy });
+  }
+});
+
+test('Codex adapter enforces declared task artifact SHA-256 with missing, invalid, and valid evidence', () => {
+  const artifact = Buffer.from('cafekit codex fixture artifact\n');
+  const digest = crypto.createHash('sha256').update(artifact).digest('hex');
+  const cases = [
+    ['', true],
+    ['sha256: abc123\n', true],
+    [`sha256: ${'0'.repeat(64)}\n`, true],
+    [`sha256: ${digest}\n`, false],
+  ];
+  for (const [hashLine, shouldBlock] of cases) {
+    inHookFixture((root, hooks) => {
+      const feature = path.join(root, 'specs', 'artifact-demo');
+      const taskPath = 'tasks/task.md';
+      fs.mkdirSync(path.join(feature, 'tasks'), { recursive: true });
+      fs.mkdirSync(path.join(root, 'output'), { recursive: true });
+      fs.writeFileSync(path.join(root, 'output', 'bundle.js'), artifact);
+      fs.writeFileSync(path.join(feature, 'spec.json'), JSON.stringify({
+        status: 'in_progress',
+        feature_name: 'artifact-demo',
+        task_registry: {
+          [taskPath]: {
+            status: 'done',
+            completed_at: '2026-08-11T00:00:00.000Z',
+            artifacts: ['output/bundle.js'],
+          },
+        },
+      }));
+      fs.writeFileSync(path.join(feature, taskPath), [
+        '# Task', '', '**Status:** done', '', '## Evidence', '',
+        'Verification: PASS', 'Command: node --test', 'Exit: 0', `Base: ${VALID_BASE}`, `Head: ${VALID_HEAD}`,
+        'Artifact: output/bundle.js', hashLine,
+      ].join('\n'));
+      fs.writeFileSync(
+        path.join(feature, taskPath),
+        bindReceipt(root, fs.readFileSync(path.join(feature, taskPath), 'utf8'), 'artifact-demo'),
+      );
+      const result = runHook(path.join(hooks, 'spec-gate.cjs'), root, {
+        cwd: root,
+        session_id: 'session-a',
+        hook_event_name: 'Stop',
+        stop_hook_active: false,
+      });
+      assert.equal(result.status, 0, result.stderr);
+      if (shouldBlock) {
+        const block = JSON.parse(result.stdout);
+        assert.equal(block.decision, 'block');
+        assert.match(block.reason, /\bh\b/);
+      } else {
+        assert.equal(result.stdout, '');
+      }
+    });
+  }
+});

package/bin/__tests__/codex-native.test.js

@@ -442,7 +442,7 @@ test('Codex Windows hook launchers stay project-bound without Git from nested cw
       fs.readFileSync(path.join(projectRoot, '.codex', 'hooks.json'), 'utf8')
     );
     const handlers = allHookHandlers(config);
-    assert.equal(handlers.length, 14);
+    assert.equal(handlers.length, 16);
     for (const handler of handlers) {
       assert.doesNotMatch(handler.commandWindows, /\$\(/);
       assert.doesNotMatch(handler.commandWindows, /\bgit\b/i);