pi-smart-compact 7.22.0 → 8.0.0-rc.2

package/CHANGELOG.md

@@ -1,5 +1,58 @@
 # Changelog
 
+## [Unreleased]
+
+No changes yet.
+
+## [8.0.0-rc.2] - 2026-08-06
+
+### Fixed
+
+- Durable state, fingerprint, context graph, and success telemetry now commit only after a run-id-correlated native `session_compact`; cancellation, failure, shutdown, and stale generations leave no false success state.
+- Semantic verification detects negated/conditional goal, decision, and constraint inversions, inconsistent blocker placeholders, unresolved-error omissions, and fabricated files; deterministic quality-floor replacement is coverage-aware.
+- Canary promotion now requires ≥85 absolute quality, ≥95% success, and ≥70% run-correlated damage-observation coverage in stable and canary cohorts; Data Confidence and Quality Health remain separate.
+- Provider accounting includes uncached input plus cache reads/writes and reserves concurrent/failed-stream output; cross-process 0600 leases enforce the global run limit.
+- Smart Memory requires real interactive host confirmation, treats recall as untrusted evidence, preserves/deduplicates project-scoped manual facts, and bounds structural graph nodes.
+- Zero-call planning rejects token-dense/tool-heavy windows; synthesis caches include every behavior-affecting route/profile/thinking limit; unused route auth resolves lazily; retention protects the two newest user turns.
+- Provider evaluation uses only explicitly stage-local pre-repair synthesis quality instead of copying one final verifier score into every route.
+- Native continuity survives reload/process gaps in a bounded, locked project/session/branch-scoped handoff; apply-confirmed context-graph indexing is deferred and coalesced off the host compaction hook.
+- Backup retention/restoration ignores foreign files in custom directories, filesystem locks fail closed, and atomic-write documentation no longer claims unimplemented fsync durability.
+- Production runs share only bounded provider capability/token-calibration knowledge; transient probe failures cannot poison the capability cache. Removed the unused automatic LLM retry wrapper.
+
+## [8.0.0-rc.1] - 2026-08-06
+
+### Added
+
+- **Adaptive modes** — `/smart-compact` and the tool now support `auto`, `balanced`, `aggressive`, `fast`, and `thorough` execution policies with finite call and prompt-token ceilings plus observed output-token stop thresholds. Legacy `light` remains a `thorough` alias.
+- **Continuity Ledger** — previous verified summaries and bounded structured state now carry goals, decisions, constraints, unresolved errors, and open loops forward until explicit resolution.
+- **Aggregate prompt budget** — every LLM request reserves estimated input centrally and reconciles against provider usage; `--max-input-tokens` / `max_input_tokens` can override the mode ceiling.
+- **Codex hybrid output limiter** — custom Codex endpoints receive `max_output_tokens`; ChatGPT subscription Codex uses a configurable per-call stream watchdog and visible-output ceiling because its endpoint rejects all server-side output-cap fields.
+- **Smart Recall context graph** — consumed verified state is indexed into a project-isolated, 2,000-node SQLite FTS5 graph with file-reference edges, weighted same-session/branch retrieval, active fact resolution, and bounded `smart_recall` results.
+- **Explicit project memory** — `smart_save_memory` stores deduplicated, user-confirmed durable facts after configured secret/PII scrubbing; `contextGraphEnabled` disables indexing and both memory tools.
+- **Stage-aware provider routing** — Explore, Synthesis, and Verify can use independent explicitly configured models; all default to the selected model and mode changes never reroute providers.
+- **Provider evaluation harness** — schema-v2 per-stage telemetry feeds an advisory context-pressure × tool-density matrix, plus an explicit paid-API scenario probe; neither path edits routing automatically.
+- **Privacy-safe canary telemetry** — aggregate-only exports omit conversation/session/project data, failures use a stable content-free taxonomy, and explicit stable/canary tags drive Hold/Rollback/Promote gates for quality, failures, latency, tokens, fallback, and damage.
+- **Dashboard trust UX** — TUI/text/HTML surfaces now show an auditable Data Confidence score (≥85 target), quality bands and repair gain, stage/provider/model evidence with quality coverage, stable-vs-canary deltas, rollback triggers, and failure taxonomy.
+- **Session-aware run control** — same-session runs serialize, different sessions share a bounded global concurrency of two, pending state is TTL/LRU bounded, and synthesis caches key by session/branch/model/mode.
+- **Native continuity bridge** — after Pi native compaction, scoped continuity is delivered exactly once at the next agent start instead of being lost or repeatedly injected.
+
+### Fixed
+
+- **Runaway token consumption** — compaction windows now use Pi's active, compaction-aware entries instead of re-summarizing append-only session history. Retained tokens are re-counted after anchor/tool-call boundary expansion; non-viable automatic windows fall back to native compaction before any LLM call.
+- **Repeated staged runs** — a same-session pending summary is reused rather than regenerated.
+- **Unbounded LLM amplification** — safe defaults now use at most 8 calls, 3 exploration rounds, minimal per-phase reasoning, no automatic whole-request retries, explicit exploration output caps, and prompt caching for the growing exploration loop.
+- **Calibration skew** — request calibration includes system/tools and cached prompt tokens instead of calibrating message text against incomplete usage.
+- **Oversized synthesis chunks** — `maxChunkTokens` is now enforced by splitting large semantic segments; batch output budgets match the requested 2–4 sentence summaries instead of allocating 1,500 tokens per chunk.
+- **Cross-generation context loss** — absent prior facts are no longer interpreted as deleted; cumulative state is conservatively merged and bounded.
+- **Cross-session/branch contamination** — continuity state now carries project/session/branch ancestry scope with Branch > Session > Project precedence; legacy project-wide state is not injected into unrelated work.
+- **Post-compaction false positives** — one normal file re-read or topic mention no longer counts as damage; repeated re-reads and explicit correction language remain actionable signals.
+
+### Changed
+
+- High-confidence Fast/Aggressive runs can use zero-call deterministic synthesis; the verifier replaces lower-scoring model output with a deterministic quality floor, and Auto planning escalates from continuity/prior-damage risk.
+- Recent-tail retention scales with model context, preserves the two newest user turns when enough history exists, and validates mode-specific post-compaction headroom.
+- Refreshed the development lockfile to Pi `0.84.0`, TypeBox `1.3.11`, and `@types/node` `26.1.2` while preserving Pi host packages as wildcard-only peer dependencies.
+
 ## [7.22.0] - 2026-07-15
 
 ### Added

package/README.md

@@ -31,9 +31,9 @@ pi install git:github.com/alpertarhan/pi-smart-compact
 ## Quick start
 
 ```bash
-/smart-compact                                         # interactive model + profile picker
-/smart-compact balanced                                # direct profile
-/smart-compact anthropic/claude-sonnet-4 balanced     # direct model + profile
+/smart-compact                                         # interactive model + mode picker
+/smart-compact auto                                    # adaptive default
+/smart-compact anthropic/claude-sonnet-4 fast         # direct model + mode
 /smart-compact balanced --focus=auth                   # preserve extra auth detail
 /smart-compact metrics                                 # text metrics report
 /smart-compact dashboard                               # interactive metrics dashboard
@@ -43,7 +43,7 @@ pi install git:github.com/alpertarhan/pi-smart-compact
 
 The extension also participates in Pi's native compaction flow automatically
 when actual context usage crosses the configured threshold (60% by default),
-and exposes a `smart_compact` tool for long-running agents.
+and exposes `smart_compact`, `smart_recall`, and `smart_save_memory` tools for long-running agents.
 
 > The tool path stages a safe pending summary. It never compacts the active
 > conversation in the middle of an agent turn.
@@ -57,6 +57,7 @@ and exposes a `smart_compact` tool for long-running agents.
 | File/error omissions can be silent | Verifies coverage and repairs known gaps |
 | One strategy for every session | Chooses single-pass or hierarchical synthesis |
 | No quality feedback | Tracks provenance, damage signals, and metrics |
+| No scoped cross-session recall | Searches a project-isolated SQLite FTS5 context graph |
 
 The design principle is simple:
 
@@ -81,9 +82,9 @@ Pi conversation
 | Stage | Responsibility |
 | --- | --- |
 | **Extract** | Deterministically catalogs files, errors, decisions, constraints, topics, media metadata, and open loops. This is the verification ground truth. |
-| **Explore** | Uses a cheaper segmentation model when a complex session needs deeper topic boundaries or error-chain inspection. Simple sessions skip it. |
-| **Synthesize** | Uses one pass for short sessions and bounded chunk/assembly fallbacks for long sessions. Focus and call/latency budgets are enforced here. |
-| **Verify** | Checks canonical sections and extracted facts, applies every safe deterministic repair, and escalates only unresolved low-scoring gaps to an LLM patch. |
+| **Explore** | Runs only in `thorough` mode (or when `auto` selects it); cheaper modes use deterministic boundaries. |
+| **Synthesize** | Uses adaptive single-pass or bounded hierarchical synthesis with per-mode call, prompt-token, chunk, and output budgets. |
+| **Verify** | Always applies deterministic repairs. Only `thorough` may spend one additional LLM call on unresolved gaps. |
 
 ### What survives compaction
 
@@ -94,47 +95,131 @@ Pi conversation
 - Open follow-ups, blockers, priorities, and pinned loops
 - Next actions and critical continuation context
 - Changes since the previous compaction
+- A bounded **Continuity Ledger** carrying prior decisions, constraints, unresolved errors, and open loops until explicit resolution
 
 Summaries use a canonical H1/H2/H3-aware structure, collision-safe file
 matching, typed verification gaps, and persisted repair provenance.
 
+### Smart Recall
+
+Applied compactions also index their verified scoped state into a bounded,
+project-isolated SQLite FTS5 context graph. `smart_recall` searches goals,
+decisions, constraints, unresolved errors, open loops, files, and critical
+context across this project's sessions; same-session and same-branch evidence
+ranks first. File relationships add one-hop graph recall without an embedding
+service or extra LLM call.
+
+`smart_save_memory` persists or explicitly resolves one user-confirmed decision,
+constraint, preference, warning, procedure, or context fact. It rejects empty inputs,
+scrubs configured secrets/PII, deduplicates exact facts, and must not be used
+for guesses, transient progress, secrets, or code that is cheap to re-read.
+Set `contextGraphEnabled` to `false` to disable indexing and both tools.
+
 ## Usage surfaces
 
 | Surface | Behavior |
 | --- | --- |
 | `/smart-compact` | Explicit manual run. Supports picker UI, direct args, dry-run, focus, and budgets. |
-| `session_before_compact` | Auto path. Runs before Pi's native compaction and returns a verification-scored result when context pressure is high. |
+| `session_before_compact` | Auto path. Returns/stages a verification-scored summary under pressure; durable state waits for matching `session_compact`. |
 | `smart_compact` tool | Agent path. Produces a pending summary for Pi's next natural compact; does not compact mid-turn. |
 | `/smart-compact loops` | Project-level open-loop manager: resolve/reopen, priority, pin/unpin. |
 
 ### Focus and budgets
 
 ```bash
-/smart-compact balanced --focus=authentication
-/smart-compact aggressive --max-calls=6 --max-latency=30000
-/smart-compact balanced --focus=src/auth.ts --max-calls=8
+/smart-compact auto --focus=authentication
+/smart-compact aggressive --max-input-tokens=120000
+/smart-compact fast --focus=src/auth.ts --max-calls=3
+/smart-compact thorough
 ```
 
 - `--focus` assigns more synthesis/exploration budget to a topic or path. It
   does **not** attempt unsupported non-contiguous compaction.
 - `--max-calls` accepts `1–100`.
-- `--max-latency` accepts `5000–600000` milliseconds.
-- Call-budget exhaustion degrades to deterministic summaries. The latency
-  budget is a hard cancellation deadline.
+- `--max-input-tokens` accepts `10000–1000000` aggregate prompt tokens.
+- `--max-latency` accepts `5000–600000` milliseconds as an explicit hard override; mode latency targets are otherwise soft.
+- Budget exhaustion degrades to deterministic summaries instead of dropping context.
+
+The tool exposes equivalent `focus`, `max_calls`, `max_input_tokens`, and
+`max_latency_ms` parameters.
+
+## Modes
+
+| Mode | Calls | Prompt cap | Output cap | Behavior |
+| --- | ---: | ---: | ---: | --- |
+| `auto` | adaptive | adaptive | adaptive | Default; selects from context pressure and deterministic session risk |
+| `balanced` | 6 | 200K | 40K | Token/continuity balance; deterministic boundaries and repair |
+| `aggressive` | 4 | 120K | 25K | Maximum context recovery with a 3K summary and 10K live tail |
+| `fast` | 3 | 100K | 20K | Favors larger single-pass windows and minimum waiting |
+| `thorough` (`slow` alias) | 8 | 300K | 80K | Maximum fidelity; enables Explore and one optional LLM repair |
+
+Fast and aggressive modes use a zero-call deterministic summary when extraction confidence is high; otherwise they keep the bounded LLM path. Auto planning also raises fidelity when scoped continuity or prior damage indicates risk. Recent-tail retention scales with model context while preserving the two newest user turns when enough history exists.
 
-The tool exposes equivalent `focus`, `max_calls`, and `max_latency_ms`
-parameters.
+Output caps stop subsequent calls after observed usage reaches the threshold.
+The ChatGPT Codex subscription endpoint rejects `max_output_tokens`,
+`max_tokens`, and `max_completion_tokens`; Smart Compact therefore enforces a
+15–90 second per-call watchdog plus a streamed visible-output ceiling and falls
+back deterministically on abort. Custom Codex endpoints receive
+`max_output_tokens` through Pi AI's payload hook.
 
-## Profiles
+Legacy compression profiles remain as advanced/backwards-compatible policy:
+`light` maps to `thorough`; `balanced` and `aggressive` map to their same-named
+modes. The selected model never changes automatically.
 
-| Profile | Summary budget | Recent context kept | Best for |
-| --- | ---: | ---: | --- |
-| `light` | 10,000 tokens | 30,000 tokens | Maximum continuity and detail |
-| `balanced` | 6,000 tokens | 20,000 tokens | General use; default |
-| `aggressive` | 3,000 tokens | 10,000 tokens | Tight context budgets |
+### Stage-aware provider routing
+
+All stages use the selected Pi model by default. Routing is explicit and
+independent of modes:
+
+| Stage | Config key | Default |
+|---|---|---|
+| Explore / segmentation | `segmentationModel` | selected model |
+| Synthesis / assembly | `summaryModel` | selected model |
+| Verification repair | `verificationModel` | summary/selected model |
+
+Every run persists per-stage provider, model, reliability, latency, and token
+telemetry with schema-versioned verifier quality. `bun run provider-eval`
+builds an advisory matrix by context pressure and tool density; it never edits
+configuration or selects a model. Legacy rows contribute operational evidence
+but not quality because old verifier score semantics are incompatible.
+
+A reproducible paid-API probe is opt-in only:
+
+```bash
+bun run provider-eval:live --live \
+  --models=openai/gpt-5.4,anthropic/claude-sonnet-4-6
+```
 
-Profiles are a starting policy. Provider/model calibration, conversation shape,
-focus hints, damage feedback, and explicit budgets refine the actual run.
+It runs three bounded, identical coding-continuity scenarios and reports
+verification score, latency, and token usage. Apply a route manually only after
+representative evidence. See the dated [provider evaluation baseline](./docs/provider-evaluation-2026-08-06.md).
+
+### Privacy-safe telemetry and canary gates
+
+Raw local JSONL remains available to the interactive dashboard, while
+`bun run telemetry-report` emits aggregate-only telemetry: no session/project
+IDs, prompts, summaries, paths, or error text. Failures use a stable taxonomy
+(cancelled, timeout, rate limit, authentication, budget, output limit,
+provider, persistence, validation, internal).
+
+Set `telemetryChannel` to `canary` only on the externally selected canary
+cohort. The report compares schema-v2 canary runs with the stable baseline and
+returns `HOLD`, `ROLLBACK`, or `PROMOTE`. Rollback triggers are: failure rate
++5pp and ≥10%, verifier quality −5 points, p95 latency +50%, tokens +50%,
+heuristic fallback +10pp, or post-compaction damage +10pp. Promotion requires
+at least 20 canary runs, a stable baseline, ≥70% verifier-quality coverage,
+≥70% run-correlated damage-observation coverage in both cohorts, ≥85 absolute
+canary quality, and ≥95% success. The extension reports the decision; it never
+edits config or deploys automatically.
+
+The interactive and HTML dashboards make trust evidence explicit: a **Data
+Confidence** score (target ≥85) combines recent sample size (25 points),
+schema-v2 coverage (25), verifier-quality coverage (20), field completeness
+(20), and seven-day freshness (10). Separate views show repair gain and quality
+bands, stage/provider/model reliability with quality coverage, stable-vs-canary
+deltas, rollback triggers, and the failure taxonomy. Low confidence is shown as
+low—not silently filled from incompatible legacy scores—and includes concrete
+guidance for reaching the target.
 
 ## Safety and privacy
 
@@ -147,7 +232,8 @@ focus hints, damage feedback, and explicit budgets refine the actual run.
 - Mandatory deterministic repair for patchable verification gaps
 - Cross-session guard and five-minute TTL for pending summaries
 - Session-log recovery for older, truncated tool results
-- Retention-pruned backups before compaction
+- Marker-owned retention-pruned backups before compaction; foreign files in a
+  custom directory are untouched
 
 ### Secrets and PII
 
@@ -155,7 +241,7 @@ High-confidence secret scrubbing is enabled by default at every relevant trust
 boundary:
 
 ```text
-provider request · extraction cache · backup · state · pending summary
+provider request · extraction cache · backup · state · context graph · pending summary
 ```
 
 It covers common API keys, cloud/GitHub/Slack tokens, JWTs, bearer tokens,
@@ -169,11 +255,14 @@ handling or a dedicated DLP system**. See the
 ### Approval and feedback
 
 - `requireApproval: true` adds a fail-closed manual **Apply / Cancel** decision
-  after the provenance review screen. Auto and tool paths retain their native
-  staged lifecycle.
+  after the provenance review screen. Every path stages first; fingerprint,
+  continuity state, context graph, and success telemetry commit only after the
+  host confirms the matching native `session_compact` event.
 - Online damage monitoring observes the first post-compaction messages and
-  records re-read files or repeated context. Remediation hints feed those files
-  into the next compaction.
+  records re-read files or repeated context. Observations join the originating
+  compaction by a local run id; missing evidence lowers coverage rather than
+  counting as a clean run. Remediation hints feed affected files into the next
+  compaction.
 - `adaptiveDamageFeedback` can opt a project into larger preservation budgets
   after repeated high-damage reports.
 
@@ -199,20 +288,27 @@ Add `smartCompact` to `~/.pi/agent/settings.json`:
 ```json
 {
   "smartCompact": {
+    "mode": "auto",
     "profile": "balanced",
     "summaryModel": null,
     "segmentationModel": null,
-    "summaryThinkingLevel": null,
-    "segmentationThinkingLevel": null,
+    "verificationModel": null,
+    "summaryThinkingLevel": "minimal",
+    "segmentationThinkingLevel": "minimal",
     "autoTrigger": true,
     "minContextPercent": 60,
     "backupEnabled": true,
     "scrubSecrets": true,
     "scrubPii": false,
     "requireApproval": false,
-    "maxLlmCalls": 0,
+    "maxLlmCalls": 8,
+    "maxLlmInputTokens": 0,
+    "codexMaxCallMs": 0,
     "maxLatencyMs": 0,
     "focusWeighting": true,
+    "zeroCallEnabled": true,
+    "contextGraphEnabled": true,
+    "telemetryChannel": "stable",
     "onlineDamageMonitor": true,
     "adaptiveDamageFeedback": false,
     "pinPaths": []
@@ -235,21 +331,35 @@ use a stronger one:
 ```
 
 `segmentationThinkingLevel` applies to exploration; `summaryThinkingLevel`
-applies to synthesis, assembly, and repair. Supported values are `minimal`,
-`low`, `medium`, `high`, `xhigh`, and `max`. Leave either value as `null` to
-preserve the provider's existing behavior. An explicit call-level reasoning
-option takes precedence over these defaults.
+applies to synthesis, assembly, and repair. Both default to `minimal` because
+reasoning tokens from multi-call compaction add up quickly. Supported values
+are `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. Set either value to
+`null` to restore the provider's default behavior. An explicit call-level
+reasoning option takes precedence.
+
+### Cost safeguards
+
+Automatic and tool-triggered runs operate on Pi's current active context, not
+the append-only session history. A same-session staged summary is reused, the
+exploration loop is limited to three rounds, provider and outer retries are
+disabled, and every mode has finite call plus aggregate prompt-token budgets.
+If anchor/tool-call
+protection leaves too much live context to get below the configured trigger,
+Smart Compact spends no LLM tokens and lets Pi's native compactor handle it.
+Manual `/smart-compact` remains an explicit force path.
 
 <details>
 <summary><strong>All configuration keys</strong></summary>
 
 | Key | Type | Default | Notes |
 | --- | --- | --- | --- |
-| `profile` | `light \| balanced \| aggressive` | `balanced` | Default policy profile |
+| `mode` | `auto \| balanced \| aggressive \| fast \| thorough` | `auto` | User-facing execution preset |
+| `profile` | `light \| balanced \| aggressive` | `balanced` | Legacy/advanced compression profile; used when mode is absent |
 | `summaryModel` | `string \| null` | `null` | Uses the active session model when null |
-| `segmentationModel` | `string \| null` | `null` | Optional cheaper model for Explore |
-| `summaryThinkingLevel` | `minimal \| low \| medium \| high \| xhigh \| max \| null` | `null` | Reasoning level for synthesis and repair; provider default when null |
-| `segmentationThinkingLevel` | `minimal \| low \| medium \| high \| xhigh \| max \| null` | `null` | Reasoning level for exploration; provider default when null |
+| `segmentationModel` | `string \| null` | `null` | Optional explicit model for Explore |
+| `verificationModel` | `string \| null` | `null` | Optional explicit model for LLM verification repair |
+| `summaryThinkingLevel` | `minimal \| low \| medium \| high \| xhigh \| max \| null` | `minimal` | Reasoning level for synthesis and repair; provider default when null |
+| `segmentationThinkingLevel` | `minimal \| low \| medium \| high \| xhigh \| max \| null` | `minimal` | Reasoning level for exploration; provider default when null |
 | `autoTrigger` | `boolean` | `true` | Participate in Pi's native compact hook |
 | `autoTriggerTimeoutMs` | `number` | `120000` | Hard timeout for automatic runs |
 | `minContextPercent` | `number` | `60` | Actual context usage gate |
@@ -260,9 +370,14 @@ option takes precedence over these defaults.
 | `requireApproval` | `boolean` | `false` | Manual UI only; cancel/error fails closed |
 | `scrubSecrets` | `boolean` | `true` | High-confidence credential redaction |
 | `scrubPii` | `boolean` | `false` | Email/phone/card-shaped redaction |
-| `maxLlmCalls` | integer `0–100` | `0` | `0` means unlimited |
+| `maxLlmCalls` | integer `0–100` | `8` | Global ceiling combined with the selected mode |
+| `maxLlmInputTokens` | integer `0–1000000` | `0` | `0` uses the selected mode's aggregate prompt-token cap |
+| `codexMaxCallMs` | integer `0` or `5000–300000` | `0` | ChatGPT Codex per-call watchdog; `0` derives 15–90s from requested output tokens |
 | `maxLatencyMs` | `0` or `5000–600000` | `0` | `0` means unlimited |
 | `focusWeighting` | `boolean` | `true` | Weight focused topics/paths higher |
+| `zeroCallEnabled` | `boolean` | `true` | Use deterministic synthesis for high-confidence fast/aggressive runs |
+| `contextGraphEnabled` | `boolean` | `true` | Index verified state and enable project-scoped recall/save tools |
+| `telemetryChannel` | `stable \| canary` | `stable` | Tag local schema-v2 metrics for external canary comparison |
 | `onlineDamageMonitor` | `boolean` | `true` | Observe post-compaction regression signals |
 | `adaptiveDamageFeedback` | `boolean` | `false` | Increase preservation after repeated damage |
 
@@ -277,37 +392,37 @@ The legacy `semanticCompact` root key is still accepted for compatibility.
 
 ```markdown
 ## Goal
-Add retry/backoff to the LLM client without breaking cancellation.
+Tighten aggregate token budgets without breaking cancellation.
 
 ## Constraints & Preferences
 - [requirement] Never compact mid-turn from the tool path.
 
 ## Progress
 ### Done
-- [x] Added `withRetry` in `src/infra/llm-retry.ts`.
+- [x] Reserved concurrent output budgets before provider calls.
 ### In Progress
-- [ ] Wire the retry client into run-scoped services.
+- [ ] Collect canary evidence for the new limits.
 ### Blocked
 - None.
 
 ## Key Decisions
-- **Honor Retry-After verbatim**: provider limits are authoritative.
+- **Charge failed streams conservatively**: an interrupted stream consumes its output reservation.
 
 ## Files Modified
-- src/infra/llm-retry.ts
-- src/infra/llm-client.ts
+- src/infra/services.ts
+- src/utils/cache.ts
 
 ## Open Loops
-- [high] Preserve AbortSignal behavior across providers.
+- [high] Verify provider usage reconciliation across cache-read/write responses.
 
 ## Changes Since Last Compaction
-- New files touched: src/infra/llm-retry.ts
+- Concurrent output accounting now fails closed.
 
 ## Next Steps
-1. Add an outer timeout as a second line of defense.
+1. Run the adversarial release gate.
 
 ## Critical Context
-- Retry 408/425/429/5xx; fail fast on other 4xx responses.
+- Input accounting includes uncached input, cache reads, and cache writes.
 ```
 
 </details>
@@ -320,7 +435,7 @@ Add retry/backoff to the LLM client without breaking cancellation.
 /smart-compact restore       # browse, inspect, and restore backups
 ```
 
-Metrics include method, profile, provider, phase timing, token/call estimates,
+Metrics include effective mode, profile, provider, phase timing, token/call estimates,
 verification quality, cache behavior, redactions, adaptation, fallbacks, and
 cancelled runs.
 
@@ -332,12 +447,15 @@ All files live under `~/.pi/agent/`.
 | Path | Purpose |
 | --- | --- |
 | `settings.json` | Configuration (read only) |
-| `compact-backups/` | Retention-pruned conversation backups |
+| `compact-backups/` | Marker-owned retention-pruned conversation backups |
 | `.cache/compact-extraction-<session>.json` | Incremental extraction cache |
 | `.cache/compact-metrics.jsonl` | Tail-retained metrics log; 5 MiB cap |
 | `.cache/smart-compact-report.html` | Local HTML dashboard |
 | `.cache/smart-compact/projects/<projectId>.json` | Project fingerprint |
-| `.cache/smart-compact/states/<projectId>.json` | Compaction state and loop overrides |
+| `.cache/smart-compact/states/<projectId>/<sessionId>.json` | Scoped compaction state and loop overrides |
+| `.cache/smart-compact/run-locks/` | 0600 cross-process session/global concurrency leases |
+| `.cache/smart-compact/native-continuity/` | 0600 one-shot project/session/branch handoffs |
+| `.cache/smart-compact/context-graph.sqlite` | Project-isolated FTS5 context graph and explicit saved memory |
 | `.cache/smart-compact/damage-reports.jsonl` | Damage reports; 5 MiB cap |
 | `.cache/smart-compact/remediation-<projectId>.json` | Files to preserve after damage |
 
@@ -378,6 +496,7 @@ the build in GitHub Actions.
 - [Contributing](https://github.com/alpertarhan/pi-smart-compact/blob/main/CONTRIBUTING.md)
 - [Security](https://github.com/alpertarhan/pi-smart-compact/blob/main/SECURITY.md)
 - [Support](https://github.com/alpertarhan/pi-smart-compact/blob/main/SUPPORT.md)
+- [v8 migration guide](https://github.com/alpertarhan/pi-smart-compact/blob/main/docs/MIGRATING_TO_V8.md)
 - [Release checklist](https://github.com/alpertarhan/pi-smart-compact/blob/main/docs/RELEASE.md)
 
 ## License

package/dist/app/compaction-commit-store.d.ts

@@ -0,0 +1,19 @@
+import type { PendingCompaction } from "../types.ts";
+export type CommitDiscardReason = "expired" | "evicted" | "aborted" | "shutdown" | "apply-error";
+export interface CompactionCommitStore {
+    stage(pending: PendingCompaction): void;
+    take(runId: string, sessionId: string): PendingCompaction | null;
+    discard(runId: string, reason: CommitDiscardReason): PendingCompaction | null;
+    clearSession(sessionId: string, reason?: CommitDiscardReason): PendingCompaction[];
+    size(): number;
+}
+/**
+ * Holds summaries only between session_before_compact and session_compact.
+ * Nothing durable is written until `take()` confirms both run and session.
+ */
+export declare function createCompactionCommitStore(options?: {
+    ttlMs?: number;
+    maxEntries?: number;
+    onDiscard?: (pending: PendingCompaction, reason: CommitDiscardReason) => void;
+}): CompactionCommitStore;
+//# sourceMappingURL=compaction-commit-store.d.ts.map

package/dist/app/compaction-commit-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compaction-commit-store.d.ts","sourceRoot":"","sources":["../../src/app/compaction-commit-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAOrD,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,UAAU,GAAG,aAAa,CAAC;AAEjG,MAAM,WAAW,qBAAqB;IACpC,KAAK,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACxC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAAC;IACjE,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,GAAG,iBAAiB,GAAG,IAAI,CAAC;IAC9E,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,mBAAmB,GAAG,iBAAiB,EAAE,CAAC;IACnF,IAAI,IAAI,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,GAAE;IACnD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,mBAAmB,KAAK,IAAI,CAAC;CAC1E,GAAG,qBAAqB,CAgE7B"}

package/dist/app/mode-policy.d.ts

@@ -0,0 +1,29 @@
+import type { CompactionMode, CompactionState, CompressionProfile, EffectiveCompactionMode, StructuredExtraction } from "../types.ts";
+export interface ModePolicy {
+    profile: CompressionProfile;
+    maxLlmCalls: number;
+    maxInputTokens: number;
+    maxOutputTokens: number;
+    explore: boolean;
+    allowLlmPatch: boolean;
+    singlePassMultiplier: number;
+    batchOutput: {
+        min: number;
+        perChunk: number;
+        max: number;
+    };
+    softLatencyMs: number;
+    targetContextPercent: number;
+}
+export declare const MODE_POLICIES: Readonly<Record<EffectiveCompactionMode, ModePolicy>>;
+export declare function modeFromLegacyProfile(profile: CompressionProfile): EffectiveCompactionMode;
+/** Cheap preflight choice used before deterministic extraction is available. */
+export declare function resolveMode(requested: CompactionMode, contextPercent: number, extraction?: StructuredExtraction, additionalRisk?: number): EffectiveCompactionMode;
+export declare function deterministicExtractionConfidence(extraction: StructuredExtraction, context?: {
+    conversationTokens?: number;
+    toolPercent?: number;
+}): number;
+export declare function continuityRisk(state: CompactionState | null): number;
+export declare function batchOutputLimit(mode: EffectiveCompactionMode, chunks: number, providerMax: number): number;
+export declare function effectiveBudget(configured: number, modeDefault: number): number;
+//# sourceMappingURL=mode-policy.d.ts.map

package/dist/app/mode-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode-policy.d.ts","sourceRoot":"","sources":["../../src/app/mode-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EAAE,eAAe,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,oBAAoB,EACnG,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,kBAAkB,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,OAAO,CAAC;IACvB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,WAAW,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5D,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,uBAAuB,EAAE,UAAU,CAAC,CAqB/E,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,kBAAkB,GAAG,uBAAuB,CAE1F;AAED,gFAAgF;AAChF,wBAAgB,WAAW,CACzB,SAAS,EAAE,cAAc,EACzB,cAAc,EAAE,MAAM,EACtB,UAAU,CAAC,EAAE,oBAAoB,EACjC,cAAc,SAAI,GACjB,uBAAuB,CAezB;AAED,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,oBAAoB,EAChC,OAAO,GAAE;IAAE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAO,GAClE,MAAM,CAeR;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,GAAG,MAAM,CAOpE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,uBAAuB,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAG3G;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAG/E"}

package/dist/app/native-continuity-bridge.d.ts

@@ -0,0 +1,18 @@
+export interface NativeContinuityScope {
+    projectId: string;
+    sessionId: string;
+    branchHeadId: string;
+}
+export interface NativeContinuityBridge {
+    stage(scope: NativeContinuityScope, text: string): void;
+    take(scope: NativeContinuityScope): string | null;
+    clear(scope?: NativeContinuityScope): void;
+    size(): number;
+}
+export declare function createNativeContinuityBridge(opts?: {
+    ttlMs?: number;
+    maxEntries?: number;
+    now?: () => number;
+    dir?: string;
+}): NativeContinuityBridge;
+//# sourceMappingURL=native-continuity-bridge.d.ts.map

package/dist/app/native-continuity-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-continuity-bridge.d.ts","sourceRoot":"","sources":["../../src/app/native-continuity-bridge.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;CACtB;AASD,MAAM,WAAW,sBAAsB;IACrC,KAAK,CAAC,KAAK,EAAE,qBAAqB,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACxD,IAAI,CAAC,KAAK,EAAE,qBAAqB,GAAG,MAAM,GAAG,IAAI,CAAC;IAClD,KAAK,CAAC,KAAK,CAAC,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAC3C,IAAI,IAAI,MAAM,CAAC;CAChB;AAMD,wBAAgB,4BAA4B,CAAC,IAAI,GAAE;IACjD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;CACT,GAAG,sBAAsB,CAqG9B"}

package/dist/app/pending-slot.d.ts

@@ -1,46 +1,6 @@
-/**
- * Pending-compaction slot.
- *
- * A single-element, owner-private state cell that holds the *most recently
- * prepared* `PendingCompaction` until the next `session_before_compact`
- * event consumes it. Concurrency model:
- *
- *   - One producer (`runSmartCompact` → `stagePendingCompaction`).
- *   - One consumer (`session_before_compact` event handler).
- *   - Single-threaded JS event loop; no atomic primitives needed.
- *
- * Design rationale — why an encapsulated factory instead of a mutable
- * `{ value, createdAt }` ref-cell:
- *
- *   1. **Invariant centralization.** The "set → consume → clear" lifecycle
- *      lives in one file. Callers cannot accidentally null `value` without
- *      also resetting `createdAt`, nor can they read a `value` snapshot
- *      against a freshly-overwritten `createdAt` (the original bare-ref
- *      shape allowed this race; see B3 in code-review #3).
- *
- *   2. **Observable consume result.** `consume()` returns a discriminated
- *      union that records *why* a payload was rejected (empty / expired /
- *      session-mismatch). The previous helper folded all three into
- *      `null`, which hid information the caller might want to surface as
- *      metrics or differentiated notifications.
- *
- *   3. **Atomic snapshot.** Every consume path destructures a single
- *      `{ value, createdAt }` snapshot up front so the TTL and id checks
- *      operate on a coherent view, even if a future maintainer threads an
- *      `await` into the middle of the function.
- *
- *   4. **No host-context coupling.** The slot does NOT call
- *      `ctx.ui.notify` itself — the caller decides the UX (silent metric,
- *      toast, log line). This keeps the module pure / fully unit-testable
- *      without a fake host context.
- */
+/** Session-scoped pending compaction store with TTL and bounded memory. */
 import type { PendingCompaction } from "../types.ts";
 import { type SessionIdentityContext } from "../infra/session-identity.ts";
-/**
- * Outcome of `PendingSlot.consume()`. Discriminated union so callers can
- * react differently to each rejection reason (e.g. log a stale payload at
- * `warn`, but a cross-session mismatch at `error`).
- */
 export type ConsumeResult = {
     kind: "ok";
     pending: PendingCompaction;
@@ -54,35 +14,18 @@ export type ConsumeResult = {
     expected: string;
     actual: string;
 };
-/**
- * Public surface of an owned pending-compaction slot. Producers call
- * `set()` once they have a finished summary; consumers call `consume()` at
- * the next compact boundary. `isPresent()` is a non-mutating peek used by
- * the orchestrator for UI wording ("prepared, awaiting native /compact"
- * vs. "run finished").
- */
 export interface PendingSlot {
     set(pending: PendingCompaction): void;
     consume(ctx: SessionIdentityContext): ConsumeResult;
-    clear(): void;
-    isPresent(): boolean;
-    /**
-     * Side-effect-free read. Returns the staged payload without consuming it
-     * or running any guard checks. Intended for *display* paths (e.g. a tool
-     * response that wants to surface `tokensBefore` after a prepare-only run).
-     * Callers must NOT pass the returned payload to the host — only `consume`
-     * enforces the freshness + session-match invariants.
-     */
-    peek(): Readonly<PendingCompaction> | null;
+    clear(sessionId?: string): void;
+    isPresent(sessionId?: string): boolean;
+    peek(sessionId?: string): Readonly<PendingCompaction> | null;
+    size(): number;
 }
-/**
- * Optional injection seam for `Date.now`. Tests pass a fake clock so they
- * can advance time without `await new Promise(setTimeout)`. Production
- * callers omit this and get real wall-clock time.
- */
 export interface PendingSlotOptions {
     ttlMs: number;
     now?: () => number;
+    maxEntries?: number;
 }
 export declare function createPendingSlot(opts: PendingSlotOptions): PendingSlot;
 //# sourceMappingURL=pending-slot.d.ts.map