@haposoft/cafekit 0.15.1 → 0.16.0-rc.1

package/README.md

@@ -2,7 +2,7 @@
 
 > Native spec-driven workflow and runtime bundle for Claude Code, Codex CLI, and OpenCode.
 
-[![Version](https://img.shields.io/badge/version-0.15.1-blue.svg)](https://github.com/haposoft/cafekit)
+[![Version](https://img.shields.io/badge/version-0.16.0-blue.svg)](https://github.com/haposoft/cafekit)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 [![Claude%20Code](https://img.shields.io/badge/Claude%20Code-Native-orange.svg)](https://claude.ai/code)
 [![Codex%20CLI](https://img.shields.io/badge/Codex%20CLI-Native-111111.svg)](https://developers.openai.com/codex)
@@ -68,8 +68,10 @@ On install, CafeKit updates the **project-root** `.gitignore` with:
 ```text
 # CafeKit / Ecosystem
 specs/_shared/
-plans/
+plans/*
+!plans/*.md
 !plans/templates/
+!plans/templates/**
 .cafekit-backup/
 .cafekit.lock
 .claude/
@@ -134,6 +136,8 @@ AGENTS.md
 CafeKit owns only its marked block in root `AGENTS.md`. Codex discovers skills
 and custom agents natively after the repository is trusted; no project
 `config.toml` is generated. Review and trust project hooks with `/hooks`.
+On Windows, installed hook commands are bound to the canonical project path
+without requiring Git and remain stable when a session starts in a subdirectory.
 CafeKit uses Codex's native status and usage UI instead of installing the
 Claude statusline.
 

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

@@ -27,6 +27,10 @@ function inHookFixture(run) {
   try {
     fs.cpSync(CODEX_HOOKS, hooks, { recursive: true });
     fs.mkdirSync(path.join(root, '.codex', 'scripts'), { recursive: true });
+    fs.copyFileSync(
+      path.join(PACKAGE_ROOT, 'src/claude/scripts/workflow-policy.cjs'),
+      path.join(root, '.codex', 'scripts', 'workflow-policy.cjs'),
+    );
     fs.writeFileSync(path.join(root, '.codex', 'scripts', 'spec-scaffold.cjs'), '');
     return run(root, hooks);
   } finally {
@@ -329,3 +333,139 @@ test('Codex state hook persists direct native event fields at project root', ()
     assert.equal(codexStateDir(root, ''), null);
   });
 });
+
+test('Codex canonical receipt provenance requires both Base and Head', () => {
+  const receipt = require(path.join(CODEX_HOOKS, 'lib', 'spec-receipt.cjs'));
+  const onlyBase = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nBase: abc\n');
+  assert.ok(onlyBase.includes('provenance'), 'only Base should fail');
+  const onlyHead = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nHead: def\n');
+  assert.ok(onlyHead.includes('provenance'), 'only Head should fail');
+  const both = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nBase: abc\nHead: def\n');
+  assert.deepEqual(both, [], 'both Base and Head should pass');
+  const onlyBaseSha = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nbase_sha: abc\n');
+  assert.ok(onlyBaseSha.includes('provenance'));
+  const bothSha = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nbase_sha: abc\nhead_sha: def\n');
+  assert.deepEqual(bothSha, [], 'both base_sha and head_sha should pass');
+  // Empty / bare provenance must fail — non-empty same-line value required
+  const emptyBase = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nBase:\nHead: def\n');
+  assert.ok(emptyBase.includes('provenance'), 'empty Base: should fail');
+  const spacesBase = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nBase:   \nHead: def\n');
+  assert.ok(spacesBase.includes('provenance'), 'Base: spaces only should fail');
+  const emptyHead = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nBase: abc\nHead:\n');
+  assert.ok(emptyHead.includes('provenance'), 'empty Head: should fail');
+  const bareBaseSha = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nbase_sha\nhead_sha: def\n');
+  assert.ok(bareBaseSha.includes('provenance'), 'bare base_sha without colon/value should fail');
+  const emptyBaseSha = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nbase_sha:\nhead_sha: def\n');
+  assert.ok(emptyBaseSha.includes('provenance'), 'empty base_sha: should fail');
+  const spacesBaseSha = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nbase_sha:   \nhead_sha: def\n');
+  assert.ok(spacesBaseSha.includes('provenance'), 'base_sha spaces only should fail');
+  const bareBoth = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nbase_sha head_sha\n');
+  assert.ok(bareBoth.includes('provenance'), 'bare base_sha head_sha without colon should fail');
+  const validBaseHead = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nBase: abc123\nHead: def456\n');
+  assert.deepEqual(validBaseHead, [], 'valid Base+Head with values should pass');
+  const validSha = receipt.validateCanonicalReceipt('Verification: PASS\nCommand: pnpm test\nExit: 0\nbase_sha: abc123\nhead_sha: def456\n');
+  assert.deepEqual(validSha, [], 'valid base_sha+head_sha with values should pass');
+
+  // Integration via spec-gate hook: only Base blocks, both passes
+  inHookFixture((root, hooks) => {
+    const feature = path.join(root, 'specs', 'auth');
+    const taskPath = 'tasks/task-R0-01-auth.md';
+    fs.mkdirSync(path.join(feature, 'tasks'), { recursive: true });
+    const gate = path.join(hooks, 'spec-gate.cjs');
+    const payload = { cwd: path.join(root, 'packages', 'app'), session_id: 'session-a', hook_event_name: 'Stop', stop_hook_active: false };
+
+    // only Base -> block
+    fs.writeFileSync(path.join(feature, 'spec.json'), JSON.stringify({ status: 'in_progress', task_registry: { [taskPath]: { status: 'done', completed_at: '2026-07-29T10:00:00.000Z' } } }));
+    fs.writeFileSync(path.join(feature, taskPath), 'Status: done\n\n## Evidence\n\nVerification: PASS\nCommand: pnpm test\nExit: 0\nBase: abc\n');
+    fs.mkdirSync(payload.cwd, { recursive: true });
+    const blocked = runHook(gate, payload.cwd, payload);
+    assert.equal(JSON.parse(blocked.stdout).decision, 'block');
+    assert.match(JSON.parse(blocked.stdout).reason, /\bg\b|\bprovenance\b/);
+
+    // both -> no block
+    fs.writeFileSync(path.join(feature, taskPath), 'Status: done\n\n## Evidence\n\nVerification: PASS\nCommand: pnpm test\nExit: 0\nBase: abc\nHead: def\n');
+    const passed = runHook(gate, payload.cwd, payload);
+    assert.equal(passed.stdout, '');
+
+    // empty Base: should block provenance — reset gate cache so re-checked as newly-done
+    try { fs.rmSync(path.join(root, '.codex', 'hooks', '.logs', 'spec-gate-last.json'), { force: true }); } catch {}
+    fs.writeFileSync(path.join(feature, taskPath), 'Status: done\n\n## Evidence\n\nVerification: PASS\nCommand: pnpm test\nExit: 0\nBase:\nHead: def\n');
+    const blockedEmpty = runHook(gate, payload.cwd, payload);
+    assert.equal(JSON.parse(blockedEmpty.stdout).decision, 'block');
+    assert.match(JSON.parse(blockedEmpty.stdout).reason, /\bg\b/);
+
+    // bare base_sha without colon should block — reset cache again
+    try { fs.rmSync(path.join(root, '.codex', 'hooks', '.logs', 'spec-gate-last.json'), { force: true }); } catch {}
+    fs.writeFileSync(path.join(feature, taskPath), 'Status: done\n\n## Evidence\n\nVerification: PASS\nCommand: pnpm test\nExit: 0\nbase_sha head_sha\n');
+    const blockedBare = runHook(gate, payload.cwd, payload);
+    assert.equal(JSON.parse(blockedBare.stdout).decision, 'block');
+    assert.match(JSON.parse(blockedBare.stdout).reason, /\bg\b/);
+  });
+});
+
+test('Codex cache hardening: every done re-validated — mutation, deletion, malformed cache, unchanged valid', () => {
+  inHookFixture((root, hooks) => {
+    const feature = path.join(root, 'specs', 'auth');
+    const taskPath = 'tasks/task-R0-01-auth.md';
+    fs.mkdirSync(path.join(feature, 'tasks'), { recursive: true });
+    const gate = path.join(hooks, 'spec-gate.cjs');
+    const appCwd = path.join(root, 'packages', 'app');
+    fs.mkdirSync(appCwd, { recursive: true });
+    const payload = { cwd: appCwd, session_id: 'session-a', hook_event_name: 'Stop', stop_hook_active: false };
+    const cacheFile = path.join(root, '.codex', 'hooks', '.logs', 'spec-gate-last.json');
+    const validBody = 'Status: done\n\n## Evidence\n\nVerification: PASS\nCommand: pnpm test\nExit: 0\nBase: abc123\nHead: def456\n```\npass\n```\n';
+
+    // first-run (no cache) with valid receipt → no block, cache seeded
+    try { fs.rmSync(cacheFile, { force: true }); } catch {}
+    fs.writeFileSync(path.join(feature, 'spec.json'), JSON.stringify({ status: 'in_progress', task_registry: { [taskPath]: { status: 'done', completed_at: '2026-07-29T10:00:00.000Z' } } }));
+    fs.writeFileSync(path.join(feature, taskPath), validBody);
+    let res = runHook(gate, appCwd, payload);
+    assert.equal(res.stdout, '', 'first-run valid should not block');
+    assert.ok(fs.existsSync(cacheFile), 'cache file must be created on first valid run');
+    assert.equal(JSON.parse(fs.readFileSync(cacheFile, 'utf8')).auth[taskPath], 'done');
+
+    // cache-hit unchanged valid → still no block (revalidation passes)
+    res = runHook(gate, appCwd, payload);
+    assert.equal(res.stdout, '', 'cache-hit unchanged valid must not block');
+
+    // mutation: remove Command/Verification → must block even though cache says done
+    fs.writeFileSync(path.join(feature, taskPath), 'Status: done\n\n## Evidence\n\nExit: 0\nBase: abc123\nHead: def456\n```\npass\n```\n');
+    res = runHook(gate, appCwd, payload);
+    assert.equal(JSON.parse(res.stdout).decision, 'block', 'mutated receipt missing Verification/Command should block on cache-hit');
+    assert.match(JSON.parse(res.stdout).reason, /\bc\b|\be\b/);
+    // second hit still blocks
+    res = runHook(gate, appCwd, payload);
+    assert.equal(JSON.parse(res.stdout).decision, 'block', 'second hit after mutation still blocks');
+
+    // restore valid, then mutate provenance (remove Head) → block
+    fs.writeFileSync(path.join(feature, taskPath), validBody);
+    assert.equal(runHook(gate, appCwd, payload).stdout, '', 'restored valid should pass again');
+    fs.writeFileSync(path.join(feature, taskPath), 'Status: done\n\n## Evidence\n\nVerification: PASS\nCommand: pnpm test\nExit: 0\nBase: abc123\n```\npass\n```\n');
+    res = runHook(gate, appCwd, payload);
+    assert.equal(JSON.parse(res.stdout).decision, 'block');
+    assert.match(JSON.parse(res.stdout).reason, /\bg\b/);
+
+    // deletion → block with check a
+    fs.writeFileSync(path.join(feature, taskPath), validBody);
+    assert.equal(runHook(gate, appCwd, payload).stdout, '');
+    fs.unlinkSync(path.join(feature, taskPath));
+    res = runHook(gate, appCwd, payload);
+    assert.equal(JSON.parse(res.stdout).decision, 'block');
+    assert.match(JSON.parse(res.stdout).reason, /\ba\b/);
+    // restore for next sub-test
+    fs.writeFileSync(path.join(feature, taskPath), validBody);
+    try { fs.rmSync(cacheFile, { force: true }); } catch {}
+    assert.equal(runHook(gate, appCwd, payload).stdout, '');
+
+    // malformed cache with valid receipt → must still pass (cache parse fail-open)
+    fs.writeFileSync(cacheFile, '{ malformed');
+    fs.writeFileSync(path.join(feature, taskPath), validBody);
+    res = runHook(gate, appCwd, payload);
+    assert.equal(res.stdout, '', 'malformed cache with valid receipt must not block');
+    // malformed cache with invalid receipt → must still block
+    fs.writeFileSync(cacheFile, '{ malformed again');
+    fs.writeFileSync(path.join(feature, taskPath), 'Status: done\n');
+    res = runHook(gate, appCwd, payload);
+    assert.equal(JSON.parse(res.stdout).decision, 'block', 'malformed cache with invalid receipt must block');
+  });
+});

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

@@ -18,6 +18,7 @@ const {
   resolvePlatforms,
   selectLanguage
 } = require('../phases/select-platform');
+const { MESSAGES } = require('../lib/i18n');
 
 const PACKAGE_ROOT = path.join(__dirname, '../..');
 const PACKAGE_VERSION = JSON.parse(
@@ -59,6 +60,12 @@ function allFiles(root, predicate) {
   return found;
 }
 
+function allHookHandlers(config) {
+  return Object.values(config.hooks).flatMap((groups) => (
+    groups.flatMap((group) => group.hooks)
+  ));
+}
+
 function parseGeneratedTomlString(content, key) {
   const match = content.match(new RegExp(`^${key} = (.+)$`, 'm'));
   assert.ok(match, `missing TOML key: ${key}`);
@@ -67,13 +74,13 @@ function parseGeneratedTomlString(content, key) {
 
 test('Codex payload transform emits native skill and subagent syntax', () => {
   const transformed = normalizeCodexBody(
-    'Agent(subagent_type="god-developer", prompt="Implement it", description="Code Feature")\n' +
+    'Agent(subagent_type="implementer", prompt="Implement it", description="Code Feature")\n' +
     'Use `/specs auth`, `SendMessage`, `Bash`, `Read`, and `Edit`.'
   );
 
   assert.match(
     transformed,
-    /spawn_agent\(agent_type="god_developer", fork_turns="none", message="Implement it", task_name="code_feature"\)/
+    /spawn_agent\(agent_type="implementer", fork_turns="none", message="Implement it", task_name="code_feature"\)/
   );
   assert.match(transformed, /\$hapo-specs auth/);
   assert.match(transformed, /`send_message`/);
@@ -196,6 +203,114 @@ test('same-version install can add Codex beside an existing runtime', async () =
   }
 });
 
+test('resolvePlatforms interactive prompts to add more platforms when prior install exists', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-add-platforms-'));
+  const originalCwd = process.cwd();
+  try {
+    fs.mkdirSync(path.join(root, '.claude'), { recursive: true });
+    fs.writeFileSync(
+      path.join(root, '.claude', 'cafekit.json'),
+      `${JSON.stringify({ version: PACKAGE_VERSION, platform: 'claude' })}\n`
+    );
+    process.chdir(root);
+    const ctx = {
+      options: { platforms: [], forceOverwrite: false },
+      interactive: true,
+      dryRun: false,
+      ui: {
+        info() {},
+        confirm: async ({ message }) => {
+          if (message.includes('Existing platforms') || message.includes('addPlatformsPrompt')) return true;
+          if (message.includes('confirmAllDetected') || message.includes('existing configs')) return true;
+          return true;
+        },
+        select: async ({ message, options }) => {
+          if (message.includes('selectPlatform') || message.includes('Select platform')) {
+            return ['codex'];
+          }
+          return options[0].value;
+        },
+        isCancel: () => false
+      },
+      t: (key, vars) => {
+        const tpl = (MESSAGES.en && MESSAGES.en[key]) || key;
+        if (vars) return tpl.replace(/\{(\w+)\}/g, (_, name) => (vars[name] !== undefined ? String(vars[name]) : `{${name}}`));
+        return tpl;
+      }
+    };
+    await resolvePlatforms(ctx);
+    assert.deepEqual(ctx.platforms.sort(), ['claude', 'codex'].sort());
+  } finally {
+    process.chdir(originalCwd);
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('resolvePlatforms interactive keeps existing platforms when user declines to add more', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-keep-platforms-'));
+  const originalCwd = process.cwd();
+  try {
+    fs.mkdirSync(path.join(root, '.claude'), { recursive: true });
+    fs.writeFileSync(
+      path.join(root, '.claude', 'cafekit.json'),
+      `${JSON.stringify({ version: PACKAGE_VERSION, platform: 'claude' })}\n`
+    );
+    process.chdir(root);
+    const ctx = {
+      options: { platforms: [], forceOverwrite: false },
+      interactive: true,
+      dryRun: false,
+      ui: {
+        info() {},
+        confirm: async ({ message }) => {
+          // Check that the message is properly rendered without {names} placeholder
+          // If i18n uses {existing} but ctx passes {names}, the rendered message will contain {existing}
+          if (message.includes('Existing platforms') || message.includes('既存プラットフォーム') || message.includes('Nền tảng hiện có')) {
+            assert.ok(!message.includes('{'), `Message should not contain unrendered placeholder: ${message}`);
+            assert.ok(!message.includes('}'), `Message should not contain unrendered placeholder: ${message}`);
+            return false; // decline to add more
+          }
+          return true; // confirmAllDetected
+        },
+        select: async () => ['claude'],
+        isCancel: () => false
+      },
+      t: (key, vars) => {
+        const tpl = (MESSAGES.en && MESSAGES.en[key]) || key;
+        if (vars) return tpl.replace(/\{(\w+)\}/g, (_, name) => (vars[name] !== undefined ? String(vars[name]) : `{${name}}`));
+        return tpl;
+      }
+    };
+    await resolvePlatforms(ctx);
+    assert.deepEqual(ctx.platforms, ['claude']);
+  } finally {
+    process.chdir(originalCwd);
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('addPlatformsPrompt placeholder consistency across all locales', () => {
+  const expectedPlaceholders = ['names'];
+  const placeholderRegex = /\{(\w+)\}/g;
+
+  for (const [locale, messages] of Object.entries(MESSAGES)) {
+    const template = messages.addPlatformsPrompt;
+    assert.ok(template, `Missing addPlatformsPrompt key in locale: ${locale}`);
+
+    const placeholders = [];
+    let match;
+    while ((match = placeholderRegex.exec(template)) !== null) {
+      placeholders.push(match[1]);
+    }
+
+    assert.deepEqual(
+      placeholders,
+      expectedPlaceholders,
+      `Locale ${locale} addPlatformsPrompt has incorrect placeholders. Template: "${template}". Expected: ${JSON.stringify(expectedPlaceholders)}, Got: ${JSON.stringify(placeholders)}`
+    );
+  }
+});
+
 test('same-version non-interactive install performs a selective refresh', async () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-codex-version-'));
   const originalCwd = process.cwd();
@@ -316,6 +431,64 @@ test('Codex dry-run leaves both managed roots untouched', () => {
   });
 });
 
+test('Codex Windows hook launchers stay project-bound without Git from nested cwd', () => {
+  inTempProject((root) => {
+    const projectRoot = path.join(root, 'project with spaces');
+    fs.mkdirSync(projectRoot, { recursive: true });
+    const installed = install(projectRoot);
+    assert.equal(installed.status, 0, `${installed.stdout}\n${installed.stderr}`);
+
+    const config = JSON.parse(
+      fs.readFileSync(path.join(projectRoot, '.codex', 'hooks.json'), 'utf8')
+    );
+    const handlers = allHookHandlers(config);
+    assert.equal(handlers.length, 14);
+    for (const handler of handlers) {
+      assert.doesNotMatch(handler.commandWindows, /\$\(/);
+      assert.doesNotMatch(handler.commandWindows, /\bgit\b/i);
+      assert.doesNotMatch(handler.commandWindows, /process\.cwd\(\)|existsSync/);
+      const encodedPath = handler.commandWindows.match(/\s([A-Za-z0-9_-]+)$/)?.[1];
+      assert.ok(encodedPath, `missing encoded hook path in: ${handler.commandWindows}`);
+      const target = Buffer.from(encodedPath, 'base64url').toString('utf8');
+      assert.equal(path.dirname(target), fs.realpathSync(path.join(projectRoot, '.codex', 'hooks')));
+      assert.equal(
+        fs.existsSync(target),
+        true,
+        `missing installed hook: ${path.basename(target)}`
+      );
+    }
+
+    const nested = path.join(projectRoot, 'nested', 'workspace');
+    fs.mkdirSync(nested, { recursive: true });
+    const shadowHooks = path.join(projectRoot, 'nested', '.codex', 'hooks');
+    const shadowMarker = path.join(root, 'shadow-hook-ran');
+    fs.mkdirSync(shadowHooks, { recursive: true });
+    fs.writeFileSync(
+      path.join(shadowHooks, 'session.cjs'),
+      `require('node:fs').writeFileSync(${JSON.stringify(shadowMarker)}, 'unsafe')\n`
+    );
+    const session = config.hooks.SessionStart[0].hooks[0];
+    const nodeCommand = session.commandWindows.replace(/^node /, `"${process.execPath}" `);
+    const noGitEnv = { ...process.env, PATH: '' };
+    const launched = spawnSync(nodeCommand, {
+      cwd: nested,
+      encoding: 'utf8',
+      input: JSON.stringify({
+        session_id: 'windows-launcher-test',
+        cwd: nested,
+        hook_event_name: 'SessionStart',
+        source: 'startup'
+      }),
+      env: noGitEnv,
+      shell: true
+    });
+    assert.equal(launched.status, 0, launched.stderr);
+    assert.match(launched.stdout, /Session startup\./);
+    assert.match(launched.stdout, /CafeKit project root:/);
+    assert.equal(fs.existsSync(shadowMarker), false);
+  });
+});
+
 test('Codex install is project-local, native, and upgrade-safe', () => {
   inTempProject((root) => {
     const userInstructions = '# User rules\n\nKeep this exact.\n';
@@ -456,3 +629,58 @@ test('Codex install is project-local, native, and upgrade-safe', () => {
     assert.doesNotMatch(fs.readFileSync(questionSkill, 'utf8'), /USER-CODEX-SENTINEL/);
   });
 });
+
+test('Codex install on top of existing Claude installation preserves content and adds Codex', () => {
+  inTempProject((root) => {
+    // Setup existing Claude installation with content
+    fs.mkdirSync(path.join(root, '.claude'), { recursive: true });
+    fs.writeFileSync(
+      path.join(root, '.claude', 'cafekit.json'),
+      `${JSON.stringify({ version: PACKAGE_VERSION, platform: 'claude' })}\n`
+    );
+
+    // Existing CLAUDE.md with content
+    const claudeMdContent = '# CLAUDE.md\n\n## User Instructions\n\nThis is my existing CLAUDE.md content.\n';
+    fs.writeFileSync(path.join(root, 'CLAUDE.md'), claudeMdContent);
+
+    // Existing AGENTS.md with content
+    const agentsMdContent = '# AGENTS.md\n\n## User Rules\n\nKeep this exact.\n';
+    fs.writeFileSync(path.join(root, 'AGENTS.md'), agentsMdContent);
+
+    // Run Codex install
+    const result = install(root, ['--platform', 'codex']);
+    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
+
+    // Assert .claude/ and its content still exist
+    assert.equal(fs.existsSync(path.join(root, '.claude')), true, '.claude should exist');
+    assert.equal(fs.existsSync(path.join(root, '.claude', 'cafekit.json')), true, '.claude/cafekit.json should exist');
+    const claudeMetadata = JSON.parse(fs.readFileSync(path.join(root, '.claude', 'cafekit.json'), 'utf8'));
+    assert.equal(claudeMetadata.platform, 'claude', '.claude/cafekit.json should still be claude platform');
+
+    // Assert .codex/ is created with payload
+    assert.equal(fs.existsSync(path.join(root, '.codex')), true, '.codex should be created');
+    assert.equal(fs.existsSync(path.join(root, '.codex', 'hooks.json')), true, '.codex/hooks.json should exist');
+    assert.equal(fs.existsSync(path.join(root, '.codex', 'runtime.json')), true, '.codex/runtime.json should exist');
+    assert.equal(fs.existsSync(path.join(root, '.codex', 'hooks', 'privacy-block.cjs')), true, '.codex/hooks/privacy-block.cjs should exist');
+    assert.equal(fs.existsSync(path.join(root, '.codex', 'rules', 'workflow.md')), true, '.codex/rules/workflow.md should exist');
+    assert.equal(fs.existsSync(path.join(root, '.codex', 'scripts', 'validate-spec-output.cjs')), true, '.codex/scripts/validate-spec-output.cjs should exist');
+    assert.equal(fs.existsSync(path.join(root, '.agents', '.gitignore')), true, '.agents/.gitignore should exist');
+    assert.equal(fs.existsSync(path.join(root, '.agents', 'skills', 'specs', 'SKILL.md')), true, '.agents/skills/specs/SKILL.md should exist');
+
+    // Assert .codex/cafekit.json has platform codex
+    const codexMetadata = JSON.parse(fs.readFileSync(path.join(root, '.codex', 'cafekit.json'), 'utf8'));
+    assert.equal(codexMetadata.platform, 'codex', '.codex/cafekit.json should have platform codex');
+    assert.equal(codexMetadata.version, PACKAGE_VERSION, '.codex/cafekit.json should have current version');
+
+    // Assert AGENTS.md root contains CODEX markers AND preserves original content
+    const agentsMd = fs.readFileSync(path.join(root, 'AGENTS.md'), 'utf8');
+    assert.match(agentsMd, /<!-- CAFEKIT CODEX START -->/, 'AGENTS.md should have CODEX START marker');
+    assert.match(agentsMd, /<!-- CAFEKIT CODEX END -->/, 'AGENTS.md should have CODEX END marker');
+    assert.match(agentsMd, /Keep this exact\./, 'AGENTS.md should preserve original user content');
+    assert.ok(agentsMd.startsWith(agentsMdContent), 'AGENTS.md should start with original user content');
+
+    // Assert CLAUDE.md is unchanged
+    const claudeMd = fs.readFileSync(path.join(root, 'CLAUDE.md'), 'utf8');
+    assert.equal(claudeMd, claudeMdContent, 'CLAUDE.md should be unchanged');
+  });
+});