@haposoft/cafekit 0.18.0 → 0.18.2

package/bin/__tests__/legacy-hooks-retired.test.js

@@ -48,6 +48,7 @@ function install(root, platforms) {
   const result = spawnSync(process.execPath, [INSTALLER, '--platform', platforms.join(','), '--yes'],
     { cwd: root, encoding: 'utf8', env: { ...process.env, PATH: '/usr/bin:/bin' } });
   assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
+  return result;
 }
 
 function commands(settings) {
@@ -74,7 +75,7 @@ test('fresh installs ship and register none of the five legacy hooks', () => {
   });
 });
 
-test('claude upgrade removes the legacy hooks and their CafeKit entries but keeps foreign ones', () => {
+test('claude upgrade preserves edited legacy hooks while removing their CafeKit entries', () => {
   inTempProject((root) => {
     install(root, ['claude']);
     const settingsPath = path.join(root, '.claude', 'settings.json');
@@ -99,10 +100,11 @@ test('claude upgrade removes the legacy hooks and their CafeKit entries but keep
     settings.hooks.SubagentStop[0].hooks.push({ type: 'command', command: cmd('semantic-review-authority.cjs') });
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
 
-    install(root, ['claude']);
-    for (const name of NAMES) assert.equal(fs.existsSync(path.join(root, '.claude', 'hooks', name)), false, name);
+    const upgrade = install(root, ['claude']);
+    assert.match(upgrade.stdout + upgrade.stderr, /Preserved 5 obsolete runtime/);
+    for (const name of NAMES) assert.equal(fs.readFileSync(path.join(root, '.claude', 'hooks', name), 'utf8'), '// user edit\n', name);
     const after = readJson(manifestPath);
-    for (const name of NAMES) assert.equal(Object.prototype.hasOwnProperty.call(after.files, `hooks/${name}`), false, `record ${name}`);
+    for (const name of NAMES) assert.equal(after.files[`hooks/${name}`].sha256, '0'.repeat(64), `record ${name}`);
     const afterCommands = commands(readJson(settingsPath));
     for (const name of REGISTERED) {
       assert.equal(afterCommands.some((command) => command.includes(`.claude/hooks/${name}`)), false, name);
@@ -112,7 +114,7 @@ test('claude upgrade removes the legacy hooks and their CafeKit entries but keep
   });
 });
 
-test('codex upgrade removes the legacy hooks, their records and their CafeKit entries but keeps foreign ones', () => {
+test('codex upgrade preserves edited legacy hooks and prunes only absent records', () => {
   inTempProject((root) => {
     install(root, ['codex']);
     const hooksPath = path.join(root, '.codex', 'hooks.json');
@@ -137,10 +139,18 @@ test('codex upgrade removes the legacy hooks, their records and their CafeKit en
     add('UserPromptSubmit', FOREIGN[0]);
     fs.writeFileSync(hooksPath, JSON.stringify(config, null, 2));
 
-    install(root, ['codex']);
-    for (const name of NAMES) assert.equal(fs.existsSync(path.join(root, '.codex', 'hooks', name)), false, name);
+    const upgrade = install(root, ['codex']);
+    assert.match(upgrade.stdout + upgrade.stderr, /Preserved 4 obsolete runtime/);
+    for (const name of NAMES) {
+      const file = path.join(root, '.codex', 'hooks', name);
+      if (name === 'completion-authority-state.cjs') assert.equal(fs.existsSync(file), false, name);
+      else assert.equal(fs.readFileSync(file, 'utf8'), '// user edit\n', name);
+    }
     const after = readJson(manifestPath);
-    for (const name of NAMES) assert.equal(Object.prototype.hasOwnProperty.call(after.files, `.codex/hooks/${name}`), false, `record ${name}`);
+    for (const name of NAMES) {
+      if (name === 'completion-authority-state.cjs') assert.equal(after.files[`.codex/hooks/${name}`], undefined, `record ${name}`);
+      else assert.equal(after.files[`.codex/hooks/${name}`].sha256, '0'.repeat(64), `record ${name}`);
+    }
     const afterCommands = commands(readJson(hooksPath));
     for (const name of REGISTERED) {
       assert.equal(afterCommands.some((command) => command.includes(`.codex/hooks/${name}`) || command.includes(`.codex\\hooks\\${name}`)), false, name);

package/bin/__tests__/omp-bridge.test.js

@@ -22,15 +22,18 @@ const MANIFEST = require(path.join(PACKAGE_ROOT, 'src/claude/migration-manifest.
  * The hooks an omp install runs: the Claude set the manifest ships, then `src/omp/hooks/`
  * written over it. Composed once under a dotted folder so runtime-dir.cjs derives `.omp`.
  */
-const COMPOSED_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-omp-composed-'));
-const HOOKS = path.join(COMPOSED_ROOT, '.omp', 'hooks');
-for (const rel of MANIFEST.runtime.files.filter((f) => f.startsWith('hooks/'))) {
-  const target = path.join(COMPOSED_ROOT, '.omp', rel);
-  fs.mkdirSync(path.dirname(target), { recursive: true });
-  fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/claude', rel), target);
+function composeOmp(root) {
+  for (const rel of MANIFEST.runtime.files.filter((f) => f.startsWith('hooks/'))) {
+    const target = path.join(root, '.omp', rel);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/claude', rel), target);
+  }
+  fs.cpSync(path.join(PACKAGE_ROOT, 'src/omp/hooks'), path.join(root, '.omp', 'hooks'), { recursive: true });
+  fs.cpSync(path.join(PACKAGE_ROOT, 'src/claude/scripts'), path.join(root, '.omp', 'scripts'), { recursive: true });
+  return path.join(root, '.omp', 'hooks');
 }
-fs.cpSync(path.join(PACKAGE_ROOT, 'src/omp/hooks'), HOOKS, { recursive: true });
-fs.cpSync(path.join(PACKAGE_ROOT, 'src/claude/scripts'), path.join(COMPOSED_ROOT, '.omp', 'scripts'), { recursive: true });
+const COMPOSED_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-omp-composed-'));
+const HOOKS = composeOmp(COMPOSED_ROOT);
 
 let bridge;
 test.before(async () => { bridge = await import(BRIDGE); });
@@ -49,10 +52,10 @@ function registered(eventName) {
     .filter(Boolean);
 }
 
-// Deliberate, named divergences while omp is not yet updated. Each must still be a real
-// difference, so the test fails (and the entry must go) once omp catches up.
-const CLAUDE_ONLY = { PostToolUse: ['spec-state.cjs'] };
-const OMP_ONLY = { SessionStart: ['docs-sync.cjs'] };
+// Deliberate, named divergences. Each must still be a real difference, so the test fails
+// (and the entry must go) once omp catches up.
+const CLAUDE_ONLY = {};
+const OMP_ONLY = {};
 
 test('the dispatch table mirrors settings.json for every event omp can deliver', () => {
   const { DISPATCH } = bridge;
@@ -169,3 +172,54 @@ test('input injections flow back as a transform that keeps the user text intact'
     assert.match(r.inject, /Secret handling/, 'secret-output-guardrail must inject on a credential prompt');
   } finally { fs.rmSync(root, { recursive: true, force: true }); }
 });
+
+test('the omp session id is used for every event that does not carry its own', () => {
+  const ctx = { cwd: '/tmp/project', sessionManager: { getSessionId: () => 'omp-session-1' } };
+  assert.equal(bridge.shapePayload('input', { text: 'hi' }, ctx).session_id, 'omp-session-1');
+  assert.equal(bridge.shapePayload('tool_result', { toolName: 'edit', input: {} }, ctx).session_id, 'omp-session-1');
+  assert.equal(bridge.shapePayload('session_stop', { session_id: 'omp-session-1' }, ctx).session_id, 'omp-session-1',
+    'session_stop carries the same id omp hands extensions, so touch and state stay in one place');
+  assert.ok(!bridge.DISPATCH.session_start.hooks.includes('docs-sync.cjs'), 'docs-sync runs on demand, as on Claude');
+});
+
+function ompPacket(root, name) {
+  const dir = path.join(root, 'specs', name);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'plan.md'), `# ${name}\nSpecs-Contract: process-first-ready-v1\n`);
+  fs.writeFileSync(path.join(dir, 'task-01-work.md'), ['# Task 01 — work', '', 'Status: pending', '',
+    '## Dependencies', '', '- none', '', '## Verification Plan', '', '- Command: node --test', ''].join('\n'));
+  return dir;
+}
+
+test('an omp edit inside a packet scopes the tollgate to it', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-omp-touch-'));
+  try {
+    const hooks = composeOmp(root);
+    const alpha = ompPacket(root, 'alpha');
+    ompPacket(root, 'beta');
+    const { spawnSync } = require('node:child_process');
+    for (const args of [['init', '-q'], ['config', 'user.email', 'cafekit@example.invalid'],
+      ['config', 'user.name', 'CafeKit Test'], ['commit', '--allow-empty', '-qm', 'fixture']]) {
+      assert.equal(spawnSync('git', ['-C', root, ...args], { encoding: 'utf8' }).status, 0);
+    }
+    const session = (id) => ({ cwd: root, sessionManager: { getSessionId: () => id } });
+
+    const untouched = await bridge.runEvent('input', { text: 'Continue' }, session('omp-a'), { dir: hooks });
+    assert.doesNotMatch(untouched.inject, /Multiple active specs|Spec state changed/, 'a session that touched nothing hears nothing');
+
+    // A failed edit records nothing.
+    await bridge.runEvent('tool_result', { toolName: 'edit', input: { path: path.join(alpha, 'plan.md') }, content: [], isError: true },
+      session('omp-a'), { dir: hooks });
+    const afterFailure = await bridge.runEvent('input', { text: 'Continue' }, session('omp-a'), { dir: hooks });
+    assert.doesNotMatch(afterFailure.inject, /Multiple active specs|Spec state changed/, 'a failed edit records nothing');
+
+    await bridge.runEvent('tool_result', { toolName: 'edit', input: { path: path.join(alpha, 'plan.md') }, content: [], isError: false },
+      session('omp-a'), { dir: hooks });
+    // As on Claude, a session that touched one of two active packets is told about both.
+    const touched = await bridge.runEvent('input', { text: 'Continue' }, session('omp-a'), { dir: hooks });
+    assert.match(touched.inject, /Multiple active specs detected: alpha, beta/);
+
+    const other = await bridge.runEvent('input', { text: 'Continue' }, session('omp-b'), { dir: hooks });
+    assert.doesNotMatch(other.inject, /Multiple active specs|Spec state changed/, "another omp session's touch does not leak");
+  } finally { fs.rmSync(root, { recursive: true, force: true }); }
+});

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

@@ -133,11 +133,9 @@ function expectedOverlay(name) {
     source = source.replace(from, to);
   };
   if (name === 'privacy-block.cjs') {
-    edit("        permissionDecision: 'ask',\n        permissionDecisionReason: `Sensitive file access requires approval: ${basename}`\n",
-      "        // omp has no ask state on tool_call, so an ask under Claude becomes a denial here.\n"
-      + "        permissionDecision: 'deny',\n        permissionDecisionReason: `Sensitive file access requires approval: ${basename}`\n");
-    edit("      permissionDecision: 'ask',\n      permissionDecisionReason: 'Sensitive access could not be evaluated safely.'\n",
-      "      permissionDecision: 'deny',\n      permissionDecisionReason: 'Sensitive access could not be evaluated safely.'\n");
+    edit("      permissionDecision: 'ask',\n",
+      "      // omp has no ask state on tool_call, so an ask under Claude becomes a denial here.\n"
+      + "      permissionDecision: 'deny',\n");
   }
   return source;
 }
@@ -157,3 +155,11 @@ test('the fork differs from Claude only by its overlay', () => {
   assert.match(phase, /claudeHookFiles/, 'the phase must install the Claude set first');
   assert.match(phase, /overlayFiles/, 'the phase must write the overlay over it');
 });
+
+test('an empty stdin is denied under omp, where Claude asks', () => {
+  const result = spawnSync(process.execPath, [path.join(INSTALLED, 'privacy-block.cjs')], { input: '', encoding: 'utf8' });
+  assert.equal(result.status, 0, result.stderr);
+  const output = JSON.parse(result.stdout).hookSpecificOutput;
+  assert.equal(output.permissionDecision, 'deny');
+  assert.match(output.permissionDecisionReason, /Sensitive access could not be evaluated safely\./);
+});

package/bin/__tests__/orca-session.test.js

@@ -149,8 +149,15 @@ function composeCodexHookTree(root) {
     path.join(hooksDir, 'lib', 'hook-context.cjs'));
   fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/codex/hooks/lib/privacy-state.cjs'),
     path.join(hooksDir, 'lib', 'privacy-state.cjs'));
+  fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/codex/hooks/lib/rules-reservation.cjs'),
+    path.join(hooksDir, 'lib', 'rules-reservation.cjs'));
+  fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/claude/hooks/lib/update-check.cjs'),
+    path.join(hooksDir, 'lib', 'update-check.cjs'));
   fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/claude/hooks/lib/runtime-path-safety.cjs'),
     path.join(hooksDir, 'lib', 'runtime-path-safety.cjs'));
+  for (const name of ['privacy-paths.cjs', 'privacy-command-analysis.cjs']) {
+    fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/claude/hooks/lib', name), path.join(hooksDir, 'lib', name));
+  }
   return path.join(hooksDir, 'session.cjs');
 }
 

package/bin/__tests__/package-inventory.test.js

@@ -114,13 +114,6 @@ const REQUIRED_PAYLOAD = [
   'src/claude/scripts/workflow-policy.cjs',
   'src/claude/scripts/provenance.cjs',
   'src/claude/scripts/spec-receipt.cjs',
-  'src/claude/scripts/spec-ground.cjs',
-  'src/claude/scripts/spec-final-state.cjs',
-  'src/claude/scripts/spec-readiness.cjs',
-  'src/claude/scripts/spec-semantic-model.cjs',
-  'src/claude/scripts/validate-spec-output.cjs',
-  'src/claude/scripts/spec-authoring-validation.cjs',
-  'src/claude/scripts/spec-authoring-digest.cjs',
   'src/claude/scripts/generate-skill-catalog.cjs',
   'src/claude/rules/process-management.md',
   'src/claude/rules/review-audit-self-decision.md',
@@ -1522,13 +1515,11 @@ function assertInstalledProvenance(root, platform, fixture) {
   const policy = path.join(scripts, 'workflow-policy.cjs');
   const resolver = path.join(scripts, 'spec-resolver.cjs');
   const receipt = path.join(scripts, 'spec-receipt.cjs');
-  const finalState = path.join(scripts, 'spec-final-state.cjs');
-  const readiness = path.join(scripts, 'spec-readiness.cjs');
   const gate = path.join(
     root,
     platform === 'claude' ? '.claude/hooks/spec-gate.cjs' : '.codex/hooks/spec-gate.cjs'
   );
-  for (const file of [helper, policy, resolver, receipt, finalState, readiness]) {
+  for (const file of [helper, policy, resolver, receipt]) {
     assert.equal(fs.existsSync(file), true, `${platform} installed file missing: ${file}`);
   }
   assert.equal(fs.existsSync(gate), true, `${platform} installed gate missing: ${gate}`);
@@ -1660,26 +1651,13 @@ function assertInstalledScripts(root, platform) {
   const scripts = path.join(root, RUNTIMES[platform].root, 'scripts');
   const policy = path.join(scripts, 'workflow-policy.cjs');
   const scanner = path.join(scripts, 'scan-staged-secrets.cjs');
-  const grounder = path.join(scripts, 'spec-ground.cjs');
-  const finalState = path.join(scripts, 'spec-final-state.cjs');
-  const readiness = path.join(scripts, 'spec-readiness.cjs');
-  const validator = path.join(scripts, 'validate-spec-output.cjs');
   assert.ok(fs.existsSync(policy), `installed policy missing: ${policy}`);
   assert.ok(fs.existsSync(scanner), `installed scanner missing: ${scanner}`);
-  assert.ok(fs.existsSync(grounder), `installed validator dependency missing: ${grounder}`);
-  assert.ok(fs.existsSync(finalState), `installed final-state dependency missing: ${finalState}`);
-  assert.ok(fs.existsSync(readiness), `installed readiness finalizer missing: ${readiness}`);
-  assert.ok(fs.existsSync(validator), `installed validator missing: ${validator}`);
 
   const policyRun = spawnSync(process.execPath, [policy, '--json'], { cwd: root, encoding: 'utf8' });
   assert.equal(policyRun.status, 0, `${policyRun.stdout}\n${policyRun.stderr}`);
   assert.equal(JSON.parse(policyRun.stdout).contract, 'execution-policy');
 
-  const validatorRun = spawnSync(process.execPath, [validator], { cwd: root, encoding: 'utf8' });
-  assert.equal(validatorRun.status, 2, `${validatorRun.stdout}\n${validatorRun.stderr}`);
-  assert.match(validatorRun.stderr, /Usage: .*validate-spec-output\.cjs/);
-  assert.doesNotMatch(validatorRun.stderr, /MODULE_NOT_FOUND|Cannot find module/);
-
   const safe = path.join(root, 'safe.txt');
   fs.writeFileSync(safe, 'mode=safe\n');
   spawnSync('git', ['init', '-q'], { cwd: root });
@@ -1689,347 +1667,10 @@ function assertInstalledScripts(root, platform) {
   assert.match(scannerRun.stdout, /No staged secrets found/);
 }
 
-function installedSemanticPaths(root, platform) {
-  const runtimeRoot = path.join(root, RUNTIMES[platform].root);
-  const skillRoot = platform === 'codex'
-    ? path.join(root, '.agents', 'skills')
-    : path.join(runtimeRoot, 'skills');
-  const paths = {
-    policy: path.join(runtimeRoot, 'scripts', 'workflow-policy.cjs'),
-    scaffold: path.join(runtimeRoot, 'scripts', 'spec-scaffold.cjs'),
-    validator: path.join(runtimeRoot, 'scripts', 'validate-spec-output.cjs'),
-    authoringValidator: path.join(runtimeRoot, 'scripts', 'spec-authoring-validation.cjs'),
-    authoringDigest: path.join(runtimeRoot, 'scripts', 'spec-authoring-digest.cjs'),
-    grounder: path.join(runtimeRoot, 'scripts', 'spec-ground.cjs'),
-    finalState: path.join(runtimeRoot, 'scripts', 'spec-final-state.cjs'),
-    readiness: path.join(runtimeRoot, 'scripts', 'spec-readiness.cjs'),
-    semanticModel: path.join(runtimeRoot, 'scripts', 'spec-semantic-model.cjs'),
-    resolver: path.join(runtimeRoot, 'scripts', 'spec-resolver.cjs'),
-    provenance: path.join(runtimeRoot, 'scripts', 'provenance.cjs'),
-    stateTemplate: path.join(skillRoot, 'specs', 'templates', 'spec-state.json'),
-  };
-  for (const [name, target] of Object.entries(paths)) {
-    assert.equal(fs.existsSync(target), true, `${platform} installed ${name} missing: ${target}`);
-    assert.equal(path.relative(root, target).startsWith('..'), false, `${platform} ${name} escaped install root`);
-  }
-  return paths;
-}
-
-function runInstalled(script, args, root, expected = 0) {
-  const result = spawnSync(process.execPath, [script, ...args], { cwd: root, encoding: 'utf8' });
-  assert.equal(result.status, expected, `${script}\n${result.stdout}\n${result.stderr}`);
-  return result;
-}
-
 function writeJson(target, value) {
   fs.writeFileSync(target, `${JSON.stringify(value, null, 2)}\n`);
 }
 
-function materializeSpecState(paths, root, feature, { strict = false } = {}) {
-  const featureDir = path.join(root, 'specs', feature);
-  runInstalled(paths.scaffold, [feature], root);
-  const state = JSON.parse(fs.readFileSync(path.join(featureDir, 'spec.json'), 'utf8'));
-  state.scope_lock.in_scope = [`${feature} behavior`];
-  state.scope_lock.out_of_scope = ['unrelated behavior'];
-  if (strict) {
-    state.workflow_policy.assurance_level = 'Strict';
-    state.workflow_policy.classified_minimum.assurance_level = 'Strict';
-    state.workflow_policy.risks = ['auth'];
-  }
-  writeJson(path.join(featureDir, 'spec.json'), state);
-  return { featureDir, specFile: path.join(featureDir, 'spec.json'), state };
-}
-
-function requirementsProjection({ proof = false } = {}) {
-  return `# Requirements
-
-## Requirements
-
-### Requirement 1: Installed behavior
-
-- **R1.1**: The CommonJS entrypoint \`src/entry.js\` shall return an object containing only status \`enabled\` when its sole \`valid\` argument is the boolean \`true\`; it shall return an object containing only status \`rejected\` for \`false\`, a missing argument, or any non-boolean value.${proof ? '\n- **R1.2**: The installed verifier shall prove the observed entry behavior through its grounded evidence boundary.' : ''}
-`;
-}
-
-const TYPED_ANCHOR_COLUMNS = ['ID', 'Type', 'Target', 'Role', 'Access', 'Action'];
-
-function typedAnchorTable(rows) {
-  assert.ok(Array.isArray(rows) && rows.length > 0, 'typed anchor projection requires rows');
-  const header = `| ${TYPED_ANCHOR_COLUMNS.join(' | ')} |`;
-  const separator = `|${TYPED_ANCHOR_COLUMNS.map(() => '---').join('|')}|`;
-  const body = rows.map((row) => {
-    assert.deepEqual(Object.keys(row), ['id', 'type', 'target', 'role', 'access', 'action']);
-    assert.ok(Object.values(row).every((value) => typeof value === 'string' && value.trim() !== ''));
-    return `| ${row.id} | ${row.type} | \`${row.target}\` | ${row.role} | ${row.access} | ${row.action} |`;
-  });
-  return [header, separator, ...body].join('\n');
-}
-
-function designProjection({
-  expected = 'exit 0; boolean true returns the exact enabled object; false, undefined, null, `"true"`, 1, and an object return the exact rejected object',
-  taskful = false,
-} = {}) {
-  const anchors = typedAnchorTable([{
-    id: 'A-D-01', type: 'file', target: taskful ? 'src/design-boundary.js' : 'src/entry.js',
-    role: taskful ? 'existing design boundary for the entrypoint' : 'existing runtime entrypoint and contract owner',
-    access: 'read', action: 'read',
-  }]);
-  const reachabilityAnchors = taskful ? 'A-R1-01-01, A-R1-02-02' : 'A-D-01';
-  return `# Design
-
-## Boundary
-
-- **Owns:** The exact return contract of the CommonJS function exported by \`src/entry.js\`.
-- **Reads:** One \`valid\` argument; only the boolean \`true\` is valid.
-- **Writes/exposes:** Exactly one status field whose value is \`enabled\` or \`rejected\`.
-- **Outside boundary:** Unrelated runtime behavior.
-
-## Typed Anchors
-
-${anchors}
-
-## Decisions and Invariants
-
-### D1 — Installed result decision
-
-- **Decision:** \`valid === true\` returns an object containing only status \`enabled\`; every other value returns an object containing only status \`rejected\`.
-- **Rejects ambiguity:** Truthy non-booleans such as \`"true"\` never count as valid.
-- **Negative path:** \`false\`, \`undefined\`, \`null\`, strings, numbers, and objects return rejected.
-- **Anchors:** A-D-01
-
-### I1 — Rejection invariant
-
-Any input other than the boolean \`true\` never returns enabled.
-
-### C1 — Result contract
-
-- **Owner:** A-D-01
-- **Consumers:** \`test/entry.test.js\` and callers of the CommonJS export.
-- **Shape/behavior:** The result is an object with exactly one \`status\` field set to \`enabled\` or \`rejected\`.
-- **Compatibility:** The strict boolean discriminator, exact object shape, and two status values remain stable.
-
-## Verification Definitions
-
-- **V1**: Criteria R1.1; Owner ${taskful ? 'R1-01' : 'A-D-01'}; ${taskful ? 'Proof criteria R1.2; Proof owner R1-02; Evidence anchor A-R1-02-02; ' : ''}Decision refs D1, I1, C1; Method command \`node --test test/entry.test.js\`; Expected ${expected}; Negative/failure \`false\`, missing input, \`null\`, and truthy non-booleans all return the exact rejected object; Reachability/grounding entrypoint \`src/entry.js\` via ${reachabilityAnchors}.
-`;
-}
-
-function completeSemanticReview(paths, root, fixture, counterexamples) {
-  // C16/D13: only the installed spec-authoring-validation.cjs coordinator may
-  // flip authoring.* to validated and write the matching receipt (I21/R3.9) —
-  // run it over the fixture's current bytes instead of hand-writing the enum.
-  // Lifecycle order (I15/R3.7): authoring -> coordinator -> semantic review ->
-  // readiness, never the reverse.
-  runInstalled(paths.scaffold, [fixture.state.feature_name, '--sync-semantic-model'], root);
-  runInstalled(paths.authoringValidator, [fixture.featureDir], root);
-  const state = JSON.parse(fs.readFileSync(fixture.specFile, 'utf8'));
-  fixture.reviewResult = {
-    verdict: 'PASS',
-    findings: [],
-    unresolved_decisions: [],
-    graph_coverage: [
-      'criterion_local', 'cross_criterion', 'runtime_path',
-      'assumption_provenance', 'compatibility_migration',
-    ].map((surface) => ({
-      surface, covered: true,
-      notes: 'The review covers this semantic surface against the canonical model.',
-    })),
-    reviewed_criteria: counterexamples.map(({ criterion }) => criterion),
-    counterexamples,
-    reviewer_evidence: null,
-  };
-  if (state.workflow_policy.assurance_level === 'Strict') {
-    const digest = runInstalled(paths.validator, [fixture.featureDir, '--semantic-digest'], root).stdout.trim();
-    assert.match(digest, /^sha256:[a-f0-9]{64}$/);
-    return digest;
-  }
-  const reviewFile = path.join(fixture.featureDir, '.review-result.json');
-  writeJson(reviewFile, fixture.reviewResult);
-  runInstalled(paths.readiness, [fixture.featureDir, '--review-result', reviewFile], root);
-  fs.unlinkSync(reviewFile);
-  runInstalled(paths.validator, [fixture.featureDir], root);
-  runInstalled(paths.grounder, [fixture.featureDir, '--root', root], root);
-  return JSON.parse(fs.readFileSync(fixture.specFile, 'utf8')).validation.semantic_review.semantic_digest;
-}
-
-function createTasklessFixture(paths, root, feature, options = {}) {
-  fs.mkdirSync(path.join(root, 'src'), { recursive: true });
-  fs.mkdirSync(path.join(root, 'test'), { recursive: true });
-  fs.writeFileSync(path.join(root, 'src', 'entry.js'), 'module.exports = (valid) => ({ status: valid === true ? "enabled" : "rejected" });\n');
-  fs.writeFileSync(path.join(root, 'src', 'design-boundary.js'), 'module.exports = { entry: "src/entry.js" };\n');
-  fs.writeFileSync(path.join(root, 'test', 'entry.test.js'), `const test = require('node:test');
-const assert = require('node:assert/strict');
-const entry = require('../src/entry.js');
-
-test('entry accepts only the boolean true discriminator', () => {
-  assert.deepEqual(entry(true), { status: 'enabled' });
-  for (const invalid of [false, undefined, null, 'true', 1, {}]) {
-    assert.deepEqual(entry(invalid), { status: 'rejected' });
-  }
-});
-`);
-  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ scripts: { test: 'node --test' } }));
-  const fixture = materializeSpecState(paths, root, feature, options);
-  fs.writeFileSync(path.join(fixture.featureDir, 'requirements.md'), requirementsProjection());
-  fs.writeFileSync(path.join(fixture.featureDir, 'design.md'), designProjection());
-  fixture.digest = completeSemanticReview(paths, root, fixture, [{
-    criterion: 'R1.1', case_kind: 'failure',
-    scenario: 'The installed entry receives input without the required discriminator.',
-    expected: 'The installed entry returns rejected and never returns enabled.',
-    decision_refs: ['D1', 'I1', 'C1'], verification_ref: 'V1',
-  }]);
-  return fixture;
-}
-
-function taskProjection({ id, title, ownedPath, criterion, verificationRef, role, artifact = false }) {
-  const artifactPath = `artifacts/${id}.json`;
-  const anchors = typedAnchorTable([
-    { id: `A-${id}-01`, type: 'file', target: ownedPath, role: 'owner', access: 'write', action: 'modify' },
-    ...(artifact ? [{
-      id: `A-${id}-02`, type: 'artifact', target: artifactPath,
-      role: 'verifier', access: 'write', action: 'create',
-    }] : []),
-    {
-      id: `A-${id}-${artifact ? '03' : '02'}`, type: 'command',
-      target: 'node --test test/entry.test.js', role: 'verifier', access: 'read', action: 'read',
-    },
-  ]);
-  return `# Task ${id}: ${title}
-**Status:** pending
-
-## Outcome
-
-Deliver observable ${title.toLowerCase()} behavior through the installed entrypoint.
-
-## Scope
-
-- **In scope:** Exact behavior owned at ${ownedPath}.
-- **Out of scope:** Unrelated runtime behavior.
-
-## Anchors and Ownership
-
-${anchors}
-
-## Changes
-
-- [ ] Implement the exact owned behavior. _Requirements: ${criterion.slice(1)}_
-
-## Acceptance
-
-- **${criterion}:** The installed command returns the criterion-specific observable state.
-
-## Dependencies
-
-- none
-
-## Verification Plan
-
-- **Verification ref:** ${verificationRef}
-- **Task role:** ${role}
-- **Command:** \`node --test test/entry.test.js\`
-- **Expected:** Exit code 0 and the criterion-specific state is observed.${artifact ? ` The artifact \`${artifactPath}\` must exist, and SHA-256 over its current bytes must match the recorded digest.` : ''}
-- **Negative path:** Invalid input returns the named rejected state.
-- **Reachability:** \`src/entry.js\` is reached by the installed test command.
-`;
-}
-
-function createTaskFixture(paths, root, feature) {
-  fs.mkdirSync(path.join(root, 'artifacts'), { recursive: true });
-  const fixture = materializeSpecState(paths, root, feature);
-  fs.writeFileSync(path.join(fixture.featureDir, 'requirements.md'), requirementsProjection({ proof: true }));
-  fs.writeFileSync(path.join(fixture.featureDir, 'design.md'), designProjection({
-    expected: 'exit 0, status enabled, and verifier artifact `artifacts/R1-02.json` whose SHA-256 over current bytes matches the recorded digest',
-    taskful: true,
-  }));
-  const taskOne = 'tasks/task-R1-01-implement.md';
-  const taskTwo = 'tasks/task-R1-02-verify.md';
-  fs.mkdirSync(path.join(fixture.featureDir, 'tasks'), { recursive: true });
-  fs.writeFileSync(path.join(fixture.featureDir, taskOne), taskProjection({
-    id: 'R1-01', title: 'Implement behavior', ownedPath: 'src/entry.js', criterion: 'R1.1',
-    verificationRef: 'V1', role: 'subject implements R1.1',
-  }));
-  fs.writeFileSync(path.join(fixture.featureDir, taskTwo), taskProjection({
-    id: 'R1-02', title: 'Verify behavior', ownedPath: 'test/entry.test.js', criterion: 'R1.2',
-    verificationRef: 'V1', role: 'verifier verifies V1 through separately owned R1.2 proof', artifact: true,
-  }));
-  const state = fixture.state;
-  state.authoring.tasks = 'draft';
-  state.task_files = [taskOne, taskTwo];
-  state.task_registry = Object.fromEntries([
-    [taskOne, { id: 'R1-01', title: 'Implement behavior', status: 'pending', dependencies: [], blocker: null, started_at: null, completed_at: null, last_updated_at: null }],
-    [taskTwo, { id: 'R1-02', title: 'Verify behavior', status: 'pending', dependencies: [], blocker: null, started_at: null, completed_at: null, last_updated_at: null }],
-  ]);
-  state.coordination.boundaries = [{
-    id: 'B-OWN', type: 'ownership', tasks: ['R1-01', 'R1-02'],
-    write_sets: { 'R1-01': ['src/entry.js'], 'R1-02': ['test/entry.test.js', 'artifacts/R1-02.json'] },
-  }, {
-    id: 'B-PROOF', type: 'proof', subject: 'R1-01', verifier: 'R1-02',
-    verification_ref: 'V1', artifact_anchor: 'A-R1-02-02',
-  }];
-  writeJson(fixture.specFile, state);
-  fixture.digest = completeSemanticReview(paths, root, fixture, [{
-    criterion: 'R1.1', case_kind: 'failure',
-    scenario: 'Invalid input reaches the installed implementation boundary.',
-    expected: 'The implementation returns rejected and never reports enabled.',
-    decision_refs: ['D1', 'I1', 'C1'], verification_ref: 'V1',
-  }, {
-    criterion: 'R1.2', case_kind: 'failure',
-    scenario: 'The verification command completes without producing its proof artifact.',
-    expected: 'The verification criterion remains unsatisfied until `artifacts/R1-02.json` exists and its SHA-256 over current bytes matches the recorded digest.',
-    decision_refs: ['D1', 'I1', 'C1'], verification_ref: 'V1',
-  }]);
-  return fixture;
-}
-
-function initializeGit(root) {
-  fs.writeFileSync(path.join(root, '.gitignore'), `${'node_' + 'modules'}/\n`);
-  for (const args of [
-    ['init', '-q'], ['config', 'user.name', 'CafeKit Packed E2E'],
-    ['config', 'user.email', 'packed-e2e@example.invalid'],
-    ['add', '--', '.gitignore', 'src/entry.js', 'src/design-boundary.js', 'test/entry.test.js', 'package.json'],
-    ['commit', '--no-gpg-sign', '-qm', 'packed semantic fixture'],
-  ]) {
-    const result = spawnSync('git', args, { cwd: root, encoding: 'utf8' });
-    assert.equal(result.status, 0, `${args.join(' ')}\n${result.stdout}\n${result.stderr}`);
-  }
-}
-
-function assertStrictRefusedAsUnsupported(paths, root, fixture) {
-  const specFile = path.join(fixture.featureDir, 'spec.json');
-  const before = fs.readFileSync(specFile);
-  const reviewFile = path.join(root, 'strict-review.json');
-  fs.writeFileSync(reviewFile, JSON.stringify(fixture.reviewResult));
-  const result = spawnSync(process.execPath, [paths.readiness, fixture.featureDir, '--review-result', reviewFile], { cwd: root, encoding: 'utf8' });
-  fs.rmSync(reviewFile, { force: true });
-  assert.notEqual(result.status, 0, `${result.stdout}\n${result.stderr}`);
-  assert.match(`${result.stdout}\n${result.stderr}`, /Strict assurance is no longer supported/);
-  assert.equal(fs.readFileSync(specFile).equals(before), true, 'a refused Strict readiness must leave spec.json unchanged');
-}
-
-function assertStaleDigestMutations(paths, root, taskless, taskBearing) {
-  const requirementFile = path.join(taskless.featureDir, 'requirements.md');
-  const requirementBytes = fs.readFileSync(requirementFile);
-  fs.appendFileSync(requirementFile, '\nThe installed Markdown meaning changed.\n');
-  assert.match(runInstalled(paths.validator, [taskless.featureDir], root, 1).stderr, /semantic_digest: stale/);
-  fs.writeFileSync(requirementFile, requirementBytes);
-
-  const tasklessState = JSON.parse(fs.readFileSync(taskless.specFile, 'utf8'));
-  const originalPolicy = JSON.parse(JSON.stringify(tasklessState.workflow_policy));
-  tasklessState.workflow_policy.planning_depth = 'Full';
-  writeJson(taskless.specFile, tasklessState);
-  assert.match(runInstalled(paths.validator, [taskless.featureDir], root, 1).stderr, /semantic_digest: stale/);
-  tasklessState.workflow_policy = originalPolicy;
-  writeJson(taskless.specFile, tasklessState);
-
-  const taskState = JSON.parse(fs.readFileSync(taskBearing.specFile, 'utf8'));
-  const originalId = taskState.coordination.boundaries[0].id;
-  taskState.coordination.boundaries[0].id = 'B-OWN-MUTATED';
-  writeJson(taskBearing.specFile, taskState);
-  assert.match(runInstalled(paths.validator, [taskBearing.featureDir], root, 1).stderr, /semantic_digest: stale/);
-  taskState.coordination.boundaries[0].id = originalId;
-  writeJson(taskBearing.specFile, taskState);
-}
-
 function assertTransforms(root, platform) {
   const skillRoot = path.join(
     root,
@@ -2745,41 +2386,6 @@ test('repository and package guides document adaptive Docs usage', () => {
   }
 });
 
-test('packed Claude and Codex installs execute semantic kernel behavior without package source', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-packed-semantic-'));
-  const destination = path.join(root, 'pack');
-  fs.mkdirSync(destination, { recursive: true });
-  try {
-    const packed = npmPack(['--pack-destination', destination, '--json'], PACKAGE_ROOT);
-    const tarball = path.join(destination, packed.filename);
-    const runtimeClosure = packedRuntimeClosure(path.join(root, 'runtime-closure'));
-    assertCleanInventory(packedInventory(tarball));
-
-    for (const platform of ['claude', 'codex']) {
-      const project = path.join(root, platform);
-      const installer = installPacked(tarball, project, runtimeClosure);
-      runInstaller(installer, project, [platform], null);
-      const packedSource = path.resolve(path.dirname(installer), '..', 'src');
-      fs.rmSync(packedSource, { recursive: true, force: true });
-      assert.equal(fs.existsSync(packedSource), false, `${platform} package source must be unavailable`);
-
-      const paths = installedSemanticPaths(project, platform);
-      const taskless = createTasklessFixture(paths, project, 'compact-installed');
-      initializeGit(project);
-
-      const strict = createTasklessFixture(paths, project, 'strict-installed', { strict: true });
-      const taskBearing = createTaskFixture(paths, project, 'tasks-installed');
-      assertStrictRefusedAsUnsupported(paths, project, strict);
-      assertStaleDigestMutations(paths, project, taskless, taskBearing);
-      runInstalled(paths.validator, [taskless.featureDir], project);
-      runInstalled(paths.validator, [taskBearing.featureDir], project);
-      runInstalled(paths.grounder, [taskBearing.featureDir, '--root', project], project);
-    }
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
 test('packed Claude and Codex installs self-contain runtime provenance and fail closed without it', () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-provenance-package-'));
   const destination = path.join(root, 'pack');