ds4-context-engine 0.3.4 → 0.3.5

package/README.md

@@ -16,7 +16,9 @@ bounded active context with provenance
 Pi provider
 ```
 
-> **Project status:** The coordinated `0.3.4` release adds optional anchored editing, post-edit reports, adaptive reads, adaptive artifact budgets and managed local bash jobs. All five switches default to off. It carries forward the stable 0.3 line's persistence, offline storage maintenance, dedicated compaction model and configurable transport retries. Canonical history, SQLite schema 15 and runtime contracts remain unchanged; Pi remains pinned to `0.84.3`. See the [0.3.4 release record](docs/releases/0.3.4.md) for validation and publication status.
+> **Project status:** The coordinated `0.3.5` release adds bounded compaction optimizations: one validated previous-summary/source update when the complete prompt fits, a dedicated calibrated input budget, up to two concurrent segments, and metadata-only phase timings in `/context compaction`. Canonical history, SQLite schema 15 and runtime contracts remain unchanged; Pi remains pinned to `0.84.3`. See the [0.3.5 release record](docs/releases/0.3.5.md) for validation and publication status.
+
+**New compaction defaults:** `compaction.directUpdate=true`, `compaction.inputBudget="summary"`, `compaction.maxConcurrentSegments=2`. Existing compaction/master switches still apply. See [latency controls and compatibility](docs/COMPACTION.md#latency-controls) for the legacy-path settings. No real-provider speedup is claimed from mock tests. The five optional editing/reading/artifact/job features introduced in `0.3.4` remain default-off.
 
 ## Why DS4
 
@@ -87,7 +89,7 @@ Install the latest stable public npm package with:
 pi install npm:ds4-context-engine
 ```
 
-The three packages (`ds4-context-engine`, `ds4-context-core`, and `ds4-context-reference-adapter`) are released together with the same exact version. Both adapters require the matching core version. See [0.3.4](docs/releases/0.3.4.md) for this release's changes and compatibility.
+The three packages (`ds4-context-engine`, `ds4-context-core`, and `ds4-context-reference-adapter`) are released together with the same exact version. Both adapters require the matching core version. See [0.3.5](docs/releases/0.3.5.md) for this release's changes and compatibility.
 
 To dogfood the beta without replacing a global stable installation, pin the exact version in a disposable project:
 
@@ -328,7 +330,10 @@ The following example shows the main configuration groups. Omitted values use th
     "mode": "hierarchical",
     "validate": true,
     "segmentTargetTokens": 30000,
-    "preserveRecentVerbatim": true
+    "preserveRecentVerbatim": true,
+    "directUpdate": true,
+    "inputBudget": "summary",
+    "maxConcurrentSegments": 2
   },
   "privacy": {
     "enabled": false,
@@ -506,6 +511,7 @@ scripts             package and release-readiness checks
 - [Roadmap 0.2.0](docs/ROADMAP_0.2.0.md)
 - [Release process](docs/RELEASING.md)
 - [0.2.0 release readiness](docs/RELEASE_READINESS_0.2.0.md)
+- [0.3.5 release notes](docs/releases/0.3.5.md)
 - [0.3.4 release notes](docs/releases/0.3.4.md)
 - [0.3.3 release notes](docs/releases/0.3.3.md)
 - [0.3.2 release notes](docs/releases/0.3.2.md)
@@ -528,7 +534,7 @@ scripts             package and release-readiness checks
 
 The original M0–M13 roadmap is complete. `ds4-context-core` contains the compiled runtime-neutral implementation. M14 context-quality metrics, M15 rich symbol indexing, M16 hybrid semantic retrieval, M17 cross-session project memory, M18 learned-ranking shadow evaluation, M19's runtime adapter/conformance kit, and M20 opt-in local KV eligibility/replay are implemented on `main`. Learned active ranking remains promotion-gated, Pi reports local KV as unsupported, and static ranking/native completion stay authoritative on every failure.
 
-The [0.2.0 roadmap](docs/ROADMAP_0.2.0.md) is complete. The stable 0.3 line carries forward the [context persistence tool](docs/CONTEXT_PERSISTENCE_TOOL.md), privacy-safe [compaction](docs/COMPACTION.md), bounded persisted manifests, cooperative client leases and recoverable offline maintenance. Version 0.3.4 adds opt-in [anchored editing](docs/ANCHORED_EDITING.md) and [portable agent tools](docs/PORTABLE_AGENT_TOOLS.md), without backend rewind, forced sampling or operational KV integration. Confirmation, provenance, Pi fallback and canonical/configuration/SQLite/runtime contracts remain unchanged. The [0.2 readiness record](docs/RELEASE_READINESS_0.2.0.md) remains the compatibility baseline; the lexical planner stays available as the deterministic fallback.
+The [0.2.0 roadmap](docs/ROADMAP_0.2.0.md) is complete. The stable 0.3 line carries forward the [context persistence tool](docs/CONTEXT_PERSISTENCE_TOOL.md), privacy-safe [compaction](docs/COMPACTION.md), bounded persisted manifests, cooperative client leases and recoverable offline maintenance. Version 0.3.5 adds bounded compaction updates, summary input headroom, concurrent segments and phase timings. The opt-in [anchored editing](docs/ANCHORED_EDITING.md) and [portable agent tools](docs/PORTABLE_AGENT_TOOLS.md) from 0.3.4 remain default-off, without backend rewind, forced sampling or operational KV integration. Confirmation, provenance, Pi fallback and canonical/configuration/SQLite/runtime contracts remain unchanged. The [0.2 readiness record](docs/RELEASE_READINESS_0.2.0.md) remains the compatibility baseline; the lexical planner stays available as the deterministic fallback.
 
 ## Contributing
 

package/docs/ADR/061-compaction-latency.md

@@ -0,0 +1,21 @@
+# ADR-061 — Bounded compaction latency optimizations
+
+Status: accepted and implemented; coordinated 0.3.5 publication explicitly authorized by the user on 2026-09-05. See the [release record](../releases/0.3.5.md) for validation and publication evidence.
+
+## Context
+
+Pi normally updates previous summary plus discarded messages in one request. DS4 previously always summarized new segments first and then generated an aggregate when a predecessor existed. Independent segments ran sequentially and summary inputs reused the ordinary context fill target. This can add avoidable calls; provider latency and summary quality still require controlled real-provider comparisons.
+
+## Decision
+
+- Add `compaction.directUpdate` (default true): estimate the complete sanitized update prompt, including previous summary, cumulative file evidence, custom instructions, split-turn instructions and output contract. If it fits, generate and validate one immutable `task-state` node with the predecessor as a child, canonical source IDs from both spans, and a hash bound to both the new source and predecessor identity/hash/content. With no predecessor, the existing one-segment path remains sufficient. Oversized updates use bounded hierarchical segmentation/aggregation, not truncation.
+- Add `compaction.inputBudget` (`summary` default, or `context`). Summary mode uses the calibrated hard input limit instead of the ordinary active/fill target. Additionally bound input by model context minus safety margin and the actual summary output cap, converted to estimator units. Do not raise model/configured hard limits, remove calibration, reduce safety margins, or reuse ordinary context space reserved for output. Context mode preserves the old active target (also respecting actual summary output headroom).
+- Add `compaction.maxConcurrentSegments` (default 2, range 1–2). Only independent segment requests overlap. Allocate identities and assemble graph/usage in source order, not completion order. On failure stop scheduling, abort siblings, await their settlement before fallback, and persist no partial graph. Cancellation remains cooperative; provider work already accepted may still be billed. Aggregation remains ordered and bounded.
+- Expose process-local metadata-only timings for preparation, segment/direct generation, aggregation, graph preparation/persistence and total DS4 hook duration, plus chosen path, effective provider/model, direct prompt size and concurrency. Timings use a monotonic clock, include retries and local validation within generation, and are wall times (not sums of overlapping calls). They are not canonical evidence, are not persisted in JSONL, and do not measure a subsequent native Pi fallback.
+- Preserve schema-v2 compaction metadata, the existing `task-state` kind, source/classification/validation contracts, Pi cut points, atomic tool exchanges, fresh routing IDs, retry policy, canonical JSONL and all-or-nothing graph preparation. `segmentSummaryId` refers to the update node itself on a direct update; do not invent a segment that was never generated.
+
+## Compatibility and validation
+
+Configuration is additive; absent fields use the new defaults. The old scheduling path can be compared using `directUpdate=false`, `inputBudget=context`, and `maxConcurrentSegments=1`. The compaction master switch still delegates to Pi when disabled. The original local implementation excluded versioning and publication; the user subsequently authorized the coordinated 0.3.5 release. No dependency upgrade, live database maintenance or Pi upgrade is part of this change.
+
+Cover exact budget boundaries and calibration/output reserve, predecessor-only exact evidence and privacy, native predecessor warnings, source ordering/provenance/hash/rebuild, bounded concurrency and out-of-order completion, cancellation/failure/transport retry drainage, and no graph persistence before full success. Retain hierarchical regression coverage explicitly even where default routing now chooses a direct update. Automated call counts and synchronization tests establish scheduling behavior, not a promise of 40-second compactions or unchanged semantic quality on real provider outputs.

package/docs/ADR/README.md

@@ -64,5 +64,6 @@ The initial decisions from the development plan are accepted:
 | [058](058-bounded-manifest-storage.md) | Bound persisted manifests and defer compression to a versioned migration | Accepted |
 | [059](059-optional-anchored-editing.md) | Opt in to anchored edit expansion inside Pi's native mutation queue | Accepted |
 | [060](060-optional-portable-agent-tools.md) | Opt in to edit reports, adaptive reads/results and session-owned local jobs | Accepted |
+| [061](061-compaction-latency.md) | Bound compaction update calls, input budgets, concurrent segments and phase timings | Accepted |
 
 Each decision will receive a dedicated record when implementation pressure introduces alternatives or consequences not already covered by the development plan.

package/docs/COMPACTION.md

@@ -6,14 +6,14 @@ DS4 intercepts Pi's `session_before_compact` event but preserves Pi's cut-point
 
 1. Pi determines `messagesToSummarize`, optional split-turn prefix, and `firstKeptEntryId`.
 2. DS4 maps every source message by exact fingerprint to a canonical branch entry ID.
-3. Pi's serializer converts the newly discarded span to bounded conversation text; enabled privacy policy sanitizes conversation, custom instructions, and file paths for the active provider.
-4. DS4 estimates the complete sanitized summary request against the calibrated active-model input budget. If the whole request does not fit, it partitions the source into ordered contiguous segments. Individual messages are indivisible, and every tool call remains in the same atomic group as all matching results; an exceptionally large turn may split only between such groups.
-5. The active model generates and validates each immutable segment summary only against that segment's sanitized evidence, with cache retention disabled and a fresh routing session ID per call. Only failures categorized as `transport` are retried: at most two retries follow bounded 200 ms and 500 ms delays, each with another fresh routing session ID. The delay and the next call both honor Pi's abort signal; all other failure categories fall back immediately.
-6. DS4 recursively aggregates ordered child summaries in bounded fan-in calls until one root remains. The ordered roots include the previous branch summary, when present, followed by every new segment. DS4-generated IDs, hashes, kinds, and graph levels remain outside model-visible evidence. A Pi-native predecessor is imported as an explicitly unverified branch node.
-7. The highest input classification is wrapped around each generated node, then all nodes are persisted atomically as one `prepared` graph batch. Usage is summed across every segment and aggregate request; Pi receives only the final root text and still appends exactly one canonical `CompactionEntry` with `fromHook: true`.
+3. Pi's serializer converts the newly discarded span to bounded conversation text; enabled privacy policy sanitizes conversation, previous summary, custom instructions, and file paths for the effective compaction provider (dedicated model when configured and eligible).
+4. DS4 estimates the **complete** sanitized request against a calibrated summary-specific input budget, including framing, instructions, file inventories and output contract. With `compaction.directUpdate` enabled, a previous summary plus new source that fits is updated and validated in **one call**, producing an immutable `task-state` node. No predecessor needs only the existing one-segment call. Oversized updates fall through to hierarchical planning; no additional source is truncated to force a fit.
+5. The hierarchical path partitions oversized source into ordered contiguous segments. Individual messages are indivisible, and every tool call remains in the same atomic group as all matching results. Up to `compaction.maxConcurrentSegments` independent segment requests run concurrently (default 2). Each summary is validated against only its own sanitized evidence. Identities, source/child order and usage accumulation follow source order, not completion order. Cache retention stays disabled and every attempt has a fresh routing session ID.
+6. Hierarchical requests recursively aggregate ordered children until one root remains: previous branch summary first, then new segments. Aggregation stays sequential and budget-checked. Direct updates instead link their single node to the predecessor and new canonical source IDs, without generating a synthetic segment or a separate aggregate. DS4-generated IDs, hashes, kinds, and graph levels never become model-visible evidence. A Pi-native predecessor is imported as an explicitly unverified branch node.
+7. The highest input classification wraps each generated node, then all nodes are persisted atomically as one `prepared` graph batch. Usage includes every returned direct/segment/aggregate request and transport replay. Pi receives only the final root text and still appends exactly one canonical `CompactionEntry` with `fromHook: true`.
 8. `session_compact` commits all nodes and associates the active root with the Pi entry; failure marks the complete prepared batch `failed`.
 
-Fan-out and fan-in are bounded to 32 segment requests, 64 aggregate requests, and 16 aggregate passes. Transport replay mirrors Pi's assistant retry policy: `compaction.transport.maxAttempts` (default 3) total attempts and `compaction.transport.baseDelayMs` (default 2000 ms, capped at 60 s) backoff, doubling per attempt, abort-aware. Replay never applies to input, usage, rate, authentication, validation, or output-limit failures. A base prompt, individual message, atomic tool exchange, pair of child summaries, or total operation that cannot fit within those limits fails closed. Any mapping, budget, model, output-limit, validation, abort, or storage error returns `undefined` from the hook, allowing Pi's default compaction to run.
+Fan-out and fan-in are bounded to 32 segment requests, 64 aggregate requests, and 16 aggregate passes. The DS4 transport replay policy is: `compaction.transport.maxAttempts` (default 3) total attempts and `compaction.transport.baseDelayMs` (default 2000 ms, capped at 60 s) backoff, doubling per attempt, abort-aware. Replay never applies to input, usage, rate, authentication, validation, or output-limit failures. A base prompt, individual message, atomic tool exchange, pair of child summaries, or total operation that cannot fit within those limits fails closed. Any mapping, budget, model, output-limit, validation, abort, or storage error returns `undefined` from the hook, allowing Pi's default compaction to run. On segment failure or cancellation DS4 stops scheduling, aborts siblings and awaits all started workers before fallback; no partial graph is installed. Cancellation is cooperative: accepted provider work may still cost tokens, and a provider that ignores abort can delay settlement.
 
 ## Required summary contract
 
@@ -32,7 +32,7 @@ Fan-out and fan-in are bounded to 32 segment requests, 64 aggregate requests, an
 ## Critical Exact Values
 ```
 
-Every section must occur once, in order, and contain content or `- None`. DS4 replaces each unique `Files Read` and `Files Modified` section with one exact path per bullet from Pi's sanitized file-operation inventory before validation; missing or duplicate sections still fail. Backticked exact values must occur in the serialized segment source, ordered child-summary content, or those known file-operation paths. A bounded unsupported exact-value bullet is removed as a whole and recorded as a validation warning; unsupported prose, more than eight affected bullets, or removal above 25% still fails closed to Pi. The prompt explicitly asks the model to omit a bullet whose complete backticked span cannot be copied verbatim. Every segment is validated independently against only its own sanitized source and deterministic file inventory. Every aggregate is validated independently against only the sanitized content of its ordered children and cumulative deterministic file inventory. Any unrepaired failure prevents the whole graph batch from being installed.
+Every section must occur once, in order, and contain content or `- None`. DS4 replaces each unique `Files Read` and `Files Modified` section with one exact path per bullet from Pi's sanitized file-operation inventory before validation; missing or duplicate sections still fail. Backticked exact values must occur in the serialized segment source, ordered child-summary content, or those known file-operation paths. A bounded unsupported exact-value bullet is removed as a whole and recorded as a validation warning; unsupported prose, more than eight affected bullets, or removal above 25% still fails closed to Pi. The prompt explicitly asks the model to omit a bullet whose complete backticked span cannot be copied verbatim. Every segment is validated independently against only its own sanitized source and deterministic file inventory. Every aggregate is validated independently against only the sanitized content of its ordered children and cumulative deterministic file inventory. A direct update is validated against both the sanitized previous summary and new source, plus cumulative sanitized file evidence; previous-summary-only exact values remain valid evidence. Custom focus instructions are not factual evidence. Any unrepaired failure prevents the whole graph batch from being installed.
 
 An unrepaired exact-value failure reports only the stage, issue code, categorical repair status, unsupported-span count, and affected-bullet count. Repair statuses distinguish an unsupported location, more than eight bullets, removal above 25%, and an unexpected invalid second validation. The disputed text is intentionally absent from logs, UI notifications, and diagnostics because it may contain sensitive source material.
 
@@ -49,7 +49,7 @@ An unrepaired exact-value failure reports only the stage, issue code, categorica
 - trigger, split-turn flag, source message count;
 - generation time, provider, and model.
 
-For aggregate compactions, details also embed every non-active node created by that operation. The active node content remains `CompactionEntry.summary`; prior ancestors remain in earlier canonical entries. SQLite stores content, ordered edges, direct/transitive sources, graph level, and lifecycle as a disposable projection. On resume or after deleting the database, DS4 replays Pi entries in append order and recreates the complete graph.
+For aggregate and direct-update compactions, details also embed every non-active node created by that operation. Direct updates reuse the schema-v2 `task-state` kind, set `segmentSummaryId` to their own node ID, increment the predecessor's level, and include the union of previous/new canonical source IDs. Their hash binds the new source hash to predecessor ID, hash, content and level. Prior nodes are never rewritten; no unused segment is fabricated. The active node content remains `CompactionEntry.summary`; prior ancestors remain in earlier canonical entries. SQLite stores content, ordered edges, direct/transitive sources, graph level, and lifecycle as a disposable projection. On resume or after deleting the database, DS4 replays Pi entries in append order and recreates the complete graph.
 
 Memory and pin custom entries do not participate directly in Pi's LLM context and are not replaced by summary text. Their append-only mutations remain in the session tree, so durable decisions and explicit classifications replay after any number of compactions without depending exclusively on a summary.
 
@@ -78,9 +78,31 @@ Semantics:
 - `compaction.summary.thinking` defaults to `off` and applies only to summary requests: `off` keeps the pre-existing request shape (no thinking fields), while other levels map per API (`thinkingEnabled`/`effort` for `anthropic-messages`, `samplingParams.reasoning_effort` for OpenAI-compatible APIs) and are ignored for unsupported providers;
 - `context.maxSummaryTokens` remains a session-level limit and does not rise for the dedicated model; the minimum with the model's `maxTokens` still applies.
 
+## Latency controls
+
+The coordinated `0.3.5` release introduces these additive defaults (absent from `0.3.4`):
+
+```json
+{
+  "compaction": {
+    "directUpdate": true,
+    "inputBudget": "summary",
+    "maxConcurrentSegments": 2
+  }
+}
+```
+
+- `directUpdate`: one validated previous-summary plus new-source request when the entire prompt fits. Set false to always retain the segment-then-aggregate route. Validation or provider failures still fall back to Pi, not an unvalidated update.
+- `inputBudget`: `summary` uses calibrated `hardInputLimit` rather than the ordinary context fill target (`activeInputBudget`). `context` selects that legacy fill target. Both are additionally capped by `(context window - safety margin - actual summary output cap) / calibration ratio`, rounded down, and never exceed the configured/model hard limit. Existing output reservations remain conservative; ordinary session planning and proactive thresholds are unchanged. This reduces avoidable fragmentation, not a guarantee of provider fit or faster processing for a larger prompt.
+- `maxConcurrentSegments`: integer **1–2**, default 2. Only independent segments overlap, including their retries. Aggregates do not run until their children have completed. Use 1 for sequential execution or providers with restrictive concurrent-request limits. Rate-limit failures are not transport-retried.
+
+For an old-path comparison set `directUpdate=false`, `inputBudget=context`, `maxConcurrentSegments=1`. All features remain behind the existing compaction/master switches. Settings are applied on session load; after upgrading the package or rebuilding a development checkout, fully restart Pi to avoid stale compiled-core modules. No schema migration is required.
+
+Mock-provider regression tests verify fewer calls, bounded overlap, exact budget boundaries, validation, privacy, immutable provenance and JSONL rebuild. They do **not** establish real-provider wall-time gains, semantic equivalence of generated summaries, or a guaranteed completion time. See [ADR-061](ADR/061-compaction-latency.md).
+
 ## Transport retry policy
 
-Summary requests are replayed only for transport-classified failures (thrown transport errors or `stopReason: "error"` responses whose message matches network/timeout patterns). The replay policy defaults to Pi's assistant retry policy and can be tuned per deployment:
+Summary requests are replayed only for transport-classified failures (thrown transport errors or `stopReason: "error"` responses whose message matches network/timeout patterns). The DS4 replay policy uses **three total attempts**, not three retries after the initial call, and can be tuned per deployment:
 
 ```json
 {
@@ -93,7 +115,7 @@ Summary requests are replayed only for transport-classified failures (thrown tra
 }
 ```
 
-- `compaction.transport.maxAttempts`: total attempts per segment or aggregate call, integer 1–10, default 3. With 1, no transport failure is retried.
+- `compaction.transport.maxAttempts`: total attempts per direct update, segment or aggregate call, integer 1–10, default 3. With 1, no transport failure is retried.
 - `compaction.transport.baseDelayMs`: base backoff before the first replay, integer 0–60000, default 2000. The delay doubles per attempt (2000, 4000, 8000, …) and is capped at 60 s.
 - Replays use a fresh routing session per attempt; diagnostics expose only stage, failed/next attempt, max attempts, and delay.
 - Aborts (including during backoff) never trigger replay; non-transport failures are never retried; usage is summed across replayed responses.
@@ -117,4 +139,4 @@ It requests compaction at most once per session leaf. Pi's native threshold and
 /context summaries
 ```
 
-The preview reports thresholds and eligibility; Pi remains authoritative for the exact cut point. Runtime diagnostics additionally report the calibrated input budget, estimated whole-source prompt size, generated segment count, aggregate-call count, and completed transport-retry count without source content. Each retry emits only stage, failed/next attempt, maximum attempts, and delay at `debug`. Routine `summary_graph_prepared` and `summary_graph_committed` lifecycle events are also emitted only at `debug`; fallback, failure, persistence, and reconciliation problems remain actionable warnings. Oversized-group and bounded-operation errors expose only numeric budgets/counts, never rejected source text. Provider failures are reduced to metadata-only categories such as `input-limit`, `usage-limit`, `rate-limit`, `authentication`, or `transport`; raw provider error details are not logged or shown. The proactive-threshold TUI notification remains a user-visible `info` notice because it explains why an automatic compaction started.
+The preview reports thresholds and eligibility; Pi remains authoritative for the exact cut point. Runtime diagnostics additionally report the effective provider/model, chosen path (`direct-update` or `hierarchical`), budget mode, calibrated input budget, estimated new-source and full-update prompt sizes, logical summary calls (excluding retries), generated segment count, aggregate-call count, concurrency cap, and completed transport-retry count without source content. Monotonic wall timings cover preparation, generation (direct or parallel segments, including validation and retries), aggregation, graph preparation/persistence, and total DS4 hook time. Parallel generation time is elapsed wall time, not a sum of overlapping requests. Total time excludes Pi's subsequent canonical append or native fallback. Timings survive the in-process commit/fallback notification, but are not persisted in JSONL or reconstructed as fake durations after restart. Metadata-only `compaction.timings` is emitted at `debug` for successful and failed attempts. Each retry emits only stage, failed/next attempt, maximum attempts, and delay at `debug`. Routine `summary_graph_prepared` and `summary_graph_committed` lifecycle events are also emitted only at `debug`; fallback, failure, persistence, and reconciliation problems remain actionable warnings. Oversized-group and bounded-operation errors expose only numeric budgets/counts, never rejected source text. Provider failures are reduced to metadata-only categories such as `input-limit`, `usage-limit`, `rate-limit`, `authentication`, or `transport`; raw provider error details are not logged or shown. The proactive-threshold TUI notification remains a user-visible `info` notice because it explains why an automatic compaction started.

package/docs/releases/0.3.4.md

@@ -1,6 +1,6 @@
 # DS4 Context Engine 0.3.4
 
-Status: release candidate; publication pending final validation and CI.
+Status: published as stable on npm under `latest`; annotated tag `v0.3.4` points to validated release commit `5845a64`.
 
 ## Added since 0.3.3
 
@@ -24,7 +24,7 @@ Local tool wrappers must not be combined with remote/sandbox replacements. `bash
 
 ## Update and enable
 
-After publication, install the exact package and fully restart Pi to load the matching compiled core:
+Install the exact package and fully restart Pi to load the matching compiled core:
 
 ```bash
 pi install npm:ds4-context-engine@0.3.4
@@ -60,4 +60,22 @@ Candidate validation on Node.js `26.5.1`, from a sanitized release source with a
 
 Pre-existing local `allowScripts` additions and `.serena/` are excluded from release commits and public packages.
 
-The initial CI run `33965143704` on candidate `4e665e3` passed Node `22.19.0`. Node `24.x` exceeded the default 5-second timeout in the existing disk-backed schema-v10 upgrade fixture (484 tests passed, one timeout). That individual correctness test now has a bounded 15-second timeout, with all assertions unchanged; no runtime/storage behavior changed. Final CI and exact registry evidence will be recorded after execution.
+The initial CI run `33965143704` on candidate `4e665e3` passed Node `22.19.0`. Node `24.x` exceeded the default 5-second timeout in the existing disk-backed schema-v10 upgrade fixture (484 tests passed, one timeout). That individual correctness test now has a bounded 15-second timeout, with all assertions unchanged; no runtime/storage behavior changed.
+
+Final validation-only CI run [`33965385188`](https://github.com/Alucard24/ds4-context-engine/actions/runs/33965385188) on `5845a64` passed both Node `22.19.0` and `24.x`, including the full test suite and clean-consumer package checks.
+
+## Registry verification and release
+
+Published manually as `alucard_24`, in dependency order, from reviewed tarballs built in a clean committed worktree:
+
+- `ds4-context-core@0.3.4`: shasum `c1f1f6c5eec392e43f8b6a0917581e5d02141c84`;
+- `ds4-context-reference-adapter@0.3.4`: shasum `61402dc240af5963f4cbbf5f69752fe9a451170d`;
+- `ds4-context-engine@0.3.4`: shasum `99b9ba52c2bc628f5fb197ea5356459963994b89`.
+
+`npm run registry:check -- 0.3.4` passed: fresh exact-version installation, matching adapter/core dependencies, public core exports, compiled reference conformance, packaged quality corpus, storage CLI usage probe and isolated offline Pi extension startup. Registry SHA-1 and integrity values match the local tarballs for all three packages.
+
+Verified dist-tags for all three: `latest=0.3.4`, `beta=0.3.0-beta.3`, `alpha=0.3.0-alpha.5`, `rc=0.2.0-rc.1`.
+
+Annotated tag `v0.3.4` targets `5845a64`, the tested/published source. This post-publication evidence update is documentation-only.
+
+GitHub Release: https://github.com/Alucard24/ds4-context-engine/releases/tag/v0.3.4

package/docs/releases/0.3.5.md

@@ -0,0 +1,70 @@
+# DS4 Context Engine 0.3.5
+
+Status: local release gates passed; commit, push and coordinated publication authorized. Validation-only CI, publication and registry verification are pending.
+
+## Added since 0.3.4
+
+Bounded compaction optimizations, enabled by default when DS4 custom compaction is enabled:
+
+- **`compaction.directUpdate=true`**: one validated previous-summary plus new-source request when the complete sanitized prompt fits. The immutable `task-state` node retains predecessor edges, transitive source IDs and a source hash bound to both inputs. Oversized updates retain hierarchical segmentation/aggregation; no synthetic segment or source truncation is introduced.
+- **`compaction.inputBudget="summary"`**: use the calibrated hard input limit rather than the ordinary context fill target, additionally capped by model context minus safety margin and actual summary output headroom. Configured/model hard limits and calibration remain authoritative; ordinary context planning is unchanged.
+- **`compaction.maxConcurrentSegments=2`** (integer 1–2): overlap only independent segment requests. Node identities, sources, graph edges and usage follow source order, never completion order. Failure or cancellation stops scheduling, aborts siblings and drains every started worker before Pi fallback; no partial graph is installed. Aggregation stays ordered and bounded.
+- **Metadata-only diagnostics**: `/context compaction` reports path, effective provider/model, full-update prompt size, logical calls, concurrency, retries and monotonic wall timings for preparation, generation, aggregation, persistence and total DS4 hook duration. Timings are process-local, exclude native fallback, and are not persisted in canonical JSONL.
+
+Transport documentation now explicitly distinguishes **three total attempts** from three retries; runtime transport policy is unchanged.
+
+See [compaction controls](../COMPACTION.md#latency-controls) and [ADR-061](../ADR/061-compaction-latency.md).
+
+## Compatibility and limitations
+
+Pi cut points, atomic tool exchanges, summary validation and bounded exact-value repair, privacy classification, immutable provenance and JSONL rebuild remain in place. Schema-v2 compaction metadata reuses the existing `task-state` kind. Pi JSONL remains canonical and append-only; SQLite remains disposable/rebuildable at schema `15`.
+
+Unchanged contracts: `ds4-context-config-v1`, `runtime-adapter-v1`, `ds4-context-persistence-tool-v1`, `ds4-context-persistence-result-v1`. The new configuration keys are additive; absent keys use the new defaults. The five optional portable tools/features introduced in 0.3.4 remain default-off. Pi stays pinned to `0.84.3`; Node.js remains `>=22.19.0`. No dependency upgrade, live database maintenance or Pi upgrade is part of this release.
+
+Mock-provider tests establish call counts, bounded overlap and deterministic safety properties, not real-provider speedups, semantic equivalence or a guaranteed compaction duration. A larger prompt may take longer to process. Rate-limit errors are not transport-retried; providers with restrictive concurrency should use `maxConcurrentSegments=1`. Cancellation is cooperative: accepted work may still be billed and providers ignoring abort may delay settlement. Linux validation does not establish Windows execution correctness.
+
+## Update and configure
+
+Install the exact coordinated package and **fully restart Pi** to load its matching compiled core:
+
+```bash
+pi install npm:ds4-context-engine@0.3.5
+```
+
+No extra opt-in is needed for the three new defaults when DS4 and custom compaction are enabled. Inspect configuration and subsequent compaction diagnostics with:
+
+```text
+/context config show
+/context compaction
+```
+
+For a legacy-path comparison in a trusted project:
+
+```text
+/context config set compaction.directUpdate false
+/context config set compaction.inputBudget context
+/context config set compaction.maxConcurrentSegments 1
+/reload
+```
+
+Use `true`, `summary`, and `2` to restore the new defaults. Add `--global` to each `set` for agent-directory configuration; trusted project settings take precedence. Disabling DS4 custom compaction still delegates to Pi.
+
+## Package policy and validation
+
+All three packages use `0.3.5`: `ds4-context-core`, `ds4-context-reference-adapter`, `ds4-context-engine`. Both adapters depend exactly on `ds4-context-core@0.3.5`. Publication is manual in that order under npm's stable `latest` tag. GitHub Actions remains validation-only with OIDC and package-write permissions denied.
+
+Candidate validation on Node.js `26.5.1`, from a sanitized release source with a fresh `npm ci`:
+
+- `npm run check`: **80 files / 508 tests passed**, including exact full-prompt budget boundaries, direct-update evidence/privacy, immutable graph rebuild, out-of-order segments, abort/failure drainage and transport retry cancellation.
+- `npm run quality:compare`: passed; frozen-corpus candidate score `0.9875` versus baseline `0.808156`. This is a planner corpus, not a real-provider summary-quality comparison.
+- `npm run schema:context-persistence`: passed, `1266` bytes / `317` estimated tokens (limits `1500` / `320`).
+- `npm run latency:check` against freshly installed exact `ds4-context-core@0.1.2`: passed; disabled-planning p95 ratio `0.903863`, maximum `1.1`. This is not a compaction/provider latency measurement.
+- `npm run pack:check`: passed in a clean consumer, core **235 files**, reference adapter **7**, engine **87**, including isolated offline Pi extension startup and registry scenarios.
+- All three `npm pack --dry-run --json` inventories and `git diff --check` passed. Tarball inventories exclude sessions, databases, credentials, test state and `.serena/`.
+- Manifests, exact core dependencies, lockfile and runtime version constants are synchronized. The lockfile contains only coordinated version changes; no dependency upgrade was performed.
+
+Pre-existing local `allowScripts` additions and `.serena/` are excluded from release commits and public packages.
+
+## Registry verification and release
+
+Pending successful local gates, validation-only CI, manual publication and exact registry verification. No release tag has been created yet.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ds4-context-engine",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Non-destructive, provider-independent context management for Pi.",
   "type": "module",
   "license": "MIT",
@@ -62,7 +62,7 @@
     ]
   },
   "dependencies": {
-    "ds4-context-core": "0.3.4"
+    "ds4-context-core": "0.3.5"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "0.84.3",

package/src/extension/commands.ts

@@ -421,6 +421,7 @@ function formatSummaryGraph(graph: SummaryGraphDiagnostics): string {
     `Nodes:                   ${count(graph.totalNodes)}`,
     `Committed/prepared/failed: ${count(graph.committedNodes)} / ${count(graph.preparedNodes)} / ${count(graph.failedNodes)}`,
     `Segment/aggregate/branch:  ${count(graph.segmentNodes)} / ${count(graph.aggregateNodes)} / ${count(graph.branchNodes)}`,
+    `Direct update nodes:      ${count(graph.taskStateNodes)}`,
     `Maximum graph level:     ${count(graph.maxGraphLevel)}`,
     `Active summary:          ${graph.activeSummaryId ?? "none on current branch"}`,
     `Active path nodes:       ${count(graph.activePathIds.length)}`,
@@ -845,11 +846,22 @@ function formatCompaction(diagnostics: RuntimeDiagnostics, preview: boolean): st
     `Last trigger:            ${compaction.trigger ?? "n/a"}`,
     `Summary ID:              ${compaction.summaryId ?? "n/a"}`,
     `Source entries:          ${count(compaction.sourceEntries)}`,
+    `Compaction model:        ${compaction.provider && compaction.model ? `${compaction.provider}/${compaction.model}` : "n/a"}`,
+    `Chosen path:             ${compaction.path ?? "n/a"}`,
+    `Input budget mode:       ${compaction.inputBudgetMode ?? "n/a"}`,
     `Input budget:            ${count(compaction.inputBudgetTokens)}`,
     `Whole-source prompt:     ${count(compaction.sourcePromptTokens)}`,
+    `Direct-update prompt:    ${count(compaction.directPromptTokens)}`,
+    `Segment concurrency cap: ${count(compaction.maxConcurrentSegments)}`,
+    `Summary calls:           ${count(compaction.summaryCalls)}`,
     `Generated segments:      ${count(compaction.segmentCount)}`,
     `Aggregate calls:         ${count(compaction.aggregateCalls)}`,
     `Transport retries:       ${count(compaction.transportRetries)}`,
+    ...(compaction.timings ? [
+      `DS4 hook time (ms):      ${compaction.timings.totalMs.toFixed(1)}`,
+      `Prepare/generate (ms):   ${compaction.timings.preparationMs.toFixed(1)} / ${compaction.timings.generationMs.toFixed(1)}`,
+      `Aggregate/persist (ms):  ${compaction.timings.aggregationMs.toFixed(1)} / ${compaction.timings.persistenceMs.toFixed(1)}`,
+    ] : []),
     `Validation:              ${compaction.validationStatus ?? "n/a"}`,
     `First kept entry:        ${compaction.firstKeptEntryId ?? "n/a"}`,
     `Tokens before:           ${count(compaction.tokensBefore)}`,

package/src/pi-adapter/compaction-coordinator.ts

@@ -1,3 +1,6 @@
+import { performance } from "node:perf_hooks";
+import { compactionInputBudget } from "ds4-context-core/compaction/input-budget";
+import { mapCompactionSegments } from "./compaction-workers.ts";
 import type {
   CompactionResult,
   ExtensionContext,
@@ -47,6 +50,7 @@ import {
   buildAggregateSummaryPrompt,
   buildSummaryPrompt,
   computeAggregateSourceHash,
+  computeUpdateSourceHash,
   type SummaryValidationStatus,
 } from "ds4-context-core/compaction/summary-contract";
 
@@ -63,6 +67,14 @@ export type CompactionPhase =
   | "pi-default"
   | "failed";
 
+export interface CompactionTimings {
+  preparationMs: number;
+  generationMs: number;
+  aggregationMs: number;
+  persistenceMs: number;
+  totalMs: number;
+}
+
 export interface CompactionDiagnostics {
   enabled: boolean;
   validate: boolean;
@@ -83,6 +95,14 @@ export interface CompactionDiagnostics {
   segmentCount?: number;
   aggregateCalls?: number;
   transportRetries?: number;
+  path?: "direct-update" | "hierarchical";
+  provider?: string;
+  model?: string;
+  inputBudgetMode?: "summary" | "context";
+  directPromptTokens?: number;
+  maxConcurrentSegments?: number;
+  summaryCalls?: number;
+  timings?: CompactionTimings;
   contextTokens?: number;
   softLimitTokens?: number;
   proactiveThresholdTokens?: number;
@@ -110,6 +130,7 @@ export interface SummaryGraphDiagnostics {
   segmentNodes: number;
   aggregateNodes: number;
   branchNodes: number;
+  taskStateNodes: number;
   maxGraphLevel: number;
   rootSummaryIds: string[];
   activeSummaryId?: string;
@@ -212,6 +233,7 @@ export class CompactionCoordinator {
     event: SessionBeforeCompactEvent,
     ctx: ExtensionContext,
   ): Promise<{ compaction?: CompactionResult } | undefined> {
+    const startedAt = performance.now();
     const config = this.dependencies.config;
     const model = this.resolveCompactionModel(ctx) ?? ctx.model;
     if (!config.compaction.enabled || !config.enabled || !model || config.context.maxSummaryTokens <= 0) {
@@ -219,6 +241,25 @@ export class CompactionCoordinator {
     }
 
     const requestedAt = this.dependencies.now();
+    const timings: CompactionTimings = {
+      preparationMs: performance.now() - startedAt,
+      generationMs: 0,
+      aggregationMs: 0,
+      persistenceMs: 0,
+      totalMs: 0,
+    };
+    const measure = async <T>(
+      phase: Exclude<keyof CompactionTimings, "totalMs">,
+      run: () => T | Promise<T>,
+    ): Promise<T> => {
+      const start = performance.now();
+      try {
+        return await run();
+      } finally {
+        timings[phase] += performance.now() - start;
+      }
+    };
+    const maxConcurrentSegments = config.compaction.maxConcurrentSegments ?? 2;
     const trigger: CompactionTrigger = this.proactiveRequested ? "proactive" : event.reason;
     this.state = {
       phase: "generating",
@@ -227,28 +268,43 @@ export class CompactionCoordinator {
       firstKeptEntryId: event.preparation.firstKeptEntryId,
       tokensBefore: event.preparation.tokensBefore,
       transportRetries: 0,
+      aggregateCalls: 0,
+      summaryCalls: 0,
+      provider: model.provider,
+      model: model.id,
+      inputBudgetMode: config.compaction.inputBudget ?? "summary",
+      maxConcurrentSegments,
+      timings,
     };
 
     try {
-      this.dependencies.syncSessionIndex(ctx);
-      const source = prepareCompactionSource(event);
-      const inputBudgetTokens = this.inputBudgetTokens(model);
-      if (inputBudgetTokens <= 0) throw new Error("Active model has no safe compaction input budget");
-      const wholePlan = this.buildSegmentPlan(source, event, model.provider);
-      this.state = {
-        ...this.state,
-        sourceEntries: source.sourceEntryIds.length,
-        inputBudgetTokens,
-        sourcePromptTokens: wholePlan.promptTokens,
-      };
-      const segmentPlans = this.partitionSegmentPlans(
-        source,
-        wholePlan,
-        event,
-        model.provider,
-        inputBudgetTokens,
-      );
-      this.state.segmentCount = segmentPlans.length;
+      const { source, inputBudgetTokens, wholePlan, directPlan, segmentPlans } = await measure("preparationMs", () => {
+        if (event.signal.aborted) throw new Error("Compaction summary generation aborted");
+        this.dependencies.syncSessionIndex(ctx);
+        const source = prepareCompactionSource(event);
+        const inputBudgetTokens = this.inputBudgetTokens(model);
+        if (inputBudgetTokens <= 0) throw new Error("Active model has no safe compaction input budget");
+        const wholePlan = this.buildSegmentPlan(source, event, model.provider);
+        const update = (config.compaction.directUpdate ?? true) && source.previousSummary
+          ? this.buildSegmentPlan({
+            ...source,
+            segmentReadFiles: source.readFiles,
+            segmentModifiedFiles: source.modifiedFiles,
+          }, event, model.provider, source.previousSummary)
+          : undefined;
+        const directPlan = update && update.promptTokens <= inputBudgetTokens ? update : undefined;
+        this.state = {
+          ...this.state,
+          path: directPlan ? "direct-update" : "hierarchical",
+          sourceEntries: source.sourceEntryIds.length,
+          inputBudgetTokens,
+          sourcePromptTokens: wholePlan.promptTokens,
+          ...(update ? { directPromptTokens: update.promptTokens } : {}),
+        };
+        const segmentPlans = directPlan ? [] : this.partitionSegmentPlans(source, wholePlan, event, model.provider, inputBudgetTokens);
+        this.state.segmentCount = segmentPlans.length;
+        return { source, inputBudgetTokens, wholePlan, directPlan, segmentPlans };
+      });
 
       const usedIds = new Set(this.graphRecords.keys());
       if (source.previousNode) usedIds.add(source.previousNode.id);
@@ -269,53 +325,59 @@ export class CompactionCoordinator {
       };
 
       const usages: GeneratedSummary["usage"][] = [];
-      const segmentNodes: EmbeddedSummaryNode[] = [];
-      for (const plan of segmentPlans) {
-        const generated = await this.generateSummary({
-          stage: "segment",
+      // Allocate in source order before concurrent requests; completion order must
+      // never determine IDs, graph edges, source order or usage accumulation.
+      const plans = directPlan ? [directPlan] : segmentPlans;
+      const ids = plans.map(() => nextId());
+      const createdNodes: EmbeddedSummaryNode[] = [];
+      let previousNode = source.previousNode;
+      if (!previousNode && source.previousSummary) {
+        previousNode = importUntrackedPreviousSummary({
+          id: nextId(),
+          content: source.previousSummary,
+          createdAt: this.dependencies.now(),
+          provider: model.provider,
+          model: model.id,
+        });
+        createdNodes.push(previousNode);
+      }
+      const results = await measure("generationMs", () => mapCompactionSegments(
+        plans, maxConcurrentSegments, event.signal, (plan, _index, signal) => this.generateSummary({
+          stage: directPlan ? "update" : "segment",
           prompt: plan.prompt,
           validationSource: plan.validationSource,
           readFiles: plan.readFiles,
           modifiedFiles: plan.modifiedFiles,
-          event,
+          event: { ...event, signal },
           ctx,
           model,
-          thinking: this.dependencies.config.compaction.summary?.thinking,
-        });
+          thinking: config.compaction.summary?.thinking,
+        }),
+      ));
+      const generatedNodes: EmbeddedSummaryNode[] = results.map((generated, index) => {
+        const plan = plans[index] as SegmentGenerationPlan;
+        const predecessor = directPlan ? previousNode : undefined;
         usages.push(generated.usage);
-        segmentNodes.push({
-          id: nextId(),
-          kind: "segment",
+        return {
+          id: ids[index] as string,
+          kind: predecessor ? "task-state" : "segment",
           content: classifiedSummary(generated.content, plan.classification),
-          sourceHash: plan.source.sourceHash,
-          sourceEntryIds: [...plan.source.sourceEntryIds],
-          childSummaryIds: [],
-          graphLevel: 0,
+          sourceHash: predecessor ? computeUpdateSourceHash(source.sourceHash, predecessor) : plan.source.sourceHash,
+          sourceEntryIds: unique([...(predecessor?.sourceEntryIds ?? []), ...plan.source.sourceEntryIds]),
+          childSummaryIds: predecessor ? [predecessor.id] : [],
+          graphLevel: predecessor ? predecessor.graphLevel + 1 : 0,
           createdAt: this.dependencies.now(),
           validationStatus: generated.validation.status,
           validationIssueCodes: unique(generated.validation.issues.map((issue) => issue.code)),
           provider: model.provider,
           model: model.id,
-        });
-      }
-      const segmentId = segmentNodes[0]?.id;
-      if (!segmentId) throw new Error("Compaction fan-out produced no segment summary node");
-
-      const createdNodes: EmbeddedSummaryNode[] = [];
-      let previousNode = source.previousNode;
-      if (!previousNode && source.previousSummary) {
-        previousNode = importUntrackedPreviousSummary({
-          id: nextId(),
-          content: source.previousSummary,
-          createdAt: this.dependencies.now(),
-          provider: model.provider,
-          model: model.id,
-        });
-        createdNodes.push(previousNode);
-      }
-      createdNodes.push(...segmentNodes);
-      const roots = [...(previousNode ? [previousNode] : []), ...segmentNodes];
-      const aggregated = await this.aggregateSummaryNodes({
+        };
+      });
+      const segmentId = generatedNodes[0]?.id;
+      if (!segmentId) throw new Error("Compaction produced no summary node");
+      createdNodes.push(...generatedNodes);
+      const roots = [...(!directPlan && previousNode ? [previousNode] : []), ...generatedNodes];
+      const aggregated = await measure("aggregationMs", () => this.aggregateSummaryNodes({
         roots,
         event,
         ctx,
@@ -328,29 +390,34 @@ export class CompactionCoordinator {
         createdNodes,
         usages,
         modelObject: model,
-      });
+      }));
       const activeNode = aggregated.activeNode;
       const embeddedNodes = createdNodes.filter((node) => node.id !== activeNode.id);
 
-      const records = embeddedNodes.map((node) => createSummaryRecord({
-        sessionId: this.dependencies.sessionId,
-        node,
-        boundary,
-        segmentSummaryId: node.kind === "segment" ? node.id : segmentId,
-        lifecycleStatus: "prepared",
-      }));
-      records.push(createSummaryRecord({
-        sessionId: this.dependencies.sessionId,
-        node: activeNode,
-        boundary,
-        segmentSummaryId: segmentId,
-        lifecycleStatus: "prepared",
-        embeddedNodes,
-      }));
-      if (this.dependencies.persisted) this.dependencies.database?.summaries.saveGraph(records);
-      for (const record of records) this.graphRecords.set(record.id, record);
-      this.pendingSummaryIds = records.map((record) => record.id);
+      const records = await measure("persistenceMs", () => {
+        if (event.signal.aborted) throw new Error("Compaction summary generation aborted");
+        const records = embeddedNodes.map((node) => createSummaryRecord({
+          sessionId: this.dependencies.sessionId,
+          node,
+          boundary,
+          segmentSummaryId: node.kind === "segment" ? node.id : segmentId,
+          lifecycleStatus: "prepared",
+        }));
+        records.push(createSummaryRecord({
+          sessionId: this.dependencies.sessionId,
+          node: activeNode,
+          boundary,
+          segmentSummaryId: segmentId,
+          lifecycleStatus: "prepared",
+          embeddedNodes,
+        }));
+        if (this.dependencies.persisted) this.dependencies.database?.summaries.saveGraph(records);
+        for (const record of records) this.graphRecords.set(record.id, record);
+        this.pendingSummaryIds = records.map((record) => record.id);
+        return records;
+      });
       this.state = {
+        ...this.state,
         phase: "prepared",
         trigger,
         summaryId: activeNode.id,
@@ -409,6 +476,16 @@ export class CompactionCoordinator {
         ctx.ui.notify(`DS4 compaction unavailable; using Pi default. ${message}`, "warning");
       }
       return undefined;
+    } finally {
+      timings.totalMs = performance.now() - startedAt;
+      this.dependencies.logger.debug("compaction.timings", {
+        path: this.state.path,
+        phase: this.state.phase,
+        provider: model.provider,
+        model: model.id,
+        summaryCalls: this.state.summaryCalls,
+        ...timings,
+      });
     }
   }
 
@@ -433,7 +510,10 @@ export class CompactionCoordinator {
       const attempt = this.state;
       const customError = attempt.lastError;
       this.state = {
+        ...attempt,
         phase: "pi-default",
+        summaryId: undefined,
+        validationStatus: undefined,
         trigger: event.reason,
         firstKeptEntryId: event.compactionEntry.firstKeptEntryId,
         tokensBefore: event.compactionEntry.tokensBefore,
@@ -467,6 +547,7 @@ export class CompactionCoordinator {
     this.pendingSummaryIds = [];
     const metadata = details.ds4ContextEngine;
     this.state = {
+      ...this.state,
       phase: "committed",
       trigger: metadata.reason,
       summaryId: metadata.summaryId,
@@ -474,7 +555,7 @@ export class CompactionCoordinator {
       validationStatus: metadata.validationStatus,
       firstKeptEntryId: effectiveEntry.firstKeptEntryId,
       tokensBefore: effectiveEntry.tokensBefore,
-      requestedAt: metadata.generatedAt,
+      requestedAt: this.state.requestedAt ?? metadata.generatedAt,
       completedAt: this.dependencies.now(),
       ...(this.state.inputBudgetTokens !== undefined
         ? { inputBudgetTokens: this.state.inputBudgetTokens }
@@ -660,6 +741,7 @@ export class CompactionCoordinator {
       segmentNodes: records.filter((record) => record.kind === "segment").length,
       aggregateNodes: records.filter((record) => record.kind === "aggregate").length,
       branchNodes: records.filter((record) => record.kind === "branch").length,
+      taskStateNodes: records.filter((record) => record.kind === "task-state").length,
       maxGraphLevel: records.reduce((maximum, record) => Math.max(maximum, record.graphLevel), 0),
       rootSummaryIds: roots,
       ...(activeId ? { activeSummaryId: activeId } : {}),
@@ -717,7 +799,8 @@ export class CompactionCoordinator {
           config.context.recentTailTokens,
         ),
       };
-    return Math.floor(resolved.budget.activeInputBudget);
+    const maxOutputTokens = Math.max(1, Math.min(config.context.maxSummaryTokens, model.maxTokens ?? config.context.maxSummaryTokens));
+    return compactionInputBudget(resolved.budget, maxOutputTokens, config.compaction.inputBudget ?? "summary");
   }
 
   private classify(text: string, provider: string): {
@@ -743,7 +826,9 @@ export class CompactionCoordinator {
     source: PreparedCompactionSourceSlice,
     event: SessionBeforeCompactEvent,
     provider: string,
+    previousSummary?: string,
   ): SegmentGenerationPlan {
+    const previousPrivacy = previousSummary === undefined ? undefined : this.classify(previousSummary, provider);
     const sourcePrivacy = this.classify(source.conversationText, provider);
     const validationPrivacy = this.classify(source.sourceText, provider);
     const instructionPrivacy = event.customInstructions
@@ -754,6 +839,7 @@ export class CompactionCoordinator {
     const classification = [
       sourcePrivacy.classification,
       validationPrivacy.classification,
+      ...(previousPrivacy ? [previousPrivacy.classification] : []),
       ...(instructionPrivacy ? [instructionPrivacy.classification] : []),
       ...readFilePrivacy.map((item) => item.classification),
       ...modifiedFilePrivacy.map((item) => item.classification),
@@ -762,6 +848,7 @@ export class CompactionCoordinator {
     const modifiedFiles = modifiedFilePrivacy.map((item) => item.value);
     const prompt = buildSummaryPrompt({
       conversationText: sourcePrivacy.value,
+      ...(previousPrivacy ? { previousSummary: previousPrivacy.value, purpose: "update" as const } : {}),
       ...(instructionPrivacy ? { customInstructions: instructionPrivacy.value } : {}),
       readFiles,
       modifiedFiles,
@@ -770,7 +857,7 @@ export class CompactionCoordinator {
     return {
       source,
       prompt,
-      validationSource: validationPrivacy.value,
+      validationSource: [previousPrivacy?.value, validationPrivacy.value].filter(Boolean).join("\n\n"),
       readFiles,
       modifiedFiles,
       classification,
@@ -950,6 +1037,7 @@ export class CompactionCoordinator {
         if (plan.promptTokens > input.inputBudgetTokens) {
           throw new Error("Compaction aggregate prompt exceeded its preflight input budget");
         }
+        this.state.aggregateCalls = aggregateCalls;
         const generated = await this.generateSummary({
           stage: "aggregate",
           prompt: plan.prompt,
@@ -991,7 +1079,7 @@ export class CompactionCoordinator {
   }
 
   private generateSummary(input: {
-    stage: "segment" | "aggregate";
+    stage: "segment" | "aggregate" | "update";
     prompt: string;
     validationSource: string;
     readFiles: readonly string[];
@@ -1001,6 +1089,7 @@ export class CompactionCoordinator {
     model: Model<Api>;
     thinking?: CompactionThinkingLevel;
   }): Promise<GeneratedSummary> {
+    this.state.summaryCalls = (this.state.summaryCalls ?? 0) + 1;
     return generateValidatedSummary({
       ...input,
       validate: this.dependencies.config.compaction.validate,
@@ -1101,6 +1190,8 @@ export class CompactionCoordinator {
       validationStatus: summary.validationStatus,
       firstKeptEntryId: summary.firstKeptEntryId,
       tokensBefore: summary.tokensBefore,
+      provider: summary.provider,
+      model: summary.model,
       requestedAt: summary.createdAt,
       ...(summary.lifecycleStatus !== "prepared" ? { completedAt: summary.createdAt } : {}),
       ...(summary.lifecycleStatus === "failed" ? { lastError: "Prepared summary was not committed by Pi" } : {}),
@@ -1128,6 +1219,7 @@ export function defaultSummaryGraphDiagnostics(): SummaryGraphDiagnostics {
     segmentNodes: 0,
     aggregateNodes: 0,
     branchNodes: 0,
+    taskStateNodes: 0,
     maxGraphLevel: 0,
     rootSummaryIds: [],
     activePathIds: [],

package/src/pi-adapter/compaction-workers.ts

@@ -0,0 +1,43 @@
+/**
+ * Ordered results from bounded, abort-cooperative work. A failure cancels peers
+ * and drains every started worker before returning, so fallback cannot overlap
+ * with unfinished custom requests. No new item starts after failure/abort.
+ */
+export async function mapCompactionSegments<T, R>(
+  items: readonly T[],
+  concurrency: number,
+  signal: AbortSignal,
+  run: (item: T, index: number, signal: AbortSignal) => Promise<R>,
+): Promise<R[]> {
+  if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > 2) {
+    throw new Error("Compaction segment concurrency must be an integer between 1 and 2");
+  }
+  const controller = new AbortController();
+  const abort = (): void => controller.abort();
+  signal.addEventListener("abort", abort, { once: true });
+  if (signal.aborted) abort();
+  const results: R[] = new Array(items.length);
+  let next = 0;
+  let failure: unknown;
+  let failed = false;
+  const worker = async (): Promise<void> => {
+    while (!controller.signal.aborted) {
+      const index = next++;
+      if (index >= items.length) return;
+      try {
+        results[index] = await run(items[index] as T, index, controller.signal);
+      } catch (error) {
+        if (!failed) { failure = error; failed = true; }
+        controller.abort();
+      }
+    }
+  };
+  try {
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, worker));
+    if (failed) throw failure;
+    if (controller.signal.aborted) throw new Error("Compaction summary generation aborted");
+    return results;
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}

package/src/pi-adapter/summary-generator.ts

@@ -18,9 +18,8 @@ export const DEFAULT_COMPACTION_TRANSPORT_BASE_DELAY_MS = 2000;
 export const COMPACTION_TRANSPORT_MAX_DELAY_MS = 60_000;
 
 /**
- * Transport retry policy for compaction summary requests. Defaults mirror Pi's
- * assistant retry settings (`retry.maxRetries` 3, `retry.baseDelayMs` 2000,
- * exponential backoff, abort-aware).
+ * Transport retry policy for compaction summary requests: three total attempts
+ * (not three retries), 2000 ms base delay, exponential backoff, abort-aware.
  */
 export interface CompactionTransportPolicy {
   /** Total attempts for transport-classified failures. Default: 3. */
@@ -48,7 +47,7 @@ export function transportRetryDelayMs(baseDelayMs: number, failedAttempt: number
 }
 
 export interface CompactionTransportRetryDiagnostic {
-  stage: "segment" | "aggregate";
+  stage: "segment" | "aggregate" | "update";
   failedAttempt: number;
   nextAttempt: number;
   maxAttempts: number;
@@ -56,7 +55,7 @@ export interface CompactionTransportRetryDiagnostic {
 }
 
 export interface GenerateValidatedSummaryInput {
-  stage: "segment" | "aggregate";
+  stage: "segment" | "aggregate" | "update";
   prompt: string;
   validationSource: string;
   readFiles: readonly string[];
@@ -69,7 +68,7 @@ export interface GenerateValidatedSummaryInput {
   model?: Model<Api>;
   /** Reasoning level for the summary request; `off` (default) keeps the pre-existing request shape. */
   thinking?: CompactionThinkingLevel;
-  /** Transport retry policy; defaults mirror Pi's assistant retry settings. */
+  /** Transport-only retry policy; three total attempts by default. */
   transport?: CompactionTransportPolicy;
   now: () => number;
   onTransportRetry?: (diagnostic: CompactionTransportRetryDiagnostic) => void;

package/src/pi-adapter/version.ts

@@ -1,4 +1,4 @@
-export const EXTENSION_VERSION = "0.3.4";
+export const EXTENSION_VERSION = "0.3.5";
 export const SUPPORTED_PI_VERSION = "0.84.3";
 export const OBSERVER_PLANNER_VERSION = "observer-model-aware-v1";
 export const PLANNER_VERSION = "managed-learned-ranking-v1";