@searls/turbocommit 0.13.2 → 0.15.0

package/README.md

@@ -2,7 +2,7 @@
 
 # turbocommit
 
-turbocommit creates a git commit containing everything Claude Code or Codex
+turbocommit creates a git commit containing the paths 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.
 
@@ -18,19 +18,68 @@ sessions concurrently and detangle which agent committed what after the fact.
 
 turbocommit registers hooks with the harnesses you use:
 
-- Claude Code: **PreToolUse**, **SessionStart**, **SessionEnd**, and **Stop**.
-- Codex: **PreToolUse**, **SessionStart**, **PreCompact**, and
-  **Stop**.
+- Claude Code: **PreToolUse**, **PostToolUse**, **SessionStart**,
+  **SessionEnd**, and **Stop**.
+- Codex: **PreToolUse**, **PostToolUse**, **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.
+- **PreToolUse** tracks the paths supplied to editing tools and snapshots the
+  repository before shell commands.
+- **PostToolUse** attributes paths that became dirty during a shell command.
+  Commands that overlap another shell command fail closed and claim nothing.
+  Read-only commands remain uncommitted.
 - **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.
+- **Stop** fires after every turn. If the session modified files, it stages and
+  commits only the paths tracked for that session. If not, it buffers the
+  transcript for pickup by a later session that does commit.
+
+### Changes across multiple repositories
+
+A session that starts in an enabled repository can commit changes in other
+enabled local checkouts during the same turn. Turbocommit discovers each
+checkout from explicit file paths supplied to Claude Code tools, Codex
+`apply_patch`, and path-bearing MCP tools. Shell commands alone do not discover
+additional repositories.
+
+Each touched checkout:
+
+- Reads its own merged global and project configuration.
+- Stages only paths attributed to the current session, preserving unrelated
+  staged and unstaged work.
+- Gets an independent commit with the full turn transcript.
+- Gives the configured title agent repository-specific bounded diff context.
+
+Turbocommit attempts every commit before pushing every successful commit whose
+repository has `push: true`. Failures are retained and retried on a later Stop,
+along with every transcript accumulated before the commit succeeds.
+
+Separate worktrees are committed independently. Enabled submodules are
+committed and pushed before enabled parent repositories. When one turn creates
+commits in multiple repositories, each commit includes a shared
+`Turbocommit-Session` trailer.
+
+Relative tool paths are matched to the checkout where that path changed. If the
+same relative path is dirty in multiple worktrees, Turbocommit skips the turn
+with an `ambiguous-tracking` monitor reason instead of guessing which checkout
+owns it, then clears that ambiguous tracking so later turns can proceed. Direct
+editing tools such as `apply_patch` resolve relative paths from their recorded
+working directory. Path-bearing MCP tools may report singular paths, path
+arrays, or local file URIs. Pathless tool calls and directory-valued path fields
+do not claim files or prevent later exact edits in the same session from
+committing.
+
+Before staging, Turbocommit resolves tracked paths to the exact changed files,
+treats Git pathspec metacharacters literally, drops paths that are no longer
+dirty, and excludes newly discovered embedded repositories. Existing tracked
+submodule gitlinks remain eligible so child commits can update their parent.
+During an active merge, cherry-pick, revert, or rebase, Git forbids partial
+commits, so Turbocommit commits the operation's resolved index as a whole.
+
+Retry manifests created by older versions did not record path ownership. On
+upgrade, Turbocommit discards those unsafe retry entries and records a
+`legacy-manifest` monitor event rather than guessing which files they owned.
 
 The commit message headline is generated by a title agent (configurable).
 The body contains the full prompt/response transcript. When planning

package/cli.js

@@ -4,7 +4,7 @@ const { readStdin } = require('./lib/io')
 const { install, uninstall } = require('./lib/install')
 const { init, deinit } = require('./lib/init')
 const { run, runPreCompact } = require('./lib/run')
-const { handleTrack } = require('./lib/track')
+const { handleTrack, handlePostTrack } = require('./lib/track')
 const { handleSessionStart, handleSessionEnd } = require('./lib/session')
 const { doctor } = require('./lib/doctor')
 const { monitor } = require('./lib/monitor')
@@ -175,6 +175,9 @@ function cmdHook (argv, harness) {
       case 'pre-tool-use':
         handleTrack(hookInput, root)
         return
+      case 'post-tool-use':
+        handlePostTrack(hookInput, root)
+        return
       case 'session-start':
         handleSessionStart(hookInput, root)
         return

package/lib/git.js

@@ -1,4 +1,5 @@
 const { execSync } = require('child_process')
+const fs = require('fs')
 const path = require('path')
 
 function git (args, opts = {}) {
@@ -12,12 +13,66 @@ function git (args, opts = {}) {
 
 function gitRoot (cwd) {
   try {
-    return git('rev-parse --show-toplevel', { cwd })
+    return canonicalRoot(git('rev-parse --show-toplevel', { cwd }))
   } catch {
     return null
   }
 }
 
+function canonicalRoot (filePath) {
+  const target = path.resolve(filePath)
+  let probe = target
+  while (!fs.existsSync(probe)) {
+    const parent = path.dirname(probe)
+    if (parent === probe) return target
+    probe = parent
+  }
+  try {
+    return path.join(fs.realpathSync(probe), path.relative(probe, target))
+  } catch {
+    return target
+  }
+}
+
+function canonicalTrackedPath (filePath) {
+  const target = path.resolve(filePath)
+  return path.join(canonicalRoot(path.dirname(target)), path.basename(target))
+}
+
+function gitRootForPath (filePath) {
+  let probe = filePath
+  try {
+    if (!fs.statSync(probe).isDirectory()) probe = path.dirname(probe)
+  } catch {
+    probe = path.dirname(probe)
+  }
+  while (probe && !fs.existsSync(probe)) {
+    const parent = path.dirname(probe)
+    if (parent === probe) return null
+    probe = parent
+  }
+  return gitRoot(probe)
+}
+
+function gitWorktrees (cwd) {
+  try {
+    return git('worktree list --porcelain', { cwd })
+      .split('\n')
+      .filter(line => line.startsWith('worktree '))
+      .map(line => line.slice('worktree '.length))
+      .map(root => {
+        try {
+          return fs.realpathSync(root)
+        } catch {
+          return null
+        }
+      })
+      .filter(Boolean)
+  } catch {
+    return []
+  }
+}
+
 function gitCommonDir (cwd) {
   try {
     const out = git('rev-parse --git-common-dir', { cwd })
@@ -44,12 +99,70 @@ function hasChanges (cwd) {
   return untracked.length > 0
 }
 
+function hasPathChanges (cwd, filePath) {
+  return changedPaths(cwd, [filePath]).length > 0
+}
+
 function addAndCommit (cwd, headline, body) {
+  stageAll(cwd)
+  commitStaged(cwd, headline, body)
+  return git('rev-parse HEAD', { cwd })
+}
+
+function stageAll (cwd) {
   git('add -A', { cwd })
+}
+
+function stagePaths (cwd, filePaths) {
+  const changed = changedPaths(cwd, filePaths)
+  const paths = pathspecs(cwd, changed)
+  if (paths.length === 0) return []
+  git(`add -A -- ${paths.map(quote).join(' ')}`, { cwd })
+  return changed
+}
+
+function commitPaths (cwd, filePaths, headline, body) {
+  const changed = stagePaths(cwd, filePaths)
+  return commitStagedPaths(cwd, changed, headline, body)
+}
+
+function commitStagedPaths (cwd, filePaths, headline, body) {
+  const paths = pathspecs(cwd, filePaths)
+  if (paths.length === 0) return null
+  if (hasRepositoryOperation(cwd)) return commitStaged(cwd, headline, body)
+  git(`commit --only -m "${esc(headline)}" -m "${esc(body)}" --no-verify -- ${paths.map(quote).join(' ')}`, { cwd })
+  return git('rev-parse HEAD', { cwd })
+}
+
+function commitStaged (cwd, headline, body) {
   git(`commit -m "${esc(headline)}" -m "${esc(body)}" --no-verify`, { cwd })
   return git('rev-parse HEAD', { cwd })
 }
 
+function stagedChangeContext (cwd, budget = 20000, filePaths) {
+  const selected = filePaths && filePaths.length > 0
+    ? ` -- ${pathspecs(cwd, filePaths).map(quote).join(' ')}`
+    : ''
+  const status = git(`status --short${selected}`, { cwd })
+  const stat = git(`diff --cached --stat${selected}`, { cwd })
+  const diff = git(`diff --cached --no-ext-diff --unified=3${selected}`, { cwd })
+  const prefix = `Status:\n${status || '(clean)'}\n\nDiff stat:\n${stat || '(none)'}\n\nDiff:\n`
+  const remaining = Math.max(0, budget - prefix.length)
+  return prefix + (diff.length > remaining ? diff.slice(0, remaining) + '\n[... diff truncated ...]' : diff)
+}
+
+function isGitlink (parentRoot, childRoot) {
+  const relative = path.relative(parentRoot, childRoot)
+  if (!relative || relative.startsWith('..')) return false
+  try {
+    return git(`ls-files --stage -- ${quote(literalPathspec(relative))}`, { cwd: parentRoot })
+      .split('\n')
+      .some(line => line.startsWith('160000 '))
+  } catch {
+    return false
+  }
+}
+
 function hasCommits (cwd) {
   try {
     git('rev-parse HEAD', { cwd })
@@ -80,13 +193,101 @@ function esc (s) {
   return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\$/g, '\\$').replace(/`/g, '\\`')
 }
 
+function quote (value) {
+  return `'${value.replace(/'/g, '\'"\'"\'')}'`
+}
+
+function pathspecs (cwd, filePaths) {
+  cwd = canonicalRoot(cwd)
+  return [...new Set(filePaths.map(filePath => path.relative(cwd, canonicalTrackedPath(filePath))))]
+    .filter(relative => relative && !relative.startsWith('..'))
+    .map(literalPathspec)
+}
+
+function literalPathspec (relative) {
+  return `:(literal)${relative}`
+}
+
+function changedPaths (cwd, filePaths) {
+  cwd = canonicalRoot(cwd)
+  const selected = pathspecs(cwd, filePaths)
+  if (selected.length === 0) return []
+  return collectChangedPaths(cwd, selected)
+}
+
+function changedPathsInRepository (cwd) {
+  cwd = canonicalRoot(cwd)
+  return collectChangedPaths(cwd, [])
+}
+
+function collectChangedPaths (cwd, selected) {
+  const args = selected.length > 0 ? ` -- ${selected.map(quote).join(' ')}` : ''
+  const tracked = hasCommits(cwd)
+    ? git(`diff --name-only --no-renames -z HEAD${args}`, { cwd })
+    : git(`ls-files --cached -z${args}`, { cwd })
+  const untracked = git(`ls-files --others --exclude-standard -z${args}`, { cwd })
+  const relativePaths = [...splitNull(tracked), ...splitNull(untracked)]
+  return [...new Set(relativePaths)]
+    .filter(relative => !isEmbeddedRepository(cwd, relative) || isHeadGitlink(cwd, relative))
+    .map(relative => path.join(cwd, relative))
+}
+
+function splitNull (value) {
+  return value ? value.split('\0').filter(Boolean) : []
+}
+
+function isEmbeddedRepository (cwd, relative) {
+  const candidate = path.join(cwd, relative)
+  try {
+    return fs.statSync(candidate).isDirectory() && fs.existsSync(path.join(candidate, '.git'))
+  } catch {
+    return false
+  }
+}
+
+function isHeadGitlink (cwd, relative) {
+  try {
+    return git(`ls-tree HEAD -- ${quote(literalPathspec(relative))}`, { cwd })
+      .split('\n')
+      .some(line => line.startsWith('160000 '))
+  } catch {
+    return false
+  }
+}
+
+function hasRepositoryOperation (cwd) {
+  return ['MERGE_HEAD', 'CHERRY_PICK_HEAD', 'REVERT_HEAD', 'rebase-merge', 'rebase-apply']
+    .some(name => {
+      try {
+        const gitPath = git(`rev-parse --git-path ${quote(name)}`, { cwd })
+        return fs.existsSync(path.isAbsolute(gitPath) ? gitPath : path.join(cwd, gitPath))
+      } catch {
+        return false
+      }
+    })
+}
+
 module.exports = {
   git,
+  canonicalRoot,
+  canonicalTrackedPath,
   gitRoot,
+  gitRootForPath,
+  gitWorktrees,
   gitCommonDir,
   hasChanges,
+  changedPaths,
+  changedPathsInRepository,
+  hasPathChanges,
   addAndCommit,
+  stageAll,
+  stagePaths,
+  commitPaths,
+  commitStagedPaths,
+  commitStaged,
+  stagedChangeContext,
   hasCommits,
   currentBranch,
-  pushClean
+  pushClean,
+  isGitlink
 }

package/lib/harness.js

@@ -75,6 +75,7 @@ function normalizeHookInput (input, event, forcedHarness) {
     transcriptPath: hookInput.transcript_path,
     toolName: hookInput.tool_name,
     toolInput: hookInput.tool_input || {},
+    toolUseId: hookInput.tool_use_id,
     cwd: hookInput.cwd,
     model: hookInput.model,
     source: hookInput.source,
@@ -85,6 +86,7 @@ function normalizeHookInput (input, event, forcedHarness) {
 function eventName (event) {
   const names = {
     'pre-tool-use': 'PreToolUse',
+    'post-tool-use': 'PostToolUse',
     'session-start': 'SessionStart',
     'session-end': 'SessionEnd',
     'pre-compact': 'PreCompact',

package/lib/install.js

@@ -10,6 +10,10 @@ const HOOK_DEFS = {
     matcher: 'Write|Edit|MultiEdit|NotebookEdit|Bash|mcp__.*',
     hooks: [{ type: 'command', command: 'turbocommit hook pre-tool-use --harness claude' }]
   },
+  PostToolUse: {
+    matcher: 'Bash',
+    hooks: [{ type: 'command', command: 'turbocommit hook post-tool-use --harness claude' }]
+  },
   SessionStart: {
     hooks: [{ type: 'command', command: 'turbocommit hook session-start --harness claude' }]
   },
@@ -23,9 +27,13 @@ const HOOK_DEFS = {
 
 const CODEX_HOOK_DEFS = {
   PreToolUse: {
-    matcher: 'Write|Edit|MultiEdit|NotebookEdit|Bash|mcp__.*',
+    matcher: 'apply_patch|Write|Edit|MultiEdit|NotebookEdit|Bash|mcp__.*',
     hooks: [{ type: 'command', command: 'turbocommit hook pre-tool-use --harness codex' }]
   },
+  PostToolUse: {
+    matcher: 'Bash',
+    hooks: [{ type: 'command', command: 'turbocommit hook post-tool-use --harness codex' }]
+  },
   SessionStart: {
     matcher: 'resume|clear',
     hooks: [{ type: 'command', command: 'turbocommit hook session-start --harness codex' }]
@@ -67,7 +75,8 @@ function hasExactHooks (groups, def) {
   return expected.every(cmd =>
     groups.some(g => {
       const hooks = g && g.hooks ? g.hooks : []
-      return hooks.some(h => h.command === cmd)
+      const matcherMatches = def.matcher === undefined || g.matcher === def.matcher
+      return matcherMatches && hooks.some(h => h.command === cmd)
     })
   )
 }
@@ -99,8 +108,7 @@ function removeTurbocommitHooks (groups) {
 }
 
 /**
- * Install turbocommit hooks for all 4 events (PreToolUse, SessionStart,
- * SessionEnd, Stop). Each event gets its own group at the end.
+ * Install every turbocommit hook event. Each event gets its own group at the end.
  * Cleans up stale entries (including old `turbocommit run`) on install.
  */
 function installClaude (settingsPath) {

package/lib/multi.js

@@ -0,0 +1,197 @@
+const crypto = require('crypto')
+const fs = require('fs')
+const path = require('path')
+const { ensureDir, loadJson } = require('./io')
+const { turbocommitDir } = require('./session')
+const { canonicalRoot, canonicalTrackedPath, gitRoot, gitRootForPath, gitWorktrees, hasPathChanges, isGitlink } = require('./git')
+const { activeConfig } = require('./config')
+
+function checkoutKey (root) {
+  return crypto.createHash('sha256').update(fs.realpathSync(root)).digest('hex').slice(0, 16)
+}
+
+function manifestPath (anchor) {
+  return path.join(turbocommitDir(anchor), 'multi', checkoutKey(anchor), 'manifest.json')
+}
+
+function loadManifest (anchor) {
+  return normalizeManifest(loadJson(manifestPath(anchor)))
+}
+
+function saveManifest (anchor, manifest) {
+  const file = manifestPath(anchor)
+  ensureDir(path.dirname(file))
+  fs.writeFileSync(file, JSON.stringify({
+    nextOrder: manifest.nextOrder,
+    repos: manifest.repos
+  }, null, 2) + '\n')
+}
+
+function deleteManifestIfEmpty (anchor, manifest) {
+  if (manifest.repos.length > 0) {
+    saveManifest(anchor, manifest)
+    return
+  }
+  try {
+    fs.unlinkSync(manifestPath(anchor))
+  } catch {}
+}
+
+function trackedChangesFromEntries (anchor, entries) {
+  const pathsByRoot = new Map()
+  const ambiguous = []
+  const add = (root, file) => {
+    root = canonicalRoot(root)
+    file = canonicalTrackedPath(file)
+    if (!root || activeConfig(root).config.enabled !== true) return
+    const relative = path.relative(root, file)
+    if (!relative || relative.startsWith('..')) return
+    if (!pathsByRoot.has(root)) pathsByRoot.set(root, new Set())
+    pathsByRoot.get(root).add(path.join(root, relative))
+  }
+
+  for (const entry of entries) {
+    const rawFiles = Array.isArray(entry.rawFiles) && entry.rawFiles.length > 0
+      ? entry.rawFiles
+      : Array.isArray(entry.files) ? entry.files : []
+    if (entry.tool === 'Bash' && rawFiles.length === 0) continue
+    if (rawFiles.length === 0) continue
+
+    for (const rawFile of rawFiles) {
+      const candidates = changedCandidates(anchor, entry.cwd || anchor, rawFile, entry.tool)
+      if (candidates.length > 1) {
+        ambiguous.push({ tool: entry.tool, path: rawFile, reason: 'multiple-worktrees' })
+      } else if (candidates.length === 1) {
+        add(candidates[0].root, candidates[0].file)
+      }
+    }
+  }
+
+  addEnabledSuperprojects(pathsByRoot, add)
+  const repos = [...pathsByRoot].map(([root, paths]) => ({ root, paths: [...paths] }))
+  return { repos, ambiguous }
+}
+
+function changedCandidates (anchor, cwd, rawFile, tool) {
+  if (path.isAbsolute(rawFile)) return changedCandidate(rawFile)
+
+  anchor = canonicalRoot(anchor)
+  const direct = canonicalTrackedPath(path.resolve(cwd, rawFile))
+  const directRoot = gitRootForPath(direct)
+  if (!isOpaquePathTool(tool) || (directRoot && directRoot !== anchor)) {
+    return changedCandidate(direct)
+  }
+
+  const relative = path.relative(anchor, direct)
+  if (!relative || relative.startsWith('..')) return changedCandidate(direct)
+  const candidates = []
+  const seen = new Set()
+  for (const worktree of gitWorktrees(anchor)) {
+    const file = canonicalTrackedPath(path.join(worktree, relative))
+    if (isDirectoryPath(file)) continue
+    const root = gitRootForPath(file)
+    if (!root || seen.has(root) || activeConfig(root).config.enabled !== true) continue
+    seen.add(root)
+    if (hasPathChanges(root, file)) candidates.push({ root, file })
+  }
+  return candidates
+}
+
+function isOpaquePathTool (tool) {
+  return typeof tool === 'string' && tool.startsWith('mcp__')
+}
+
+function changedCandidate (file) {
+  if (isDirectoryPath(file)) return []
+  file = canonicalTrackedPath(file)
+  const root = gitRootForPath(file)
+  if (!root || activeConfig(root).config.enabled !== true) return []
+  return hasPathChanges(root, file) ? [{ root, file }] : []
+}
+
+function isDirectoryPath (file) {
+  try {
+    return fs.statSync(file).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+function addEnabledSuperprojects (pathsByRoot, add) {
+  for (const child of [...pathsByRoot.keys()]) {
+    const parent = gitRoot(path.dirname(child))
+    if (parent && parent !== child && isGitlink(parent, child)) add(parent, child)
+  }
+}
+
+function dependencyOrder (repos) {
+  return [...repos].sort((a, b) => {
+    if (isGitlink(a.root, b.root)) return 1
+    if (isGitlink(b.root, a.root)) return -1
+    return a.order - b.order
+  })
+}
+
+function appendWork (manifest, root, work) {
+  let repo = manifest.repos.find(candidate => candidate.root === root)
+  if (!repo) {
+    repo = { root, order: manifest.nextOrder++, work: [] }
+    manifest.repos.push(repo)
+  }
+  if (!repo.work.some(item => item.key === work.key)) repo.work.push(work)
+  return repo
+}
+
+function normalizeManifest (stored) {
+  const manifest = stored && typeof stored === 'object' ? stored : {}
+  const repos = Array.isArray(manifest.repos) ? manifest.repos : []
+  let discardedLegacyWork = 0
+  const normalizedRepos = []
+
+  for (const repo of repos) {
+    if (!repo || typeof repo.root !== 'string' || !Array.isArray(repo.work)) continue
+    const work = repo.work.filter(item => {
+      const safe = item && Array.isArray(item.paths) && item.paths.length > 0
+      if (!safe) discardedLegacyWork++
+      return safe
+    })
+    if (work.length > 0) normalizedRepos.push({ ...repo, work })
+  }
+
+  return {
+    nextOrder: Number.isInteger(manifest.nextOrder) ? manifest.nextOrder : 0,
+    repos: normalizedRepos,
+    discardedLegacyWork
+  }
+}
+
+function multiWatermarkPath (root, sessionId) {
+  return path.join(turbocommitDir(root), 'multi-watermarks', checkoutKey(root), sessionId + '.json')
+}
+
+function readMultiWatermark (root, sessionIds) {
+  for (const sessionId of sessionIds) {
+    const value = loadJson(multiWatermarkPath(root, sessionId))
+    if (value?.commit) return value
+  }
+  return null
+}
+
+function saveMultiWatermark (root, sessionId, commit) {
+  const file = multiWatermarkPath(root, sessionId)
+  ensureDir(path.dirname(file))
+  fs.writeFileSync(file, JSON.stringify({ commit }) + '\n')
+}
+
+module.exports = {
+  appendWork,
+  checkoutKey,
+  deleteManifestIfEmpty,
+  dependencyOrder,
+  loadManifest,
+  manifestPath,
+  readMultiWatermark,
+  trackedChangesFromEntries,
+  saveManifest,
+  saveMultiWatermark
+}

package/lib/run.js

@@ -4,15 +4,25 @@ const path = require('path')
 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 { gitRoot, hasChanges, changedPaths, addAndCommit, stagePaths, commitPaths, commitStagedPaths, stagedChangeContext, currentBranch, pushClean } = require('./git')
 const { logEvent } = require('./log')
 const { wrapText } = require('./wrap')
-const { hasTrackedModifications, cleanupTracking } = require('./track')
+const { hasTrackedModifications, cleanupTracking, readTracking } = require('./track')
 const { redact, buildRedactions } = require('./redact')
 const { handleSessionEnd, getAncestors, savePending, collectPending, cleanupConsumed, cleanupStale, readWatermark, saveWatermark, resolveParentCommit } = require('./session')
 const { activeConfig } = require('./config')
 const { normalizeHookInput } = require('./harness')
 const { resolveCodexTranscriptPath } = require('./codex')
+const {
+  appendWork,
+  deleteManifestIfEmpty,
+  dependencyOrder,
+  loadManifest,
+  readMultiWatermark,
+  trackedChangesFromEntries,
+  saveManifest,
+  saveMultiWatermark
+} = require('./multi')
 
 /**
  * Map a model ID like "claude-opus-4-6" to a friendly name like "Claude Opus 4.6".
@@ -87,11 +97,47 @@ function resolveCoauthor (config, transcriptPath, root, opts = {}) {
  * Always exits 0 — never blocks Claude, never outputs to stdout.
  *
  * Skip/commit decision is based on PreToolUse tracking:
- * - If tracking file exists with entries → this agent modified files → commit
+ * - If tracking file contains changed paths → commit only those paths
  * - If tracking file missing/empty → skip, buffer transcript for later pickup
  */
 function run (input, opts = {}) {
   if (process.env.TURBOCOMMIT_DISABLED) return
+  const hookInput = typeof input === 'string'
+    ? normalizeHookInput(input, 'stop', opts.harness)
+    : input
+  if (!hookInput) return
+
+  const root = gitRoot(hookInput.cwd || process.cwd())
+  if (!root || activeConfig(root).config.enabled !== true) return
+
+  const entries = hookInput.sessionId ? readTracking(root, hookInput.sessionId) : []
+  const tracked = trackedChangesFromEntries(root, entries)
+  const manifest = loadManifest(root)
+  if (manifest.discardedLegacyWork > 0) {
+    logEvent('skip', {
+      harness: hookInput.harness,
+      project: path.basename(root),
+      branch: currentBranch(root),
+      reason: 'legacy-manifest',
+      discarded: manifest.discardedLegacyWork
+    })
+    manifest.discardedLegacyWork = 0
+    deleteManifestIfEmpty(root, manifest)
+  }
+  const hasCrossRootPath = tracked.repos.length > 0 &&
+    (tracked.repos.length !== 1 || tracked.repos[0].root !== root)
+
+  if (tracked.ambiguous.length > 0) {
+    return runSingle(hookInput, { paths: [], trackingReason: 'ambiguous-tracking' })
+  }
+  if (manifest.repos.length > 0 || tracked.repos.length > 1 || hasCrossRootPath) {
+    return runMulti(hookInput, root, tracked.repos, manifest)
+  }
+  return runSingle(hookInput, { paths: tracked.repos[0]?.paths || [] })
+}
+
+function runSingle (input, opts = {}) {
+  if (process.env.TURBOCOMMIT_DISABLED) return
 
   const hookInput = typeof input === 'string'
     ? normalizeHookInput(input, 'stop', opts.harness)
@@ -120,6 +166,7 @@ function run (input, opts = {}) {
   try { context = fs.statSync(transcriptPath).size } catch {}
 
   const sessionId = hookInput.sessionId
+  const ownedPaths = opts.paths || []
 
   // Watermark slicing: only include new pairs since last commit in this session
   const watermark = sessionId ? readWatermark(root, sessionId) : null
@@ -139,21 +186,38 @@ function run (input, opts = {}) {
     if (!(precompactWatermark && newPairs.length === 0 && selfPrecompactPending.length > 0)) {
       savePending(root, sessionId, formatBody(effectivePairs))
     }
-    logEvent('skip', { harness: hookInput.harness, project, branch, context })
+    logEvent('skip', { harness: hookInput.harness, project, branch, context, reason: 'no-tracking' })
+    cleanupStale(root)
+    return
+  }
+
+  if (sessionId && (opts.trackingReason || ownedPaths.length === 0)) {
+    if (!(precompactWatermark && newPairs.length === 0 && selfPrecompactPending.length > 0)) {
+      savePending(root, sessionId, formatBody(effectivePairs))
+    }
+    cleanupTracking(root, sessionId)
+    logEvent('skip', {
+      harness: hookInput.harness,
+      project,
+      branch,
+      context,
+      reason: opts.trackingReason || 'no-path-changes'
+    })
     cleanupStale(root)
     return
   }
 
   try {
     // Early exit: tracking fired but all changes were reverted
-    if (hasCommits(root) && !hasChanges(root)) {
+    const hasOwnedChanges = sessionId ? changedPaths(root, ownedPaths).length > 0 : hasChanges(root)
+    if (!hasOwnedChanges) {
       if (sessionId) {
         if (!(precompactWatermark && newPairs.length === 0 && selfPrecompactPending.length > 0)) {
           savePending(root, sessionId, formatBody(effectivePairs))
         }
         cleanupTracking(root, sessionId)
       }
-      logEvent('skip', { harness: hookInput.harness, project, branch, context })
+      logEvent('skip', { harness: hookInput.harness, project, branch, context, reason: 'no-path-changes' })
       cleanupStale(root)
       return
     }
@@ -214,7 +278,21 @@ function run (input, opts = {}) {
     const redactions = buildRedactions()
     const safeHeadline = redact(headline, redactions)
     const safeBody = redact(wrappedBody + tag, redactions)
-    const sha = addAndCommit(root, safeHeadline, safeBody)
+    const sha = sessionId
+      ? commitPaths(root, ownedPaths, safeHeadline, safeBody)
+      : addAndCommit(root, safeHeadline, safeBody)
+    if (!sha) {
+      if (sessionId) cleanupTracking(root, sessionId)
+      logEvent('skip', {
+        harness: hookInput.harness,
+        project,
+        branch,
+        context,
+        reason: 'no-path-changes'
+      })
+      cleanupStale(root)
+      return
+    }
 
     logEvent('success', { harness: hookInput.harness, project, branch, context, title: safeHeadline })
 
@@ -240,6 +318,211 @@ function run (input, opts = {}) {
   }
 }
 
+function runMulti (hookInput, anchor, currentRepos, manifest) {
+  recordCodexStop(hookInput, anchor)
+
+  const transcriptPath = resolveTranscriptPath(hookInput)
+  const pairs = hookInput.harness === 'codex'
+    ? parseCodexTranscript(transcriptPath)
+    : parseTranscript(transcriptPath)
+  const sessionId = hookInput.sessionId
+  const watermark = sessionId ? readWatermark(anchor, sessionId) : null
+  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(anchor, [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
+  }
+  const formattedTranscript = formatBody(effectivePairs)
+  const ancestors = sessionId ? getAncestors(anchor, sessionId) : []
+  const pending = sessionId ? collectPending(anchor, [...ancestors].reverse()) : []
+  if (precompactWatermark && newPairs.length > 0 && selfPrecompactPending.length > 0) {
+    pending.push(...selfPrecompactPending)
+  }
+  const turnBody = pending.length > 0
+    ? '## Planning\n\n' + pending.join('\n\n---\n\n') +
+      '\n\n## Implementation\n\n' + formattedTranscript
+    : formattedTranscript
+
+  const dirtyRepos = currentRepos.filter(repo => changedPaths(repo.root, repo.paths).length > 0)
+  const isMultiTurn = currentRepos.length > 1
+  const turnKey = hookInput.raw?.turn_id ||
+    cryptoKey(`${sessionId || 'no-session'}\n${pairs.length}\n${turnBody}`)
+
+  if (dirtyRepos.length === 0 && manifest.repos.length === 0) {
+    if (sessionId) {
+      savePending(anchor, sessionId, formattedTranscript)
+      cleanupTracking(anchor, sessionId)
+    }
+    logEvent('skip', {
+      harness: hookInput.harness,
+      project: path.basename(anchor),
+      branch: currentBranch(anchor),
+      context: transcriptSize(transcriptPath),
+      reason: 'no-path-changes'
+    })
+    return
+  }
+
+  for (const repo of currentRepos) {
+    appendWork(manifest, repo.root, {
+      key: turnKey,
+      body: turnBody,
+      sessionIds: isMultiTurn && sessionId ? [sessionId] : [],
+      paths: repo.paths
+    })
+  }
+
+  saveManifest(anchor, manifest)
+  const successes = []
+  const ordered = dependencyOrder(manifest.repos)
+
+  for (const repo of ordered) {
+    const root = repo.root
+    const { config } = activeConfig(root)
+    const project = path.basename(root)
+    const branch = currentBranch(root)
+    const context = transcriptSize(transcriptPath)
+    const ownedPaths = [...new Set(repo.work.flatMap(item => item.paths || []))]
+
+    if (config.enabled !== true) {
+      manifest.repos = manifest.repos.filter(candidate => candidate !== repo)
+      logEvent('skip', { harness: hookInput.harness, project, branch, context })
+      continue
+    }
+    if (ownedPaths.length === 0) {
+      logEvent('skip', {
+        harness: hookInput.harness,
+        project,
+        branch,
+        context,
+        reason: 'missing-manifest-paths'
+      })
+      continue
+    }
+    const currentPaths = changedPaths(root, ownedPaths)
+    if (currentPaths.length === 0) {
+      manifest.repos = manifest.repos.filter(candidate => candidate !== repo)
+      logEvent('skip', { harness: hookInput.harness, project, branch, context, reason: 'no-path-changes' })
+      continue
+    }
+
+    try {
+      logEvent('start', { harness: hookInput.harness, project, branch, context })
+      const stagedPaths = stagePaths(root, currentPaths)
+      if (stagedPaths.length === 0) {
+        manifest.repos = manifest.repos.filter(candidate => candidate !== repo)
+        logEvent('skip', { harness: hookInput.harness, project, branch, context, reason: 'no-path-changes' })
+        continue
+      }
+
+      const rawBody = repo.work.map(item => item.body).join('\n\n---\n\n')
+      const redactions = buildRedactions()
+      const changeContext = redact(stagedChangeContext(root, 10000, stagedPaths), redactions)
+      const titleInput = `${changeContext}\n\nTranscript:\n${rawBody}`.slice(0, 20000)
+
+      let headline
+      if (config.title?.type !== 'transcript') {
+        headline = runTitleAgent(root, config.title || {}, titleInput, hookInput.harness)
+      }
+      headline = headline || extractHeadline(effectivePairs)
+
+      let body
+      if (config.body?.type === 'agent') {
+        body = runBodyAgent(root, config.body, rawBody, hookInput.harness)
+      }
+      body = body || rawBody
+
+      const parent = sessionId
+        ? readMultiWatermark(root, [sessionId, ...ancestors])
+        : null
+      if (parent?.commit) body = `Continuation of ${parent.commit.slice(0, 7)}\n\n${body}`
+      body = wrapText(body, config.body?.maxLineLength)
+
+      const trailers = []
+      for (const work of repo.work) {
+        for (const id of work.sessionIds || []) {
+          if (!trailers.includes(id)) trailers.push(id)
+        }
+      }
+      if (trailers.length > 0) {
+        body += '\n\n' + trailers.map(id => `Turbocommit-Session: ${id}`).join('\n')
+      }
+
+      const coauthor = resolveCoauthor(config, transcriptPath, root, {
+        harness: hookInput.harness,
+        model: hookInput.model
+      })
+      if (coauthor) body += '\n\n' + coauthor
+
+      const safeHeadline = redact(headline, redactions)
+      const safeBody = redact(body, redactions)
+      const sha = commitStagedPaths(root, stagedPaths, safeHeadline, safeBody)
+      if (!sha) throw new Error('Tracked paths changed before commit')
+      if (sessionId) saveMultiWatermark(root, sessionId, sha)
+      if (root === anchor && sessionId) {
+        saveWatermark(anchor, sessionId, pairs.length, sha, { source: 'commit' })
+      }
+      manifest.repos = manifest.repos.filter(candidate => candidate !== repo)
+      successes.push({ root, config, project, branch })
+      logEvent('success', {
+        harness: hookInput.harness,
+        project,
+        branch,
+        context,
+        title: safeHeadline
+      })
+    } catch {
+      logEvent('fail', { harness: hookInput.harness, project, branch, context })
+    }
+  }
+
+  for (const success of successes) {
+    if (success.config.push !== true) continue
+    if (pushClean(success.root)) {
+      logEvent('push', {
+        harness: hookInput.harness,
+        project: success.project,
+        branch: success.branch
+      })
+    } else {
+      logEvent('push-fail', {
+        harness: hookInput.harness,
+        project: success.project,
+        branch: success.branch
+      })
+    }
+  }
+
+  if (sessionId) {
+    if (!readWatermark(anchor, sessionId)) {
+      saveWatermark(anchor, sessionId, pairs.length, undefined, { source: 'multi' })
+    }
+    cleanupConsumed(anchor, [...ancestors, sessionId])
+    cleanupTracking(anchor, sessionId)
+  }
+  deleteManifestIfEmpty(anchor, manifest)
+  cleanupStale(anchor)
+}
+
+function transcriptSize (transcriptPath) {
+  try {
+    return fs.statSync(transcriptPath).size
+  } catch {
+    return 0
+  }
+}
+
+function cryptoKey (value) {
+  return require('crypto').createHash('sha256').update(value).digest('hex').slice(0, 20)
+}
+
 function runPreCompact (input, opts = {}) {
   if (process.env.TURBOCOMMIT_DISABLED) return
   const hookInput = typeof input === 'string'

package/lib/track.js

@@ -1,7 +1,12 @@
+const crypto = require('crypto')
 const fs = require('fs')
 const path = require('path')
+const { fileURLToPath } = require('url')
 const { ensureDir } = require('./io')
 const { turbocommitDir } = require('./session')
+const { canonicalRoot, canonicalTrackedPath, changedPathsInRepository } = require('./git')
+
+const BASH_SNAPSHOT_TTL_MS = 60 * 60 * 1000
 
 /**
  * Directory under the git common dir where turbocommit stores tracking state.
@@ -21,7 +26,17 @@ function trackingPath (root, sessionId) {
 /**
  * Keys to probe in tool_input for a file path (MCP tools, Write, Edit, etc.)
  */
-const FILE_PATH_KEYS = ['file_path', 'filePath', 'path', 'file', 'notebook_path']
+const FILE_PATH_KEYS = [
+  'file_path',
+  'filePath',
+  'path',
+  'file',
+  'notebook_path',
+  'relative_path',
+  'relativePath',
+  'uri'
+]
+const FILE_PATH_ARRAY_KEYS = ['file_paths', 'filePaths', 'paths', 'files']
 
 /**
  * Extract a file path from tool_input, heuristically checking known keys.
@@ -29,13 +44,75 @@ const FILE_PATH_KEYS = ['file_path', 'filePath', 'path', 'file', 'notebook_path'
 function extractFilePath (toolInput) {
   if (!toolInput || typeof toolInput !== 'object') return null
   for (const key of FILE_PATH_KEYS) {
-    if (typeof toolInput[key] === 'string' && toolInput[key].length > 0) {
-      return toolInput[key]
-    }
+    const value = normalizeRawPath(toolInput[key], key)
+    if (value) return value
   }
   return null
 }
 
+function extractRawFilePaths (toolName, toolInput) {
+  const paths = []
+  const seen = new Set()
+  const add = (value, key) => {
+    value = normalizeRawPath(value, key)
+    if (!value) return
+    if (seen.has(value)) return
+    seen.add(value)
+    paths.push(value)
+  }
+
+  if (toolName === 'apply_patch' && typeof toolInput?.command === 'string') {
+    for (const line of toolInput.command.split('\n')) {
+      const match = line.match(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/) ||
+        line.match(/^\*\*\* Move to: (.+)$/)
+      if (match) add(match[1])
+    }
+    return paths
+  }
+
+  const visit = value => {
+    if (!value || typeof value !== 'object') return
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item)
+      return
+    }
+    for (const [key, nested] of Object.entries(value)) {
+      if (FILE_PATH_KEYS.includes(key)) add(nested, key)
+      if (FILE_PATH_ARRAY_KEYS.includes(key) && Array.isArray(nested)) {
+        for (const item of nested) add(item, key)
+      }
+      if (nested && typeof nested === 'object') visit(nested)
+    }
+  }
+  visit(toolInput)
+  return paths
+}
+
+function normalizeRawPath (value, key) {
+  if (typeof value !== 'string' || value.length === 0) return null
+  if (key !== 'uri') return value
+  if (value.startsWith('file://')) {
+    try {
+      return fileURLToPath(value)
+    } catch {
+      return null
+    }
+  }
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(value)) return null
+  return value
+}
+
+function extractFilePaths (toolName, toolInput, cwd) {
+  const seen = new Set()
+  return extractRawFilePaths(toolName, toolInput).map(value =>
+    path.isAbsolute(value) ? value : path.resolve(cwd || process.cwd(), value)
+  ).filter(value => {
+    if (seen.has(value)) return false
+    seen.add(value)
+    return true
+  })
+}
+
 /**
  * PreToolUse handler. Appends a tracking entry for potentially-modifying tools.
  * Always exits 0 (never blocks tool execution).
@@ -53,17 +130,17 @@ function handleTrack (input, root) {
 
   const toolInput = hookInput.toolInput || hookInput.tool_input || {}
 
-  const entry = { tool: toolName, t: Date.now() }
-
-  // Extract file path for file-modifying tools
-  const filePath = extractFilePath(toolInput)
-  if (filePath) {
-    entry.file = filePath
-  }
+  const cwd = hookInput.cwd || hookInput.raw?.cwd || root
+  const entry = { tool: toolName, t: Date.now(), cwd }
+  const rawFiles = extractRawFilePaths(toolName, toolInput)
+  const files = extractFilePaths(toolName, toolInput, cwd)
+  if (rawFiles.length > 0) entry.rawFiles = rawFiles
+  if (files.length > 0) entry.files = files
 
   // For Bash, record the command
   if (toolName === 'Bash' && typeof toolInput.command === 'string') {
     entry.command = toolInput.command
+    saveBashSnapshot(root, sessionId, hookInput.toolUseId || hookInput.tool_use_id)
   }
 
   // Skip Bash with no command (malformed input). All other non-Bash tools
@@ -77,6 +154,158 @@ function handleTrack (input, root) {
   fs.appendFileSync(file, JSON.stringify(entry) + '\n')
 }
 
+function handlePostTrack (input, root) {
+  const hookInput = typeof input === 'string' ? parseInput(input) : input
+  root = root || hookInput?.root
+  if (!root || !hookInput) return
+
+  const sessionId = hookInput.sessionId || hookInput.session_id
+  const toolName = hookInput.toolName || hookInput.tool_name
+  if (!sessionId || toolName !== 'Bash') return
+
+  const cwd = hookInput.cwd || hookInput.raw?.cwd || root
+  const toolUseId = hookInput.toolUseId || hookInput.tool_use_id
+  const snapshot = loadBashSnapshot(root, sessionId, toolUseId)
+  if (!snapshot) return
+
+  const now = Date.now()
+  const overlapping = hasOverlappingBashSnapshot(root, snapshot, now)
+  snapshot.endedAt = now
+  writeBashSnapshot(root, sessionId, toolUseId, snapshot)
+
+  const before = new Set(snapshot.before.map(canonicalTrackedPath))
+  const claimed = claimedPathsByOtherSessions(root, sessionId)
+  const files = overlapping
+    ? []
+    : changedPathsInRepository(snapshot.root)
+      .map(canonicalTrackedPath)
+      .filter(file => !before.has(file) && !claimed.has(file))
+
+  const entry = { tool: 'Bash', phase: 'post', t: now, cwd }
+  if (overlapping) entry.overlapping = true
+  if (files.length > 0) {
+    entry.rawFiles = files
+    entry.files = files
+  }
+  appendTracking(root, sessionId, entry)
+}
+
+function bashSnapshotDir (root) {
+  const base = turbocommitDir(root)
+  return base && path.join(base, 'bash-snapshots')
+}
+
+function bashSnapshotPath (root, sessionId, toolUseId) {
+  const dir = bashSnapshotDir(root)
+  if (!dir) return null
+  const key = crypto.createHash('sha256')
+    .update(`${sessionId}\0${toolUseId || 'current'}`)
+    .digest('hex')
+  return path.join(dir, key + '.json')
+}
+
+function saveBashSnapshot (root, sessionId, toolUseId) {
+  const checkout = canonicalRoot(root)
+  pruneBashSnapshots(root)
+  writeBashSnapshot(root, sessionId, toolUseId, {
+    root: checkout,
+    sessionId,
+    toolUseId: toolUseId || null,
+    startedAt: Date.now(),
+    before: changedPathsInRepository(checkout)
+  })
+}
+
+function writeBashSnapshot (root, sessionId, toolUseId, snapshot) {
+  const file = bashSnapshotPath(root, sessionId, toolUseId)
+  if (!file) return
+  ensureDir(path.dirname(file))
+  const temporary = file + `.${process.pid}.${crypto.randomUUID()}.tmp`
+  try {
+    fs.writeFileSync(temporary, JSON.stringify(snapshot) + '\n')
+    fs.renameSync(temporary, file)
+  } finally {
+    try { fs.unlinkSync(temporary) } catch {}
+  }
+}
+
+function loadBashSnapshot (root, sessionId, toolUseId) {
+  try {
+    return JSON.parse(fs.readFileSync(bashSnapshotPath(root, sessionId, toolUseId), 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+function hasOverlappingBashSnapshot (root, current, now) {
+  const dir = bashSnapshotDir(root)
+  let files
+  try {
+    files = fs.readdirSync(dir)
+  } catch {
+    return false
+  }
+  return files.some(file => {
+    try {
+      const other = JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'))
+      if (other.sessionId === current.sessionId && other.toolUseId === current.toolUseId) return false
+      if (canonicalRoot(other.root) !== canonicalRoot(current.root)) return false
+      const endedAt = Number.isFinite(other.endedAt) ? other.endedAt : now
+      return other.startedAt <= now && endedAt >= current.startedAt
+    } catch {
+      return false
+    }
+  })
+}
+
+function pruneBashSnapshots (root) {
+  const dir = bashSnapshotDir(root)
+  let files
+  try {
+    files = fs.readdirSync(dir)
+  } catch {
+    return
+  }
+  const cutoff = Date.now() - BASH_SNAPSHOT_TTL_MS
+  for (const file of files) {
+    try {
+      const fullPath = path.join(dir, file)
+      const snapshot = JSON.parse(fs.readFileSync(fullPath, 'utf8'))
+      if ((snapshot.endedAt || snapshot.startedAt || 0) < cutoff) fs.unlinkSync(fullPath)
+    } catch {}
+  }
+}
+
+function claimedPathsByOtherSessions (root, sessionId) {
+  const result = new Set()
+  const dir = trackingDir(root)
+  let files
+  try {
+    files = fs.readdirSync(dir)
+  } catch {
+    return result
+  }
+  for (const file of files) {
+    if (file === sessionId + '.jsonl' || !file.endsWith('.jsonl')) continue
+    try {
+      const entries = fs.readFileSync(path.join(dir, file), 'utf8').trim().split('\n')
+      for (const line of entries) {
+        const entry = JSON.parse(line)
+        if (!Array.isArray(entry.files)) continue
+        for (const claimed of entry.files) result.add(canonicalTrackedPath(claimed))
+      }
+    } catch {}
+  }
+  return result
+}
+
+function appendTracking (root, sessionId, entry) {
+  const file = trackingPath(root, sessionId)
+  if (!file) return
+  ensureDir(path.dirname(file))
+  fs.appendFileSync(file, JSON.stringify(entry) + '\n')
+}
+
 function parseInput (input) {
   try {
     return JSON.parse(input)
@@ -87,26 +316,29 @@ function parseInput (input) {
 
 /**
  * Check whether a session has tracked any file-modifying tool calls.
- * Bash entries alone don't count — Bash is too noisy (ls, git status, etc.)
- * and we can't reliably distinguish read-only from write commands.
- * The definitive signal comes from Write/Edit/NotebookEdit/MCP tools.
+ * A Bash pre-hook alone doesn't count because shell commands may be read-only.
+ * A Bash post-hook counts only when its snapshot found newly dirty paths.
  */
 function hasTrackedModifications (root, sessionId) {
+  return readTracking(root, sessionId).some(entry =>
+    entry.tool !== 'Bash' || (entry.phase === 'post' && Array.isArray(entry.files) && entry.files.length > 0)
+  )
+}
+
+function readTracking (root, sessionId) {
   const file = trackingPath(root, sessionId)
   try {
     const data = fs.readFileSync(file, 'utf8')
-    if (!data) return false
-    const lines = data.trim().split('\n')
-    return lines.some(line => {
+    if (!data) return []
+    return data.trim().split('\n').map(line => {
       try {
-        const entry = JSON.parse(line)
-        return entry.tool !== 'Bash'
+        return JSON.parse(line)
       } catch {
-        return false
+        return null
       }
-    })
+    }).filter(Boolean)
   } catch {
-    return false
+    return []
   }
 }
 
@@ -121,9 +353,13 @@ function cleanupTracking (root, sessionId) {
 
 module.exports = {
   handleTrack,
+  handlePostTrack,
   hasTrackedModifications,
   cleanupTracking,
   extractFilePath,
+  extractFilePaths,
+  extractRawFilePaths,
+  readTracking,
   trackingDir,
   trackingPath
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@searls/turbocommit",
-  "version": "0.13.2",
+  "version": "0.15.0",
   "description": "Auto-commit after every AI coding agent turn",
   "bin": {
     "turbocommit": "./cli.js"