@haposoft/cafekit 0.16.6 → 0.18.0

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

@@ -0,0 +1,221 @@
+'use strict';
+
+// The five spec.json-era hooks (completion authority, its check and state modules, the semantic
+// review authority and the scaffold guard) are gone from every runtime. Each case pins one way
+// they could survive: a fresh install, an upgrade on Claude (settings prune matches by substring,
+// so a user's own hook with the same file name must stay), an upgrade on Codex (whose tracker
+// keys are `.codex/…` and whose handlers come in three shapes), an upgrade on omp, an omp bridge
+// that still lists the removed gates, 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');
+const { spawnSync } = require('node:child_process');
+const { test } = require('node:test');
+
+const PACKAGE_ROOT = path.join(__dirname, '..', '..');
+const INSTALLER = path.join(PACKAGE_ROOT, 'bin/install.js');
+const SRC = path.join(PACKAGE_ROOT, 'src');
+const readJson = (file) => JSON.parse(fs.readFileSync(file, 'utf8'));
+const MANIFEST = readJson(path.join(SRC, 'claude/migration-manifest.json'));
+const SOURCE_SETTINGS = readJson(path.join(SRC, 'claude/settings/settings.json'));
+const SOURCE_BRIDGE_PATH = path.join(SRC, 'omp/extensions/cafekit-bridge.mjs');
+
+const NAMES = [
+  'completion-authority.cjs',
+  'completion-authority-check.cjs',
+  'completion-authority-state.cjs',
+  'semantic-review-authority.cjs',
+  'task-scaffold-guard.cjs',
+];
+const REGISTERED = ['completion-authority.cjs', 'semantic-review-authority.cjs', 'task-scaffold-guard.cjs'];
+const FOREIGN = REGISTERED.map((name) => `node ~/my-hooks/${name}`);
+
+function inTempProject(run) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-legacy-retired-'));
+  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, 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}`);
+}
+
+function commands(settings) {
+  return Object.values(settings.hooks || {})
+    .flat()
+    .flatMap((group) => (group.hooks || []).map((hook) => hook.command));
+}
+
+function mentionsName(text) {
+  return NAMES.filter((name) => text.includes(name));
+}
+
+test('fresh installs ship and register none of the five legacy hooks', () => {
+  inTempProject((root) => {
+    install(root, ['claude', 'codex', 'omp']);
+    for (const dir of ['.claude', '.codex', '.omp']) {
+      for (const name of NAMES) assert.equal(fs.existsSync(path.join(root, dir, 'hooks', name)), false, `${dir}/hooks/${name}`);
+    }
+    const claude = commands(readJson(path.join(root, '.claude', 'settings.json')));
+    const codex = commands(readJson(path.join(root, '.codex', 'hooks.json')));
+    for (const command of [...claude, ...codex]) assert.deepEqual(mentionsName(command), [], command);
+    const bridge = fs.readFileSync(path.join(root, '.omp', 'extensions', 'cafekit-bridge.mjs'), 'utf8');
+    assert.deepEqual(mentionsName(bridge), []);
+  });
+});
+
+test('claude upgrade removes the legacy hooks and their CafeKit entries but keeps foreign ones', () => {
+  inTempProject((root) => {
+    install(root, ['claude']);
+    const settingsPath = path.join(root, '.claude', 'settings.json');
+    const manifestPath = path.join(root, '.claude', 'cafekit-manifest.json');
+    const settings = readJson(settingsPath);
+    const kept = commands(settings);
+
+    const manifest = readJson(manifestPath);
+    for (const name of NAMES) {
+      fs.writeFileSync(path.join(root, '.claude', 'hooks', name), '// user edit\n');
+      manifest.files[`hooks/${name}`] = { sha256: '0'.repeat(64) };
+    }
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+    const cmd = (name) => `node "$CLAUDE_PROJECT_DIR/.claude/hooks/${name}"`;
+    settings.hooks.UserPromptSubmit[0].hooks.push(
+      { type: 'command', command: cmd('completion-authority.cjs') },
+      ...FOREIGN.map((command) => ({ type: 'command', command })),
+    );
+    settings.hooks.Stop[0].hooks.push({ type: 'command', command: cmd('completion-authority.cjs') });
+    settings.hooks.PreToolUse.push({ matcher: 'Write', hooks: [{ type: 'command', command: cmd('task-scaffold-guard.cjs') }] });
+    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 after = readJson(manifestPath);
+    for (const name of NAMES) assert.equal(Object.prototype.hasOwnProperty.call(after.files, `hooks/${name}`), false, `record ${name}`);
+    const afterCommands = commands(readJson(settingsPath));
+    for (const name of REGISTERED) {
+      assert.equal(afterCommands.some((command) => command.includes(`.claude/hooks/${name}`)), false, name);
+    }
+    for (const command of FOREIGN) assert.ok(afterCommands.includes(command), `foreign: ${command}`);
+    for (const command of kept) assert.ok(afterCommands.includes(command), `kept: ${command}`);
+  });
+});
+
+test('codex upgrade removes the legacy hooks, their records and their CafeKit entries but keeps foreign ones', () => {
+  inTempProject((root) => {
+    install(root, ['codex']);
+    const hooksPath = path.join(root, '.codex', 'hooks.json');
+    const manifestPath = path.join(root, '.codex', 'cafekit-manifest.json');
+    const config = readJson(hooksPath);
+    const kept = commands(config);
+
+    // A record whose file is already gone must leave the manifest too.
+    const manifest = readJson(manifestPath);
+    for (const name of NAMES) {
+      if (name !== 'completion-authority-state.cjs') fs.writeFileSync(path.join(root, '.codex', 'hooks', name), '// user edit\n');
+      manifest.files[`.codex/hooks/${name}`] = { sha256: '0'.repeat(64) };
+    }
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+    const posix = kept.find((command) => command.includes('spec-gate.cjs'));
+    assert.ok(posix, 'the installed spec-gate launcher is the template for the POSIX form');
+    const add = (event, command) => config.hooks[event].push({ matcher: '*', hooks: [{ type: 'command', command }] });
+    add('Stop', posix.split('spec-gate.cjs').join('completion-authority.cjs'));
+    add('PreToolUse', 'node ".codex/hooks/task-scaffold-guard.cjs"');
+    add('SubagentStop', "node 'C:\\work\\proj\\.codex\\hooks\\semantic-review-authority.cjs'");
+    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 after = readJson(manifestPath);
+    for (const name of NAMES) assert.equal(Object.prototype.hasOwnProperty.call(after.files, `.codex/hooks/${name}`), false, `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);
+    }
+    assert.ok(afterCommands.includes(FOREIGN[0]), 'a foreign hook with a legacy name survives');
+    for (const command of kept) assert.ok(afterCommands.includes(command), `kept: ${command}`);
+  });
+});
+
+test('omp upgrade removes the legacy hooks and their records', () => {
+  inTempProject((root) => {
+    install(root, ['omp']);
+    const manifestPath = path.join(root, '.omp', 'cafekit-manifest.json');
+    const manifest = readJson(manifestPath);
+    // omp records keys relative to the project root (recordRoot '.').
+    for (const name of NAMES) {
+      fs.writeFileSync(path.join(root, '.omp', 'hooks', name), '// shipped by an older CafeKit\n');
+      manifest.files[`.omp/hooks/${name}`] = { sha256: '0'.repeat(64) };
+    }
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+    install(root, ['omp']);
+    const after = readJson(manifestPath);
+    for (const name of NAMES) {
+      assert.equal(fs.existsSync(path.join(root, '.omp', 'hooks', name)), false, name);
+      assert.equal(Object.prototype.hasOwnProperty.call(after.files, `.omp/hooks/${name}`), false, `record ${name}`);
+    }
+  });
+});
+
+test('omp upgrade replaces a pristine old bridge that still lists the removed gates', () => {
+  inTempProject((root) => {
+    install(root, ['omp']);
+    const bridgePath = path.join(root, '.omp', 'extensions', 'cafekit-bridge.mjs');
+    const manifestPath = path.join(root, '.omp', 'cafekit-manifest.json');
+    const old = fs.readFileSync(SOURCE_BRIDGE_PATH, 'utf8')
+      .replace("'inspect-block.cjs']", "'inspect-block.cjs', 'task-scaffold-guard.cjs']")
+      .replace("'rules.cjs', 'spec-state.cjs'", "'rules.cjs', 'completion-authority.cjs', 'spec-state.cjs'")
+      .replace("'spec-gate.cjs', 'state.cjs'", "'spec-gate.cjs', 'completion-authority.cjs', 'state.cjs'");
+    assert.deepEqual(mentionsName(old).sort(), ['completion-authority.cjs', 'task-scaffold-guard.cjs'], 'the fixture lists the removed gates');
+    fs.writeFileSync(bridgePath, old);
+    const manifest = readJson(manifestPath);
+    manifest.files['.omp/extensions/cafekit-bridge.mjs'] = { sha256: crypto.createHash('sha256').update(old).digest('hex') };
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+    install(root, ['omp']);
+    const installed = fs.readFileSync(bridgePath, 'utf8');
+    assert.deepEqual(mentionsName(installed), []);
+    assert.equal(installed, fs.readFileSync(SOURCE_BRIDGE_PATH, 'utf8'));
+  });
+});
+
+test('no source ships, registers or bridges the five legacy hooks', () => {
+  for (const name of NAMES) {
+    assert.equal(fs.existsSync(path.join(SRC, 'claude/hooks', name)), false, `claude ${name}`);
+    assert.equal(fs.existsSync(path.join(SRC, 'codex/hooks', name)), false, `codex ${name}`);
+  }
+  for (const test of ['completion-authority.test.js', 'semantic-review-authority.test.js']) {
+    assert.equal(fs.existsSync(path.join(SRC, 'claude/hooks/__tests__', test)), false, test);
+  }
+  const runtimeFiles = MANIFEST.runtime.files.join('\n');
+  assert.deepEqual(mentionsName(runtimeFiles), []);
+  assert.deepEqual(mentionsName(JSON.stringify(SOURCE_SETTINGS)), []);
+  assert.deepEqual(mentionsName(fs.readFileSync(path.join(SRC, 'codex/hooks.json'), 'utf8')), []);
+  assert.deepEqual(mentionsName(fs.readFileSync(SOURCE_BRIDGE_PATH, 'utf8')), []);
+  for (const name of NAMES) assert.ok(MANIFEST.obsolete.runtimeFiles.includes(`hooks/${name}`), name);
+  const substrings = MANIFEST.obsolete.settingsHookCommandSubstrings;
+  assert.equal(substrings[0], 'hooks/skill-router.cjs');
+  for (const name of REGISTERED) {
+    for (const entry of [`.claude/hooks/${name}`, `.codex/hooks/${name}`, `.codex\\hooks\\${name}`]) {
+      assert.ok(substrings.includes(entry), entry);
+    }
+  }
+  // The installer's merge drops an empty group, so only the source can show one.
+  for (const [event, groups] of Object.entries(SOURCE_SETTINGS.hooks)) {
+    for (const group of groups) assert.ok(group.hooks.length > 0, `${event} ${group.matcher} has no hooks`);
+  }
+});

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

@@ -17,7 +17,6 @@ const PACKAGE_ROOT = path.join(__dirname, '../..');
 const BRIDGE = path.join(PACKAGE_ROOT, 'src/omp/extensions/cafekit-bridge.mjs');
 const SETTINGS = require(path.join(PACKAGE_ROOT, 'src/claude/settings/settings.json'));
 const MANIFEST = require(path.join(PACKAGE_ROOT, 'src/claude/migration-manifest.json'));
-const { PREFIX } = require(path.join(PACKAGE_ROOT, 'src/claude/hooks/completion-authority-state.cjs'));
 
 /**
  * The hooks an omp install runs: the Claude set the manifest ships, then `src/omp/hooks/`
@@ -50,6 +49,11 @@ 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'] };
+
 test('the dispatch table mirrors settings.json for every event omp can deliver', () => {
   const { DISPATCH } = bridge;
   const pairs = [
@@ -58,8 +62,18 @@ test('the dispatch table mirrors settings.json for every event omp can deliver',
     ['tool_result', 'PostToolUse'], ['session_stop', 'Stop'],
   ];
   for (const [omp, claude] of pairs) {
-    assert.deepEqual([...DISPATCH[omp].hooks].sort(), [...new Set(registered(claude))].sort(),
-      `${omp} must dispatch exactly the hooks settings.json registers for ${claude}`);
+    const claudeOnly = CLAUDE_ONLY[claude] || [];
+    const ompOnly = OMP_ONLY[claude] || [];
+    const claudeHooks = [...new Set(registered(claude))];
+    for (const hook of claudeOnly) {
+      assert.ok(claudeHooks.includes(hook) && !DISPATCH[omp].hooks.includes(hook), `${hook} is no longer Claude-only for ${claude}; drop it from CLAUDE_ONLY`);
+    }
+    for (const hook of ompOnly) {
+      assert.ok(!claudeHooks.includes(hook) && DISPATCH[omp].hooks.includes(hook), `${hook} is no longer omp-only for ${claude}; drop it from OMP_ONLY`);
+    }
+    const expected = [...claudeHooks.filter((hook) => !claudeOnly.includes(hook)), ...ompOnly].sort();
+    assert.deepEqual([...DISPATCH[omp].hooks].sort(), expected,
+      `${omp} must dispatch the hooks settings.json registers for ${claude}, minus CLAUDE_ONLY, plus OMP_ONLY`);
   }
   // omp has no subagent events; the gap is deliberate and documented, not forgotten.
   assert.ok(!Object.values(DISPATCH).some((e) => e.event.startsWith('Subagent')));
@@ -83,7 +97,7 @@ test('each denial mechanism becomes an omp block carrying the hook reason', () =
   assert.deepEqual([stop.block, stop.reason], [true, 'R1']);
   const deny = interpretVerdict({ code: 0, stdout: JSON.stringify({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: 'R2' } }) }, 'privacy-block.cjs');
   assert.deepEqual([deny.block, deny.reason], [true, 'R2']);
-  // inspect-block / task-scaffold-guard exit 2 and write the reason on STDOUT, not stderr.
+  // inspect-block exits 2 and writes the reason on STDOUT, not stderr.
   const exit2 = interpretVerdict({ code: 2, stdout: 'SCOPE LIMIT EXCEEDED\nRestricted zones: node_modules', stderr: '' }, 'inspect-block.cjs');
   assert.equal(exit2.block, true);
   assert.match(exit2.reason, /SCOPE LIMIT EXCEEDED/, 'a stderr-only reader would drop this reason');
@@ -127,10 +141,10 @@ test('a slow hook blocks with its own name before omp cuts it off', async () =>
 test('a crashing or missing gate blocks on gating events instead of silently allowing', async () => {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-omp-crash-'));
   try {
-    // Only the crashing gate is under test; the other two PreToolUse gates get allow stubs,
+    // Only the crashing gate is under test; the other PreToolUse gate gets an allow stub,
     // otherwise their absence is what blocks (see the missing-gate case below).
     fs.writeFileSync(path.join(dir, 'privacy-block.cjs'), 'throw new Error("boom");');
-    for (const stub of ['inspect-block.cjs', 'task-scaffold-guard.cjs']) fs.writeFileSync(path.join(dir, stub), 'process.exit(0);');
+    fs.writeFileSync(path.join(dir, 'inspect-block.cjs'), 'process.exit(0);');
     const crash = await bridge.runEvent('tool_call', { toolName: 'bash', input: { command: 'ls' } }, { cwd: dir }, { dir });
     // A bare exit 1 with no verdict is an allow under the hooks' own contract. Real gates
     // never surface a crash this way: the fork's privacy-block catch-all converts its own
@@ -147,17 +161,6 @@ test('stop_hook_active short-circuits the gate so a blocked turn cannot loop for
   assert.deepEqual([r.block, r.skipped], [false, 'stop_hook_active']);
 });
 
-test('the approval phrase reaches completion-authority through the input event', async () => {
-  const { DISPATCH, shapePayload } = bridge;
-  assert.ok(DISPATCH.input.hooks.includes('completion-authority.cjs'),
-    'the --approve path only runs on UserPromptSubmit; without this routing a blocked turn has no exit');
-  const phrase = `${PREFIX}${'a'.repeat(24)}`;
-  const p = shapePayload('input', { text: phrase, source: 'user' }, { cwd: '/tmp/p' });
-  assert.equal(p.hook_event_name, 'UserPromptSubmit', 'completion-authority selects --approve from this field');
-  assert.equal(p.prompt, phrase, 'the phrase must arrive byte-exact; the hook compares it exactly');
-  assert.ok(p.session_id, 'approve() returns early without a session id');
-});
-
 test('input injections flow back as a transform that keeps the user text intact', async () => {
   const root = tempProject(false);
   try {

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

@@ -117,25 +117,6 @@ test('an unevaluable access denies rather than allows', () => {
   }
 });
 
-test('a write to a scaffolded task path is guarded under omp lowercase names too', () => {
-  // The guard is no longer an overlay file, so this is a behaviour case on the tree an
-  // install produces: omp sends `write`, and the shared reader has to make it reach the
-  // rule that was authored against Claude's `Write`.
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cafekit-omp-guard-'));
-  try {
-    const target = path.join(root, 'specs', 'demo', 'tasks', 'task-R0-01-x.md');
-    fs.mkdirSync(path.dirname(target), { recursive: true });
-    fs.cpSync(path.join(PACKAGE_ROOT, 'src/claude/scripts'), path.join(INSTALLED_ROOT, '.omp', 'scripts'),
-      { recursive: true, force: true });
-    const r = verdict(path.join(INSTALLED, 'task-scaffold-guard.cjs'),
-      { tool_name: 'write', tool_input: { file_path: target }, cwd: root });
-    assert.equal(r.code, 2, "omp sends `write`; an exact 'Write' comparison would skip the guard entirely");
-    assert.equal(r.decision, 'deny');
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});
-
 /** Every file under a directory, relative and sorted. */
 function walk(dir, prefix = '') {
   return fs.readdirSync(dir).flatMap((name) => {

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

@@ -50,7 +50,7 @@ function silentUi() {
 
 test('manifest separates core, optional documents, and retired skills', () => {
   const manifest = loadClaudeMigrationManifest();
-  assert.equal(manifest.skills.required.includes('route'), true);
+  assert.equal(manifest.skills.required.includes('route'), false);
   assert.deepEqual(manifest.skills.bundles.documentSkills, [
     'ai-multimodal', 'docs', 'docx', 'pdf', 'pptx', 'xlsx'
   ]);
@@ -59,7 +59,8 @@ test('manifest separates core, optional documents, and retired skills', () => {
   }
   assert.deepEqual(manifest.obsolete.skills, [
     'backend-development', 'frontend-development', 'frontend-design',
-    'mobile-development', 'devops', 'react-best-practices'
+    'mobile-development', 'devops', 'react-best-practices',
+    'inspect', 'hotfix', 'question', 'loop', 'route', 'delegate'
   ]);
 });
 
@@ -167,7 +168,7 @@ test('fresh combined install defaults optional bundle OFF', () => {
     for (const platformKey of ['claude', 'codex']) {
       const platform = PLATFORMS[platformKey];
       assert.equal(fs.existsSync(path.join(platform.skillsDir, 'docs')), false);
-      assert.equal(fs.existsSync(path.join(platform.skillsDir, 'route', 'SKILL.md')), true);
+      assert.equal(fs.existsSync(path.join(platform.skillsDir, 'route', 'SKILL.md')), false);
       const metadata = JSON.parse(fs.readFileSync(path.join(platform.folder, 'cafekit.json'), 'utf8'));
       assert.equal(metadata.schemaVersion, 2);
       assert.equal(metadata.documentSkills.enabled, false);
@@ -193,7 +194,7 @@ test('explicit opt-in installs all six optional skills on both runtimes', () =>
       ], { cwd: root, encoding: 'utf8' });
       assert.equal(catalog.status, 0, catalog.stderr);
       const catalogData = JSON.parse(catalog.stdout);
-      assert.equal(catalogData.skills.some((skill) => skill.public_id === 'cf:route'), true);
+      assert.equal(catalogData.skills.some((skill) => skill.public_id === 'cf:route'), false);
       assert.equal(catalogData.skills.some((skill) => skill.public_id === 'cf:docs'), true);
       const metadata = JSON.parse(fs.readFileSync(path.join(platform.folder, 'cafekit.json'), 'utf8'));
       assert.deepEqual(metadata.documentSkills, {
@@ -247,3 +248,110 @@ test('modified retired skill is preserved but excluded from automatic routing',
       item.directory === 'backend-development' && item.code === 'retired_skill'));
   });
 });
+
+for (const platformKey of ['claude', 'codex']) {
+  test(`${platformKey} upgrade retires the inspect, hotfix and question directories`, () => {
+    withTempProject((root) => {
+      const platform = PLATFORMS[platformKey];
+      const recordRoot = platform.ownership?.recordRoot || platform.folder;
+      const key = (file) => path.relative(recordRoot, file).replace(/\\/g, '/');
+      const ownership = { schemaVersion: 1, version: 'old', files: {} };
+      for (const old of ['inspect', 'hotfix', 'question']) {
+        const file = path.join(platform.skillsDir, old, 'SKILL.md');
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, `pristine ${old}\n`);
+        ownership.files[key(file)] = { sha256: manifestLib.hashFile(file), version: 'old' };
+      }
+      const ctx = {
+        manifest: loadClaudeMigrationManifest(),
+        documentSkills: { [platformKey]: { enabled: true, selectionSource: 'cli-opt-in' } },
+        ownership: { [platform.folder]: ownership },
+        trackers: { [platformKey]: manifestLib.createTracker(platform.folder, 'next', platform.ownership) },
+        dryRun: false,
+        ui: silentUi(),
+        results: { updated: 0, preserved: 0, preservedFiles: [] }
+      };
+      reconcileSkillInventory(ctx, platformKey);
+      for (const old of ['inspect', 'hotfix', 'question']) {
+        assert.equal(fs.existsSync(path.join(root, platform.skillsDir, old)), false, old);
+      }
+      assert.equal(ctx.results.updated, 3);
+
+      // A user-modified retired copy survives with a warning, and the catalog serves cf:fix from fix/
+      // while marking the old directory retired rather than reporting a folder mismatch.
+      const edited = path.join(root, platform.skillsDir, 'hotfix', 'SKILL.md');
+      fs.mkdirSync(path.dirname(edited), { recursive: true });
+      fs.writeFileSync(edited, [
+        '---', `name: ${platformKey === 'codex' ? 'cf-fix' : 'cf:fix'}`,
+        'description: "User-modified retired copy."', '---', '# Preserved', '',
+      ].join('\n'));
+      const result = spawnSync(process.execPath, [
+        installerPath, '--platform', platformKey, '--yes'
+      ], { cwd: root, encoding: 'utf8' });
+      assert.equal(result.status, 0, result.stderr || result.stdout);
+      assert.equal(fs.existsSync(edited), true);
+      assert.match(`${result.stdout}\n${result.stderr}`, /Preserved user-owned skill: .*hotfix/);
+      for (const renamed of ['scout', 'fix', 'ask']) {
+        assert.equal(fs.existsSync(path.join(root, platform.skillsDir, renamed, 'SKILL.md')), true, renamed);
+      }
+      const scriptRoot = platformKey === 'codex' ? '.codex' : '.claude';
+      const catalog = spawnSync(process.execPath, [
+        path.join(root, scriptRoot, 'scripts', 'generate-skill-catalog.cjs'), '--json'
+      ], { cwd: root, encoding: 'utf8' });
+      assert.equal(catalog.status, 0, catalog.stderr);
+      const parsed = JSON.parse(catalog.stdout);
+      for (const id of ['cf:scout', 'cf:fix', 'cf:ask']) {
+        assert.ok(parsed.skills.some((skill) => skill.public_id === id), id);
+      }
+      assert.equal(parsed.skills.find((skill) => skill.public_id === 'cf:fix').directory, 'fix');
+      assert.ok(parsed.diagnostics.some((item) => item.directory === 'hotfix' && item.code === 'retired_skill'));
+      assert.equal(parsed.diagnostics.some((item) => item.code === 'duplicate_public_name'), false);
+    });
+  });
+}
+
+for (const platformKey of ['claude', 'codex']) {
+  test(`${platformKey} upgrade retires the removed loop, route and delegate directories`, () => {
+    withTempProject((root) => {
+      const platform = PLATFORMS[platformKey];
+      const recordRoot = platform.ownership?.recordRoot || platform.folder;
+      const key = (file) => path.relative(recordRoot, file).replace(/\\/g, '/');
+      const ownership = { schemaVersion: 1, version: 'old', files: {} };
+      const removed = ['loop', 'route', 'delegate'];
+      for (const old of removed) {
+        const file = path.join(platform.skillsDir, old, 'SKILL.md');
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, `pristine ${old}\n`);
+        ownership.files[key(file)] = { sha256: manifestLib.hashFile(file), version: 'old' };
+      }
+      // A user-edited copy has no matching ownership hash, so it must survive the upgrade.
+      const edited = path.join(platform.skillsDir, 'route', 'references', 'my-notes.md');
+      fs.mkdirSync(path.dirname(edited), { recursive: true });
+      fs.writeFileSync(edited, 'user notes\n');
+      const ctx = {
+        manifest: loadClaudeMigrationManifest(),
+        documentSkills: { [platformKey]: { enabled: true, selectionSource: 'cli-opt-in' } },
+        ownership: { [platform.folder]: ownership },
+        trackers: { [platformKey]: manifestLib.createTracker(platform.folder, 'next', platform.ownership) },
+        dryRun: false,
+        ui: silentUi(),
+        results: { updated: 0, preserved: 0, preservedFiles: [] }
+      };
+      reconcileSkillInventory(ctx, platformKey);
+      assert.equal(fs.existsSync(path.join(root, platform.skillsDir, 'loop')), false, 'loop');
+      assert.equal(fs.existsSync(path.join(root, platform.skillsDir, 'delegate')), false, 'delegate');
+      assert.equal(fs.existsSync(path.join(root, edited)), true, 'user-edited route copy is preserved');
+      assert.equal(ctx.results.updated, 2);
+      assert.equal(ctx.results.preserved, 1);
+    });
+  });
+}
+
+test('the catalog retires exactly the directories the manifest retires', () => {
+  const source = fs.readFileSync(
+    path.resolve(__dirname, '..', '..', 'src', 'claude', 'scripts', 'generate-skill-catalog.cjs'), 'utf8');
+  const block = source.match(/const RETIRED_DIRECTORIES = new Set\(\[([\s\S]*?)\]\);/);
+  assert.ok(block, 'RETIRED_DIRECTORIES not found');
+  const retired = [...block[1].matchAll(/'([^']+)'/g)].map((match) => match[1]);
+  assert.deepEqual([...retired].sort(), [...loadClaudeMigrationManifest().obsolete.skills].sort());
+});

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

@@ -145,8 +145,6 @@ function composeCodexHookTree(root) {
   const hooksDir = path.join(root, '.codex', 'hooks');
   fs.mkdirSync(path.join(hooksDir, 'lib'), { recursive: true });
   fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/codex/hooks/session.cjs'), path.join(hooksDir, 'session.cjs'));
-  fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/codex/hooks/completion-authority-state.cjs'),
-    path.join(hooksDir, 'completion-authority-state.cjs'));
   fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/codex/hooks/lib/hook-context.cjs'),
     path.join(hooksDir, 'lib', 'hook-context.cjs'));
   fs.copyFileSync(path.join(PACKAGE_ROOT, 'src/codex/hooks/lib/privacy-state.cjs'),