bug: snapshot.Clear is never called in runWithoutCache, so snapshots persist across multiple sessions until TTL expires

[claude]

Problem

The runWithCache and runLocalMode functions in cmd/run.go both call snapshot.Clear(proj.RootDir) after consuming the session snapshot (lines 232, 358, 423). This ensures the snapshot is one-shot: it's injected once then deleted.

However, runWithoutCache (cmd/run.go:385) does not call snapshot.Clear. If the cache is unavailable and runWithoutCache is called, any present session snapshot is injected into the context bomb but never cleared. On the next run invocation, the same snapshot is read again and injected a second time, and so on — until the 24-hour TTL in snapshot.DefaultTTL finally expires the file.

This means a pre-compact snapshot can be re-injected into every context bomb for up to 24 hours if the cache is consistently unavailable (e.g. on a machine with a corrupted SQLite file).

Steps to reproduce

1. Run uncompact pre-compact to write a snapshot.
2. Delete or corrupt the SQLite cache so cache.Open fails.
3. Run uncompact run multiple times.
4. Observe the snapshot section repeating in every context bomb output.

Fix

Add snapshot.Clear in runWithoutCache after the snapshot is successfully included in the rendered output, matching the pattern used in runWithCache and runLocalMode:

// After rendering and printing output, clear the snapshot so it isn't re-injected.
if snap != nil {
    if clearErr := snapshot.Clear(proj.RootDir); clearErr != nil {
        logFn("[warn] snapshot clear error: %v", clearErr)
    }
}

Location

• cmd/run.go:385 (runWithoutCache — missing snapshot.Clear call)
• Compare with cmd/run.go:232, cmd/run.go:358, cmd/run.go:423 (all call snapshot.Clear)

@claude please implement this

[claude]

Claude finished @claude[bot]'s task in 2m 38s —— View job

---

Analysis

• Gather context and understand the request
• Read cmd/run.go to locate runWithoutCache and understand the fix needed
• Verify build passes (go build ./... ✓, go vet ./... ✓)

Findings

After reading cmd/run.go, the fix described in this issue is already present in the codebase.

runWithoutCache (starting at line 385) does call snapshot.Clear at lines 421–426:

// Clear the session snapshot after it has been injected into the context bomb.
if snap != nil {
    if clearErr := snapshot.Clear(proj.RootDir); clearErr != nil {
        logFn("[warn] snapshot clear error: %v", clearErr)
    }
}

All three functions now consistently clear the snapshot after use:

• runHandler (API mode): line 231–235
• runLocalMode: line 356–360
• runWithoutCache: line 421–426 ✅

The issue may have been filed against an older version of the code. No changes are needed — the fix is already in place and go build ./... + go vet ./... both pass cleanly.

[coderabbitai]

⚠️ Possible Duplicate Issue(s)

• bug: runWithoutCache silently drops snapshot.Clear errors (inconsistent with runHandler/runLocalMode) #351

🔗 Related PRs

#18 - feat: show circular dependency warning in context bomb [merged]
#31 - feat: stderr status line + show-cache command for post-compact visibility [merged]
#39 - feat: show context bomb in chat transcript after compact with acknowledgment [merged]

---

📝 Issue Planner

_{Check the box below or use the @coderabbitai plan command to generate an implementation plan and prompts that you can use with your favorite coding assistant.}

• Create Plan

---

🧪 Issue enrichment is currently in open beta.

To disable automatic issue enrichment, add the following to your .coderabbit.yaml:

issue_enrichment:
  auto_enrich:
    enabled: false

💬 Have feedback or questions? Drop into our discord!