@searls/turbocommit 0.12.0 → 0.13.0

package/lib/git.js

@@ -1,4 +1,5 @@
 const { execSync } = require('child_process')
+const path = require('path')
 
 function git (args, opts = {}) {
   const cwd = opts.cwd || process.cwd()
@@ -17,6 +18,16 @@ function gitRoot (cwd) {
   }
 }
 
+function gitCommonDir (cwd) {
+  try {
+    const out = git('rev-parse --git-common-dir', { cwd })
+    if (!out) return null
+    return path.isAbsolute(out) ? out : path.resolve(cwd, out)
+  } catch {
+    return null
+  }
+}
+
 function hasChanges (cwd) {
   try {
     git('diff --quiet HEAD', { cwd })
@@ -72,6 +83,7 @@ function esc (s) {
 module.exports = {
   git,
   gitRoot,
+  gitCommonDir,
   hasChanges,
   addAndCommit,
   hasCommits,

package/lib/harness.js

@@ -0,0 +1,99 @@
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+
+const HARNESSES = ['claude', 'codex']
+
+function parseHarnessArg (argv) {
+  const args = []
+  let harness = null
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    if (arg === '--harness') {
+      harness = argv[++i]
+    } else if (arg.startsWith('--harness=')) {
+      harness = arg.slice('--harness='.length)
+    } else {
+      args.push(arg)
+    }
+  }
+  if (harness && !HARNESSES.includes(harness)) {
+    return { ok: false, error: `Invalid harness: ${harness}`, args, harness }
+  }
+  return { ok: true, args, harness }
+}
+
+function claudeHome () {
+  return path.join(os.homedir(), '.claude')
+}
+
+function codexHome () {
+  return process.env.CODEX_HOME || path.join(os.homedir(), '.codex')
+}
+
+function harnessHome (harness) {
+  return harness === 'codex' ? codexHome() : claudeHome()
+}
+
+function existingHarnesses () {
+  return HARNESSES.filter(h => fs.existsSync(harnessHome(h)))
+}
+
+function selectedHarnesses (harness, { create = false } = {}) {
+  if (harness) {
+    if (create) fs.mkdirSync(harnessHome(harness), { recursive: true })
+    return [harness]
+  }
+  return existingHarnesses()
+}
+
+function inferHarness (hookInput, forcedHarness) {
+  if (forcedHarness) return forcedHarness
+  if (hookInput && hookInput.hook_event_name) return 'codex'
+  return 'claude'
+}
+
+function normalizeHookInput (input, event, forcedHarness) {
+  let hookInput
+  try {
+    hookInput = JSON.parse(input)
+  } catch {
+    return null
+  }
+  const harness = inferHarness(hookInput, forcedHarness)
+  const hookEvent = hookInput.hook_event_name || eventName(event)
+  return {
+    harness,
+    event: hookEvent,
+    sessionId: hookInput.session_id,
+    transcriptPath: hookInput.transcript_path,
+    toolName: hookInput.tool_name,
+    toolInput: hookInput.tool_input || {},
+    cwd: hookInput.cwd,
+    model: hookInput.model,
+    source: hookInput.source,
+    raw: hookInput
+  }
+}
+
+function eventName (event) {
+  const names = {
+    'pre-tool-use': 'PreToolUse',
+    'session-start': 'SessionStart',
+    'session-end': 'SessionEnd',
+    'pre-compact': 'PreCompact',
+    stop: 'Stop'
+  }
+  return names[event] || event
+}
+
+module.exports = {
+  HARNESSES,
+  parseHarnessArg,
+  claudeHome,
+  codexHome,
+  harnessHome,
+  existingHarnesses,
+  selectedHarnesses,
+  normalizeHookInput
+}

package/lib/init.js

@@ -2,9 +2,10 @@ const fs = require('fs')
 const path = require('path')
 const { gitRoot } = require('./git')
 const { writeJson, ensureDir } = require('./io')
+const { neutralProjectConfigPath, legacyProjectConfigPath } = require('./config')
 
 function configPath (root) {
-  return path.join(root, '.claude', 'turbocommit.json')
+  return neutralProjectConfigPath(root)
 }
 
 function init (cwd) {
@@ -13,14 +14,18 @@ function init (cwd) {
     return { ok: false, error: 'Not a git repository' }
   }
 
-  const p = configPath(root)
-  if (fs.existsSync(p)) {
-    return { ok: true, alreadyExists: true, path: p }
+  const neutralPath = configPath(root)
+  const legacyPath = legacyProjectConfigPath(root)
+  if (fs.existsSync(neutralPath)) {
+    return { ok: true, alreadyExists: true, path: neutralPath }
+  }
+  if (fs.existsSync(legacyPath)) {
+    return { ok: true, alreadyExists: true, path: legacyPath }
   }
 
-  ensureDir(path.dirname(p))
-  writeJson(p, { enabled: true })
-  return { ok: true, alreadyExists: false, path: p }
+  ensureDir(path.dirname(neutralPath))
+  writeJson(neutralPath, { enabled: true })
+  return { ok: true, alreadyExists: false, path: neutralPath }
 }
 
 function deinit (cwd) {
@@ -29,13 +34,14 @@ function deinit (cwd) {
     return { ok: false, error: 'Not a git repository' }
   }
 
-  const p = configPath(root)
-  if (!fs.existsSync(p)) {
-    return { ok: true, existed: false, path: p }
+  const paths = [configPath(root), legacyProjectConfigPath(root)]
+  const existing = paths.filter(p => fs.existsSync(p))
+  if (existing.length === 0) {
+    return { ok: true, existed: false, path: paths[0], paths: [] }
   }
 
-  fs.unlinkSync(p)
-  return { ok: true, existed: true, path: p }
+  for (const p of existing) fs.unlinkSync(p)
+  return { ok: true, existed: true, path: existing[0], paths: existing }
 }
 
 module.exports = { init, deinit, configPath }

package/lib/install.js

@@ -1,6 +1,6 @@
-const os = require('os')
 const path = require('path')
 const { loadJson, writeJson } = require('./io')
+const { selectedHarnesses, claudeHome, codexHome } = require('./harness')
 
 /**
  * Hook definitions for each Claude Code event turbocommit uses.
@@ -21,8 +21,30 @@ const HOOK_DEFS = {
   }
 }
 
+const CODEX_HOOK_DEFS = {
+  PreToolUse: {
+    matcher: 'Write|Edit|MultiEdit|NotebookEdit|Bash|mcp__.*',
+    hooks: [{ type: 'command', command: 'turbocommit hook pre-tool-use' }]
+  },
+  SessionStart: {
+    matcher: 'resume|clear',
+    hooks: [{ type: 'command', command: 'turbocommit hook session-start' }]
+  },
+  PreCompact: {
+    matcher: 'manual|auto',
+    hooks: [{ type: 'command', command: 'turbocommit hook pre-compact' }]
+  },
+  Stop: {
+    hooks: [{ type: 'command', command: 'turbocommit hook stop' }]
+  }
+}
+
 function getSettingsPath () {
-  return path.join(os.homedir(), '.claude', 'settings.json')
+  return path.join(claudeHome(), 'settings.json')
+}
+
+function getCodexHooksPath () {
+  return path.join(codexHome(), 'hooks.json')
 }
 
 function hasTurbocommit (groups) {
@@ -43,6 +65,13 @@ function isFullyInstalled (settings) {
   )
 }
 
+function isCodexFullyInstalled (hooksConfig) {
+  if (!hooksConfig || !hooksConfig.hooks) return false
+  return Object.keys(CODEX_HOOK_DEFS).every(event =>
+    hasTurbocommit(hooksConfig.hooks[event])
+  )
+}
+
 function removeTurbocommitHooks (groups) {
   if (!Array.isArray(groups)) return groups
   return groups.map(g => {
@@ -57,7 +86,7 @@ function removeTurbocommitHooks (groups) {
  * SessionEnd, Stop). Each event gets its own group at the end.
  * Cleans up stale entries (including old `turbocommit run`) on install.
  */
-function install (settingsPath) {
+function installClaude (settingsPath) {
   settingsPath = settingsPath || getSettingsPath()
   const settings = loadJson(settingsPath) || {}
 
@@ -88,7 +117,7 @@ function install (settingsPath) {
   return { alreadyInstalled: false, settingsPath }
 }
 
-function uninstall (settingsPath) {
+function uninstallClaude (settingsPath) {
   settingsPath = settingsPath || getSettingsPath()
   const settings = loadJson(settingsPath)
 
@@ -112,4 +141,93 @@ function uninstall (settingsPath) {
   return { wasInstalled, settingsPath }
 }
 
-module.exports = { install, uninstall, hasTurbocommit, isFullyInstalled, getSettingsPath, HOOK_DEFS }
+function installCodex (hooksPath) {
+  hooksPath = hooksPath || getCodexHooksPath()
+  const hooksConfig = loadJson(hooksPath) || {}
+
+  if (!hooksConfig.hooks) hooksConfig.hooks = {}
+
+  if (isCodexFullyInstalled(hooksConfig)) {
+    return { alreadyInstalled: true, hooksPath }
+  }
+
+  for (const k of Object.keys(hooksConfig.hooks)) {
+    hooksConfig.hooks[k] = removeTurbocommitHooks(hooksConfig.hooks[k])
+    if (Array.isArray(hooksConfig.hooks[k]) && hooksConfig.hooks[k].length === 0) {
+      delete hooksConfig.hooks[k]
+    }
+  }
+
+  for (const [event, def] of Object.entries(CODEX_HOOK_DEFS)) {
+    if (!hooksConfig.hooks[event]) hooksConfig.hooks[event] = []
+    const group = { hooks: def.hooks }
+    if (def.matcher) group.matcher = def.matcher
+    hooksConfig.hooks[event].push(group)
+  }
+
+  writeJson(hooksPath, hooksConfig)
+  return { alreadyInstalled: false, hooksPath }
+}
+
+function uninstallCodex (hooksPath) {
+  hooksPath = hooksPath || getCodexHooksPath()
+  const hooksConfig = loadJson(hooksPath)
+
+  if (!hooksConfig || !hooksConfig.hooks) {
+    return { wasInstalled: false, hooksPath }
+  }
+
+  const wasInstalled = Object.keys(hooksConfig.hooks).some(event =>
+    hasTurbocommit(hooksConfig.hooks[event])
+  )
+
+  for (const k of Object.keys(hooksConfig.hooks)) {
+    hooksConfig.hooks[k] = removeTurbocommitHooks(hooksConfig.hooks[k])
+    if (Array.isArray(hooksConfig.hooks[k]) && hooksConfig.hooks[k].length === 0) {
+      delete hooksConfig.hooks[k]
+    }
+  }
+
+  writeJson(hooksPath, hooksConfig)
+  return { wasInstalled, hooksPath }
+}
+
+function install (settingsPathOrOptions) {
+  if (typeof settingsPathOrOptions === 'string') return installClaude(settingsPathOrOptions)
+  const harness = settingsPathOrOptions?.harness || null
+  const harnesses = selectedHarnesses(harness, { create: Boolean(harness) })
+  const results = harnesses.map(h =>
+    h === 'codex'
+      ? { harness: h, ...installCodex(settingsPathOrOptions?.codexHooksPath) }
+      : { harness: h, ...installClaude(settingsPathOrOptions?.claudeSettingsPath) }
+  )
+  return { results, installedHarnesses: harnesses }
+}
+
+function uninstall (settingsPathOrOptions) {
+  if (typeof settingsPathOrOptions === 'string') return uninstallClaude(settingsPathOrOptions)
+  const harness = settingsPathOrOptions?.harness || null
+  const harnesses = selectedHarnesses(harness)
+  const results = harnesses.map(h =>
+    h === 'codex'
+      ? { harness: h, ...uninstallCodex(settingsPathOrOptions?.codexHooksPath) }
+      : { harness: h, ...uninstallClaude(settingsPathOrOptions?.claudeSettingsPath) }
+  )
+  return { results, uninstalledHarnesses: harnesses }
+}
+
+module.exports = {
+  install,
+  uninstall,
+  installClaude,
+  uninstallClaude,
+  installCodex,
+  uninstallCodex,
+  hasTurbocommit,
+  isFullyInstalled,
+  isCodexFullyInstalled,
+  getSettingsPath,
+  getCodexHooksPath,
+  HOOK_DEFS,
+  CODEX_HOOK_DEFS
+}

package/lib/log.js

@@ -1,15 +1,17 @@
 const fs = require('fs')
 const path = require('path')
 const os = require('os')
+const { codexHome } = require('./harness')
 
-function logPath () {
-  return path.join(os.homedir(), '.claude', 'turbocommit', 'monitor.jsonl')
+function logPath (harness = 'claude') {
+  const home = harness === 'codex' ? codexHome() : path.join(os.homedir(), '.claude')
+  return path.join(home, 'turbocommit', 'monitor.jsonl')
 }
 
 function logEvent (event, meta = {}) {
   try {
     const entry = { event, ...meta, title: meta.title || null, at: Date.now() }
-    const p = logPath()
+    const p = logPath(meta.harness || 'claude')
     fs.mkdirSync(path.dirname(p), { recursive: true })
     fs.appendFileSync(p, JSON.stringify(entry) + '\n')
   } catch {}

package/lib/monitor.js

@@ -1,5 +1,6 @@
 const fs = require('fs')
 const { logPath } = require('./log')
+const { existingHarnesses } = require('./harness')
 
 const COLORS = {
   start: '\x1b[36m',
@@ -48,9 +49,11 @@ function readEntries (filePath) {
   }
 }
 
-function monitor () {
+function monitor (harness) {
+  harness = resolveHarness(harness)
+  if (!harness) return false
   const cols = process.stdout.columns || 80
-  const lp = logPath()
+  const lp = logPath(harness)
   const entries = readEntries(lp)
   for (const entry of entries) {
     process.stdout.write(formatEntry(entry, cols) + '\n')
@@ -87,6 +90,16 @@ function monitor () {
     fs.unwatchFile(lp)
     process.exit(0)
   })
+  return true
 }
 
-module.exports = { monitor, formatEntry, readEntries, formatSize, formatTime }
+function resolveHarness (harness) {
+  if (harness) return harness
+  const harnesses = existingHarnesses()
+  if (harnesses.length === 1) return harnesses[0]
+  if (harnesses.length === 0) return 'claude'
+  process.stderr.write('Multiple harnesses installed. Run: turbocommit monitor --harness claude|codex\n')
+  return null
+}
+
+module.exports = { monitor, formatEntry, readEntries, formatSize, formatTime, resolveHarness }

package/lib/run.js

@@ -1,15 +1,18 @@
 const fs = require('fs')
 const os = require('os')
 const path = require('path')
-const { loadJson, mergeConfig } = require('./io')
-const { parseTranscript, formatBody, formatTitleTranscript, extractHeadline, extractModel } = require('./transcript')
+const { loadJson } = require('./io')
+const { parseTranscript, parseCodexTranscript, formatBody, formatTitleTranscript, extractHeadline, extractModel, extractCodexModel } = require('./transcript')
 const { runTitleAgent, runBodyAgent } = require('./agent')
 const { gitRoot, hasChanges, addAndCommit, hasCommits, currentBranch, pushClean } = require('./git')
 const { logEvent } = require('./log')
 const { wrapText } = require('./wrap')
 const { hasTrackedModifications, cleanupTracking } = require('./track')
 const { redact, buildRedactions } = require('./redact')
-const { getAncestors, savePending, collectPending, cleanupConsumed, cleanupStale, readWatermark, saveWatermark, resolveParentCommit } = require('./session')
+const { handleSessionEnd, getAncestors, savePending, collectPending, cleanupConsumed, cleanupStale, readWatermark, saveWatermark, resolveParentCommit } = require('./session')
+const { activeConfig } = require('./config')
+const { normalizeHookInput } = require('./harness')
+const { resolveCodexTranscriptPath } = require('./codex')
 
 /**
  * Map a model ID like "claude-opus-4-6" to a friendly name like "Claude Opus 4.6".
@@ -54,7 +57,7 @@ function readClaudeAttribution (root) {
  * Tier 2: Claude Code attribution.commit setting (when running under Claude)
  * Tier 3: auto-detect model from transcript
  */
-function resolveCoauthor (config, transcriptPath, root) {
+function resolveCoauthor (config, transcriptPath, root, opts = {}) {
   // Tier 1: explicit turbocommit config
   if (config.coauthor === false) return null
 
@@ -63,16 +66,19 @@ function resolveCoauthor (config, transcriptPath, root) {
   }
 
   // Tier 2: Claude Code attribution setting
-  const claudeAttr = readClaudeAttribution(root)
+  const claudeAttr = opts.harness === 'codex' ? undefined : readClaudeAttribution(root)
   if (claudeAttr !== undefined) {
     return claudeAttr === '' ? null : claudeAttr
   }
 
   // Tier 3: auto-detect from transcript
-  const model = extractModel(transcriptPath)
+  const model = opts.harness === 'codex'
+    ? extractCodexModel(transcriptPath, opts.model)
+    : extractModel(transcriptPath)
   if (!model) return null
   const name = formatModelName(model)
-  return `Co-Authored-By: ${name} <noreply@anthropic.com>`
+  const email = opts.harness === 'codex' ? 'noreply@openai.com' : 'noreply@anthropic.com'
+  return `Co-Authored-By: ${name} <${email}>`
 }
 
 /**
@@ -84,46 +90,56 @@ function resolveCoauthor (config, transcriptPath, root) {
  * - If tracking file exists with entries → this agent modified files → commit
  * - If tracking file missing/empty → skip, buffer transcript for later pickup
  */
-function run (input) {
+function run (input, opts = {}) {
   if (process.env.TURBOCOMMIT_DISABLED) return
 
-  let hookInput
-  try {
-    hookInput = JSON.parse(input)
-  } catch {
-    return
-  }
+  const hookInput = typeof input === 'string'
+    ? normalizeHookInput(input, 'stop', opts.harness)
+    : input
+  if (!hookInput) return
 
   // Find git root
-  const root = gitRoot()
+  const root = gitRoot(hookInput.cwd || process.cwd())
   if (!root) return
 
   // Merge global + project config (project wins)
-  const globalCfg = loadJson(path.join(os.homedir(), '.claude', 'turbocommit.json'))
-  const projectCfg = loadJson(`${root}/.claude/turbocommit.json`)
-  const config = mergeConfig(globalCfg || {}, projectCfg || {})
+  const { config } = activeConfig(root)
   if (config.enabled !== true) return
+  recordCodexStop(hookInput, root)
 
   // Parse transcript
-  const pairs = parseTranscript(hookInput.transcript_path)
+  const transcriptPath = resolveTranscriptPath(hookInput)
+  const pairs = hookInput.harness === 'codex'
+    ? parseCodexTranscript(transcriptPath)
+    : parseTranscript(transcriptPath)
 
   // Gather monitor metadata
   const project = path.basename(root)
   const branch = currentBranch(root)
   let context = 0
-  try { context = fs.statSync(hookInput.transcript_path).size } catch {}
+  try { context = fs.statSync(transcriptPath).size } catch {}
 
-  const sessionId = hookInput.session_id
+  const sessionId = hookInput.sessionId
 
   // Watermark slicing: only include new pairs since last commit in this session
   const watermark = sessionId ? readWatermark(root, sessionId) : null
-  const newPairs = watermark ? pairs.slice(watermark.pairs) : pairs
-  const effectivePairs = newPairs.length > 0 ? newPairs : pairs
+  const watermarkPairCount = watermark && Number.isInteger(watermark.pairs) ? watermark.pairs : 0
+  const newPairs = watermark ? pairs.slice(watermarkPairCount) : pairs
+  const precompactWatermark = watermark && watermark.source === 'precompact'
+  const selfPrecompactPending = sessionId ? collectPending(root, [sessionId], { source: 'precompact' }) : []
+  let effectivePairs = newPairs.length > 0 ? newPairs : pairs
+  if (precompactWatermark && newPairs.length === 0 && selfPrecompactPending.length > 0) {
+    const basePairs = Number.isInteger(watermark.basePairs) ? watermark.basePairs : 0
+    const bufferedPairs = pairs.slice(basePairs, watermarkPairCount)
+    effectivePairs = bufferedPairs.length > 0 ? bufferedPairs : pairs
+  }
 
   // Skip decision: if PreToolUse never fired for this session, skip commit
   if (sessionId && !hasTrackedModifications(root, sessionId)) {
-    savePending(root, sessionId, formatBody(effectivePairs))
-    logEvent('skip', { project, branch, context })
+    if (!(precompactWatermark && newPairs.length === 0 && selfPrecompactPending.length > 0)) {
+      savePending(root, sessionId, formatBody(effectivePairs))
+    }
+    logEvent('skip', { harness: hookInput.harness, project, branch, context })
     cleanupStale(root)
     return
   }
@@ -132,15 +148,17 @@ function run (input) {
     // Early exit: tracking fired but all changes were reverted
     if (hasCommits(root) && !hasChanges(root)) {
       if (sessionId) {
-        savePending(root, sessionId, formatBody(effectivePairs))
+        if (!(precompactWatermark && newPairs.length === 0 && selfPrecompactPending.length > 0)) {
+          savePending(root, sessionId, formatBody(effectivePairs))
+        }
         cleanupTracking(root, sessionId)
       }
-      logEvent('skip', { project, branch, context })
+      logEvent('skip', { harness: hookInput.harness, project, branch, context })
       cleanupStale(root)
       return
     }
 
-    logEvent('start', { project, branch, context })
+    logEvent('start', { harness: hookInput.harness, project, branch, context })
 
     const formattedTranscript = formatBody(effectivePairs)
 
@@ -148,14 +166,14 @@ function run (input) {
     let headline
     if (config.title?.type !== 'transcript') {
       const titleTranscript = formatTitleTranscript(effectivePairs)
-      headline = runTitleAgent(root, config.title || {}, titleTranscript)
+      headline = runTitleAgent(root, config.title || {}, titleTranscript, hookInput.harness)
     }
     headline = headline || extractHeadline(effectivePairs)
 
     // Body: transcript by default, agent if opted in
     let body
     if (config.body?.type === 'agent') {
-      body = runBodyAgent(root, config.body, formattedTranscript)
+      body = runBodyAgent(root, config.body, formattedTranscript, hookInput.harness)
     }
     body = body || formattedTranscript
 
@@ -168,10 +186,12 @@ function run (input) {
         : ''
 
       const ancestors = getAncestors(root, sessionId)
-      // Collect pending from ancestors only — self-pending is already
-      // covered by effectivePairs (same watermark baseline) so including
-      // it would duplicate content between Planning and Implementation.
+      // Normal self-pending is already covered by effectivePairs. Precompact
+      // self-pending is different because PreCompact advances the watermark.
       const pending = collectPending(root, [...ancestors].reverse())
+      if (precompactWatermark && newPairs.length > 0 && selfPrecompactPending.length > 0) {
+        pending.push(...selfPrecompactPending)
+      }
 
       if (pending.length > 0) {
         combinedBody = continuation + '## Planning\n\n' + pending.join('\n\n---\n\n') +
@@ -185,7 +205,10 @@ function run (input) {
     const wrappedBody = wrapText(combinedBody, config.body?.maxLineLength)
 
     // Resolve coauthor trailer
-    const coauthor = resolveCoauthor(config, hookInput.transcript_path, root)
+    const coauthor = resolveCoauthor(config, transcriptPath, root, {
+      harness: hookInput.harness,
+      model: hookInput.model
+    })
     const tag = coauthor ? '\n\n' + coauthor : ''
 
     const redactions = buildRedactions()
@@ -193,28 +216,70 @@ function run (input) {
     const safeBody = redact(wrappedBody + tag, redactions)
     const sha = addAndCommit(root, safeHeadline, safeBody)
 
-    logEvent('success', { project, branch, context, title: safeHeadline })
+    logEvent('success', { harness: hookInput.harness, project, branch, context, title: safeHeadline })
 
     if (config.push === true) {
       if (pushClean(root)) {
-        logEvent('push', { project, branch })
+        logEvent('push', { harness: hookInput.harness, project, branch })
       } else {
-        logEvent('push-fail', { project, branch })
+        logEvent('push-fail', { harness: hookInput.harness, project, branch })
       }
     }
 
     // Post-commit: save watermark and cleanup
     if (sessionId) {
-      saveWatermark(root, sessionId, pairs.length, sha)
+      saveWatermark(root, sessionId, pairs.length, sha, { source: 'commit' })
       const ancestors = getAncestors(root, sessionId)
       cleanupConsumed(root, [...ancestors, sessionId])
       cleanupTracking(root, sessionId)
     }
     cleanupStale(root)
   } catch (err) {
-    logEvent('fail', { project, branch, context })
+    logEvent('fail', { harness: hookInput.harness, project, branch, context })
     throw err
   }
 }
 
-module.exports = { run, formatModelName, resolveCoauthor, readClaudeAttribution }
+function runPreCompact (input, opts = {}) {
+  if (process.env.TURBOCOMMIT_DISABLED) return
+  const hookInput = typeof input === 'string'
+    ? normalizeHookInput(input, 'pre-compact', opts.harness)
+    : input
+  if (!hookInput || !hookInput.sessionId) return
+
+  const root = gitRoot(hookInput.cwd || process.cwd())
+  if (!root) return
+
+  const transcriptPath = resolveTranscriptPath(hookInput)
+  const pairs = hookInput.harness === 'codex'
+    ? parseCodexTranscript(transcriptPath)
+    : parseTranscript(transcriptPath)
+  if (pairs.length === 0) return
+
+  const existing = readWatermark(root, hookInput.sessionId)
+  const existingPairCount = existing && Number.isInteger(existing.pairs) ? existing.pairs : 0
+  const baseline = existingPairCount <= pairs.length ? existingPairCount : 0
+  const pendingPairs = pairs.slice(baseline)
+  if (pendingPairs.length > 0) {
+    savePending(root, hookInput.sessionId, formatBody(pendingPairs), { source: 'precompact' })
+  }
+  const basePairs = existing && existing.source === 'precompact' && Number.isInteger(existing.basePairs)
+    ? existing.basePairs
+    : baseline
+  saveWatermark(root, hookInput.sessionId, pairs.length, existing ? existing.commit : undefined, {
+    source: 'precompact',
+    basePairs
+  })
+}
+
+function resolveTranscriptPath (hookInput) {
+  return hookInput.harness === 'codex'
+    ? resolveCodexTranscriptPath(hookInput)
+    : hookInput.transcriptPath
+}
+
+function recordCodexStop (hookInput, root) {
+  if (hookInput.harness === 'codex' && hookInput.event === 'Stop') handleSessionEnd(hookInput, root)
+}
+
+module.exports = { run, runPreCompact, formatModelName, resolveCoauthor, readClaudeAttribution, resolveTranscriptPath, recordCodexStop }