throughline 0.4.7 → 0.4.9

package/src/cli/doctor.mjs

@@ -28,7 +28,14 @@ import { resolveCodexThreadIdentity } from '../codex-thread-identity.mjs';
 import { defaultCodexHome, listCodexThreadCandidates } from '../codex-thread-index.mjs';
 import { getDb } from '../db.mjs';
 import { detectJsoncFeatures, findMonitorTaskIndex, isMonitorTaskBroken } from '../vscode-task.mjs';
-import { buildCodexStopHookCommand, isThroughlineCodexStopCommand } from './install.mjs';
+import {
+  buildCodexPostToolUseHookCommand,
+  buildCodexStopHookCommand,
+  buildCodexUserPromptSubmitHookCommand,
+  isThroughlineCodexHookCommand,
+  isThroughlineCodexPostToolUseCommand,
+  isThroughlineCodexStopCommand,
+} from './install.mjs';
 
 const GREEN = '\x1b[32m✓\x1b[0m';
 const RED = '\x1b[31m✗\x1b[0m';
@@ -390,23 +397,126 @@ function countCapturedCodexSessions(db, projectPath) {
   }
 }
 
+function parseCodexTrustedHookState(configText) {
+  const trustedKeys = new Set();
+  let currentKey = null;
+  let currentTrusted = false;
+
+  function flush() {
+    if (currentKey && currentTrusted) trustedKeys.add(currentKey);
+  }
+
+  for (const line of configText.split(/\r?\n/)) {
+    const section = line.match(/^\s*\[hooks\.state\."([^"]+)"\]\s*$/);
+    if (section) {
+      flush();
+      currentKey = section[1];
+      currentTrusted = false;
+      continue;
+    }
+    if (!currentKey) continue;
+    if (/^\s*\[/.test(line)) {
+      flush();
+      currentKey = null;
+      currentTrusted = false;
+      continue;
+    }
+    if (/^\s*trusted_hash\s*=\s*"sha256:[^"]+"\s*$/.test(line)) {
+      currentTrusted = true;
+    }
+  }
+  flush();
+  return trustedKeys;
+}
+
+function listHooksWithTrust(parsed, eventName, eventKey, hooksPath, trustedStateKeys) {
+  const groups = parsed.hooks?.[eventName] ?? [];
+  return groups.flatMap((group, groupIndex) =>
+    (group.hooks ?? []).map((hook, hookIndex) => {
+      const trustKey = `${hooksPath}:${eventKey}:${groupIndex}:${hookIndex}`;
+      return {
+        ...hook,
+        throughlineDoctorTrustKey: trustKey,
+        throughlineDoctorTrusted: trustedStateKeys.has(trustKey),
+      };
+    }),
+  );
+}
+
+function summarizeHookTrust(hooks, { hooksFeatureEnabled, codexHooksFeatureEnabled } = {}) {
+  if (hooks.length === 0) {
+    return {
+      status: 'no managed hooks',
+      trustedCount: 0,
+      totalCount: 0,
+    };
+  }
+  const trustedCount = hooks.filter(h => h.throughlineDoctorTrusted).length;
+  if (trustedCount === hooks.length) {
+    return {
+      status: 'trusted',
+      trustedCount,
+      totalCount: hooks.length,
+    };
+  }
+  if (hooksFeatureEnabled) {
+    return {
+      status: `${trustedCount}/${hooks.length} trusted - accept hooks in Codex menu`,
+      trustedCount,
+      totalCount: hooks.length,
+    };
+  }
+  if (codexHooksFeatureEnabled) {
+    return {
+      status: 'not recorded (legacy codex_hooks)',
+      trustedCount,
+      totalCount: hooks.length,
+    };
+  }
+  return {
+    status: 'not trusted',
+    trustedCount,
+    totalCount: hooks.length,
+  };
+}
+
 function readCodexHookDiagnosis(codexHome) {
   const hooksPath = join(codexHome, 'hooks.json');
   const configPath = join(codexHome, 'config.toml');
-  const expectedCommand = buildCodexStopHookCommand();
+  const expectedStopCommand = buildCodexStopHookCommand();
+  const expectedPromptCommand = buildCodexUserPromptSubmitHookCommand();
+  const expectedPostToolUseCommand = buildCodexPostToolUseHookCommand();
   const out = {
     hooksPath,
     configPath,
-    expectedCommand,
+    expectedStopCommand,
+    expectedPromptCommand,
+    expectedPostToolUseCommand,
     hooksReadable: false,
     featureEnabled: false,
+    codexHooksFeatureEnabled: false,
+    hooksFeatureEnabled: false,
+    trustedStateKeys: new Set(),
+    managedHookTrust: {
+      status: 'no managed hooks',
+      trustedCount: 0,
+      totalCount: 0,
+    },
+    managedPromptHooks: [],
+    legacyManagedPromptHooks: [],
+    managedPostToolUseHooks: [],
+    legacyManagedPostToolUseHooks: [],
     managedStopHooks: [],
     legacyManagedStopHooks: [],
   };
 
   if (existsSync(configPath)) {
     try {
-      out.featureEnabled = /^\s*codex_hooks\s*=\s*true\s*$/m.test(readFileSync(configPath, 'utf8'));
+      const config = readFileSync(configPath, 'utf8');
+      out.codexHooksFeatureEnabled = /^\s*codex_hooks\s*=\s*true\s*$/m.test(config);
+      out.hooksFeatureEnabled = /^\s*hooks\s*=\s*true\s*$/m.test(config);
+      out.featureEnabled = out.codexHooksFeatureEnabled || out.hooksFeatureEnabled;
+      out.trustedStateKeys = parseCodexTrustedHookState(config);
     } catch {
       out.featureEnabled = false;
     }
@@ -421,9 +531,37 @@ function readCodexHookDiagnosis(codexHome) {
   }
 
   out.hooksReadable = true;
-  const stopHooks = (parsed.hooks?.Stop ?? []).flatMap(group => group.hooks ?? []);
+  const promptHooks = listHooksWithTrust(
+    parsed,
+    'UserPromptSubmit',
+    'user_prompt_submit',
+    hooksPath,
+    out.trustedStateKeys,
+  );
+  const postToolUseHooks = listHooksWithTrust(
+    parsed,
+    'PostToolUse',
+    'post_tool_use',
+    hooksPath,
+    out.trustedStateKeys,
+  );
+  const stopHooks = listHooksWithTrust(parsed, 'Stop', 'stop', hooksPath, out.trustedStateKeys);
+  out.managedPromptHooks = promptHooks.filter(h => isThroughlineCodexHookCommand(h.command));
+  out.legacyManagedPromptHooks = out.managedPromptHooks.filter(h => h.command !== expectedPromptCommand);
+  out.managedPostToolUseHooks = postToolUseHooks.filter(h => isThroughlineCodexPostToolUseCommand(h.command));
+  out.legacyManagedPostToolUseHooks = out.managedPostToolUseHooks.filter(
+    h => h.command !== expectedPostToolUseCommand,
+  );
   out.managedStopHooks = stopHooks.filter(h => isThroughlineCodexStopCommand(h.command));
-  out.legacyManagedStopHooks = out.managedStopHooks.filter(h => h.command !== expectedCommand);
+  out.legacyManagedStopHooks = out.managedStopHooks.filter(h => h.command !== expectedStopCommand);
+  out.managedHookTrust = summarizeHookTrust(
+    [
+      ...out.managedPromptHooks,
+      ...out.managedPostToolUseHooks,
+      ...out.managedStopHooks,
+    ],
+    out,
+  );
   return out;
 }
 
@@ -456,6 +594,35 @@ function runCodexDiagnosis({
   console.log(`  project:               ${cwd}`);
   console.log(`  CODEX_HOME:            ${codexHome}`);
   console.log(`  Codex hooks feature:   ${hookDiagnosis.featureEnabled ? 'enabled' : 'not enabled'}`);
+  console.log(`  Codex hook trust:      ${hookDiagnosis.managedHookTrust.status}`);
+  console.log(`  Codex UserPrompt hook: ${
+    hookDiagnosis.managedPromptHooks.length === 0
+      ? 'not registered'
+      : hookDiagnosis.legacyManagedPromptHooks.length > 0
+        ? 'legacy command needs reinstall'
+        : 'registered'
+  }`);
+  if (hookDiagnosis.managedPromptHooks.length > 0) {
+    const h = hookDiagnosis.managedPromptHooks[0];
+    console.log(`    command:             ${h.command}`);
+    console.log(`    async:               ${h.async === false ? 'false' : String(h.async)}`);
+    console.log(`    timeoutSec:          ${h.timeoutSec ?? '(default)'}`);
+    console.log(`    trusted:             ${h.throughlineDoctorTrusted ? 'yes' : 'no'}`);
+  }
+  console.log(`  Codex PostTool hook:   ${
+    hookDiagnosis.managedPostToolUseHooks.length === 0
+      ? 'not registered'
+      : hookDiagnosis.legacyManagedPostToolUseHooks.length > 0
+        ? 'legacy command needs reinstall'
+        : 'registered'
+  }`);
+  if (hookDiagnosis.managedPostToolUseHooks.length > 0) {
+    const h = hookDiagnosis.managedPostToolUseHooks[0];
+    console.log(`    command:             ${h.command}`);
+    console.log(`    async:               ${h.async === false ? 'false' : String(h.async)}`);
+    console.log(`    timeoutSec:          ${h.timeoutSec ?? '(default)'}`);
+    console.log(`    trusted:             ${h.throughlineDoctorTrusted ? 'yes' : 'no'}`);
+  }
   console.log(`  Codex Stop hook:       ${
     hookDiagnosis.managedStopHooks.length === 0
       ? 'not registered'
@@ -468,6 +635,7 @@ function runCodexDiagnosis({
     console.log(`    command:             ${h.command}`);
     console.log(`    async:               ${h.async === false ? 'false' : String(h.async)}`);
     console.log(`    timeoutSec:          ${h.timeoutSec ?? '(default)'}`);
+    console.log(`    trusted:             ${h.throughlineDoctorTrusted ? 'yes' : 'no'}`);
   }
   console.log(`  VSCode monitor task:   ${monitorTaskDiagnosis.status}`);
   if (monitorTaskDiagnosis.path) {

package/src/cli/doctor.test.mjs

@@ -155,6 +155,8 @@ test('runCodexDiagnosis: reports env thread and captured DB session', () => {
 
     assert.match(output, /\[Codex primary\]/);
     assert.match(output, /Codex hooks feature:\s+not enabled/);
+    assert.match(output, /Codex UserPrompt hook:\s+not registered/);
+    assert.match(output, /Codex PostTool hook:\s+not registered/);
     assert.match(output, /Codex Stop hook:\s+not registered/);
     assert.match(output, /VSCode monitor task:\s+not registered/);
     assert.match(output, /created by the next VSCode hook event/);
@@ -328,7 +330,7 @@ test('buildCodexContextRefreshDiagnosis keeps ready label when restore safety is
   }
 });
 
-test('readCodexHookDiagnosis detects legacy bare Throughline Codex Stop hook', () => {
+test('readCodexHookDiagnosis detects Codex prompt and Stop hooks', () => {
   const codexHome = mkdtempSync(join(tmpdir(), 'tl-doctor-codex-home-'));
   try {
     mkdirSync(join(codexHome), { recursive: true });
@@ -337,6 +339,30 @@ test('readCodexHookDiagnosis detects legacy bare Throughline Codex Stop hook', (
       JSON.stringify(
         {
           hooks: {
+            UserPromptSubmit: [
+              {
+                hooks: [
+                  {
+                    type: 'command',
+                    command: '/usr/bin/node /pkg/bin/throughline.mjs codex-hook user-prompt-submit',
+                    timeoutSec: 30,
+                    async: false,
+                  },
+                ],
+              },
+            ],
+            PostToolUse: [
+              {
+                hooks: [
+                  {
+                    type: 'command',
+                    command: '/usr/bin/node /pkg/bin/throughline.mjs codex-hook post-tool-use',
+                    timeoutSec: 30,
+                    async: false,
+                  },
+                ],
+              },
+            ],
             Stop: [
               {
                 hooks: [
@@ -355,11 +381,41 @@ test('readCodexHookDiagnosis detects legacy bare Throughline Codex Stop hook', (
         2,
       ) + '\n',
     );
-    writeFileSync(join(codexHome, 'config.toml'), '[features]\ncodex_hooks = true\n');
+    const hooksPath = join(codexHome, 'hooks.json');
+    writeFileSync(
+      join(codexHome, 'config.toml'),
+      [
+        '[features]',
+        'codex_hooks = true',
+        'hooks = true',
+        '',
+        `[hooks.state."${hooksPath}:user_prompt_submit:0:0"]`,
+        'trusted_hash = "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"',
+        '',
+        `[hooks.state."${hooksPath}:post_tool_use:0:0"]`,
+        'trusted_hash = "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"',
+        '',
+        `[hooks.state."${hooksPath}:stop:0:0"]`,
+        'trusted_hash = "sha256:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"',
+        '',
+      ].join('\n'),
+    );
 
     const diagnosis = readCodexHookDiagnosis(codexHome);
     assert.equal(diagnosis.featureEnabled, true);
+    assert.equal(diagnosis.codexHooksFeatureEnabled, true);
+    assert.equal(diagnosis.hooksFeatureEnabled, true);
+    assert.equal(diagnosis.managedHookTrust.status, 'trusted');
+    assert.equal(diagnosis.managedHookTrust.trustedCount, 3);
+    assert.equal(diagnosis.managedHookTrust.totalCount, 3);
+    assert.equal(diagnosis.managedPromptHooks.length, 1);
+    assert.equal(diagnosis.managedPromptHooks[0].throughlineDoctorTrusted, true);
+    assert.equal(diagnosis.legacyManagedPromptHooks.length, 1);
+    assert.equal(diagnosis.managedPostToolUseHooks.length, 1);
+    assert.equal(diagnosis.managedPostToolUseHooks[0].throughlineDoctorTrusted, true);
+    assert.equal(diagnosis.legacyManagedPostToolUseHooks.length, 1);
     assert.equal(diagnosis.managedStopHooks.length, 1);
+    assert.equal(diagnosis.managedStopHooks[0].throughlineDoctorTrusted, true);
     assert.equal(diagnosis.legacyManagedStopHooks.length, 1);
   } finally {
     rmSync(codexHome, { recursive: true, force: true });

package/src/cli/help.test.mjs

@@ -9,6 +9,8 @@ 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 user-prompt-submit',
+  'throughline codex-hook post-tool-use',
   'throughline codex-hook stop',
   'throughline codex-summarize',
   'throughline codex-resume',

package/src/cli/install.mjs

@@ -54,6 +54,8 @@ const SC_HOOKS = {
 
 const CODEX_COMMANDS = [
   'throughline codex-hook stop',
+  'throughline codex-hook user-prompt-submit',
+  'throughline codex-hook post-tool-use',
 ];
 
 function quoteCommandPath(p) {
@@ -67,6 +69,36 @@ export function buildCodexStopHookCommand({
   return `${quoteCommandPath(nodePath)} ${quoteCommandPath(cliScriptPath)} codex-hook stop`;
 }
 
+export function buildCodexUserPromptSubmitHookCommand({
+  nodePath = process.execPath,
+  cliScriptPath = join(PACKAGE_ROOT, 'bin', 'throughline.mjs'),
+} = {}) {
+  return `${quoteCommandPath(nodePath)} ${quoteCommandPath(cliScriptPath)} codex-hook user-prompt-submit`;
+}
+
+export function buildCodexPostToolUseHookCommand({
+  nodePath = process.execPath,
+  cliScriptPath = join(PACKAGE_ROOT, 'bin', 'throughline.mjs'),
+} = {}) {
+  return `${quoteCommandPath(nodePath)} ${quoteCommandPath(cliScriptPath)} codex-hook post-tool-use`;
+}
+
+export function isThroughlineCodexHookCommand(command) {
+  if (typeof command !== 'string') return false;
+  const normalized = command.replace(/["']/g, '');
+  return (
+    normalized === 'throughline codex-hook stop' ||
+    normalized === 'throughline codex-hook user-prompt-submit' ||
+    normalized === 'throughline codex-hook post-tool-use' ||
+    normalized.includes('throughline codex-hook stop') ||
+    normalized.includes('throughline codex-hook user-prompt-submit') ||
+    normalized.includes('throughline codex-hook post-tool-use') ||
+    normalized.includes('throughline.mjs codex-hook stop') ||
+    normalized.includes('throughline.mjs codex-hook user-prompt-submit') ||
+    normalized.includes('throughline.mjs codex-hook post-tool-use')
+  );
+}
+
 export function isThroughlineCodexStopCommand(command) {
   if (typeof command !== 'string') return false;
   const normalized = command.replace(/["']/g, '');
@@ -77,8 +109,40 @@ export function isThroughlineCodexStopCommand(command) {
   );
 }
 
+export function isThroughlineCodexPostToolUseCommand(command) {
+  if (typeof command !== 'string') return false;
+  const normalized = command.replace(/["']/g, '');
+  return (
+    normalized === 'throughline codex-hook post-tool-use' ||
+    normalized.includes('throughline codex-hook post-tool-use') ||
+    normalized.includes('throughline.mjs codex-hook post-tool-use')
+  );
+}
+
 function createCodexHooks() {
   return {
+    UserPromptSubmit: {
+      hooks: [
+        {
+          type: 'command',
+          command: buildCodexUserPromptSubmitHookCommand(),
+          timeoutSec: 30,
+          async: false,
+          statusMessage: null,
+        },
+      ],
+    },
+    PostToolUse: {
+      hooks: [
+        {
+          type: 'command',
+          command: buildCodexPostToolUseHookCommand(),
+          timeoutSec: 30,
+          async: false,
+          statusMessage: null,
+        },
+      ],
+    },
     Stop: {
       hooks: [
         {
@@ -253,11 +317,19 @@ function ensureCodexHooksFeature(configPath) {
   const existing = existsSync(configPath) ? readFileSync(configPath, 'utf8') : '';
   const lines = existing.split(/\r?\n/);
   const sectionStart = lines.findIndex((line) => line.trim() === '[features]');
+  const ensureFeatureLine = (featureLines, name) => {
+    const idx = featureLines.findIndex((line) => new RegExp(`^\\s*${name}\\s*=`).test(line));
+    if (idx === -1) {
+      featureLines.push(`${name} = true`);
+    } else {
+      featureLines[idx] = `${name} = true`;
+    }
+  };
   let updated;
 
   if (sectionStart === -1) {
     const prefix = existing.trimEnd();
-    updated = `${prefix}${prefix ? '\n\n' : ''}[features]\ncodex_hooks = true\n`;
+    updated = `${prefix}${prefix ? '\n\n' : ''}[features]\ncodex_hooks = true\nhooks = true\n`;
   } else {
     let sectionEnd = lines.length;
     for (let i = sectionStart + 1; i < lines.length; i++) {
@@ -267,14 +339,10 @@ function ensureCodexHooksFeature(configPath) {
       }
     }
 
-    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';
-    }
+    const featureLines = lines.slice(sectionStart + 1, sectionEnd);
+    ensureFeatureLine(featureLines, 'codex_hooks');
+    ensureFeatureLine(featureLines, 'hooks');
+    lines.splice(sectionStart + 1, sectionEnd - sectionStart - 1, ...featureLines);
     updated = lines.join('\n').replace(/\n*$/, '\n');
   }
 
@@ -294,7 +362,7 @@ function installCodexHooks() {
     const list = existingHooks[key] ?? [];
     const preserved = [];
     for (const group of list) {
-      const hooks = (group.hooks ?? []).filter(h => !isThroughlineCodexStopCommand(h.command));
+      const hooks = (group.hooks ?? []).filter(h => !isThroughlineCodexHookCommand(h.command));
       if (hooks.length > 0) preserved.push({ ...group, hooks });
     }
     existingHooks[key] = [entry, ...preserved];
@@ -323,7 +391,7 @@ function uninstallCodexHooks() {
         const hooks = (group.hooks ?? []).filter((hook) => {
           const shouldRemove =
             CODEX_COMMANDS.includes(hook.command) ||
-            isThroughlineCodexStopCommand(hook.command);
+            isThroughlineCodexHookCommand(hook.command);
           if (shouldRemove) removed++;
           return !shouldRemove;
         });
@@ -422,7 +490,9 @@ export async function run(args = []) {
   console.log('  Stop             → throughline process-turn   (L1 要約 + L2 本文保存 + L3 詳細保存)');
   console.log('  UserPromptSubmit → throughline prompt-submit  (/tl & /clear バトン書き込み)');
   if (codex) {
-    console.log(`  Codex Stop       → ${buildCodexStopHookCommand()} (Codex rollout capture + L1 要約)`);
+    console.log(`  Codex UserPromptSubmit → ${buildCodexUserPromptSubmitHookCommand()} (75% 到達時に current session へ $throughline 指示を注入)`);
+    console.log(`  Codex PostToolUse      → ${buildCodexPostToolUseHookCommand()} (tool loop 中も 75% 到達時に $throughline 指示を注入)`);
+    console.log(`  Codex Stop             → ${buildCodexStopHookCommand()} (Codex rollout capture + L1 要約)`);
   }
   console.log('');
   if (installedCommands.length > 0) {

package/src/cli/install.test.mjs

@@ -4,7 +4,13 @@ import { mkdtempSync, rmSync, existsSync, readFileSync, writeFileSync, mkdirSync
 import { tmpdir, homedir } from 'node:os';
 import { join } from 'node:path';
 
-import { buildCodexStopHookCommand, run, resolveThroughlineOnPath } from './install.mjs';
+import {
+  buildCodexPostToolUseHookCommand,
+  buildCodexStopHookCommand,
+  buildCodexUserPromptSubmitHookCommand,
+  run,
+  resolveThroughlineOnPath,
+} from './install.mjs';
 
 function makeTempHome() {
   const dir = mkdtempSync(join(tmpdir(), 'tl-install-test-'));
@@ -94,7 +100,7 @@ test('project install copies commands to cwd/.claude/commands/', async () => {
   }
 });
 
-test('global install registers Codex Stop hook and enables codex_hooks feature', async () => {
+test('global install registers Codex session hooks and enables hooks features', async () => {
   const home = makeTempHome();
   if (home.resolved !== home.dir) {
     home.restore();
@@ -104,15 +110,30 @@ test('global install registers Codex Stop hook and enables codex_hooks feature',
   try {
     await run([]);
     const hooks = JSON.parse(readFileSync(join(home.dir, '.codex', 'hooks.json'), 'utf8'));
-    const expectedCommand = buildCodexStopHookCommand();
+    const expectedStopCommand = buildCodexStopHookCommand();
+    const expectedPromptCommand = buildCodexUserPromptSubmitHookCommand();
+    const expectedPostToolUseCommand = buildCodexPostToolUseHookCommand();
     const codexHook = hooks.hooks.Stop
       .flatMap(g => g.hooks ?? [])
-      .find(h => h.command === expectedCommand);
+      .find(h => h.command === expectedStopCommand);
     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 promptHook = hooks.hooks.UserPromptSubmit
+      .flatMap(g => g.hooks ?? [])
+      .find(h => h.command === expectedPromptCommand);
+    assert.ok(promptHook, 'Codex UserPromptSubmit should have absolute throughline.mjs codex-hook user-prompt-submit');
+    assert.equal(promptHook.async, false, 'Codex UserPromptSubmit hook should be synchronous for context injection');
+    assert.equal(promptHook.timeoutSec, 30, 'Codex UserPromptSubmit hook should be short');
+    const postToolUseHook = hooks.hooks.PostToolUse
+      .flatMap(g => g.hooks ?? [])
+      .find(h => h.command === expectedPostToolUseCommand);
+    assert.ok(postToolUseHook, 'Codex PostToolUse should have absolute throughline.mjs codex-hook post-tool-use');
+    assert.equal(postToolUseHook.async, false, 'Codex PostToolUse hook should be synchronous for context injection');
+    assert.equal(postToolUseHook.timeoutSec, 30, 'Codex PostToolUse hook should be short');
     const config = readFileSync(join(home.dir, '.codex', 'config.toml'), 'utf8');
     assert.match(config, /^\[features\]\ncodex_hooks = true/m);
+    assert.match(config, /^hooks = true/m);
   } finally {
     unsilence();
     home.restore();
@@ -215,21 +236,30 @@ test('global install preserves existing Codex hooks and is idempotent', async ()
     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 stopCommands = hooks.hooks.Stop.flatMap(g => g.hooks ?? []).map(h => h.command);
+    const promptCommands = hooks.hooks.UserPromptSubmit.flatMap(g => g.hooks ?? []).map(h => h.command);
+    const postToolUseCommands = hooks.hooks.PostToolUse.flatMap(g => g.hooks ?? []).map(h => h.command);
+    const expectedStopCommand = buildCodexStopHookCommand();
+    const expectedPromptCommand = buildCodexUserPromptSubmitHookCommand();
+    const expectedPostToolUseCommand = buildCodexPostToolUseHookCommand();
+    assert.ok(stopCommands.includes('/usr/bin/node /home/kite/.npm-global/bin/caveat codex-hook stop'));
+    assert.equal(stopCommands.filter(c => c === expectedStopCommand).length, 1);
+    assert.equal(promptCommands.filter(c => c === expectedPromptCommand).length, 1);
+    assert.equal(postToolUseCommands.filter(c => c === expectedPostToolUseCommand).length, 1);
+    assert.ok(!stopCommands.includes('throughline codex-hook stop'));
+    assert.ok(!promptCommands.includes('throughline codex-hook user-prompt-submit'));
+    assert.ok(!postToolUseCommands.includes('throughline codex-hook post-tool-use'));
     const config = readFileSync(join(home.dir, '.codex', 'config.toml'), 'utf8');
     assert.match(config, /other = true/);
     assert.match(config, /codex_hooks = true/);
+    assert.match(config, /hooks = true/);
   } finally {
     unsilence();
     home.restore();
   }
 });
 
-test('global install updates existing Throughline Codex Stop hook shape', async () => {
+test('global install updates existing Throughline Codex hook shapes', async () => {
   const home = makeTempHome();
   if (home.resolved !== home.dir) {
     home.restore();
@@ -241,6 +271,32 @@ test('global install updates existing Throughline Codex Stop hook shape', async
     JSON.stringify(
       {
         hooks: {
+          UserPromptSubmit: [
+            {
+              hooks: [
+                {
+                  type: 'command',
+                  command: 'throughline codex-hook user-prompt-submit',
+                  timeoutSec: 300,
+                  async: true,
+                  statusMessage: null,
+                },
+              ],
+            },
+          ],
+          PostToolUse: [
+            {
+              hooks: [
+                {
+                  type: 'command',
+                  command: 'throughline codex-hook post-tool-use',
+                  timeoutSec: 300,
+                  async: true,
+                  statusMessage: null,
+                },
+              ],
+            },
+          ],
           Stop: [
             {
               hooks: [
@@ -264,17 +320,39 @@ test('global install updates existing Throughline Codex Stop hook shape', async
   try {
     await run([]);
     const hooks = JSON.parse(readFileSync(join(home.dir, '.codex', 'hooks.json'), 'utf8'));
-    const expectedCommand = buildCodexStopHookCommand();
+    const expectedStopCommand = buildCodexStopHookCommand();
+    const expectedPromptCommand = buildCodexUserPromptSubmitHookCommand();
+    const expectedPostToolUseCommand = buildCodexPostToolUseHookCommand();
     const codexHooks = hooks.hooks.Stop
       .flatMap(g => g.hooks ?? [])
-      .filter(h => h.command === expectedCommand);
+      .filter(h => h.command === expectedStopCommand);
     assert.equal(codexHooks.length, 1);
     assert.equal(codexHooks[0].async, false);
     assert.equal(codexHooks[0].timeoutSec, 300);
+    const promptHooks = hooks.hooks.UserPromptSubmit
+      .flatMap(g => g.hooks ?? [])
+      .filter(h => h.command === expectedPromptCommand);
+    assert.equal(promptHooks.length, 1);
+    assert.equal(promptHooks[0].async, false);
+    assert.equal(promptHooks[0].timeoutSec, 30);
+    const postToolUseHooks = hooks.hooks.PostToolUse
+      .flatMap(g => g.hooks ?? [])
+      .filter(h => h.command === expectedPostToolUseCommand);
+    assert.equal(postToolUseHooks.length, 1);
+    assert.equal(postToolUseHooks[0].async, false);
+    assert.equal(postToolUseHooks[0].timeoutSec, 30);
     assert.equal(
       hooks.hooks.Stop.flatMap(g => g.hooks ?? []).filter(h => h.command === 'throughline codex-hook stop').length,
       0,
     );
+    assert.equal(
+      hooks.hooks.UserPromptSubmit.flatMap(g => g.hooks ?? []).filter(h => h.command === 'throughline codex-hook user-prompt-submit').length,
+      0,
+    );
+    assert.equal(
+      hooks.hooks.PostToolUse.flatMap(g => g.hooks ?? []).filter(h => h.command === 'throughline codex-hook post-tool-use').length,
+      0,
+    );
   } finally {
     unsilence();
     home.restore();
@@ -330,10 +408,16 @@ test('global uninstall removes only Throughline-managed Codex hook', async () =>
 
     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')));
+    const stopCommands = after.hooks.Stop.flatMap(g => g.hooks ?? []).map(h => h.command);
+    const promptCommands = after.hooks.UserPromptSubmit?.flatMap(g => g.hooks ?? []).map(h => h.command) ?? [];
+    const postToolUseCommands = after.hooks.PostToolUse?.flatMap(g => g.hooks ?? []).map(h => h.command) ?? [];
+    assert.ok(stopCommands.includes('/usr/bin/node /home/kite/.npm-global/bin/caveat codex-hook stop'));
+    assert.ok(!stopCommands.includes('throughline codex-hook stop'));
+    assert.ok(!stopCommands.some(c => c.includes('throughline.mjs codex-hook stop')));
+    assert.ok(!promptCommands.includes('throughline codex-hook user-prompt-submit'));
+    assert.ok(!promptCommands.some(c => c.includes('throughline.mjs codex-hook user-prompt-submit')));
+    assert.ok(!postToolUseCommands.includes('throughline codex-hook post-tool-use'));
+    assert.ok(!postToolUseCommands.some(c => c.includes('throughline.mjs codex-hook post-tool-use')));
   } finally {
     unsilence();
     home.restore();