@searls/turbocommit 0.14.1 → 0.15.1

package/lib/run.js

@@ -4,10 +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, stageAll, commitStaged, stagedChangeContext, hasCommits, currentBranch, pushClean } = require('./git')
+const { gitRoot, hasChanges, changedPaths, addAndCommit, stagePaths, commitPaths, commitStagedPaths, stagedChangeContext, currentBranch, pushClean, hasRepositoryOperation } = require('./git')
 const { logEvent } = require('./log')
 const { wrapText } = require('./wrap')
-const { hasTrackedModifications, cleanupTracking, readTracking } = require('./track')
+const {
+  hasTrackedModifications,
+  cleanupTracking,
+  readTracking,
+  finalizeBashSnapshots,
+  recordBashSessionStop,
+  readReadyBashOverlaps,
+  pruneBashSnapshots,
+  compactBashOverlapEvents,
+  resolveBashOverlap,
+  invalidateBashOverlap,
+  hasActiveBashSnapshot,
+  acquireBashOverlapRecoveryLock,
+  fingerprintTrackedPath,
+  claimedPathsBySessions
+} = require('./track')
 const { redact, buildRedactions } = require('./redact')
 const { handleSessionEnd, getAncestors, savePending, collectPending, cleanupConsumed, cleanupStale, readWatermark, saveWatermark, resolveParentCommit } = require('./session')
 const { activeConfig } = require('./config')
@@ -19,7 +34,7 @@ const {
   dependencyOrder,
   loadManifest,
   readMultiWatermark,
-  rootsFromEntries,
+  trackedChangesFromEntries,
   saveManifest,
   saveMultiWatermark
 } = require('./multi')
@@ -97,7 +112,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 = {}) {
@@ -108,19 +123,130 @@ function run (input, opts = {}) {
   if (!hookInput) return
 
   const root = gitRoot(hookInput.cwd || process.cwd())
-  if (!root || activeConfig(root).config.enabled !== true) return
+  if (!root) return
+  const { config } = activeConfig(root)
+  if (config.enabled !== true) return
+  const recoveryDeadline = opts.recoveryDeadline ?? recoveryDeadlineFromWait(opts.recoveryWaitMs ?? 5000)
 
+  if (hookInput.sessionId) {
+    const finalized = finalizeBashSnapshots(root, hookInput.sessionId, Date.now(), remainingRecoveryWait(recoveryDeadline))
+    if (finalized == null) return
+    recordBashSessionStop(root, hookInput.sessionId)
+  }
+
+  try {
+    return runTrackedStop(hookInput, root, opts)
+  } finally {
+    const recoveryConfig = opts.deferPush ? { ...config, push: false } : config
+    recoverBashOverlaps(root, hookInput, recoveryConfig, remainingRecoveryWait(recoveryDeadline))
+  }
+}
+
+function recoveryDeadlineFromWait (waitMs) {
+  return waitMs === Infinity ? Infinity : Date.now() + waitMs
+}
+
+function remainingRecoveryWait (deadline) {
+  return deadline === Infinity ? Infinity : Math.max(0, deadline - Date.now())
+}
+
+function runTrackedStop (hookInput, root, opts) {
   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 (tracked.ambiguous.length > 0) {
+    return runSingle(hookInput, { paths: [], trackingReason: 'ambiguous-tracking', operationDeadline: opts.operationDeadline })
+  }
+  if (manifest.repos.length > 0 || tracked.repos.length > 1 || hasCrossRootPath) {
+    return runMulti(hookInput, root, tracked.repos, manifest, opts)
+  }
+  return runSingle(hookInput, { paths: tracked.repos[0]?.paths || [], operationDeadline: opts.operationDeadline })
+}
 
-  if (manifest.repos.length > 0 || roots.length > 1 || hasCrossRootPath) {
-    return runMulti(hookInput, root, roots, manifest)
+function recoverBashOverlaps (root, hookInput, config, waitMs = 5000) {
+  if (process.env.TURBOCOMMIT_DISABLED || !root) return
+  hookInput = hookInput || {}
+  config = config || activeConfig(root).config
+  if (config.enabled !== true) return
+  const release = acquireBashOverlapRecoveryLock(root, waitMs)
+  if (!release) return
+  let shouldPush = false
+  try {
+    pruneBashSnapshots(root)
+    if (hasActiveBashSnapshot(root) || hasRepositoryOperation(root)) return
+    for (const overlap of readReadyBashOverlaps(root)) {
+      const claimed = claimedPathsBySessions(root)
+      const changedFingerprint = overlap.paths.some(item =>
+        item.fingerprint == null || fingerprintTrackedPath(item.path) !== item.fingerprint)
+      const claimedPath = overlap.paths.some(item => claimed.has(item.path))
+      if (changedFingerprint || claimedPath) {
+        logEvent('skip', {
+          harness: hookInput.harness,
+          project: path.basename(root),
+          branch: currentBranch(root),
+          reason: changedFingerprint ? 'bash-overlap-changed' : 'bash-overlap-claimed',
+          paths: overlap.paths.length
+        })
+        if (changedFingerprint) {
+          invalidateBashOverlap(root, overlap.eventIds, 'changed-fingerprint')
+        }
+        continue
+      }
+
+      const paths = changedPaths(root, overlap.paths.map(item => item.path))
+      if (paths.length === 0) {
+        resolveBashOverlap(root, overlap.eventIds)
+        continue
+      }
+
+      const title = 'Recover overlapping shell changes'
+      const body = 'Recovered unchanged paths observed during overlapping shell commands.\n\n' +
+        overlap.sessionIds.map(sessionId => `Session: ${sessionId}`).join('\n')
+      const commit = commitPaths(root, paths, title, body, { pathScoped: true })
+      if (!commit) continue
+
+      logEvent('success', {
+        harness: hookInput.harness,
+        project: path.basename(root),
+        branch: currentBranch(root),
+        title,
+        recovered: paths.length
+      })
+      if (config.push === true) shouldPush = true
+      resolveBashOverlap(root, overlap.eventIds)
+    }
+  } catch {
+    logEvent('fail', {
+      harness: hookInput.harness,
+      project: path.basename(root),
+      branch: currentBranch(root),
+      reason: 'bash-overlap-recovery'
+    })
+  } finally {
+    try { compactBashOverlapEvents(root) } catch {}
+    release()
+  }
+  if (shouldPush) {
+    logEvent(pushClean(root) ? 'push' : 'push-fail', {
+      harness: hookInput.harness,
+      project: path.basename(root),
+      branch: currentBranch(root)
+    })
   }
-  return runSingle(hookInput)
 }
 
 function runSingle (input, opts = {}) {
@@ -153,6 +279,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 +299,39 @@ 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 })
+    cleanupTracking(root, sessionId)
+    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
     }
@@ -199,14 +344,14 @@ function runSingle (input, opts = {}) {
     let headline
     if (config.title?.type !== 'transcript') {
       const titleTranscript = formatTitleTranscript(effectivePairs)
-      headline = runTitleAgent(root, config.title || {}, titleTranscript, hookInput.harness)
+      headline = runTitleAgent(root, config.title || {}, titleTranscript, hookInput.harness, { deadline: opts.operationDeadline })
     }
     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, hookInput.harness)
+      body = runBodyAgent(root, config.body, formattedTranscript, hookInput.harness, { deadline: opts.operationDeadline })
     }
     body = body || formattedTranscript
 
@@ -247,11 +392,25 @@ 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 })
 
-    if (config.push === true) {
+    if (config.push === true && !opts.deferPush) {
       if (pushClean(root)) {
         logEvent('push', { harness: hookInput.harness, project, branch })
       } else {
@@ -273,7 +432,7 @@ function runSingle (input, opts = {}) {
   }
 }
 
-function runMulti (hookInput, anchor, currentRoots, manifest) {
+function runMulti (hookInput, anchor, currentRepos, manifest, opts = {}) {
   recordCodexStop(hookInput, anchor)
 
   const transcriptPath = resolveTranscriptPath(hookInput)
@@ -305,12 +464,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 +478,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,36 +503,53 @@ 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
       if (config.title?.type !== 'transcript') {
-        headline = runTitleAgent(root, config.title || {}, titleInput, hookInput.harness)
+        headline = runTitleAgent(root, config.title || {}, titleInput, hookInput.harness, { deadline: opts.operationDeadline })
       }
       headline = headline || extractHeadline(effectivePairs)
 
       let body
       if (config.body?.type === 'agent') {
-        body = runBodyAgent(root, config.body, rawBody, hookInput.harness)
+        body = runBodyAgent(root, config.body, rawBody, hookInput.harness, { deadline: opts.operationDeadline })
       }
       body = body || rawBody
 
@@ -399,7 +577,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' })
@@ -420,6 +599,7 @@ function runMulti (hookInput, anchor, currentRoots, manifest) {
 
   for (const success of successes) {
     if (success.config.push !== true) continue
+    if (opts.deferPush && success.root === anchor) continue
     if (pushClean(success.root)) {
       logEvent('push', {
         harness: hookInput.harness,
@@ -500,4 +680,4 @@ function recordCodexStop (hookInput, root) {
   if (hookInput.harness === 'codex' && hookInput.event === 'Stop') handleSessionEnd(hookInput, root)
 }
 
-module.exports = { run, runPreCompact, formatModelName, resolveCoauthor, readClaudeAttribution, resolveTranscriptPath, recordCodexStop }
+module.exports = { run, runPreCompact, recoverBashOverlaps, formatModelName, resolveCoauthor, readClaudeAttribution, resolveTranscriptPath, recordCodexStop }

package/lib/session.js

@@ -257,7 +257,7 @@ function cleanupStale (root, maxAgeMs) {
   const base = turbocommitDir(root)
   if (!base) return
 
-  for (const sub of ['breadcrumbs', 'chains', 'tracking', 'watermarks']) {
+  for (const sub of ['breadcrumbs', 'chains', 'watermarks']) {
     const dir = path.join(base, sub)
     let files
     try {
@@ -276,6 +276,8 @@ function cleanupStale (root, maxAgeMs) {
     }
   }
 
+  cleanupStaleTracking(root, now, ttl)
+
   // Clean stale pending directories
   const pDir = path.join(base, 'pending')
   let pdirs
@@ -300,6 +302,43 @@ function cleanupStale (root, maxAgeMs) {
   }
 }
 
+function cleanupStaleTracking (root, now, ttl) {
+  const dir = path.join(turbocommitDir(root), 'tracking')
+  let files
+  try {
+    files = fs.readdirSync(dir)
+  } catch {
+    return
+  }
+  for (const file of files) {
+    const fullPath = path.join(dir, file)
+    try {
+      const stat = fs.statSync(fullPath)
+      if (now - stat.mtimeMs <= ttl || trackingMayDescribeModifications(fullPath)) continue
+      fs.unlinkSync(fullPath)
+    } catch {}
+  }
+}
+
+function trackingMayDescribeModifications (file) {
+  let lines
+  try {
+    const data = fs.readFileSync(file, 'utf8').trim()
+    lines = data ? data.split('\n') : []
+  } catch {
+    return true
+  }
+  return lines.some(line => {
+    try {
+      const entry = JSON.parse(line)
+      return entry.tool !== 'Bash' ||
+        (entry.phase === 'post' && Array.isArray(entry.files) && entry.files.length > 0)
+    } catch {
+      return true
+    }
+  })
+}
+
 module.exports = {
   handleSessionEnd,
   handleSessionStart,