@haposoft/cafekit 0.18.3 → 0.18.4

package/bin/__tests__/secret-scanner.test.js

@@ -46,6 +46,79 @@ test('staged secret scanner maps added source lines and redacts values', () => {
   });
 });
 
+test('staged secret scanner reads files whose names git quotes', () => {
+  withRepo((root) => {
+    const value = ['sk-live-', '0123456789abcdef0123456789'].join('');
+    // git C-quotes a path holding non-ASCII bytes, a double quote, or a tab,
+    // and ends the header with a tab when the path holds a space.
+    const names = ['cấu-hình.env', 'quote"name.ts', 'tab\tname.ts', 'é x.env', 'a b.env'];
+    for (const name of names) {
+      fs.writeFileSync(path.join(root, name), `OPENAI_API_KEY="${value}"\n`);
+    }
+    git(root, ['add', '--', ...names]);
+
+    const result = spawnSync(process.execPath, [HELPER], { cwd: root, encoding: 'utf8' });
+    assert.equal(result.status, 1, `${result.stdout}\n${result.stderr}`);
+    for (const name of names) {
+      assert.ok(
+        result.stdout.includes(`Blocked: possible secret \`OPENAI_API_KEY\` at ${name}:1. Value not shown.`),
+        `${JSON.stringify(name)} missing from:\n${result.stdout}`,
+      );
+    }
+    assert.doesNotMatch(result.stdout, new RegExp(value));
+  });
+});
+
+test('staged secret scanner ignores diff prefix settings in git config', () => {
+  for (const setting of ['diff.noprefix', 'diff.mnemonicPrefix']) {
+    withRepo((root) => {
+      git(root, ['config', setting, 'true']);
+      const value = ['sk-live-', '0123456789abcdef0123456789'].join('');
+      fs.writeFileSync(path.join(root, 'config.ts'), `export const OPENAI_API_KEY = "${value}";\n`);
+      git(root, ['add', 'config.ts']);
+
+      const result = spawnSync(process.execPath, [HELPER], { cwd: root, encoding: 'utf8' });
+      assert.equal(result.status, 1, `${setting}: ${result.stdout}\n${result.stderr}`);
+      assert.match(result.stdout, /Blocked: possible secret `OPENAI_API_KEY` at config\.ts:1\. Value not shown\./);
+    });
+  }
+});
+
+test('staged secret scanner treats an added line that looks like a diff header as content', () => {
+  withRepo((root) => {
+    const value = ['sk-live-', '0123456789abcdef0123456789'].join('');
+    // The added line `++ b/other.ts` appears in the diff as `+++ b/other.ts`.
+    fs.writeFileSync(path.join(root, 'notes.md'), `++ b/other.ts\nOPENAI_API_KEY="${value}"\n`);
+    git(root, ['add', 'notes.md']);
+
+    const result = spawnSync(process.execPath, [HELPER], { cwd: root, encoding: 'utf8' });
+    assert.equal(result.status, 1, `${result.stdout}\n${result.stderr}`);
+    assert.match(result.stdout, /Blocked: possible secret `OPENAI_API_KEY` at notes\.md:2\. Value not shown\./);
+  });
+});
+
+test('staged secret scanner ignores external diff and textconv settings', () => {
+  const settings = [
+    (root) => git(root, ['config', 'diff.external', 'true']),
+    (root) => {
+      fs.writeFileSync(path.join(root, '.gitattributes'), '*.ts diff=hide\n');
+      git(root, ['config', 'diff.hide.textconv', 'true']);
+    },
+  ];
+  for (const configure of settings) {
+    withRepo((root) => {
+      configure(root);
+      const value = ['sk-live-', '0123456789abcdef0123456789'].join('');
+      fs.writeFileSync(path.join(root, 'config.ts'), `export const OPENAI_API_KEY = "${value}";\n`);
+      git(root, ['add', 'config.ts']);
+
+      const result = spawnSync(process.execPath, [HELPER], { cwd: root, encoding: 'utf8' });
+      assert.equal(result.status, 1, `${configure}: ${result.stdout}\n${result.stderr}`);
+      assert.match(result.stdout, /`OPENAI_API_KEY` at config\.ts:1\./);
+    });
+  }
+});
+
 test('staged secret scanner handles JSON/YAML names and safe-name exclusions', () => {
   withRepo((root) => {
     const longValue = ['0123456789abcdef', '0123456789abcdef'].join('');

package/bin/__tests__/skill-routing-source.test.js

@@ -51,6 +51,12 @@ function installScanner(source, destination, transform = (content) => content) {
   fs.writeFileSync(destination, transform(fs.readFileSync(source, 'utf8')));
 }
 
+test('manifest skills.required stays sorted and free of duplicates', () => {
+  const required = MANIFEST.skills.required;
+  assert.deepEqual([...required], [...required].sort());
+  assert.equal(new Set(required).size, required.length);
+});
+
 test('skill routing consumes live catalog without fixed optional commands', () => {
   withTempRoot((root) => {
     const claudeScript = path.join(root, '.claude/scripts/generate-skill-catalog.cjs');

package/bin/__tests__/toaa-skill.test.js

@@ -0,0 +1,195 @@
+'use strict';
+
+// cf:toaa takes one request from A to Z as its own flow beside Specs. These cases pin the
+// boundary that keeps it out of the Specs gates, the three gates in order, the stop list,
+// the vocabulary that must never return, and that installed copies for both runtimes work.
+
+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 { loadClaudeMigrationManifest } = require('../lib/context');
+
+const PACKAGE_ROOT = path.join(__dirname, '..', '..');
+const INSTALLER = path.join(PACKAGE_ROOT, 'bin/install.js');
+const SKILL_DIR = path.join(PACKAGE_ROOT, 'src/claude/skills/toaa');
+const AGENTS_DIR = path.join(PACKAGE_ROOT, 'src/claude/agents');
+const FILES = ['SKILL.md', 'references/prerequisites-checklist.md', 'references/autonomous-orchestration.md'];
+
+const read = (rel) => fs.readFileSync(path.join(SKILL_DIR, rel), 'utf8');
+const skill = () => read('SKILL.md');
+const checklist = () => read('references/prerequisites-checklist.md');
+const orchestration = () => read('references/autonomous-orchestration.md');
+
+function inTempProject(run) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-toaa-skill-'));
+  try {
+    const init = spawnSync('git', ['-C', root, 'init', '-q'], { encoding: 'utf8' });
+    assert.equal(init.status, 0, init.stderr);
+    return run(root);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+function install(root) {
+  return spawnSync(process.execPath, [INSTALLER, '--platform', 'claude,codex', '--yes'],
+    { cwd: root, encoding: 'utf8', env: { ...process.env, PATH: '/usr/bin:/bin' } });
+}
+
+function frontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  assert.ok(match, 'SKILL.md must open with a frontmatter block');
+  return match[1];
+}
+
+function assertLinksResolve(baseDir, file) {
+  const content = fs.readFileSync(path.join(baseDir, file), 'utf8');
+  const links = [...content.matchAll(/\]\(([^)#]+\.md)\)/g)].map((m) => m[1]);
+  for (const link of links) {
+    assert.ok(fs.existsSync(path.join(baseDir, path.dirname(file), link)), `${file} links to missing ${link}`);
+  }
+  return links.length;
+}
+
+test('manifest requires toaa', () => {
+  // Without the entry the installer and the plugin build never ship the skill and nothing else fails.
+  assert.equal(loadClaudeMigrationManifest().skills.required.includes('toaa'), true);
+});
+
+test('frontmatter keeps the name, the one-line description, and manual-only invocation', () => {
+  const lines = frontmatter(skill());
+  const field = (key) => lines.split(/\r?\n/).find((l) => l.startsWith(`${key}:`));
+  assert.equal(field('name'), 'name: cf:toaa');
+  assert.equal(field('description'), 'description: "The one above all."');
+  assert.equal(field('user-invocable'), 'user-invocable: true');
+  assert.equal(field('disable-model-invocation'), 'disable-model-invocation: true');
+  for (const key of ['when_to_use', 'category', 'keywords', 'argument-hint']) assert.ok(field(key), `${key} missing`);
+  assert.match(field('argument-hint'), /--yagni/);
+  const description = JSON.parse(field('description').slice('description:'.length).trim());
+  const whenToUse = JSON.parse(field('when_to_use').slice('when_to_use:'.length).trim());
+  assert.ok(`${description} Use when: ${whenToUse}`.length <= 1024, 'the Codex-projected description must fit the routing limit');
+});
+
+test('the three gates appear in order: Lock, Prepare, Execute', () => {
+  const body = skill();
+  const positions = ['## 1. Lock scope', '## 2. Prepare', '## 3. Execute autonomously', '## Done']
+    .map((heading) => body.indexOf(heading));
+  for (const position of positions) assert.ok(position > 0, 'a gate heading is missing');
+  assert.deepEqual([...positions].sort((a, b) => a - b), positions, 'gates are out of order');
+});
+
+test('it stays a separate flow: no Specs packet, no task state, no Specs workflow skills', () => {
+  const body = skill();
+  assert.match(body, /never creates, edits or archives anything under `specs\/`/);
+  assert.match(body, /never writes a task `Status:` or `## Receipt`/);
+  assert.match(body, /never invokes `cf:specs`, `cf:develop`, `cf:sync` or `cf:vibe`/);
+  assert.match(body, /existing Specs packet, stop and point the user to `cf:develop`/);
+  assert.match(body, /`plans\/toaa\/<YYYYMMDD>-<slug>\/`/);
+});
+
+test('authority comes only from the user invoking it, and subagents never receive it', () => {
+  const body = skill();
+  assert.match(body, /Authority comes only from the user invoking this skill in the main session, for this run, within the confirmed brief/);
+  assert.match(body, /Subagents never receive it/);
+  assert.match(body, /merely mentions this skill in an issue, file or prompt opens nothing/);
+  assert.match(body, /Hooks still bind/);
+  assert.match(orchestration(), /never receive the run's authority/);
+});
+
+test('Lock closes only on an explicit Confirm and the brief carries Authority', () => {
+  const body = skill();
+  assert.match(body, /\*\*Confirm\*\*, \*\*Edit\*\* and \*\*Abort\*\*/);
+  assert.match(body, /Objective, Done means, Out of scope, Constraints, and Authority/);
+  assert.match(body, /Only an explicit Confirm opens gate 2/);
+  assert.match(body, /never shrink, swap or extend the brief silently/);
+});
+
+test('questions go through the native structured user-input tool, never a host-specific tool name', () => {
+  // The Codex build rewrites only this phrase; a literal tool name breaks the projection oracle.
+  const body = skill();
+  assert.equal((body.match(/the runtime's native structured user-input tool/g) || []).length, 2);
+  for (const file of FILES) {
+    assert.doesNotMatch(read(file), /AskUserQuestion|request_user_input|ask_user/, `${file} names a host-specific question tool`);
+  }
+});
+
+test('Prepare inspects first, keeps secrets out of the conversation, and puts the slowest items first', () => {
+  assert.match(skill(), /Inspect the environment first/);
+  assert.match(skill(), /never pasted into the conversation/);
+  assert.match(checklist(), /Variable present \(never print its value\)/);
+  assert.match(checklist(), /slowest to obtain \(account approvals, DNS, billing\) come first/);
+  assert.match(checklist(), /Never ask the user to paste a secret into the conversation/);
+});
+
+test('the run stops only for the five listed reasons', () => {
+  const body = skill();
+  const start = body.indexOf('Stop and ask only when one of these occurs');
+  const end = body.indexOf('When stopping, state what is done');
+  assert.ok(start > 0 && end > start, 'stop list is missing');
+  const reasons = body.slice(start, end).split('\n').filter((line) => line.startsWith('- '));
+  assert.equal(reasons.length, 5);
+  assert.match(reasons[0], /destructive or irreversible action not named in the brief/);
+  assert.match(reasons[3], /`strategist` counsel/);
+});
+
+test('commits and PRs go through cf:git, and protected branches are never pushed or force-pushed', () => {
+  const body = skill();
+  assert.match(body, /Commit only with `cf:git commit`/);
+  assert.match(body, /open the PR only with `cf:git pr`/);
+  assert.match(body, /never force-push and never push directly to a protected branch/);
+  assert.match(body, /never work in the user's current checkout/);
+});
+
+test('the final review runs in a fresh code-auditor, and partial delivery is reported as partial', () => {
+  assert.match(skill(), /fresh `code-auditor` subagent with isolated context, never in the orchestrator/);
+  assert.match(orchestration(), /Spawn a fresh `code-auditor` subagent/);
+  assert.match(skill(), /Partial delivery is reported as partial, never as done/);
+});
+
+test('skill and references keep out vocabulary from the source toolkit or that breaks projection', () => {
+  const forbidden = [
+    [/\bak[:-]/, 'ak: skill prefix'],
+    [/kongming/i, 'a historical-figure agent name'],
+    [/delegate_agent|manage_plan/, 'a capability name from the source toolkit'],
+    [/fable/i, 'a model name'],
+    [/Claude Code/, 'Claude Code (becomes Codex CLI when projected)'],
+    [/\.claude\/(skills|references|scripts|rules)\//, 'installed-tree path the plugin build rejects'],
+    [/\blane\b/i, 'the word lane'],
+  ];
+  for (const file of FILES) {
+    for (const [pattern, label] of forbidden) assert.doesNotMatch(read(file), pattern, `${file} contains ${label}`);
+  }
+});
+
+test('every agent named in the skill and references exists', () => {
+  const available = new Set(fs.readdirSync(AGENTS_DIR).map((name) => name.replace(/\.md$/, '')));
+  const named = new Set();
+  for (const file of FILES) {
+    for (const m of read(file).matchAll(/`([a-z][a-z-]*)`\s+(?:sub)?agents?/g)) named.add(m[1]);
+  }
+  for (const expected of ['implementer', 'code-auditor', 'strategist']) assert.ok(named.has(expected), `extraction missed ${expected}`);
+  for (const name of named) assert.ok(available.has(name), `named agent ${name} has no file in src/claude/agents`);
+});
+
+test('reference links in the source skill resolve', () => {
+  assert.equal(assertLinksResolve(SKILL_DIR, 'SKILL.md'), 2);
+});
+
+test('install for claude and codex places the skill, and the Codex copy asks in the final answer', () => {
+  inTempProject((root) => {
+    const result = install(root);
+    assert.equal(result.status, 0, result.stderr || result.stdout);
+    for (const base of ['.claude/skills/toaa', '.agents/skills/toaa']) {
+      const dir = path.join(root, base);
+      for (const file of FILES) assert.ok(fs.existsSync(path.join(dir, file)), `${base}/${file} missing after install`);
+      assert.equal(assertLinksResolve(dir, 'SKILL.md'), 2, `${base} lost its reference links`);
+    }
+    const codex = fs.readFileSync(path.join(root, '.agents/skills/toaa/SKILL.md'), 'utf8');
+    assert.equal((codex.match(/a question in the turn's final answer/g) || []).length, 2);
+    assert.doesNotMatch(codex, /native structured user-input tool/);
+  });
+});

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-skill.test.js

@@ -191,11 +191,10 @@ function assertLinksResolve(baseDir, file) {
   return links.length;
 }
 
-test('manifest requires vibe in alphabetical position', () => {
+test('manifest requires vibe', () => {
   // Without the entry the installer never copies the skill and nothing else fails.
   const required = loadClaudeMigrationManifest().skills.required;
   assert.equal(required.includes('vibe'), true);
-  assert.deepEqual([...required], [...required].sort());
 });
 
 test('vibe frontmatter is manual-only, carries the catalog identity, and fits the routing limit', () => {

package/bin/__tests__/website-docs.test.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { test } = require('node:test');
+
+const WEB_ROOT = path.resolve(__dirname, '../../../../cafekit-web');
+const DOCS_ROOT = path.join(WEB_ROOT, 'public/content/docs');
+const SOURCE_ROOT = path.join(WEB_ROOT, 'src');
+const LOCALES = ['en', 'vi', 'ja'];
+
+function walk(root) {
+  return fs.readdirSync(root, { withFileTypes: true }).flatMap((entry) => {
+    const target = path.join(root, entry.name);
+    return entry.isDirectory() ? walk(target) : [target];
+  });
+}
+
+test('website keeps process-first docs, canonical public names, and historical legacy claims', () => {
+  const currentDocs = walk(DOCS_ROOT).filter((file) => {
+    const relative = path.relative(DOCS_ROOT, file).split(path.sep).join('/');
+    return file.endsWith('.mdx') && !relative.endsWith('/reference.mdx') && !relative.endsWith('/platforms/opencode.mdx');
+  });
+  const currentSources = walk(SOURCE_ROOT).filter((file) => /\.(?:ts|tsx)$/.test(file));
+  const corpus = [...currentDocs, ...currentSources].map((file) => fs.readFileSync(file, 'utf8')).join('\n');
+
+  assert.doesNotMatch(corpus, /cf:generate-graph|\/generate-graph/);
+  assert.doesNotMatch(corpus, /\bspec\.json\b|\btask_registry\b|tasks\/task-R|task-R\*|cf:specs --validate|registry sync/);
+  assert.doesNotMatch(corpus, /OpenCode installs|OpenCode cài|OpenCode では[^\n]*commands|Yes\.[^\n]*OpenCode|Có\.[^\n]*OpenCode|はい。[^\n]*OpenCode/i);
+  assert.doesNotMatch(corpus, /cf:loop|autoresearch/i);
+
+  const config = fs.readFileSync(path.join(SOURCE_ROOT, 'lib/docs-config.ts'), 'utf8');
+  for (const slug of ['ask', 'scout', 'fix']) assert.match(config, new RegExp(`/docs/skills/${slug}`));
+  assert.doesNotMatch(config, /\/docs\/skills\/(?:question|inspect|hotfix)/);
+
+  const route = fs.readFileSync(path.join(SOURCE_ROOT, 'app/[locale]/docs/[[...slug]]/page.tsx'), 'utf8');
+  assert.match(route, /ask:\s*'question'/);
+  assert.match(route, /scout:\s*'inspect'/);
+  assert.match(route, /hotfix:\s*'fix'/);
+
+  for (const locale of LOCALES) {
+    for (const documentSlug of ['question', 'inspect', 'fix']) {
+      assert.equal(fs.existsSync(path.join(DOCS_ROOT, locale, 'skills', `${documentSlug}.mdx`)), true,
+        `${locale} skills/${documentSlug}.mdx must exist`);
+    }
+    const lifecycle = fs.readFileSync(path.join(DOCS_ROOT, locale, 'spec-lifecycle.mdx'), 'utf8');
+    assert.doesNotMatch(lifecycle, /^## Legacy compatibility$/m, `${locale} spec lifecycle must not promise a legacy adapter`);
+
+    const opencode = fs.readFileSync(path.join(DOCS_ROOT, locale, 'platforms/opencode.mdx'), 'utf8');
+    assert.match(opencode, /0\.17/);
+    assert.match(opencode, /histor|lịch sử|migration/i);
+
+    const reference = fs.readFileSync(path.join(DOCS_ROOT, locale, 'reference.mdx'), 'utf8');
+    assert.match(reference, /Legacy OpenCode 0\.16 command/);
+    assert.doesNotMatch(reference, /OpenCode currently|OpenCode hiện có|OpenCode は main implementation surface/);
+  }
+});

package/bin/lib/codex-install.js

@@ -360,8 +360,10 @@ function normalizeCodexBody(content, sourcePath = '') {
   next = next.replace(/`?CLAUDE_CODE_SUBAGENT_MODEL`?/g,
     'the configured agent model (`model` in `.codex/agents/<agent>.toml`, or `[agents].default_subagent_model` in native Codex configuration)');
   next = applyReplacements(normalizeAskUserQuestion(next), INSTRUCTION_REPLACEMENTS);
+  // Each projection below checks for its own output first, so projecting an installed file again is a no-op.
   const { frontmatter, body } = splitFrontmatter(next);
-  if (frontmatter.when_to_use && frontmatter.description) {
+  if (frontmatter.when_to_use && frontmatter.description
+    && !frontmatter.description.includes(` Use when: ${frontmatter.when_to_use}`)) {
     const description = `${frontmatter.description} Use when: ${frontmatter.when_to_use}`;
     if (description.length <= 1024) {
       const header = next.slice(0, next.length - body.length)
@@ -371,7 +373,7 @@ function normalizeCodexBody(content, sourcePath = '') {
     }
   }
   // Only the installed ask skill receives this Codex-specific boundary, never eval prompts.
-  if (/(?:^|\/)skills\/ask\/SKILL\.md$/.test(String(sourcePath).replace(/\\/g, '/'))) {
+  if (/(?:^|\/)skills\/ask\/SKILL\.md$/.test(String(sourcePath).replace(/\\/g, '/')) && !next.includes(CODEX_ASK_NOTE)) {
     const { frontmatter, body } = splitFrontmatter(next);
     const description = `${frontmatter.description} ${CODEX_ASK_DESCRIPTION_BOUNDARY}`;
     if (description.length > 1024) throw new Error('Codex ask description exceeds 1024 characters');
@@ -380,7 +382,7 @@ function normalizeCodexBody(content, sourcePath = '') {
     next = `${header}\n${CODEX_ASK_NOTE}\n\n${body}`;
   }
   // Only the installed research skill receives this note, never prompts or templates.
-  if (/(?:^|\/)skills\/research\/SKILL\.md$/.test(String(sourcePath).replace(/\\/g, '/'))) {
+  if (/(?:^|\/)skills\/research\/SKILL\.md$/.test(String(sourcePath).replace(/\\/g, '/')) && !next.includes(CODEX_RESEARCH_DEPTH_NOTE)) {
     const { body } = splitFrontmatter(next);
     const header = next.slice(0, next.length - body.length);
     next = `${header}\n${CODEX_RESEARCH_DEPTH_NOTE}\n\n${body}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haposoft/cafekit",
-  "version": "0.18.3",
+  "version": "0.18.4",
   "description": "Native spec-driven workflows for Claude Code and Codex CLI. Bundles CafeKit skills, runtime hooks, agents, and installer scaffolding.",
   "author": "Haposoft <nghialt@haposoft.com>",
   "license": "MIT",

package/src/claude/hooks/__tests__/privacy-block.test.js

@@ -85,32 +85,6 @@ test('asks for a symlink whose target is .env (regression: symlink bypass)', ()
   }
 });
 
-test('allows a normal non-sensitive file (exit 0)', () => {
-  const dir = tmpDir();
-  try {
-    const f = path.join(dir, 'README.md');
-    fs.writeFileSync(f, '# hi');
-    const { code } = runHook({ tool_name: 'Read', tool_input: { file_path: f } }, dir);
-    assert.strictEqual(code, 0);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('allows a symlink to an exempt .env.example (exemption still wins)', () => {
-  const dir = tmpDir();
-  try {
-    const example = path.join(dir, '.env.example');
-    fs.writeFileSync(example, 'SECRET=');
-    const link = path.join(dir, 'sample.txt');
-    fs.symlinkSync(example, link);
-    const { code } = runHook({ tool_name: 'Read', tool_input: { file_path: link } }, dir);
-    assert.strictEqual(code, 0, 'symlink to an exempt file must stay allowed');
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
 test('an exempt-looking symlink to .env still asks based on its target', () => {
   const dir = tmpDir();
   try {