@searls/turbocommit 0.12.1 → 0.13.1

package/README.md

@@ -2,28 +2,32 @@
 
 # turbocommit
 
-turbocommit creates a git commit containing everything Claude Code changes 
-on each turn. Think of it like save state in a game emulator: whenever you 
-fall in a pit, you can safely rewind and try again.
+turbocommit creates a git commit containing everything Claude Code or Codex
+changes on each turn. Think of it like save state in a game emulator: whenever
+you fall in a pit, you can safely rewind and try again.
 
 Captures every prompt/response transcript for the associated changes so you 
 and your agent never lose the thread on what you were doing after the fact,
 even if you didn't leave behind any comments or docs.
 
-Each commit also [links back to the previous commit from the same Claude Code
-session](#continuity-across-workstreams), so you can run multiple agent 
+Each commit also [links back to the previous commit from the same agent
+session](#continuity-across-workstreams), so you can run multiple agent
 sessions concurrently and detangle which agent committed what after the fact.
 
 ## How it works
 
-turbocommit registers four hooks with Claude Code: **PreToolUse**,
-**SessionStart**, **SessionEnd**, and **Stop**.
+turbocommit registers hooks with the harnesses you use:
+
+- Claude Code: **PreToolUse**, **SessionStart**, **SessionEnd**, and **Stop**.
+- Codex: **PreToolUse**, **SessionStart**, **PreCompact**, and
+  **Stop**.
 
 - **PreToolUse** tracks which sessions actually modify files (Write, Edit,
   MultiEdit, NotebookEdit, MCP tools). Read-only sessions (Grep, Read,
   Bash-only) are never committed.
 - **SessionStart / SessionEnd** chain sessions across `/clear` boundaries
   so planning context survives into the eventual commit.
+- **PreCompact** on Codex buffers visible transcript context before compaction.
 - **Stop** fires after every turn. If the session modified files, it
   commits with `git add -A`. If not, it buffers the transcript for pickup
   by a later session that does commit.
@@ -40,6 +44,22 @@ brew install searlsco/tap/turbocommit
 turbocommit install
 ```
 
+Or install from npm:
+
+```bash
+npm install -g @searls/turbocommit
+turbocommit install
+```
+
+With no flags, `turbocommit install` installs into existing harness config
+directories only: `~/.claude` and/or `~/.codex`. To force one harness and create
+its config directory if needed:
+
+```bash
+turbocommit install --harness claude
+turbocommit install --harness codex
+```
+
 Then enable it per-project:
 
 ```bash
@@ -57,20 +77,24 @@ brew uninstall turbocommit
 
 ## Where turbocommit goes in your hook chain
 
-`turbocommit install` adds one hook group per event (PreToolUse,
-SessionStart, SessionEnd, Stop). The hooks are fire-and-forget: they
-always exit 0 and never block Claude.
+`turbocommit install` adds one hook group per event for each installed harness.
+The hooks are fire-and-forget: they always exit 0 and never block the agent.
+
+If you rearrange your hooks manually, the turbocommit hooks can go anywhere.
+Order doesn't matter since they never block.
 
-If you rearrange your hooks manually, the turbocommit hooks can go
-anywhere — order doesn't matter since they never block.
+Codex users should restart Codex and run `/hooks` after install to review and
+trust the hook commands.
 
 ## Commands
 
 | Command | Description |
 |---------|-------------|
-| `turbocommit install` | Add hooks to `~/.claude/settings.json` |
+| `turbocommit install` | Add hooks to existing Claude and/or Codex config dirs |
+| `turbocommit install --harness claude` | Add hooks to `~/.claude/settings.json` |
+| `turbocommit install --harness codex` | Add hooks to `~/.codex/hooks.json` |
 | `turbocommit uninstall` | Remove them |
-| `turbocommit init` | Create `.claude/turbocommit.json` in current repo |
+| `turbocommit init` | Create `.turbocommit.json` in current repo |
 | `turbocommit deinit` | Remove it |
 | `turbocommit doctor` | Check hook and config health |
 | `turbocommit monitor` | Tail the event log (start/success/skip/fail) |
@@ -80,8 +104,8 @@ anywhere — order doesn't matter since they never block.
 ## Continuity across workstreams
 
 Every turbocommit adds a `Continuation of <SHA>` reference linking back to
-the previous commit from the same Claude session. This means you can run
-multiple sessions in parallel — different tabs, different tasks — all
+the previous commit from the same agent session. This means you can run
+multiple sessions in parallel, across different tabs and different tasks, all
 committing to a single branch, and still trace each logical workstream
 by following the SHA chain.
 
@@ -119,9 +143,24 @@ is traceable.
 
 ## Configuration
 
-`turbocommit init` creates `.claude/turbocommit.json` with `{"enabled": true}`.
-You can also place a global config at `~/.claude/turbocommit.json` — project
-config is deep-merged on top.
+`turbocommit init` creates `.turbocommit.json` with `{"enabled": true}`.
+The legacy project path `.claude/turbocommit.json` is still read when the
+neutral file is absent.
+
+Global config follows the XDG Unix config standard:
+
+```text
+$XDG_CONFIG_HOME/turbocommit/config.json
+```
+
+When `XDG_CONFIG_HOME` is unset, turbocommit reads:
+
+```text
+~/.config/turbocommit/config.json
+```
+
+The legacy global path `~/.claude/turbocommit.json` is still read when the XDG
+file is absent. Project config is deep-merged on top of global config.
 
 Here's every property with its default:
 
@@ -152,7 +191,7 @@ Here's every property with its default:
 
     // Prompt template sent to the title agent. Use {{transcript}} as the
     // placeholder for the session transcript.
-    "prompt": "You have 10 seconds. Write a single-line git commit headline (max 72 chars) from this coding session transcript. Speed over perfection — a rough title beats no title.\n\nRules:\n- Imperative mood (\"Add\", \"Fix\", \"Update\")\n- Specific about what changed\n- No trailing period\n- No conventional commit prefixes unless clearly a fix/feat\n\nTranscript:\n{{transcript}}\n\nRespond with ONLY the headline, nothing else. Do not deliberate."
+    "prompt": "You have 10 seconds. Write a single-line git commit headline (max 72 chars) from this coding session transcript. Speed over perfection: a rough title beats no title.\n\nRules:\n- Imperative mood (\"Add\", \"Fix\", \"Update\")\n- Specific about what changed\n- No trailing period\n- No conventional commit prefixes unless clearly a fix/feat\n\nTranscript:\n{{transcript}}\n\nRespond with ONLY the headline, nothing else. Do not deliberate."
   },
 
   "body": {
@@ -165,7 +204,7 @@ Here's every property with its default:
 
     // Prompt template sent to the body agent. Use {{transcript}} as the
     // placeholder for the session transcript.
-    "prompt": "Given this transcript of a coding session, write a concise git commit body.\n\nRules:\n- Summarize what was done and why\n- Be concise — a few sentences or bullet points\n- Focus on the \"why\" more than the \"what\"\n\nTranscript:\n{{transcript}}\n\nRespond with ONLY the commit body, nothing else.",
+    "prompt": "Given this transcript of a coding session, write a concise git commit body.\n\nRules:\n- Summarize what was done and why\n- Be concise: a few sentences or bullet points\n- Focus on the \"why\" more than the \"what\"\n\nTranscript:\n{{transcript}}\n\nRespond with ONLY the commit body, nothing else.",
 
     // Wrap prose lines at this width. Code blocks, tables, headers, and
     // other structured content are preserved verbatim.
@@ -182,4 +221,4 @@ runtime without changing config.
 
 - Node.js >= 18
 - Git
-- Claude Code
+- Claude Code or Codex CLI

package/cli.js

@@ -3,26 +3,27 @@
 const { readStdin } = require('./lib/io')
 const { install, uninstall } = require('./lib/install')
 const { init, deinit } = require('./lib/init')
-const { run } = require('./lib/run')
+const { run, runPreCompact } = require('./lib/run')
 const { handleTrack } = require('./lib/track')
 const { handleSessionStart, handleSessionEnd } = require('./lib/session')
 const { doctor } = require('./lib/doctor')
 const { monitor } = require('./lib/monitor')
 const { gitRoot } = require('./lib/git')
+const { parseHarnessArg, normalizeHookInput } = require('./lib/harness')
 
 const VERSION = require('./package.json').version
 
 const USAGE = `turbocommit v${VERSION}
-Auto-commit after every Claude Code turn.
+Auto-commit after every AI coding agent turn.
 
 Commands:
-  install     Add turbocommit hooks to ~/.claude/settings.json
-  uninstall   Remove turbocommit from settings
-  init        Create .claude/turbocommit.json in current git repo
-  deinit      Remove .claude/turbocommit.json
+  install     Add turbocommit hooks to installed harnesses
+  uninstall   Remove turbocommit hooks
+  init        Create .turbocommit.json in current git repo
+  deinit      Remove turbocommit project config
   doctor      Check hook and config health
   monitor     Tail the event log (start/success/fail)
-  hook        Hook entry points (called by Claude Code, not manually)
+  hook        Hook entry points (called by harness hooks, not manually)
   help        Show this help text
   --version, -v  Show version
 
@@ -34,23 +35,30 @@ Usage:
 `
 
 function main (argv) {
-  const cmd = argv[0]
+  const parsed = parseHarnessArg(argv)
+  if (!parsed.ok) {
+    console.error(parsed.error)
+    console.error('Run "turbocommit help" for usage.')
+    process.exitCode = 1
+    return
+  }
+  const cmd = parsed.args[0]
 
   switch (cmd) {
     case 'install':
-      return cmdInstall()
+      return cmdInstall(parsed.harness)
     case 'uninstall':
-      return cmdUninstall()
+      return cmdUninstall(parsed.harness)
     case 'doctor':
-      return cmdDoctor()
+      return cmdDoctor(parsed.harness)
     case 'monitor':
-      return cmdMonitor()
+      return cmdMonitor(parsed.harness)
     case 'init':
       return cmdInit()
     case 'deinit':
       return cmdDeinit()
     case 'hook':
-      return cmdHook(argv.slice(1))
+      return cmdHook(parsed.args.slice(1), parsed.harness)
     case 'run':
       return cmdRunDeprecated()
     case '--version':
@@ -71,33 +79,42 @@ function main (argv) {
   }
 }
 
-function cmdInstall () {
-  const result = install()
-  if (result.alreadyInstalled) {
-    console.log('turbocommit already installed.')
-    console.log(`  Settings: ${result.settingsPath}`)
+function cmdInstall (harness) {
+  const result = install({ harness })
+  if (result.results.length === 0) {
+    console.log('No supported harness config dirs found.')
     return
   }
-  console.log('turbocommit installed.')
-  console.log(`  Settings: ${result.settingsPath}`)
+  for (const r of result.results) {
+    console.log(r.alreadyInstalled ? `turbocommit already installed for ${r.harness}.` : `turbocommit installed for ${r.harness}.`)
+    console.log(`  ${r.harness === 'codex' ? 'Hooks' : 'Settings'}: ${r.hooksPath || r.settingsPath}`)
+  }
   console.log('')
   console.log('════════════════════════════════════════════════════════════════════')
-  console.log('IMPORTANT: Restart Claude Code for the hooks to take effect.')
+  for (const r of result.results) {
+    if (r.harness === 'codex') {
+      console.log('IMPORTANT: Restart Codex and run /hooks to review turbocommit hooks.')
+    } else {
+      console.log('IMPORTANT: Restart Claude Code for the hooks to take effect.')
+    }
+  }
   console.log('════════════════════════════════════════════════════════════════════')
   console.log('')
   console.log('Next steps:')
-  console.log('  1. Restart Claude Code (required)')
+  console.log('  1. Restart the installed harness')
   console.log('  2. Run: turbocommit init  in a repo to enable auto-commits')
 }
 
-function cmdUninstall () {
-  const result = uninstall()
-  if (!result.wasInstalled) {
-    console.log('turbocommit was not installed.')
+function cmdUninstall (harness) {
+  const result = uninstall({ harness })
+  if (result.results.length === 0) {
+    console.log('No supported harness config dirs found.')
     return
   }
-  console.log('turbocommit uninstalled.')
-  console.log(`  Settings: ${result.settingsPath}`)
+  for (const r of result.results) {
+    console.log(r.wasInstalled ? `turbocommit uninstalled for ${r.harness}.` : `turbocommit was not installed for ${r.harness}.`)
+    console.log(`  ${r.harness === 'codex' ? 'Hooks' : 'Settings'}: ${r.hooksPath || r.settingsPath}`)
+  }
 }
 
 function cmdInit () {
@@ -124,16 +141,17 @@ function cmdDeinit () {
     return
   }
   if (!result.existed) {
-    console.log('turbocommit was not enabled in this repo.')
+    console.log('turbocommit project config was not found.')
+    console.log('Global config may still enable turbocommit.')
     return
   }
   console.log('turbocommit disabled.')
-  console.log(`  Removed: ${result.path}`)
+  for (const p of result.paths) console.log(`  Removed: ${p}`)
 }
 
-function cmdDoctor () {
+function cmdDoctor (harness) {
   const STATUS = { ok: '  ok', warn: 'warn', error: ' err', info: 'info' }
-  const result = doctor()
+  const result = doctor({ harness })
   for (const check of result.checks) {
     console.log(`[${STATUS[check.status] || check.status}] ${check.name}: ${check.message}`)
   }
@@ -142,34 +160,39 @@ function cmdDoctor () {
   }
 }
 
-function cmdMonitor () {
-  monitor()
+function cmdMonitor (harness) {
+  if (!monitor(harness)) process.exitCode = 1
 }
 
-function cmdHook (argv) {
+function cmdHook (argv, harness) {
   const event = argv[0]
   try {
     const input = readStdin()
-    const root = gitRoot()
+    const hookInput = normalizeHookInput(input, event, harness)
+    if (!hookInput) return
+    const root = gitRoot(hookInput.cwd || process.cwd())
     switch (event) {
       case 'pre-tool-use':
-        handleTrack(input, root)
+        handleTrack(hookInput, root)
         return
       case 'session-start':
-        handleSessionStart(input, root)
+        handleSessionStart(hookInput, root)
         return
       case 'session-end':
-        handleSessionEnd(input, root)
+        handleSessionEnd(hookInput, root)
+        return
+      case 'pre-compact':
+        runPreCompact(hookInput)
         return
       case 'stop':
-        run(input)
+        run(hookInput)
         break
       default:
-        // Unknown hook event — ignore silently (never fail)
+        // Unknown hook event: ignore silently (never fail)
         break
     }
   } catch {
-    // Never fail — fire and forget
+    // Never fail: fire and forget
   }
 }
 

package/lib/agent.js

@@ -1,6 +1,7 @@
 const { tryRun } = require('./io')
 
 const DEFAULT_COMMAND = 'claude -p --model haiku'
+const DEFAULT_CODEX_COMMAND = 'codex exec --ephemeral -'
 
 const DEFAULT_TITLE_PROMPT = `You have 10 seconds. Write a single-line git commit headline (max 72 chars) from this coding session transcript. Speed over perfection — a rough title beats no title.
 
@@ -49,8 +50,12 @@ function runAgent (root, command, prompt) {
   return output || null
 }
 
-function runTitleAgent (root, titleCfg, transcript) {
-  const command = titleCfg.command || DEFAULT_COMMAND
+function defaultCommand (harness) {
+  return harness === 'codex' ? DEFAULT_CODEX_COMMAND : DEFAULT_COMMAND
+}
+
+function runTitleAgent (root, titleCfg, transcript, harness) {
+  const command = titleCfg.command || defaultCommand(harness)
   const template = titleCfg.prompt || DEFAULT_TITLE_PROMPT
   const prompt = renderPrompt(template, transcript)
   const result = runAgent(root, command, prompt)
@@ -59,8 +64,8 @@ function runTitleAgent (root, titleCfg, transcript) {
   return result.split('\n')[0].slice(0, 72) || null
 }
 
-function runBodyAgent (root, bodyCfg, transcript) {
-  const command = bodyCfg.command || DEFAULT_COMMAND
+function runBodyAgent (root, bodyCfg, transcript, harness) {
+  const command = bodyCfg.command || defaultCommand(harness)
   const template = bodyCfg.prompt || DEFAULT_BODY_PROMPT
   const prompt = renderPrompt(template, transcript)
   return runAgent(root, command, prompt)
@@ -68,8 +73,10 @@ function runBodyAgent (root, bodyCfg, transcript) {
 
 module.exports = {
   DEFAULT_COMMAND,
+  DEFAULT_CODEX_COMMAND,
   DEFAULT_TITLE_PROMPT,
   DEFAULT_BODY_PROMPT,
+  defaultCommand,
   renderPrompt,
   runAgent,
   runTitleAgent,

package/lib/codex.js

@@ -0,0 +1,34 @@
+const fs = require('fs')
+const path = require('path')
+const { codexHome } = require('./harness')
+
+function resolveCodexTranscriptPath (hookInput) {
+  if (hookInput.transcriptPath) return hookInput.transcriptPath
+  if (!hookInput.sessionId) return null
+
+  const catalog = path.join(codexHome(), 'sessions', 'index', 'catalog.jsonl')
+  let lines
+  try {
+    lines = fs.readFileSync(catalog, 'utf8').split('\n')
+  } catch {
+    return null
+  }
+
+  for (const line of lines) {
+    if (!line.trim()) continue
+    let entry
+    try {
+      entry = JSON.parse(line)
+    } catch {
+      continue
+    }
+    if (entry.session_id === hookInput.sessionId && entry.rollout_path) {
+      return path.isAbsolute(entry.rollout_path)
+        ? entry.rollout_path
+        : path.join(codexHome(), entry.rollout_path)
+    }
+  }
+  return null
+}
+
+module.exports = { resolveCodexTranscriptPath }

package/lib/config.js

@@ -0,0 +1,52 @@
+const os = require('os')
+const path = require('path')
+const { loadJson, mergeConfig } = require('./io')
+
+function xdgConfigPath () {
+  const base = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config')
+  return path.join(base, 'turbocommit', 'config.json')
+}
+
+function legacyGlobalConfigPath () {
+  return path.join(os.homedir(), '.claude', 'turbocommit.json')
+}
+
+function globalConfigPath () {
+  return loadJson(xdgConfigPath()) ? xdgConfigPath() : legacyGlobalConfigPath()
+}
+
+function neutralProjectConfigPath (root) {
+  return path.join(root, '.turbocommit.json')
+}
+
+function legacyProjectConfigPath (root) {
+  return path.join(root, '.claude', 'turbocommit.json')
+}
+
+function projectConfigPath (root) {
+  return loadJson(neutralProjectConfigPath(root)) ? neutralProjectConfigPath(root) : legacyProjectConfigPath(root)
+}
+
+function activeConfig (root) {
+  const globalPath = globalConfigPath()
+  const projectPath = root ? projectConfigPath(root) : null
+  const globalCfg = loadJson(globalPath)
+  const projectCfg = projectPath ? loadJson(projectPath) : null
+  return {
+    globalPath,
+    projectPath,
+    globalCfg,
+    projectCfg,
+    config: mergeConfig(globalCfg || {}, projectCfg || {})
+  }
+}
+
+module.exports = {
+  xdgConfigPath,
+  legacyGlobalConfigPath,
+  globalConfigPath,
+  neutralProjectConfigPath,
+  legacyProjectConfigPath,
+  projectConfigPath,
+  activeConfig
+}

package/lib/doctor.js

@@ -1,20 +1,46 @@
 const os = require('os')
 const path = require('path')
 const { loadJson, mergeConfig } = require('./io')
-const { hasTurbocommit, isFullyInstalled, getSettingsPath, HOOK_DEFS } = require('./install')
+const { hasTurbocommit, isFullyInstalled, isCodexFullyInstalled, getSettingsPath, getCodexHooksPath, HOOK_DEFS, CODEX_HOOK_DEFS } = require('./install')
 const { gitRoot } = require('./git')
 const { configPath } = require('./init')
+const { activeConfig, xdgConfigPath, legacyGlobalConfigPath, neutralProjectConfigPath, legacyProjectConfigPath } = require('./config')
+const { selectedHarnesses } = require('./harness')
 
 function globalConfigPath () {
   return path.join(os.homedir(), '.claude', 'turbocommit.json')
 }
 
-function doctor (settingsPath, cwd) {
+function doctor (settingsPathOrOptions, cwd) {
+  if (typeof settingsPathOrOptions === 'string' || settingsPathOrOptions == null) {
+    return doctorLegacy(settingsPathOrOptions, cwd)
+  }
+  const options = settingsPathOrOptions || {}
+  cwd = options.cwd || process.cwd()
+  const checks = []
+  const harnesses = selectedHarnesses(options.harness)
+
+  for (const harness of harnesses) {
+    if (harness === 'codex') {
+      checkCodex(checks, options.codexHooksPath || getCodexHooksPath())
+    } else {
+      checkClaude(checks, options.claudeSettingsPath || getSettingsPath())
+    }
+  }
+  if (harnesses.length === 0) {
+    checks.push({ name: 'Harnesses', status: 'info', message: 'No supported harness config dirs found' })
+  }
+
+  checkConfig(checks, cwd)
+
+  const ok = checks.every(c => c.status !== 'error')
+  return { ok, checks }
+}
+
+function doctorLegacy (settingsPath, cwd) {
   settingsPath = settingsPath || getSettingsPath()
   cwd = cwd || process.cwd()
   const checks = []
-
-  // 1. Global settings exist
   const settings = loadJson(settingsPath)
   if (!settings) {
     checks.push({ name: 'Global settings', status: 'error', message: `Not found: ${settingsPath}` })
@@ -32,7 +58,7 @@ function doctor (settingsPath, cwd) {
   }
   checks.push({ name: 'Hooks installed', status: 'ok', message: `All ${Object.keys(HOOK_DEFS).length} hooks installed` })
 
-  // 3. Stop group isolation — turbocommit must be the sole hook in the last group
+  // 3. Stop group isolation: turbocommit must be the sole hook in the last group
   const stopGroups = (settings.hooks && settings.hooks.Stop) || []
   const tcGroupIndex = findTurbocommitGroup(stopGroups)
   if (tcGroupIndex >= 0) {
@@ -41,7 +67,7 @@ function doctor (settingsPath, cwd) {
     const isSoleHook = tcGroup.hooks.length === 1
 
     if (!isSoleHook) {
-      checks.push({ name: 'Group isolation', status: 'warn', message: 'turbocommit shares a Stop group with other hooks — will commit even if another hook blocks' })
+      checks.push({ name: 'Group isolation', status: 'warn', message: 'turbocommit shares a Stop group with other hooks; will commit even if another hook blocks' })
     } else if (!isLastGroup) {
       checks.push({ name: 'Group isolation', status: 'warn', message: 'Another group runs after turbocommit in Stop' })
     } else {
@@ -61,21 +87,23 @@ function doctor (settingsPath, cwd) {
   // 5. Local config exists
   const root = gitRoot(cwd)
   if (!root) {
-    checks.push({ name: 'Local config', status: 'info', message: 'Not in a git repo — skipping local checks' })
+    checks.push({ name: 'Local config', status: 'info', message: 'Not in a git repo; skipping local checks' })
   } else {
-    const localPath = configPath(root)
+    const neutralPath = configPath(root)
+    const legacyPath = legacyProjectConfigPath(root)
+    const localPath = loadJson(neutralPath) ? neutralPath : legacyPath
     const localConfig = loadJson(localPath)
     if (!localConfig) {
       if (globalCfg) {
         checks.push({ name: 'Local config', status: 'info', message: 'Not found (using global config)' })
       } else {
-        checks.push({ name: 'Local config', status: 'warn', message: `Not found: ${localPath}. Run: turbocommit init` })
+        checks.push({ name: 'Local config', status: 'warn', message: `Not found: ${neutralPath}. Run: turbocommit init` })
       }
     } else {
       checks.push({ name: 'Local config', status: 'ok', message: localPath })
     }
 
-    // 6. Enabled — evaluate merged config
+    // 6. Enabled: evaluate merged config
     const merged = mergeConfig(globalCfg || {}, localConfig || {})
     if (merged.enabled !== true) {
       checks.push({ name: 'Enabled', status: 'warn', message: 'enabled is not true in merged config' })
@@ -88,6 +116,70 @@ function doctor (settingsPath, cwd) {
   return { ok, checks }
 }
 
+function checkClaude (checks, settingsPath) {
+  const settings = loadJson(settingsPath)
+  if (!settings) {
+    checks.push({ name: 'Claude settings', status: 'error', message: `Not found: ${settingsPath}` })
+    return
+  }
+  checks.push({ name: 'Claude settings', status: 'ok', message: settingsPath })
+
+  if (!isFullyInstalled(settings)) {
+    const missing = Object.keys(HOOK_DEFS).filter(event =>
+      !hasTurbocommit((settings.hooks && settings.hooks[event]) || [])
+    )
+    checks.push({ name: 'Claude hooks', status: 'error', message: `Missing hooks: ${missing.join(', ')}` })
+    return
+  }
+  checks.push({ name: 'Claude hooks', status: 'ok', message: `All ${Object.keys(HOOK_DEFS).length} hooks installed` })
+}
+
+function checkCodex (checks, hooksPath) {
+  const hooks = loadJson(hooksPath)
+  if (!hooks) {
+    checks.push({ name: 'Codex hooks', status: 'error', message: `Not found: ${hooksPath}` })
+    return
+  }
+  if (!isCodexFullyInstalled(hooks)) {
+    const missing = Object.keys(CODEX_HOOK_DEFS).filter(event =>
+      !hasTurbocommit((hooks.hooks && hooks.hooks[event]) || [])
+    )
+    checks.push({ name: 'Codex hooks', status: 'error', message: `Missing hooks: ${missing.join(', ')}` })
+    return
+  }
+  checks.push({ name: 'Codex hooks', status: 'ok', message: `All ${Object.keys(CODEX_HOOK_DEFS).length} hooks installed` })
+  checks.push({ name: 'Codex hook trust', status: 'warn', message: 'Unknown. Run /hooks in Codex to verify trust.' })
+}
+
+function checkConfig (checks, cwd) {
+  const root = gitRoot(cwd)
+  const xdgPath = xdgConfigPath()
+  const legacyGlobal = legacyGlobalConfigPath()
+  const globalPath = loadJson(xdgPath) ? xdgPath : legacyGlobal
+  const globalCfg = loadJson(globalPath)
+  checks.push(globalCfg
+    ? { name: 'Global config', status: 'ok', message: globalPath }
+    : { name: 'Global config', status: 'info', message: 'Not found (optional)' })
+
+  if (!root) {
+    checks.push({ name: 'Project config', status: 'info', message: 'Not in a git repo' })
+    return
+  }
+
+  const neutralPath = neutralProjectConfigPath(root)
+  const legacyPath = legacyProjectConfigPath(root)
+  const projectPath = loadJson(neutralPath) ? neutralPath : legacyPath
+  const projectCfg = loadJson(projectPath)
+  checks.push(projectCfg
+    ? { name: 'Project config', status: 'ok', message: projectPath }
+    : { name: 'Project config', status: 'info', message: `Not found: ${configPath(root)}` })
+
+  const { config } = activeConfig(root)
+  checks.push(config.enabled === true
+    ? { name: 'Enabled', status: 'ok', message: 'Enabled' }
+    : { name: 'Enabled', status: 'warn', message: 'enabled is not true in active config' })
+}
+
 function findTurbocommitGroup (groups) {
   for (let i = 0; i < groups.length; i++) {
     const hooks = (groups[i] && groups[i].hooks) || []