@searls/turbocommit 0.14.1 → 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,22 @@ 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
 
@@ -43,7 +46,8 @@ additional repositories.
 Each touched checkout:
 
 - Reads its own merged global and project configuration.
-- Keeps the normal `git add -A` behavior.
+- 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.
 
@@ -56,6 +60,27 @@ 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
 context was buffered from ancestor sessions, it appears under a

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

@@ -13,12 +13,32 @@ 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 {
@@ -34,6 +54,25 @@ function gitRootForPath (filePath) {
   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 })
@@ -60,6 +99,10 @@ 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)
@@ -70,15 +113,39 @@ 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) {
-  const status = git('status --short', { cwd })
-  const stat = git('diff --cached --stat', { cwd })
-  const diff = git('diff --cached --no-ext-diff --unified=3', { 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)
@@ -88,7 +155,7 @@ function isGitlink (parentRoot, childRoot) {
   const relative = path.relative(parentRoot, childRoot)
   if (!relative || relative.startsWith('..')) return false
   try {
-    return git(`ls-files --stage -- "${esc(relative)}"`, { cwd: parentRoot })
+    return git(`ls-files --stage -- ${quote(literalPathspec(relative))}`, { cwd: parentRoot })
       .split('\n')
       .some(line => line.startsWith('160000 '))
   } catch {
@@ -126,14 +193,97 @@ 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,

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' }]
   },
@@ -26,6 +30,10 @@ const CODEX_HOOK_DEFS = {
     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

@@ -3,7 +3,7 @@ const fs = require('fs')
 const path = require('path')
 const { ensureDir, loadJson } = require('./io')
 const { turbocommitDir } = require('./session')
-const { gitRoot, gitRootForPath, isGitlink } = require('./git')
+const { canonicalRoot, canonicalTrackedPath, gitRoot, gitRootForPath, gitWorktrees, hasPathChanges, isGitlink } = require('./git')
 const { activeConfig } = require('./config')
 
 function checkoutKey (root) {
@@ -15,13 +15,16 @@ function manifestPath (anchor) {
 }
 
 function loadManifest (anchor) {
-  return loadJson(manifestPath(anchor)) || { nextOrder: 0, repos: [] }
+  return normalizeManifest(loadJson(manifestPath(anchor)))
 }
 
 function saveManifest (anchor, manifest) {
   const file = manifestPath(anchor)
   ensureDir(path.dirname(file))
-  fs.writeFileSync(file, JSON.stringify(manifest, null, 2) + '\n')
+  fs.writeFileSync(file, JSON.stringify({
+    nextOrder: manifest.nextOrder,
+    repos: manifest.repos
+  }, null, 2) + '\n')
 }
 
 function deleteManifestIfEmpty (anchor, manifest) {
@@ -34,41 +37,91 @@ function deleteManifestIfEmpty (anchor, manifest) {
   } catch {}
 }
 
-function rootsFromEntries (anchor, entries) {
-  const roots = []
-  const seen = new Set()
-  const add = root => {
-    if (!root) return
-    let real
-    try {
-      real = fs.realpathSync(root)
-    } catch {
-      return
-    }
-    if (seen.has(real)) return
-    if (activeConfig(real).config.enabled !== true) return
-    seen.add(real)
-    roots.push(real)
+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) {
-    if (entry.tool === 'Bash') continue
-    if (Array.isArray(entry.files) && entry.files.length > 0) {
-      for (const file of entry.files) add(gitRootForPath(file) || anchor)
-    } else {
-      add(anchor)
+    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)
+      }
     }
   }
-  return addEnabledSuperprojects(roots, add)
+
+  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 addEnabledSuperprojects (roots, add) {
-  for (let i = 0; i < roots.length; i++) {
-    const child = roots[i]
+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)
+    if (parent && parent !== child && isGitlink(parent, child)) add(parent, child)
   }
-  return roots
 }
 
 function dependencyOrder (repos) {
@@ -89,6 +142,29 @@ function appendWork (manifest, root, 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')
 }
@@ -115,7 +191,7 @@ module.exports = {
   loadManifest,
   manifestPath,
   readMultiWatermark,
-  rootsFromEntries,
+  trackedChangesFromEntries,
   saveManifest,
   saveMultiWatermark
 }

package/lib/run.js

@@ -4,7 +4,7 @@ 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, stageAll, commitStaged, stagedChangeContext, 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, readTracking } = require('./track')
@@ -19,7 +19,7 @@ const {
   dependencyOrder,
   loadManifest,
   readMultiWatermark,
-  rootsFromEntries,
+  trackedChangesFromEntries,
   saveManifest,
   saveMultiWatermark
 } = require('./multi')
@@ -97,7 +97,7 @@ 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 = {}) {
@@ -111,16 +111,29 @@ function run (input, opts = {}) {
   if (!root || activeConfig(root).config.enabled !== true) return
 
   const entries = hookInput.sessionId ? readTracking(root, hookInput.sessionId) : []
-  const roots = rootsFromEntries(root, entries)
+  const tracked = trackedChangesFromEntries(root, entries)
   const manifest = loadManifest(root)
-  const hasCrossRootPath = entries.some(entry =>
-    Array.isArray(entry.files) && entry.files.length > 0
-  ) && (roots.length !== 1 || roots[0] !== 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 (manifest.repos.length > 0 || roots.length > 1 || hasCrossRootPath) {
-    return runMulti(hookInput, root, roots, manifest)
+  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)
+  return runSingle(hookInput, { paths: tracked.repos[0]?.paths || [] })
 }
 
 function runSingle (input, opts = {}) {
@@ -153,6 +166,7 @@ function runSingle (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
@@ -172,21 +186,38 @@ function runSingle (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
     }
@@ -247,7 +278,21 @@ function runSingle (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 })
 
@@ -273,7 +318,7 @@ function runSingle (input, opts = {}) {
   }
 }
 
-function runMulti (hookInput, anchor, currentRoots, manifest) {
+function runMulti (hookInput, anchor, currentRepos, manifest) {
   recordCodexStop(hookInput, anchor)
 
   const transcriptPath = resolveTranscriptPath(hookInput)
@@ -305,12 +350,12 @@ function runMulti (hookInput, anchor, currentRoots, manifest) {
       '\n\n## Implementation\n\n' + formattedTranscript
     : formattedTranscript
 
-  const dirtyRoots = currentRoots.filter(root => !hasCommits(root) || hasChanges(root))
-  const isMultiTurn = currentRoots.length > 1
+  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 (dirtyRoots.length === 0 && manifest.repos.length === 0) {
+  if (dirtyRepos.length === 0 && manifest.repos.length === 0) {
     if (sessionId) {
       savePending(anchor, sessionId, formattedTranscript)
       cleanupTracking(anchor, sessionId)
@@ -319,16 +364,18 @@ function runMulti (hookInput, anchor, currentRoots, manifest) {
       harness: hookInput.harness,
       project: path.basename(anchor),
       branch: currentBranch(anchor),
-      context: transcriptSize(transcriptPath)
+      context: transcriptSize(transcriptPath),
+      reason: 'no-path-changes'
     })
     return
   }
 
-  for (const root of currentRoots) {
-    appendWork(manifest, root, {
+  for (const repo of currentRepos) {
+    appendWork(manifest, repo.root, {
       key: turnKey,
       body: turnBody,
-      sessionIds: isMultiTurn && sessionId ? [sessionId] : []
+      sessionIds: isMultiTurn && sessionId ? [sessionId] : [],
+      paths: repo.paths
     })
   }
 
@@ -342,25 +389,42 @@ function runMulti (hookInput, anchor, currentRoots, manifest) {
     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 (hasCommits(root) && !hasChanges(root)) {
+    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 })
+      logEvent('skip', { harness: hookInput.harness, project, branch, context, reason: 'no-path-changes' })
       continue
     }
 
     try {
       logEvent('start', { harness: hookInput.harness, project, branch, context })
-      stageAll(root)
+      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), redactions)
+      const changeContext = redact(stagedChangeContext(root, 10000, stagedPaths), redactions)
       const titleInput = `${changeContext}\n\nTranscript:\n${rawBody}`.slice(0, 20000)
 
       let headline
@@ -399,7 +463,8 @@ function runMulti (hookInput, anchor, currentRoots, manifest) {
 
       const safeHeadline = redact(headline, redactions)
       const safeBody = redact(body, redactions)
-      const sha = commitStaged(root, safeHeadline, safeBody)
+      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' })

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,22 +44,21 @@ 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 extractFilePaths (toolName, toolInput, cwd) {
+function extractRawFilePaths (toolName, toolInput) {
   const paths = []
   const seen = new Set()
-  const add = value => {
-    if (typeof value !== 'string' || value.length === 0) return
-    const resolved = path.isAbsolute(value) ? value : path.resolve(cwd || process.cwd(), value)
-    if (seen.has(resolved)) return
-    seen.add(resolved)
-    paths.push(resolved)
+  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') {
@@ -63,7 +77,10 @@ function extractFilePaths (toolName, toolInput, cwd) {
       return
     }
     for (const [key, nested] of Object.entries(value)) {
-      if (FILE_PATH_KEYS.includes(key)) add(nested)
+      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)
     }
   }
@@ -71,6 +88,31 @@ function extractFilePaths (toolName, toolInput, cwd) {
   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).
@@ -88,15 +130,17 @@ function handleTrack (input, root) {
 
   const toolInput = hookInput.toolInput || hookInput.tool_input || {}
 
-  const entry = { tool: toolName, t: Date.now() }
-
   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
@@ -110,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)
@@ -120,12 +316,13 @@ 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')
+  return readTracking(root, sessionId).some(entry =>
+    entry.tool !== 'Bash' || (entry.phase === 'post' && Array.isArray(entry.files) && entry.files.length > 0)
+  )
 }
 
 function readTracking (root, sessionId) {
@@ -156,10 +353,12 @@ 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.14.1",
+  "version": "0.15.0",
   "description": "Auto-commit after every AI coding agent turn",
   "bin": {
     "turbocommit": "./cli.js"