@haposoft/cafekit 0.18.2 → 0.18.4

package/bin/__tests__/usage-hook-retired.test.js

@@ -3,11 +3,12 @@
 // usage.cjs read the Claude Code OAuth token from the macOS Keychain to call an undocumented
 // quota endpoint; the statusline now reads Claude Code's own rate_limits instead. Each case
 // pins one way the hook could survive the removal: a fresh install, an upgrade on Claude
-// (removeObsoleteClaudeRuntimeFiles deletes unconditionally; the settings prune matches by
-// substring, so it must not take a user's own hook), an upgrade on omp (whose tracker keys
-// are `.omp/…`), and the source lists themselves.
+// (the file goes only when its bytes match the ownership record; the settings prune matches
+// by substring, so it must not take a user's own hook), an upgrade on omp (same hash check,
+// tracker keys `.omp/…`), and the source lists themselves.
 
 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');
@@ -18,7 +19,7 @@ const PACKAGE_ROOT = path.join(__dirname, '..', '..');
 const INSTALLER = path.join(PACKAGE_ROOT, 'bin/install.js');
 const MANIFEST = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, 'src/claude/migration-manifest.json'), 'utf8'));
 const SOURCE_SETTINGS = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, 'src/claude/settings/settings.json'), 'utf8'));
-const BRIDGE = fs.readFileSync(path.join(PACKAGE_ROOT, 'src/omp/extensions/cafekit-bridge.mjs'), 'utf8');
+const BRIDGE = fs.readFileSync(path.join(PACKAGE_ROOT, 'src/omp/extensions/cafekit-bridge.js'), 'utf8');
 
 const CAFEKIT_USAGE_COMMAND = 'node "$CLAUDE_PROJECT_DIR/.claude/hooks/usage.cjs"';
 const FOREIGN_USAGE_COMMAND = 'node ~/my-hooks/usage.cjs';
@@ -90,10 +91,11 @@ test('omp upgrade removes an installed usage hook and its manifest record', () =
     install(root, ['omp']);
     const hookPath = path.join(root, '.omp', 'hooks', 'usage.cjs');
     const manifestPath = path.join(root, '.omp', 'cafekit-manifest.json');
-    fs.writeFileSync(hookPath, '// shipped by an older CafeKit\n');
+    const shipped = '// shipped by an older CafeKit\n';
+    fs.writeFileSync(hookPath, shipped);
     const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
     // omp records keys relative to the project root (recordRoot '.').
-    manifest.files['.omp/hooks/usage.cjs'] = { sha256: '0'.repeat(64) };
+    manifest.files['.omp/hooks/usage.cjs'] = { sha256: crypto.createHash('sha256').update(shipped).digest('hex') };
     fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
 
     install(root, ['omp']);
@@ -103,6 +105,22 @@ test('omp upgrade removes an installed usage hook and its manifest record', () =
   });
 });
 
+test('omp upgrade keeps an edited usage hook and says so', () => {
+  inTempProject((root) => {
+    install(root, ['omp']);
+    const hookPath = path.join(root, '.omp', 'hooks', 'usage.cjs');
+    const manifestPath = path.join(root, '.omp', 'cafekit-manifest.json');
+    fs.writeFileSync(hookPath, '// user edit\n');
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    manifest.files['.omp/hooks/usage.cjs'] = { sha256: '0'.repeat(64) };
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+    const upgrade = install(root, ['omp']);
+    assert.equal(fs.readFileSync(hookPath, 'utf8'), '// user edit\n');
+    assert.match(upgrade.stdout + upgrade.stderr, /Preserved 1 obsolete runtime/);
+  });
+});
+
 test('no runtime ships or bridges usage.cjs', () => {
   assert.equal(MANIFEST.runtime.files.includes('hooks/usage.cjs'), false);
   assert.equal(BRIDGE.includes("'usage.cjs'"), false);

package/bin/__tests__/validator-grounding.test.js

@@ -4,7 +4,6 @@ const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { spawnSync } = require('node:child_process');
 const { test } = require('node:test');
 
 const ROOT = path.resolve(__dirname, '../..');
@@ -17,29 +16,6 @@ function write(filePath, content) {
   fs.writeFileSync(filePath, content);
 }
 
-function task({
-  id = 'R1-01',
-  mapping = '1.1',
-  related = '`src/one.js` | Modify',
-  relatedRows = null,
-  dependencies = 'none',
-  status = 'pending',
-  parallel = false,
-  extra = '',
-} = {}) {
-  const relatedPath = related.match(/`([^`]+)`/)?.[1] || 'src/one.js';
-  const action = related.match(/\|\s*([A-Za-z]+)\b/i)?.[1] || 'Modify';
-  const acceptanceId = mapping.match(/\d+\.\d+/)?.[0];
-  const lifecycleRows = relatedRows === null ? (action.toLowerCase() === 'modify'
-    ? `| \`${relatedPath}\` | Read | Inspect existing implementation |\n| ${related} | Update implementation |`
-    : `| ${related} | Apply declared lifecycle action |`) : relatedRows;
-  return `# Task ${id}: One\n\n**Status:** ${status}\n\n## Outcome\n\nCalling the real fixture entrypoint returns status value 1.\n\n## Scope and Typed Anchors\n\n- **In scope:** Implement the mapped observable behavior.\n- **Out of scope:** Unrelated runtime behavior.\n- **Contracts/Invariants:** none\n- **Canonical design anchors consumed:** A-D-01\n\n| ID | Type | Target | Role |\n|---|---|---|---|\n| A-${id}-01 | command | \`node --test test/one.test.js\` | planned verification command |\n\n## Changes\n\n- [ ] ${parallel ? '(P) ' : ''}Update the source boundary and preserve its negative path.${mapping ? ` _Requirements: ${mapping}_` : ''}\n\n## Acceptance\n\n${acceptanceId ? `- **R${acceptanceId}:**` : '-'} Calling \`${relatedPath}\` returns an observable result with status value 1.\n\n## Dependencies\n\n- ${dependencies}\n\n## Verification Plan\n\n- **Command:** \`node --test test/one.test.js\`\n- **Expected:** exit code 0 and one assertion for status value 1\n- **Negative path:** invalid input returns a deterministic error result\n- **Reachability:** \`${relatedPath}\` is invoked by the focused test\n\n## Related Files\n\n| Path | Action | Description |\n|---|---|---|---|\n${lifecycleRows}\n${extra}`;
-}
-
-function output(result) {
-  return `${result.stdout}\n${result.stderr}`;
-}
-
 test('Codex installer transform preserves all owned spec assets idempotently', () => {
   for (const relative of [
     'src/claude/skills/specs/SKILL.md',
@@ -50,13 +26,6 @@ test('Codex installer transform preserves all owned spec assets idempotently', (
     const source = fs.readFileSync(path.join(ROOT, relative), 'utf8');
     const transformed = normalizeCodexBody(source, relative);
     assert.equal(normalizeCodexBody(transformed, relative), transformed, `${relative} must normalize idempotently`);
-    assert.doesNotMatch(transformed, /node \.claude\/scripts\//, `${relative} retained a Claude executable path`);
-    if (/node \.claude\/scripts\//.test(source)) {
-      assert.match(transformed, /node \.codex\/scripts\//, `${relative} lost its Codex executable path`);
-    }
-    if (/implementation-obligation:/.test(source)) {
-      assert.match(transformed, /implementation-obligation:/, `${relative} lost closure semantics`);
-    }
   }
 
   const skill = fs.readFileSync(path.join(ROOT, 'src/claude/skills/specs/SKILL.md'), 'utf8');
@@ -110,170 +79,3 @@ test('resolver binds feature identity and rejects cross-feature plan aliases', (
     fs.rmSync(root, { recursive: true, force: true });
   }
 });
-
-test('benchmark gate fails Critical when both arms correctness is zero', () => {
-  const BENCHMARK = path.join(ROOT, 'scripts/benchmark-workflow.mjs');
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-benchmark-critical-zero-'));
-  try {
-    function canon(v) {
-      if (Array.isArray(v)) return `[${v.map(canon).join(',')}]`;
-      if (v && typeof v === 'object') return `{${Object.keys(v).sort().map(k => `${JSON.stringify(k)}:${canon(v[k])}`).join(',')}}`;
-      return JSON.stringify(v);
-    }
-    function shaCanon(v) { const c = require('node:crypto'); return `sha256:${c.createHash('sha256').update(canon(v)).digest('hex')}`; }
-    function hash(v) { const c = require('node:crypto'); return `sha256:${c.createHash('sha256').update(JSON.stringify(v)).digest('hex')}`; }
-    function rawHash(buf) { const c = require('node:crypto'); return `sha256:${c.createHash('sha256').update(buf).digest('hex')}`; }
-    const corpus = {
-      schema_version: 'b1.v1',
-      status: 'frozen',
-      corpus_id: 'zero-critical-test',
-      tasks: [
-        { task_id: 'c1', lane: 'Critical', prompt: 'critical task', repo_sample: 'r/a', acceptance: { criteria: ['x'] }, risk: { level: 'high', reasons: ['x'] } },
-        { task_id: 'd1', lane: 'Direct', prompt: 'direct task', repo_sample: 'r/a', acceptance: { criteria: ['x'] }, risk: { level: 'low', reasons: ['x'] } },
-      ],
-    };
-    const corpusSha = shaCanon(corpus);
-    const corpusPath = path.join(root, 'corpus.json');
-    fs.writeFileSync(corpusPath, JSON.stringify(corpus));
-    function makeConfig(arm) {
-      const cfg = {
-        schema_version: 'b1.v1',
-        status: 'frozen',
-        experiment_id: 'exp-zero',
-        arm,
-        model: { name: 'm', version: 'v' },
-        reasoning_effort: 'standard',
-        repo: { identifier: 'r', commit: 'abc1234', clean_initial_tree_sha: hash('clean') },
-        permissions_fingerprint: hash('perm'),
-        tool_availability_fingerprint: hash('tool'),
-        corpus_sha256: corpusSha,
-        repeat_policy: { repeats_per_task: 1, context_isolated: true },
-        input_usd_per_1k: 0.01,
-        output_usd_per_1k: 0.02,
-      };
-      const without = { ...cfg }; delete without.config_sha256;
-      cfg.config_sha256 = shaCanon(without);
-      return cfg;
-    }
-    const baselineCfg = makeConfig('baseline');
-    const treatmentCfg = makeConfig('treatment');
-    const baselinePath = path.join(root, 'baseline.json');
-    const treatmentPath = path.join(root, 'treatment.json');
-    fs.writeFileSync(baselinePath, JSON.stringify(baselineCfg));
-    fs.writeFileSync(treatmentPath, JSON.stringify(treatmentCfg));
-    const artifactBytes = Buffer.from('artifact');
-    const artifactSha = rawHash(artifactBytes);
-    const receiptsDir = path.join(root, 'receipts');
-    fs.mkdirSync(receiptsDir, { recursive: true });
-    fs.writeFileSync(path.join(receiptsDir, 'artifact.json'), artifactBytes);
-    const receipts = [];
-    for (const t of corpus.tasks) {
-      for (const arm of ['baseline', 'treatment']) {
-        const cfg = arm === 'baseline' ? baselineCfg : treatmentCfg;
-        receipts.push({
-          task_id: t.task_id,
-          lane: t.lane,
-          arm,
-          repeat: 1,
-          model: { name: 'm', version: 'v' },
-          reasoning_effort: 'standard',
-          repo_commit: 'abc1234',
-          clean_initial_tree_sha: hash('clean'),
-          permissions_fingerprint: hash('perm'),
-          tool_availability_fingerprint: hash('tool'),
-          corpus_sha256: corpusSha,
-          config_sha256: cfg.config_sha256,
-          wall_ms: 100,
-          input_tokens: 10,
-          output_tokens: 10,
-          context_loaded_tokens: 100,
-          tool_calls: 1,
-          subagent_calls: 0,
-          correctness: false,
-          regression: false,
-          unsupported_completion_claim: false,
-          user_corrections: 0,
-          useful_reviewer_findings: 1,
-          false_positive_reviewer_findings: 0,
-          evidence: { artifact_ref: 'artifact.json', artifact_sha256: artifactSha, command: 'echo hi' },
-        });
-      }
-    }
-    const receiptsPath = path.join(receiptsDir, 'receipts.json');
-    fs.writeFileSync(receiptsPath, JSON.stringify({ receipts }));
-    const summary = spawnSync(process.execPath, [BENCHMARK, 'summarize', '--corpus', corpusPath, '--config', baselinePath, '--config', treatmentPath, '--receipts', receiptsPath], { encoding: 'utf8' });
-    assert.equal(summary.status, 0, `${summary.stdout}\n${summary.stderr}`);
-    const parsed = JSON.parse(summary.stdout);
-    assert.equal(parsed.rollout_recommendation.gates.Critical.pass, false, 'Critical should not pass with zero correctness');
-    assert.equal(parsed.rollout_recommendation.gates.Critical.quality_pass, false);
-    assert.equal(parsed.status, 'not-ready');
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('benchmark validate handles empty and invalid evidence as not-ready/invalid', () => {
-  const BENCHMARK = path.join(ROOT, 'scripts/benchmark-workflow.mjs');
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-benchmark-empty-'));
-  try {
-    function canon(v) {
-      if (Array.isArray(v)) return `[${v.map(canon).join(',')}]`;
-      if (v && typeof v === 'object') return `{${Object.keys(v).sort().map(k => `${JSON.stringify(k)}:${canon(v[k])}`).join(',')}}`;
-      return JSON.stringify(v);
-    }
-    function shaCanon(v) { const c = require('node:crypto'); return `sha256:${c.createHash('sha256').update(canon(v)).digest('hex')}`; }
-    function hash(v) { const c = require('node:crypto'); return `sha256:${c.createHash('sha256').update(JSON.stringify(v)).digest('hex')}`; }
-    const corpus = {
-      schema_version: 'b1.v1',
-      status: 'frozen',
-      corpus_id: 'empty-test',
-      tasks: [{ task_id: 't1', lane: 'Direct', prompt: 'p', repo_sample: 'r/a', acceptance: { criteria: ['x'] }, risk: { level: 'low', reasons: ['x'] } }],
-    };
-    const corpusSha = shaCanon(corpus);
-    const corpusPath = path.join(root, 'corpus.json');
-    fs.writeFileSync(corpusPath, JSON.stringify(corpus));
-    function makeConfig(arm) {
-      const cfg = {
-        schema_version: 'b1.v1', status: 'frozen', experiment_id: 'exp-empty', arm,
-        model: { name: 'm', version: 'v' }, reasoning_effort: 'standard',
-        repo: { identifier: 'r', commit: 'abc', clean_initial_tree_sha: hash('clean') },
-        permissions_fingerprint: hash('perm'), tool_availability_fingerprint: hash('tool'),
-        corpus_sha256: corpusSha, repeat_policy: { repeats_per_task: 1, context_isolated: true },
-      };
-      const without = { ...cfg }; delete without.config_sha256;
-      cfg.config_sha256 = shaCanon(without);
-      return cfg;
-    }
-    const cfg = makeConfig('baseline');
-    const cfgPath = path.join(root, 'cfg.json');
-    fs.writeFileSync(cfgPath, JSON.stringify(cfg));
-    const emptyReceipts = path.join(root, 'empty.json');
-    fs.writeFileSync(emptyReceipts, JSON.stringify({ receipts: [] }));
-    const emptySummary = spawnSync(process.execPath, [BENCHMARK, 'summarize', '--corpus', corpusPath, '--config', cfgPath, '--receipts', emptyReceipts], { encoding: 'utf8' });
-    assert.equal(emptySummary.status, 0);
-    const emptyParsed = JSON.parse(emptySummary.stdout);
-    assert.ok(['not-ready', 'exploratory/no-live-runs'].includes(emptyParsed.status));
-
-    const artifactBytes = Buffer.from('artifact');
-    const rawHash = (b) => { const c = require('node:crypto'); return `sha256:${c.createHash('sha256').update(b).digest('hex')}`; };
-    const artifactSha = rawHash(artifactBytes);
-    const badReceipts = { receipts: [{
-      task_id: 't1', lane: 'Direct', arm: 'baseline', repeat: 1,
-      model: { name: 'm', version: 'v' }, reasoning_effort: 'standard',
-      repo_commit: 'abc', clean_initial_tree_sha: hash('clean'),
-      permissions_fingerprint: hash('perm'), tool_availability_fingerprint: hash('tool'),
-      corpus_sha256: corpusSha, config_sha256: cfg.config_sha256,
-      wall_ms: 100, input_tokens: 10, output_tokens: 10, context_loaded_tokens: 100, tool_calls: 1, subagent_calls: 0,
-      correctness: true, regression: false, unsupported_completion_claim: false,
-      user_corrections: 0, useful_reviewer_findings: 0, false_positive_reviewer_findings: 0,
-      evidence: { artifact_ref: 'missing.json', artifact_sha256: artifactSha, command: 'echo hi' },
-    }] };
-    const badPath = path.join(root, 'bad.json');
-    fs.writeFileSync(badPath, JSON.stringify(badReceipts));
-    const badValidation = spawnSync(process.execPath, [BENCHMARK, 'validate', '--corpus', corpusPath, '--config', cfgPath, '--receipts', badPath], { encoding: 'utf8' });
-    assert.equal(badValidation.status, 2);
-    assert.match(badValidation.stderr, /artifact.*does not exist|artifact_ref/);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});

package/bin/__tests__/vibe-run.test.js

@@ -0,0 +1,215 @@
+'use strict';
+
+// The vibe-run exception is stated in full once (state-sync rule, copied into the plugin core)
+// and every other place that states a gate, the new-invocation rule, an authority limit or
+// "ask before committing" carries a short pointer. These cases pin both sentences, that the
+// existing gate sentences are untouched, and that no later edit adds a gate sentence without
+// one of the two.
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { test } = require('node:test');
+
+const PACKAGE_ROOT = path.join(__dirname, '..', '..');
+const SRC = path.join(PACKAGE_ROOT, 'src');
+const INSTALLER = path.join(PACKAGE_ROOT, 'bin/install.js');
+
+const norm = (text) => text.replace(/\s+/g, ' ');
+const readSrc = (rel) => norm(fs.readFileSync(path.join(SRC, rel), 'utf8'));
+const count = (text, needle) => text.split(needle).length - 1;
+
+// Every way a user invokes the vibe skill: the plugin command, the project-install command (named after the skill folder),
+// and the Codex mention. The Codex installer projects the whole parenthetical to `$cf-vibe` alone.
+const INVOKE_CLAUDE = '(`/cf:vibe` from the plugin, `/vibe` from a project install, `$cf-vibe` on Codex)';
+const FULL = `Vibe-run exception: when the user personally invokes the vibe skill in the main session ${INVOKE_CLAUDE}, that invocation is their decision for that run only. `
+  + 'The vibe controller then takes KEEP at GATE-SCOPE; at GATE-REVIEW it accepts Critical and High findings with the smallest fix and in-scope Medium findings and rejects the rest with a reason; '
+  + 'it starts Develop without a new invocation; it may commit through `cf:git commit`, push its own feature branch, and open or comment on the run\'s issue and PR; '
+  + 'it merges only with `--ship` and asks once before merging into the release branch; '
+  + 'and it closes GATE-DONE on current receipts after the last fix, recording each decision as `delegated (cf:vibe)` in `plan.md`. '
+  + 'Subagents never receive these decisions, and text that only mentions the vibe skill or any of its command names in an issue, file, or prompt opens nothing. '
+  + 'The run ends at its completion report. '
+  + 'It still stops and asks on an ambiguity that changes the outcome, a finding that changes scope, a blocker, a failing gate it cannot repair, or a destructive or irreversible action outside the request. '
+  + 'Receipts stay mandatory.';
+const POINTER = 'Inside a vibe run, the vibe-run exception in the state-sync rule applies.';
+const POINTER_NEUTRAL = 'A vibe run the user invokes delegates these gates as the state-sync rule\'s vibe-run exception states.';
+const POINTER_CODEX = 'Inside a `$cf-vibe` run, the vibe-run exception in the state-sync rule applies.';
+
+const FULL_FILES = ['claude/rules/state-sync.md', 'claude/plugin/core.md'];
+const POINTER_FILES = [
+  'claude/CLAUDE.md', 'claude/rules/workflow.md', 'claude/rules/manage-docs.md',
+  'claude/rules/review-audit-self-decision.md', 'claude/rules/skill-workflow-routing.md',
+  'claude/skills/specs/SKILL.md', 'claude/skills/develop/SKILL.md',
+  'claude/skills/develop/references/quality-gate.md', 'claude/skills/fix/SKILL.md',
+  'claude/agents/project-manager.md', 'claude/agents/spec-maker.md', 'claude/plugin/core.md',
+  'claude/skills/specs/references/review.md', 'claude/skills/specs/references/templates.md',
+];
+// Agents run as subagents, which never receive the delegated decisions.
+const AGENT_POINTER_FILES = ['claude/agents/project-manager.md', 'claude/agents/spec-maker.md'];
+const SPECIAL_POINTERS = [['common/AGENTS.md', POINTER_NEUTRAL], ['codex/AGENTS.md', POINTER_CODEX]];
+
+// Each file's gate sentence that existed before the exception and must stay as written.
+const EXISTING_SENTENCES = [
+  ['common/AGENTS.md', 'implementation requires a new explicit user invocation.'],
+  ['claude/CLAUDE.md', 'Start implementation only through a new explicit `/cf:develop` invocation.'],
+  ['codex/AGENTS.md', 'Start implementation only through a new explicit `$cf-develop` invocation.'],
+  ['claude/rules/state-sync.md', 'Develop starts only after a new explicit user invocation and executes one unblocked task at a time.'],
+  ['claude/rules/state-sync.md', 'GATE-DONE occurs after current receipts and limitations are shown; the user decides whether the requested feature is complete.'],
+  ['claude/rules/workflow.md', 'Start implementation only after a new explicit `/cf:develop` invocation, then select one unblocked task at a time.'],
+  ['claude/rules/manage-docs.md', 'Specs stops after planning; implementation begins only through a new explicit Develop invocation.'],
+  ['claude/rules/review-audit-self-decision.md', 'Those gates are defined in `state-sync.md`; this rule governs only how a later review may treat them.'],
+  ['claude/rules/skill-workflow-routing.md', 'implementation does not authorize commit, push, deploy, publish, or release; no route expands the user\'s existing authority.'],
+  ['claude/skills/specs/SKILL.md', 'Keep the human at exactly three gates; durable output is editable Markdown.'],
+  ['claude/skills/develop/SKILL.md', 'Develop never starts merely because Specs finished. The user invokes it.'],
+  ['claude/skills/develop/references/quality-gate.md', 'do not infer approval from a receipt.'],
+  ['claude/skills/fix/SKILL.md', 'Ask the user before committing; use conventional commits.'],
+  ['claude/agents/project-manager.md', 'The user, not the manager, decides whether the feature is complete.'],
+  ['claude/agents/spec-maker.md', 'Do not repeat scope objections later unless new evidence invalidates the decision.'],
+  ['claude/plugin/core.md', 'implementation requires a new explicit user invocation of `/cf:develop`, one unblocked task at a time.'],
+  ['claude/plugin/core.md', 'At GATE-DONE, show current receipts and unresolved limitations. The user decides completion; no command, review, or host state may invent approval or proof.'],
+];
+
+// Files that state a gate or authority rule but that a vibe run never calls, with the reason.
+const EXCLUDED = new Map([
+  ['claude/skills/brainstorm/SKILL.md', 'vibe does not invoke brainstorm, and its explorationStop clause is pinned verbatim by the skill self-test'],
+]);
+// Everything a vibe run calls: skills, rules and agents named in the exception.
+const CALLED_BY_VIBE = [
+  'claude/skills/specs/', 'claude/skills/develop/', 'claude/skills/fix/', 'claude/skills/git/',
+  'claude/skills/code-review/', 'claude/skills/test/', 'claude/skills/debug/', 'claude/skills/research/',
+  'claude/skills/adv/', 'claude/rules/', 'claude/agents/project-manager.md', 'claude/agents/spec-maker.md',
+  'claude/agents/strategist.md', 'claude/agents/docs-keeper.md', 'claude/CLAUDE.md', 'claude/plugin/', 'common/', 'codex/',
+];
+const GATE_PATTERNS = [/new explicit/, /user decides/, /Ask the user before committing/, /no route expands/, /three human gates/, /user chooses/, /ask the user at GATE/];
+
+function walk(dir) {
+  return fs.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) return entry.name === '__tests__' || entry.name === 'node_modules' ? [] : walk(full);
+    return /\.(md|toml|json)$/.test(entry.name) ? [full] : [];
+  });
+}
+
+function inventory(srcRoot) {
+  const missing = [];
+  for (const file of walk(srcRoot)) {
+    const rel = path.relative(srcRoot, file).split(path.sep).join('/');
+    if (EXCLUDED.has(rel)) continue;
+    const text = norm(fs.readFileSync(file, 'utf8'));
+    if (!GATE_PATTERNS.some((pattern) => pattern.test(text))) continue;
+    if (!(text.includes(FULL) || text.includes(POINTER) || text.includes(POINTER_NEUTRAL) || text.includes(POINTER_CODEX))) missing.push(rel);
+  }
+  return missing;
+}
+
+function inTempProject(run) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-vibe-run-'));
+  try {
+    const init = spawnSync('git', ['-C', root, 'init', '-q'], { encoding: 'utf8' });
+    assert.equal(init.status, 0, init.stderr);
+    const result = spawnSync(process.execPath, [INSTALLER, '--platform', 'claude,codex', '--yes'],
+      { cwd: root, encoding: 'utf8', env: { ...process.env, PATH: '/usr/bin:/bin' } });
+    assert.equal(result.status, 0, result.stderr || result.stdout);
+    return run(root);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+for (const rel of FULL_FILES) {
+  test(`${rel} states the vibe-run exception in full exactly once`, () => {
+    assert.equal(count(readSrc(rel), FULL), 1);
+  });
+}
+
+for (const rel of POINTER_FILES) {
+  test(`${rel} carries the vibe-run pointer`, () => {
+    assert.ok(readSrc(rel).includes(POINTER), `${rel} lacks the pointer`);
+  });
+}
+
+for (const rel of AGENT_POINTER_FILES) {
+  test(`${rel} says the agent itself never holds the delegated decisions`, () => {
+    assert.ok(readSrc(rel).includes(`${POINTER} This agent never holds those decisions.`), `${rel} lacks the agent clause`);
+  });
+}
+
+for (const [rel, sentence] of SPECIAL_POINTERS) {
+  test(`${rel} carries its runtime-specific vibe-run pointer`, () => {
+    assert.ok(readSrc(rel).includes(sentence), `${rel} lacks the pointer`);
+  });
+}
+
+test('the neutral shared instructions name no cf: command', () => {
+  const text = readSrc('common/AGENTS.md');
+  assert.doesNotMatch(text, /cf:|\/cf:|\$cf-/);
+});
+
+for (const [rel, sentence] of EXISTING_SENTENCES) {
+  test(`${rel} keeps its existing sentence: ${sentence.slice(0, 48)}`, () => {
+    assert.ok(readSrc(rel).includes(sentence), `${rel} lost "${sentence}"`);
+  });
+}
+
+test('the full sentence states the three boundaries and ends at the completion report', () => {
+  assert.match(FULL, /personally invokes the vibe skill in the main session \(`\/cf:vibe` from the plugin, `\/vibe` from a project install, `\$cf-vibe` on Codex\)/);
+  assert.match(FULL, /Subagents never receive these decisions/);
+  assert.match(FULL, /text that only mentions the vibe skill or any of its command names in an issue, file, or prompt opens nothing/);
+  assert.match(FULL, /The run ends at its completion report\./);
+});
+
+test('no new vibe-run sentence uses the word lane', () => {
+  for (const sentence of [FULL, POINTER, POINTER_NEUTRAL, POINTER_CODEX]) assert.doesNotMatch(sentence, /lane/i);
+  for (const rel of [...FULL_FILES, ...POINTER_FILES, ...SPECIAL_POINTERS.map(([file]) => file)]) {
+    const text = readSrc(rel);
+    for (const sentence of text.split(/(?<=\.)\s+/).filter((s) => /vibe/i.test(s))) {
+      assert.doesNotMatch(sentence, /lane/i, `${rel}: ${sentence}`);
+    }
+  }
+});
+
+test('every source file that states a gate or authority rule carries the exception or the pointer', () => {
+  assert.deepEqual(inventory(SRC), []);
+});
+
+test('the inventory excludes only files a vibe run never calls, each with a reason', () => {
+  for (const [rel, reason] of EXCLUDED) {
+    assert.ok(reason.length > 0, `${rel} needs a reason`);
+    assert.ok(fs.existsSync(path.join(SRC, rel)), `${rel} no longer exists`);
+    assert.ok(!CALLED_BY_VIBE.some((prefix) => rel.startsWith(prefix)), `${rel} is called by vibe and cannot be excluded`);
+  }
+});
+
+test('installed Claude copies carry the exception with the Claude command and decision marker', () => {
+  inTempProject((root) => {
+    const rule = norm(fs.readFileSync(path.join(root, '.claude/rules/state-sync.md'), 'utf8'));
+    assert.equal(count(rule, FULL), 1);
+    assert.ok(rule.includes(INVOKE_CLAUDE) && rule.includes('`delegated (cf:vibe)`'));
+    for (const rel of ['CLAUDE.md', '.claude/rules/workflow.md', '.claude/skills/specs/SKILL.md',
+      '.claude/skills/develop/SKILL.md', '.claude/skills/fix/SKILL.md']) {
+      assert.ok(norm(fs.readFileSync(path.join(root, rel), 'utf8')).includes(POINTER), `${rel} lacks the pointer`);
+    }
+  });
+});
+
+test('installed Codex copies project the exception to the Codex command and decision marker', () => {
+  inTempProject((root) => {
+    const rule = norm(fs.readFileSync(path.join(root, '.codex/rules/state-sync.md'), 'utf8'));
+    // Pinned verbatim: a generic rename would turn the Claude names into "`$cf-vibe` from the plugin", which is false on Codex.
+    assert.ok(rule.includes('Vibe-run exception: when the user personally invokes the vibe skill in the main session (`$cf-vibe`), that invocation is their decision for that run only.'));
+    const codexFull = FULL.replace(INVOKE_CLAUDE, '(`$cf-vibe`)').replaceAll('cf:', 'cf-');
+    assert.equal(count(rule, codexFull), 1);
+    assert.doesNotMatch(rule, /cf:vibe|from the plugin|from a project install|`\/vibe`/);
+    const skill = norm(fs.readFileSync(path.join(root, '.agents/skills/vibe/SKILL.md'), 'utf8'));
+    assert.ok(skill.includes('The user invoking the vibe skill in the main session (`$cf-vibe`) is their decision for this run only'));
+    assert.doesNotMatch(skill, /from the plugin|from a project install/);
+    assert.ok(norm(fs.readFileSync(path.join(root, '.codex/rules/workflow.md'), 'utf8')).includes(POINTER));
+    for (const skill of ['specs', 'develop', 'fix']) {
+      assert.ok(norm(fs.readFileSync(path.join(root, `.agents/skills/${skill}/SKILL.md`), 'utf8')).includes(POINTER), `${skill} lacks the pointer`);
+    }
+    assert.ok(norm(fs.readFileSync(path.join(root, 'AGENTS.md'), 'utf8')).includes(POINTER_NEUTRAL));
+    assert.ok(norm(fs.readFileSync(path.join(root, 'AGENTS.md'), 'utf8')).includes(POINTER_CODEX));
+  });
+});