throughline 0.3.24 → 0.4.0

package/src/cli/help.test.mjs

@@ -0,0 +1,64 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const REPO_ROOT = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+const BIN_PATH = join(REPO_ROOT, 'bin/throughline.mjs');
+const CODEX_HELP_COMMANDS = [
+  'throughline codex-capture',
+  'throughline codex-hook stop',
+  'throughline codex-summarize',
+  'throughline codex-resume',
+  'throughline codex-handoff-smoke',
+  'throughline codex-handoff-model-smoke',
+  'throughline codex-handoff-start',
+  'throughline codex-visibility-smoke',
+  'throughline codex-rollback-model-visible-smoke',
+  'throughline codex-restore-smoke',
+  'throughline codex-restore-source-audit',
+  'throughline codex-host-primitive-audit',
+  'throughline codex-vscode-restore-smoke',
+  'throughline codex-vscode-rollback-smoke',
+  'throughline codex-threads',
+  'throughline codex-sidecar-diagnostics',
+  'throughline codex-sidecar-dry-run',
+];
+
+function runThroughline(args = []) {
+  return spawnSync(process.execPath, [BIN_PATH, ...args], {
+    cwd: REPO_ROOT,
+    encoding: 'utf8',
+  });
+}
+
+function dispatchCommand(command) {
+  return command.replace(/^throughline\s+/, '').split(/\s+/)[0];
+}
+
+test('CLI help exposes guided Codex handoff and guarded execute semantics', () => {
+  const result = runThroughline(['--help']);
+
+  assert.equal(result.status, 0, result.stderr);
+  for (const command of CODEX_HELP_COMMANDS) {
+    assert.match(result.stdout, new RegExp(command.replaceAll('-', '\\-')));
+  }
+  assert.match(result.stdout, /Guided read-only fresh-thread handoff start plan/);
+  assert.match(result.stdout, /throughline trim --execute/);
+  assert.match(result.stdout, /injectable DB memory/);
+  assert.match(result.stdout, /matching/);
+  assert.match(result.stdout, /rollout\/app-server turns/);
+  assert.match(result.stdout, /--inspect-risky-rollout/);
+  assert.match(result.stdout, /risk-evidence inspection/);
+});
+
+test('CLI help Codex commands are dispatchable', () => {
+  const bin = readFileSync(BIN_PATH, 'utf8');
+
+  for (const command of CODEX_HELP_COMMANDS) {
+    const subcommand = dispatchCommand(command);
+    assert.match(bin, new RegExp(`case '${subcommand}':`), `${command} is missing dispatch`);
+  }
+});

package/src/cli/install.mjs

@@ -6,11 +6,12 @@
  * --project : .claude/settings.json（プロジェクトローカル）
  * --uninstall: hook を削除
  *
- * 登録コマンドは PATH 解決型 (throughline <subcommand>) を使う。
- * node のインストール先や OS が変わっても PATH さえ通れば動く。
+ * Claude-facing hook は従来通り PATH 解決型 (throughline <subcommand>) を使う。
+ * Codex-facing hook は VSCode App Server の PATH 差分を避けるため、絶対 node + CLI
+ * script path で登録する。
  */
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, copyFileSync, unlinkSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, copyFileSync, unlinkSync, rmSync } from 'node:fs';
 import { join, dirname, resolve, delimiter } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
@@ -18,6 +19,10 @@ import { homedir } from 'node:os';
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
 const SLASH_COMMANDS_SRC = join(PACKAGE_ROOT, '.claude', 'commands');
 const SC_SLASH_COMMAND_FILES = ['tl.md', 'sc-detail.md'];
+const CODEX_SKILLS_SRC = join(PACKAGE_ROOT, 'codex', 'skills');
+const CODEX_SKILL_NAMES = ['throughline'];
+const CODEX_HOOKS_RELATIVE_PATH = ['.codex', 'hooks.json'];
+const CODEX_CONFIG_RELATIVE_PATH = ['.codex', 'config.toml'];
 
 // Throughline が管理する hook コマンド一覧
 // schema v4 以降: PostToolUse (capture-tool) は廃止。Stop 内で L2/L3 を一括処理する。
@@ -46,6 +51,47 @@ const SC_HOOKS = {
   },
 };
 
+const CODEX_COMMANDS = [
+  'throughline codex-hook stop',
+];
+
+function quoteCommandPath(p) {
+  return /\s/.test(p) ? `"${p.replace(/"/g, '\\"')}"` : p;
+}
+
+export function buildCodexStopHookCommand({
+  nodePath = process.execPath,
+  cliScriptPath = join(PACKAGE_ROOT, 'bin', 'throughline.mjs'),
+} = {}) {
+  return `${quoteCommandPath(nodePath)} ${quoteCommandPath(cliScriptPath)} codex-hook stop`;
+}
+
+export function isThroughlineCodexStopCommand(command) {
+  if (typeof command !== 'string') return false;
+  const normalized = command.replace(/["']/g, '');
+  return (
+    normalized === 'throughline codex-hook stop' ||
+    normalized.includes('throughline codex-hook stop') ||
+    normalized.includes('throughline.mjs codex-hook stop')
+  );
+}
+
+function createCodexHooks() {
+  return {
+    Stop: {
+      hooks: [
+        {
+          type: 'command',
+          command: buildCodexStopHookCommand(),
+          timeoutSec: 300,
+          async: false,
+          statusMessage: null,
+        },
+      ],
+    },
+  };
+}
+
 function resolveSettingsPath(args) {
   if (args.includes('--project')) {
     return join(process.cwd(), '.claude', 'settings.json');
@@ -60,6 +106,18 @@ function resolveCommandsDir(args) {
   return join(homedir(), '.claude', 'commands');
 }
 
+function resolveCodexHooksPath() {
+  return join(homedir(), ...CODEX_HOOKS_RELATIVE_PATH);
+}
+
+function resolveCodexConfigPath() {
+  return join(homedir(), ...CODEX_CONFIG_RELATIVE_PATH);
+}
+
+function resolveCodexSkillsDir() {
+  return join(homedir(), '.codex', 'skills');
+}
+
 function installSlashCommands(commandsDir) {
   if (!existsSync(SLASH_COMMANDS_SRC)) {
     return { installed: [], skipped: 'source-missing' };
@@ -89,6 +147,48 @@ function uninstallSlashCommands(commandsDir) {
   return removed;
 }
 
+function copyDirectory(srcDir, destDir) {
+  mkdirSync(destDir, { recursive: true });
+  for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
+    const src = join(srcDir, entry.name);
+    const dest = join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectory(src, dest);
+    } else if (entry.isFile()) {
+      copyFileSync(src, dest);
+    }
+  }
+}
+
+function installCodexSkills(skillsDir) {
+  if (!existsSync(CODEX_SKILLS_SRC)) {
+    return { installed: [], skipped: 'source-missing' };
+  }
+  mkdirSync(skillsDir, { recursive: true });
+  const installed = [];
+  for (const name of CODEX_SKILL_NAMES) {
+    const src = join(CODEX_SKILLS_SRC, name);
+    if (!existsSync(src)) continue;
+    const dest = join(skillsDir, name);
+    rmSync(dest, { recursive: true, force: true });
+    copyDirectory(src, dest);
+    installed.push(name);
+  }
+  return { installed, skipped: null };
+}
+
+function uninstallCodexSkills(skillsDir) {
+  const removed = [];
+  for (const name of CODEX_SKILL_NAMES) {
+    const dest = join(skillsDir, name);
+    if (existsSync(dest)) {
+      rmSync(dest, { recursive: true, force: true });
+      removed.push(name);
+    }
+  }
+  return removed;
+}
+
 /**
  * PATH 上で 'throughline' (Windows なら .cmd / .ps1 / .exe) が解決できるかを確認する。
  *
@@ -148,10 +248,105 @@ function writeSettings(settingsPath, obj) {
   writeFileSync(settingsPath, JSON.stringify(obj, null, 2) + '\n');
 }
 
+function ensureCodexHooksFeature(configPath) {
+  const existing = existsSync(configPath) ? readFileSync(configPath, 'utf8') : '';
+  const lines = existing.split(/\r?\n/);
+  const sectionStart = lines.findIndex((line) => line.trim() === '[features]');
+  let updated;
+
+  if (sectionStart === -1) {
+    const prefix = existing.trimEnd();
+    updated = `${prefix}${prefix ? '\n\n' : ''}[features]\ncodex_hooks = true\n`;
+  } else {
+    let sectionEnd = lines.length;
+    for (let i = sectionStart + 1; i < lines.length; i++) {
+      if (/^\s*\[[^\]]+\]\s*$/.test(lines[i])) {
+        sectionEnd = i;
+        break;
+      }
+    }
+
+    const codexHooksLine = lines
+      .slice(sectionStart + 1, sectionEnd)
+      .findIndex((line) => /^\s*codex_hooks\s*=/.test(line));
+    if (codexHooksLine === -1) {
+      lines.splice(sectionStart + 1, 0, 'codex_hooks = true');
+    } else {
+      lines[sectionStart + 1 + codexHooksLine] = 'codex_hooks = true';
+    }
+    updated = lines.join('\n').replace(/\n*$/, '\n');
+  }
+
+  const dir = dirname(configPath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(configPath, updated);
+}
+
+function installCodexHooks() {
+  const hooksPath = resolveCodexHooksPath();
+  const configPath = resolveCodexConfigPath();
+  const current = readSettings(hooksPath);
+  const existingHooks = current.hooks ?? {};
+  const codexHooks = createCodexHooks();
+
+  for (const [key, entry] of Object.entries(codexHooks)) {
+    const list = existingHooks[key] ?? [];
+    const preserved = [];
+    for (const group of list) {
+      const hooks = (group.hooks ?? []).filter(h => !isThroughlineCodexStopCommand(h.command));
+      if (hooks.length > 0) preserved.push({ ...group, hooks });
+    }
+    existingHooks[key] = [entry, ...preserved];
+  }
+
+  current.hooks = existingHooks;
+  writeSettings(hooksPath, current);
+  ensureCodexHooksFeature(configPath);
+
+  return { hooksPath, configPath };
+}
+
+function uninstallCodexHooks() {
+  const hooksPath = resolveCodexHooksPath();
+  if (!existsSync(hooksPath)) {
+    return { hooksPath, removed: 0 };
+  }
+
+  const current = readSettings(hooksPath);
+  const existingHooks = current.hooks ?? {};
+  let removed = 0;
+
+  for (const [key, groups] of Object.entries(existingHooks)) {
+    existingHooks[key] = groups
+      .map((group) => {
+        const hooks = (group.hooks ?? []).filter((hook) => {
+          const shouldRemove =
+            CODEX_COMMANDS.includes(hook.command) ||
+            isThroughlineCodexStopCommand(hook.command);
+          if (shouldRemove) removed++;
+          return !shouldRemove;
+        });
+        return { ...group, hooks };
+      })
+      .filter((group) => group.hooks.length > 0);
+    if (existingHooks[key].length === 0) delete existingHooks[key];
+  }
+
+  if (Object.keys(existingHooks).length === 0) {
+    delete current.hooks;
+  } else {
+    current.hooks = existingHooks;
+  }
+
+  writeSettings(hooksPath, current);
+  return { hooksPath, removed };
+}
+
 export async function run(args = []) {
   const uninstall = args.includes('--uninstall');
   const settingsPath = resolveSettingsPath(args);
   const commandsDir = resolveCommandsDir(args);
+  const codexSkillsDir = resolveCodexSkillsDir();
   const current = readSettings(settingsPath);
   const existingHooks = current.hooks ?? {};
   const scSet = new Set(SC_COMMANDS);
@@ -172,11 +367,19 @@ export async function run(args = []) {
 
     writeSettings(settingsPath, current);
     const removedCommands = uninstallSlashCommands(commandsDir);
+    const codex = args.includes('--project') ? null : uninstallCodexHooks();
+    const removedCodexSkills = args.includes('--project') ? [] : uninstallCodexSkills(codexSkillsDir);
     console.log('Throughline hooks を削除しました。');
     console.log(`  ${settingsPath}`);
     if (removedCommands.length > 0) {
       console.log(`  slash commands 削除: ${removedCommands.join(', ')} (${commandsDir})`);
     }
+    if (codex?.removed > 0) {
+      console.log(`  Codex hooks 削除: ${codex.removed} (${codex.hooksPath})`);
+    }
+    if (removedCodexSkills.length > 0) {
+      console.log(`  Codex skills 削除: ${removedCodexSkills.join(', ')} (${codexSkillsDir})`);
+    }
     return;
   }
 
@@ -195,15 +398,27 @@ export async function run(args = []) {
   current.hooks = existingHooks;
   writeSettings(settingsPath, current);
   const { installed: installedCommands, skipped } = installSlashCommands(commandsDir);
+  const codex = args.includes('--project') ? null : installCodexHooks();
+  const codexSkills = args.includes('--project') ? { installed: [], skipped: null } : installCodexSkills(codexSkillsDir);
 
   const scope = args.includes('--project') ? 'プロジェクトローカル' : 'グローバル（全プロジェクト）';
   console.log(`Throughline hooks をインストールしました [${scope}]`);
   console.log(`  ${settingsPath}`);
+  if (codex) {
+    console.log(`  ${codex.hooksPath}`);
+    console.log(`  ${codex.configPath}`);
+    if (codexSkills.installed.length > 0) {
+      console.log(`  ${codexSkillsDir}`);
+    }
+  }
   console.log('');
   console.log('有効な hooks:');
   console.log('  SessionStart     → throughline session-start  (セッション記録・バトン消費・引き継ぎ注入)');
   console.log('  Stop             → throughline process-turn   (L1 要約 + L2 本文保存 + L3 詳細保存)');
   console.log('  UserPromptSubmit → throughline prompt-submit  (/tl バトン書き込み)');
+  if (codex) {
+    console.log(`  Codex Stop       → ${buildCodexStopHookCommand()} (Codex rollout capture + L1 要約)`);
+  }
   console.log('');
   if (installedCommands.length > 0) {
     console.log(`slash commands を配置しました: ${installedCommands.map(n => '/' + n.replace(/\.md$/, '')).join(', ')}`);
@@ -213,6 +428,14 @@ export async function run(args = []) {
     console.log('注意: パッケージ内に slash commands のソースが見つからないためスキップしました。');
     console.log('');
   }
+  if (codexSkills.installed.length > 0) {
+    console.log(`Codex skills を配置しました: ${codexSkills.installed.map(n => '$' + n).join(', ')}`);
+    console.log(`  ${codexSkillsDir}`);
+    console.log('');
+  } else if (codexSkills.skipped === 'source-missing') {
+    console.log('注意: パッケージ内に Codex skills のソースが見つからないためスキップしました。');
+    console.log('');
+  }
   console.log('  アンインストール: throughline uninstall');
 
   if (!resolveThroughlineOnPath()) {

package/src/cli/install.test.mjs

@@ -4,7 +4,7 @@ import { mkdtempSync, rmSync, existsSync, readFileSync, writeFileSync, mkdirSync
 import { tmpdir, homedir } from 'node:os';
 import { join } from 'node:path';
 
-import { run, resolveThroughlineOnPath } from './install.mjs';
+import { buildCodexStopHookCommand, run, resolveThroughlineOnPath } from './install.mjs';
 
 function makeTempHome() {
   const dir = mkdtempSync(join(tmpdir(), 'tl-install-test-'));
@@ -40,7 +40,7 @@ function silence() {
   };
 }
 
-test('global install copies /tl and /sc-detail to ~/.claude/commands/', async () => {
+test('global install copies Throughline slash commands to ~/.claude/commands/', async () => {
   const home = makeTempHome();
   if (home.resolved !== home.dir) {
     home.restore();
@@ -51,8 +51,10 @@ test('global install copies /tl and /sc-detail to ~/.claude/commands/', async ()
     await run([]);
     const tl = join(home.dir, '.claude', 'commands', 'tl.md');
     const sc = join(home.dir, '.claude', 'commands', 'sc-detail.md');
+    const trim = join(home.dir, '.claude', 'commands', 'tl-trim.md');
     assert.ok(existsSync(tl), 'tl.md should be installed globally');
     assert.ok(existsSync(sc), 'sc-detail.md should be installed globally');
+    assert.ok(!existsSync(trim), 'tl-trim.md should NOT be installed (deprecated in v0.4.0)');
     const tlBody = readFileSync(tl, 'utf8');
     assert.match(tlBody, /Throughline/, 'tl.md content should be real');
     const settings = JSON.parse(readFileSync(join(home.dir, '.claude', 'settings.json'), 'utf8'));
@@ -79,6 +81,8 @@ test('project install copies commands to cwd/.claude/commands/', async () => {
     assert.ok(existsSync(tl), 'tl.md should be installed in project');
     const globalTl = join(home.dir, '.claude', 'commands', 'tl.md');
     assert.ok(!existsSync(globalTl), '--project should NOT touch global dir');
+    assert.ok(!existsSync(join(home.dir, '.codex', 'hooks.json')), '--project should NOT touch global Codex hooks');
+    assert.ok(!existsSync(join(home.dir, '.codex', 'skills', 'throughline')), '--project should NOT touch global Codex skills');
   } finally {
     unsilence();
     process.chdir(origCwd);
@@ -87,6 +91,161 @@ test('project install copies commands to cwd/.claude/commands/', async () => {
   }
 });
 
+test('global install registers Codex Stop hook and enables codex_hooks feature', async () => {
+  const home = makeTempHome();
+  if (home.resolved !== home.dir) {
+    home.restore();
+    return;
+  }
+  const unsilence = silence();
+  try {
+    await run([]);
+    const hooks = JSON.parse(readFileSync(join(home.dir, '.codex', 'hooks.json'), 'utf8'));
+    const expectedCommand = buildCodexStopHookCommand();
+    const codexHook = hooks.hooks.Stop
+      .flatMap(g => g.hooks ?? [])
+      .find(h => h.command === expectedCommand);
+    assert.ok(codexHook, 'Codex Stop should have absolute throughline.mjs codex-hook stop');
+    assert.equal(codexHook.async, false, 'Codex Stop hook should be synchronous for Codex');
+    assert.equal(codexHook.timeoutSec, 300, 'Codex Stop hook should allow summarizer time');
+    const config = readFileSync(join(home.dir, '.codex', 'config.toml'), 'utf8');
+    assert.match(config, /^\[features\]\ncodex_hooks = true/m);
+  } finally {
+    unsilence();
+    home.restore();
+  }
+});
+
+test('global install copies Throughline Codex skill to ~/.codex/skills/', async () => {
+  const home = makeTempHome();
+  if (home.resolved !== home.dir) {
+    home.restore();
+    return;
+  }
+  const unsilence = silence();
+  try {
+    await run([]);
+    const skill = join(home.dir, '.codex', 'skills', 'throughline', 'SKILL.md');
+    const metadata = join(home.dir, '.codex', 'skills', 'throughline', 'agents', 'openai.yaml');
+    assert.ok(existsSync(skill), 'Throughline Codex skill should be installed globally');
+    assert.ok(existsSync(metadata), 'Throughline Codex skill UI metadata should be installed globally');
+    const skillBody = readFileSync(skill, 'utf8');
+    const metadataBody = readFileSync(metadata, 'utf8');
+    assert.match(skillBody, /name: throughline/);
+    assert.match(skillBody, /Bare "\$throughline"/);
+    assert.match(skillBody, /throughline codex-handoff-start --session codex:<current-thread-id> --json/);
+    assert.match(skillBody, /throughline trim --execute --host codex --all/);
+    assert.match(metadataBody, /inspect guarded Codex trim/);
+    assert.doesNotMatch(metadataBody, /preview blocked Codex trim/);
+  } finally {
+    unsilence();
+    home.restore();
+  }
+});
+
+test('global install preserves existing Codex hooks and is idempotent', async () => {
+  const home = makeTempHome();
+  if (home.resolved !== home.dir) {
+    home.restore();
+    return;
+  }
+  mkdirSync(join(home.dir, '.codex'), { recursive: true });
+  writeFileSync(
+    join(home.dir, '.codex', 'hooks.json'),
+    JSON.stringify(
+      {
+        hooks: {
+          Stop: [
+            {
+              hooks: [
+                {
+                  type: 'command',
+                  command: '/usr/bin/node /home/kite/.npm-global/bin/caveat codex-hook stop',
+                  timeoutSec: 5,
+                  async: false,
+                  statusMessage: null,
+                },
+              ],
+            },
+          ],
+        },
+      },
+      null,
+      2,
+    ) + '\n',
+  );
+  writeFileSync(join(home.dir, '.codex', 'config.toml'), '[features]\nother = true\n');
+  const unsilence = silence();
+  try {
+    await run([]);
+    await run([]);
+    const hooks = JSON.parse(readFileSync(join(home.dir, '.codex', 'hooks.json'), 'utf8'));
+    const commands = hooks.hooks.Stop.flatMap(g => g.hooks ?? []).map(h => h.command);
+    const expectedCommand = buildCodexStopHookCommand();
+    assert.ok(commands.includes('/usr/bin/node /home/kite/.npm-global/bin/caveat codex-hook stop'));
+    assert.equal(commands.filter(c => c === expectedCommand).length, 1);
+    assert.ok(!commands.includes('throughline codex-hook stop'));
+    const config = readFileSync(join(home.dir, '.codex', 'config.toml'), 'utf8');
+    assert.match(config, /other = true/);
+    assert.match(config, /codex_hooks = true/);
+  } finally {
+    unsilence();
+    home.restore();
+  }
+});
+
+test('global install updates existing Throughline Codex Stop hook shape', async () => {
+  const home = makeTempHome();
+  if (home.resolved !== home.dir) {
+    home.restore();
+    return;
+  }
+  mkdirSync(join(home.dir, '.codex'), { recursive: true });
+  writeFileSync(
+    join(home.dir, '.codex', 'hooks.json'),
+    JSON.stringify(
+      {
+        hooks: {
+          Stop: [
+            {
+              hooks: [
+                {
+                  type: 'command',
+                  command: 'throughline codex-hook stop',
+                  timeoutSec: 300,
+                  async: true,
+                  statusMessage: null,
+                },
+              ],
+            },
+          ],
+        },
+      },
+      null,
+      2,
+    ) + '\n',
+  );
+  const unsilence = silence();
+  try {
+    await run([]);
+    const hooks = JSON.parse(readFileSync(join(home.dir, '.codex', 'hooks.json'), 'utf8'));
+    const expectedCommand = buildCodexStopHookCommand();
+    const codexHooks = hooks.hooks.Stop
+      .flatMap(g => g.hooks ?? [])
+      .filter(h => h.command === expectedCommand);
+    assert.equal(codexHooks.length, 1);
+    assert.equal(codexHooks[0].async, false);
+    assert.equal(codexHooks[0].timeoutSec, 300);
+    assert.equal(
+      hooks.hooks.Stop.flatMap(g => g.hooks ?? []).filter(h => h.command === 'throughline codex-hook stop').length,
+      0,
+    );
+  } finally {
+    unsilence();
+    home.restore();
+  }
+});
+
 test('uninstall removes slash command files', async () => {
   const home = makeTempHome();
   if (home.resolved !== home.dir) {
@@ -102,6 +261,44 @@ test('uninstall removes slash command files', async () => {
     assert.ok(!existsSync(tl), 'uninstall should remove tl.md');
     const sc = join(home.dir, '.claude', 'commands', 'sc-detail.md');
     assert.ok(!existsSync(sc), 'uninstall should remove sc-detail.md');
+    const codexSkill = join(home.dir, '.codex', 'skills', 'throughline', 'SKILL.md');
+    assert.ok(!existsSync(codexSkill), 'uninstall should remove Throughline Codex skill');
+  } finally {
+    unsilence();
+    home.restore();
+  }
+});
+
+test('global uninstall removes only Throughline-managed Codex hook', async () => {
+  const home = makeTempHome();
+  if (home.resolved !== home.dir) {
+    home.restore();
+    return;
+  }
+  const unsilence = silence();
+  try {
+    await run([]);
+    const hooksPath = join(home.dir, '.codex', 'hooks.json');
+    const hooks = JSON.parse(readFileSync(hooksPath, 'utf8'));
+    hooks.hooks.Stop.push({
+      hooks: [
+        {
+          type: 'command',
+          command: '/usr/bin/node /home/kite/.npm-global/bin/caveat codex-hook stop',
+          timeoutSec: 5,
+          async: false,
+          statusMessage: null,
+        },
+      ],
+    });
+    writeFileSync(hooksPath, JSON.stringify(hooks, null, 2) + '\n');
+
+    await run(['--uninstall']);
+    const after = JSON.parse(readFileSync(hooksPath, 'utf8'));
+    const commands = after.hooks.Stop.flatMap(g => g.hooks ?? []).map(h => h.command);
+    assert.ok(commands.includes('/usr/bin/node /home/kite/.npm-global/bin/caveat codex-hook stop'));
+    assert.ok(!commands.includes('throughline codex-hook stop'));
+    assert.ok(!commands.some(c => c.includes('throughline.mjs codex-hook stop')));
   } finally {
     unsilence();
     home.restore();
@@ -127,7 +324,7 @@ test('uninstall preserves unrelated slash commands in the same dir', async () =>
   }
 });
 
-test('Stop hook is registered with async:true so it does not block ターン完了 UX', async () => {
+test('Claude Stop hook is registered with async:true so it does not block ターン完了 UX', async () => {
   const home = makeTempHome();
   if (home.resolved !== home.dir) {
     home.restore();
@@ -177,11 +374,15 @@ test('resolveThroughlineOnPath: finds throughline binary in PATH directory', ()
   const dir = mkdtempSync(join(tmpdir(), 'tl-path-found-'));
   try {
     if (process.platform === 'win32') {
+      // PATHEXT は通常大文字 (.EXE;.CMD;.BAT) だが、resolveThroughlineOnPath が
+      // 返すパスはその ext をそのまま join するため、書き込んだ実ファイル名 (小文字)
+      // と厳密一致するよう小文字を渡す。Windows FS は case-insensitive で
+      // existsSync は通る。
       const binPath = join(dir, 'throughline.cmd');
       writeFileSync(binPath, '@echo off\n');
       const result = resolveThroughlineOnPath({
         PATH: dir,
-        PATHEXT: '.CMD',
+        PATHEXT: '.cmd',
       });
       assert.equal(result, binPath);
     } else {