@searls/turbocommit 0.15.0 → 0.15.2

package/lib/rescue.js

@@ -0,0 +1,308 @@
+const crypto = require('crypto')
+const { execFileSync } = require('child_process')
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const { gitCommonDir } = require('./git')
+const { ensureDir } = require('./io')
+
+function createSessionEndRescue (root, hookInput) {
+  const gitDir = gitCommonDir(root)
+  if (!gitDir || !hookInput?.sessionId) return null
+  const id = crypto.randomUUID()
+  const ref = `refs/turbocommit/session-end-rescues/${id}`
+  const stateDir = path.join(gitDir, 'turbocommit', 'session-end-rescues')
+  const index = path.join(stateDir, `${id}.index`)
+  const recordPath = path.join(stateDir, `${id}.json`)
+  const env = { ...process.env, GIT_INDEX_FILE: index }
+  let checkoutIdentity
+  try {
+    ensureDir(stateDir)
+    const rawIndex = gitOutput(root, ['rev-parse', '--git-path', 'index'])
+    const realIndex = path.isAbsolute(rawIndex) ? rawIndex : path.resolve(root, rawIndex)
+    if (realIndex && fs.existsSync(realIndex)) {
+      fs.copyFileSync(realIndex, index)
+    } else {
+      gitOutput(root, ['read-tree', 'HEAD'], { env })
+    }
+    gitOutput(root, ['add', '-A'], { env })
+    const tree = gitOutput(root, ['write-tree'], { env })
+    const head = gitOutput(root, ['rev-parse', 'HEAD'])
+    const branch = gitOutput(root, ['branch', '--show-current'])
+    const commit = gitOutput(root, ['commit-tree', tree, '-p', head, '-m', 'turbocommit SessionEnd rescue'])
+    gitOutput(root, ['update-ref', ref, commit, '0'.repeat(commit.length)])
+    checkoutIdentity = createCheckoutIdentity(root, id)
+    if (!checkoutIdentity) throw new Error('Could not identify rescued checkout')
+    const rescue = {
+      id,
+      ref,
+      commit,
+      head,
+      branch: branch || null,
+      root,
+      gitDir,
+      checkoutIdentity,
+      recordPath,
+      hookInput
+    }
+    writeRecord(recordPath, rescue)
+    return rescue
+  } catch {
+    try { gitOutput(root, ['update-ref', '-d', ref]) } catch {}
+    cleanupCheckoutIdentity(checkoutIdentity)
+    try { fs.unlinkSync(recordPath) } catch {}
+    return null
+  } finally {
+    try { fs.unlinkSync(index) } catch {}
+  }
+}
+
+function restoreSessionEndRescue (rescue) {
+  if (!rescue?.gitDir || !rescue.root || !rescue.commit) return false
+  if (fs.existsSync(rescue.root)) return false
+  let created = false
+  try {
+    ensureDir(path.dirname(rescue.root))
+    const args = ['--git-dir', rescue.gitDir, 'worktree', 'add', '--force', '--detach', rescue.root, rescue.head]
+    execFileSync('git', args, { cwd: stableGitCwd(rescue.gitDir), stdio: 'ignore' })
+    created = true
+    gitOutput(rescue.root, ['restore', '--source', rescue.commit, '--worktree', '--', '.'])
+    return true
+  } catch {
+    if (created) removeSessionEndRescueWorktree(rescue)
+    return false
+  }
+}
+
+function matchesSessionEndRescueRoot (rescue, root) {
+  if (!rescue?.checkoutIdentity || !root) return false
+  try {
+    if (canonicalExistingPath(gitCommonDir(root)) !== canonicalExistingPath(rescue.gitDir)) return false
+    if (gitOutput(root, ['rev-parse', 'HEAD']) !== rescue.head) return false
+    if ((gitOutput(root, ['branch', '--show-current']) || null) !== rescue.branch) return false
+    return sameCheckoutIdentity(readCheckoutIdentity(root), rescue.checkoutIdentity) &&
+      hasCheckoutIdentityMarker(rescue.checkoutIdentity)
+  } catch {
+    return false
+  }
+}
+
+function finalizeRestoredSessionEndRescue (rescue, { clean = false } = {}) {
+  const recovered = preserveSessionEndRecoveredCommit(rescue, rescue.root)
+  if (!recovered) return { resolved: false, preserved: false }
+  const { recoveredCommit, recoveredRef } = recovered
+
+  if (!clean) {
+    recordPreservedSessionEndRescue(rescue, recovered, 'dirty-recovery-worktree')
+    return { resolved: false, preserved: true, recoveredCommit, recoveredRef, removeWorktree: false }
+  }
+
+  if (!rescue.branch) {
+    recordPreservedSessionEndRescue(rescue, recovered, 'detached-recovered')
+    return { resolved: false, preserved: true, recoveredCommit, recoveredRef, removeWorktree: true }
+  }
+
+  if (!removeSessionEndRescueWorktree(rescue)) {
+    recordPreservedSessionEndRescue(rescue, recovered, 'restore-worktree-removal-failed')
+    return { resolved: false, preserved: true, recoveredCommit, recoveredRef, removeWorktree: false }
+  }
+
+  let attached = false
+  try {
+    execFileSync('git', ['--git-dir', rescue.gitDir, 'worktree', 'add', rescue.root, rescue.branch], {
+      cwd: stableGitCwd(rescue.gitDir),
+      stdio: 'ignore'
+    })
+    attached = true
+    if (gitOutput(rescue.root, ['rev-parse', 'HEAD']) !== rescue.head) throw new Error('Branch advanced')
+    if (gitOutput(rescue.root, ['branch', '--show-current']) !== rescue.branch) throw new Error('Wrong branch')
+    if (!isClean(rescue.root)) throw new Error('Attached worktree is dirty')
+    gitOutput(rescue.root, ['merge', '--ff-only', recoveredRef])
+    if (gitOutput(rescue.root, ['rev-parse', 'HEAD']) !== recoveredCommit) throw new Error('Branch did not advance')
+    return { resolved: true, preserved: true, recoveredCommit, recoveredRef, attached: true }
+  } catch {
+    if (attached) removeSessionEndRescueWorktree(rescue)
+    const status = branchAtCapturedHead(rescue) ? 'branch-unavailable' : 'branch-advanced'
+    recordPreservedSessionEndRescue(rescue, recovered, status)
+    return { resolved: false, preserved: true, recoveredCommit, recoveredRef, removeWorktree: false }
+  }
+}
+
+function recordPreservedSessionEndRescue (rescue, recovered, status) {
+  try {
+    writeRecord(rescue.recordPath, {
+      ...rescue,
+      ...recovered,
+      status
+    })
+  } catch {}
+}
+
+function branchAtCapturedHead (rescue) {
+  if (!rescue?.branch || !rescue.gitDir || !rescue.head) return false
+  try {
+    return gitOutput(stableGitCwd(rescue.gitDir), [
+      '--git-dir', rescue.gitDir, 'rev-parse', '--verify', `refs/heads/${rescue.branch}`
+    ]) === rescue.head
+  } catch {
+    return false
+  }
+}
+
+function preserveSessionEndRecoveredCommit (rescue, root) {
+  if (!rescue?.gitDir || !rescue.id || !root) return null
+  try {
+    const recoveredCommit = gitOutput(root, ['rev-parse', 'HEAD'])
+    const recoveredRef = `refs/turbocommit/session-end-recovered/${rescue.id}`
+    let current = null
+    try {
+      current = gitOutput(stableGitCwd(rescue.gitDir), [
+        '--git-dir', rescue.gitDir, 'rev-parse', '--verify', recoveredRef
+      ])
+    } catch {}
+    if (current && current !== recoveredCommit) return null
+    if (!current) {
+      execFileSync('git', [
+        '--git-dir', rescue.gitDir,
+        'update-ref', recoveredRef, recoveredCommit, '0'.repeat(recoveredCommit.length)
+      ], {
+        cwd: stableGitCwd(rescue.gitDir),
+        stdio: 'ignore'
+      })
+    }
+    return { recoveredCommit, recoveredRef }
+  } catch {
+    return null
+  }
+}
+
+function removeSessionEndRescueWorktree (rescue, { force = false } = {}) {
+  if (!rescue?.gitDir || !rescue.root) return false
+  try {
+    const args = ['--git-dir', rescue.gitDir, 'worktree', 'remove']
+    if (force) args.push('--force')
+    args.push(rescue.root)
+    execFileSync('git', args, {
+      cwd: stableGitCwd(rescue.gitDir),
+      stdio: 'ignore'
+    })
+  } catch {}
+  return !fs.existsSync(rescue.root)
+}
+
+function cleanupSessionEndRescue (rescue, { removeWorktree = false } = {}) {
+  if (!rescue) return false
+  if (removeWorktree && !removeSessionEndRescueWorktree(rescue)) return false
+  if (rescue.gitDir && rescue.ref && rescue.commit) {
+    try {
+      execFileSync('git', ['--git-dir', rescue.gitDir, 'update-ref', '-d', rescue.ref, rescue.commit], {
+        cwd: stableGitCwd(rescue.gitDir),
+        stdio: 'ignore'
+      })
+    } catch {}
+  }
+  cleanupCheckoutIdentity(rescue.checkoutIdentity)
+  try { fs.unlinkSync(rescue.recordPath) } catch {}
+  return true
+}
+
+function isClean (root) {
+  try {
+    return gitOutput(root, ['status', '--porcelain']) === ''
+  } catch {
+    return false
+  }
+}
+
+function writeRecord (file, rescue) {
+  const temporary = file + `.${process.pid}.${crypto.randomUUID()}.tmp`
+  try {
+    fs.writeFileSync(temporary, JSON.stringify(rescue) + '\n')
+    fs.renameSync(temporary, file)
+  } finally {
+    try { fs.unlinkSync(temporary) } catch {}
+  }
+}
+
+function readCheckoutIdentity (root) {
+  try {
+    const rootStat = fs.statSync(root, { bigint: true })
+    const rawGitDir = gitOutput(root, ['rev-parse', '--git-dir'])
+    const worktreeGitDir = canonicalExistingPath(path.isAbsolute(rawGitDir) ? rawGitDir : path.resolve(root, rawGitDir))
+    const gitDirStat = fs.statSync(worktreeGitDir, { bigint: true })
+    return {
+      rootDevice: rootStat.dev.toString(),
+      rootInode: rootStat.ino.toString(),
+      worktreeGitDir,
+      gitDirDevice: gitDirStat.dev.toString(),
+      gitDirInode: gitDirStat.ino.toString()
+    }
+  } catch {
+    return null
+  }
+}
+
+function createCheckoutIdentity (root, id) {
+  const identity = readCheckoutIdentity(root)
+  if (!identity) return null
+  const markerDir = path.join(identity.worktreeGitDir, 'turbocommit-rescue-identities')
+  const markerPath = path.join(markerDir, `${id}.marker`)
+  const markerToken = crypto.randomUUID()
+  ensureDir(markerDir)
+  fs.writeFileSync(markerPath, markerToken + '\n', { flag: 'wx' })
+  return { ...identity, markerPath, markerToken }
+}
+
+function hasCheckoutIdentityMarker (identity) {
+  if (!identity?.markerPath || !identity.markerToken) return false
+  try {
+    return fs.readFileSync(identity.markerPath, 'utf8').trim() === identity.markerToken
+  } catch {
+    return false
+  }
+}
+
+function cleanupCheckoutIdentity (identity) {
+  if (!identity?.markerPath) return
+  try { fs.unlinkSync(identity.markerPath) } catch {}
+  try { fs.rmdirSync(path.dirname(identity.markerPath)) } catch {}
+}
+
+function sameCheckoutIdentity (actual, expected) {
+  if (!actual || !expected) return false
+  return actual.rootDevice === expected.rootDevice &&
+    actual.rootInode === expected.rootInode &&
+    actual.worktreeGitDir === expected.worktreeGitDir &&
+    actual.gitDirDevice === expected.gitDirDevice &&
+    actual.gitDirInode === expected.gitDirInode
+}
+
+function canonicalExistingPath (filePath) {
+  return fs.realpathSync(path.resolve(filePath))
+}
+
+function gitOutput (cwd, args, opts = {}) {
+  return execFileSync('git', args, {
+    cwd,
+    env: opts.env || process.env,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore']
+  }).trim()
+}
+
+function stableGitCwd (gitDir) {
+  const parent = path.dirname(gitDir)
+  return fs.existsSync(parent) ? parent : os.tmpdir()
+}
+
+module.exports = {
+  createSessionEndRescue,
+  restoreSessionEndRescue,
+  matchesSessionEndRescueRoot,
+  finalizeRestoredSessionEndRescue,
+  preserveSessionEndRecoveredCommit,
+  recordPreservedSessionEndRescue,
+  removeSessionEndRescueWorktree,
+  cleanupSessionEndRescue,
+  isClean
+}

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, changedPaths, addAndCommit, stagePaths, commitPaths, commitStagedPaths, stagedChangeContext, 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')
@@ -108,8 +123,34 @@ 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 tracked = trackedChangesFromEntries(root, entries)
   const manifest = loadManifest(root)
@@ -128,12 +169,84 @@ function run (input, opts = {}) {
     (tracked.repos.length !== 1 || tracked.repos[0].root !== root)
 
   if (tracked.ambiguous.length > 0) {
-    return runSingle(hookInput, { paths: [], trackingReason: 'ambiguous-tracking' })
+    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)
+    return runMulti(hookInput, root, tracked.repos, manifest, opts)
+  }
+  return runSingle(hookInput, { paths: tracked.repos[0]?.paths || [], operationDeadline: opts.operationDeadline })
+}
+
+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, { paths: tracked.repos[0]?.paths || [] })
 }
 
 function runSingle (input, opts = {}) {
@@ -186,6 +299,7 @@ function runSingle (input, opts = {}) {
     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: 'no-tracking' })
     cleanupStale(root)
     return
@@ -230,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
 
@@ -296,7 +410,7 @@ function runSingle (input, opts = {}) {
 
     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 {
@@ -318,7 +432,7 @@ function runSingle (input, opts = {}) {
   }
 }
 
-function runMulti (hookInput, anchor, currentRepos, manifest) {
+function runMulti (hookInput, anchor, currentRepos, manifest, opts = {}) {
   recordCodexStop(hookInput, anchor)
 
   const transcriptPath = resolveTranscriptPath(hookInput)
@@ -429,13 +543,13 @@ function runMulti (hookInput, anchor, currentRepos, manifest) {
 
       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
 
@@ -485,6 +599,7 @@ function runMulti (hookInput, anchor, currentRepos, 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,
@@ -565,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,