acp-kernel 0.0.94 → 0.0.95-pr.454.305

package/DESIGN.md

@@ -9,7 +9,7 @@ Framework-agnostic, model-driven context-compression engine. This document is th
 ACP-style compression is **not** like zip in one essential way: **the model writes the summaries; this library orchestrates everything around them.**
 
 - **zip**: computes the compressed output itself (`bytes → bytes`).
-- **acp-kernel**: the *summary text* is produced externally (by an LLM) and passed in as an argument. The core decides *when* to compress, *what range* to compress, tracks *state*, applies a compress *decision*, prunes ranges, and supports decompress/search. **It never calls a model.**
+- **acp-kernel**: the _summary text_ is produced externally (by an LLM) and passed in as an argument. The core decides _when_ to compress, _what range_ to compress, tracks _state_, applies a compress _decision_, prunes ranges, and supports decompress/search. **It never calls a model.**
 
 This is precisely why the core can be a pure library: the one external dependency (the summarizer) is reduced to a string input.
 
@@ -48,60 +48,60 @@ Portable, host-agnostic. Adapters translate host-native messages into `CoreMessa
 
 ```ts
 type CoreMessage = {
-    id: string;
-    role: "user" | "assistant" | "system" | "tool";
-    contentType: "text" | "tool-call" | "tool-result" | "reasoning";
-    text?: string;
-    toolName?: string;      // for protected-tool filtering
-    toolCallId?: string;    // links tool-call ↔ tool-result
+  id: string;
+  role: "user" | "assistant" | "system" | "tool";
+  contentType: "text" | "tool-call" | "tool-result" | "reasoning";
+  text?: string;
+  toolName?: string; // for protected-tool filtering
+  toolCallId?: string; // links tool-call ↔ tool-result
 };
 
 type CompressionBlock = {
-    blockId: string;                    // "b0", "b1", ...
-    runId: string;
-    tier: 1 | 2 | 3;
-    topic?: string;
-    summary: string;                    // produced by the model
-    directMessageIds: string[];
-    effectiveMessageIds: string[];
-    directBlockIds: string[];           // nested blocks consumed
-    createdAt: number;
-    survivedCount: number;
-    generation: "young" | "old";
-    active: boolean;
+  blockId: string; // "b0", "b1", ...
+  runId: string;
+  tier: 1 | 2 | 3;
+  topic?: string;
+  summary: string; // produced by the model
+  directMessageIds: string[];
+  effectiveMessageIds: string[];
+  directBlockIds: string[]; // nested blocks consumed
+  createdAt: number;
+  survivedCount: number;
+  generation: "young" | "old";
+  active: boolean;
 };
 
 type CompressionState = {
-    blocks: CompressionBlock[];
-    messageRefs: { byRaw: Record<string, string>; byRef: Record<string, string> }; // raw ↔ mNNNNN
-    nudge: {
-        lastPerMessageNudgeTokens: number;
-        lastNudgeShownTokens: number;
-        baselineTokens: number;
-        anchors: Record<string, unknown>;
-    };
-    stats: { tokensCompressed: number; compressionCount: number };
-    nextBlockId: number;
-    nextRunId: number;
+  blocks: CompressionBlock[];
+  messageRefs: { byRaw: Record<string, string>; byRef: Record<string, string> }; // raw ↔ mNNNNN
+  nudge: {
+    lastPerMessageNudgeTokens: number;
+    lastNudgeShownTokens: number;
+    baselineTokens: number;
+    anchors: Record<string, unknown>;
+  };
+  stats: { tokensCompressed: number; compressionCount: number };
+  nextBlockId: number;
+  nextRunId: number;
 };
 
 type Config = {
-    tiers: { enabled: boolean; tier2Trigger: number; tier3Trigger: number };
-    nudge: {
-        maxContextLimitPct: number;   // e.g. 0.55 (currently advisory; threshold gate uses minContextLimitPct)
-        minContextLimitPct: number;   // e.g. 0.45 — nudge threshold gate
-        frequency: number;            // advisory (reserved for future turn-frequency gating)
-        iterationThreshold: number;   // advisory (reserved for future iteration gating)
-        force: "soft" | "strong";
-    };
-    // young→old promotion after N survivals (drives the merge-blocks node).
-    // NOTE: there is no GC — no age-based deactivation, no summary truncation.
-    promotionThreshold: number;
-    truncate: { threshold: number };          // emergency tool-output truncation node (LAST safety valve); 1.0 = 100%
-    merge: { maxSummaryLength: number; minOldGenBlocks: number }; // batch-merge old-gen blocks into one summary
-    protectedTools: string[];
-    preserveRecentMessages: number;
-    modelContextLimit: number;
+  tiers: { enabled: boolean; tier2Trigger: number; tier3Trigger: number };
+  nudge: {
+    maxContextLimitPct: number; // e.g. 0.55 (currently advisory; threshold gate uses minContextLimitPct)
+    minContextLimitPct: number; // e.g. 0.45 — nudge threshold gate
+    frequency: number; // advisory (reserved for future turn-frequency gating)
+    iterationThreshold: number; // advisory (reserved for future iteration gating)
+    force: "soft" | "strong";
+  };
+  // young→old promotion after N survivals (drives the merge-blocks node).
+  // NOTE: there is no GC — no age-based deactivation, no summary truncation.
+  promotionThreshold: number;
+  truncate: { threshold: number }; // emergency tool-output truncation node (LAST safety valve); 1.0 = 100%
+  merge: { maxSummaryLength: number; minOldGenBlocks: number }; // batch-merge old-gen blocks into one summary
+  protectedTools: string[];
+  preserveRecentMessages: number;
+  modelContextLimit: number;
 };
 ```
 
@@ -111,78 +111,99 @@ type Config = {
 
 ```ts
 interface CompressionCore {
-    // Per-turn node pipeline (replaces the message-transform hook's algorithm part).
-    // Runs every turn (canonical order): assign-refs → sync-blocks → merge-blocks →
-    // prune → ccr-store → filter → hide-compress-calls → nudge-inject →
-    // emergency-truncate → render-refs. Survives/promotes blocks via advanceSurvival
-    // (no age-based deactivation). Returns transformed messages + updated state +
-    // nudge decision + the (possibly grown) content store.
-    processTurn(input: {
-        messages: CoreMessage[];
-        state: CompressionState;
-        config: Config;
-        tokenCount: number;
-        /** Per-session CCR content store from the previous turn (optional; an
-         *  empty store is created when omitted). */
-        contentStore?: MessageContentStore;
-    }): {
-        messages: CoreMessage[];
-        state: CompressionState;
-        nudge?: NudgeDecision;
-        /** Always present; pass back as input.contentStore next turn. */
-        contentStore: MessageContentStore;
+  // Per-turn node pipeline (replaces the message-transform hook's algorithm part).
+  // Runs every turn (canonical order): assign-refs → sync-blocks → merge-blocks →
+  // prune → ccr-store → filter → hide-compress-calls → nudge-inject →
+  // emergency-truncate → render-refs. Survives/promotes blocks via advanceSurvival
+  // (no age-based deactivation). Returns transformed messages + updated state +
+  // nudge decision + the (possibly grown) content store.
+  processTurn(input: {
+    messages: CoreMessage[];
+    state: CompressionState;
+    config: Config;
+    tokenCount: number;
+    /** Per-session CCR content store from the previous turn (optional; an
+     *  empty store is created when omitted). */
+    contentStore?: MessageContentStore;
+  }): {
+    messages: CoreMessage[];
+    state: CompressionState;
+    nudge?: NudgeDecision;
+    /** Always present; pass back as input.contentStore next turn. */
+    contentStore: MessageContentStore;
+  };
+
+  // When the model calls acp_retrieve. Pure lookup over the host-provided store
+  // plus an ephemeral injection message (id prefix acp_retrieved_*) that consumes
+  // no ref and never enters fold space. Hallucinated refs → not-found ack.
+  retrieve(store: MessageContentStore, ref: string): ApplyRetrieveResult;
+
+  // When the model calls compress. `ranges[].summary` is model-produced text.
+  // Allocates block(s), deactivates consumed blocks, updates indices, resets the
+  // nudge growth baseline on success (§5.7 feedback-loop fix).
+  applyCompression(input: {
+    ranges: {
+      startRef: string;
+      endRef: string;
+      summary: string;
+      topic?: string;
+    }[];
+    messages: CoreMessage[];
+    state: CompressionState;
+    config: Config;
+  }): {
+    state: CompressionState;
+    result: {
+      blocksCreated: number;
+      tokensCompressed: number;
+      errors: string[];
     };
-
-    // When the model calls acp_retrieve. Pure lookup over the host-provided store
-    // plus an ephemeral injection message (id prefix acp_retrieved_*) that consumes
-    // no ref and never enters fold space. Hallucinated refs → not-found ack.
-    retrieve(store: MessageContentStore, ref: string): ApplyRetrieveResult;
-
-    // When the model calls compress. `ranges[].summary` is model-produced text.
-    // Allocates block(s), deactivates consumed blocks, updates indices, resets the
-    // nudge growth baseline on success (§5.7 feedback-loop fix).
-    applyCompression(input: {
-        ranges: { startRef: string; endRef: string; summary: string; topic?: string }[];
-        messages: CoreMessage[];
-        state: CompressionState;
-        config: Config;
-    }): {
-        state: CompressionState;
-        result: { blocksCreated: number; tokensCompressed: number; errors: string[] };
-    };
-
-    resolveBoundaries(input: {
-        startRef: string;
-        endRef: string;
-        messages: CoreMessage[];
-        state: CompressionState;
-    }): { startIndex: number; endIndex: number; protectedGaps: number[] };
-    // protectedGaps is reserved (currently always []); protected-tool hard-exclusion
-    // is intentionally NOT implemented in the core — see README "Known limitation".
-
-    decompress(blockId: string, state: CompressionState): CompressionBlock | undefined;
-
-    search(query: string, state: CompressionState): CompressionBlock[];
-
-    status(state: CompressionState, tokenCount: number, config: Config): StatusReport;
-
-    // No gc(): age-based deactivation was removed (it caused memory-loss upstream).
-    // Block promotion (young→old) still happens via advanceSurvival in sync-blocks,
-    // and old-gen blocks are batch-merged by the merge-blocks node — not dropped.
+  };
+
+  resolveBoundaries(input: {
+    startRef: string;
+    endRef: string;
+    messages: CoreMessage[];
+    state: CompressionState;
+  }): { startIndex: number; endIndex: number; protectedGaps: number[] };
+  // protectedGaps is reserved (currently always []); protected-tool hard-exclusion
+  // is intentionally NOT implemented in the core — see README "Known limitation".
+
+  decompress(
+    blockId: string,
+    state: CompressionState,
+  ): CompressionBlock | undefined;
+
+  search(query: string, state: CompressionState): CompressionBlock[];
+
+  status(
+    state: CompressionState,
+    tokenCount: number,
+    config: Config,
+  ): StatusReport;
+
+  // No gc(): age-based deactivation was removed (it caused memory-loss upstream).
+  // Block promotion (young→old) still happens via advanceSurvival in sync-blocks,
+  // and old-gen blocks are batch-merged by the merge-blocks node — not dropped.
 }
 
 type CompressCall = {
-    mode: "range" | "message";
-    ranges: { startRef: string; endRef: string; summary: string; topic?: string }[];
+  mode: "range" | "message";
+  ranges: {
+    startRef: string;
+    endRef: string;
+    summary: string;
+    topic?: string;
+  }[];
 };
 
 type NudgeDecision = {
-    shouldInject: boolean;
-    reason: string;
-    compressibleRanges: { startRef: string; endRef: string; tokens: number }[];
-    contextUsage: number;       // 0..1
-    tier: 1 | 2 | 3 | null;     // multi-tier trigger, if any
-    breakdown: Record<string, number>;
+  shouldInject: boolean;
+  reason: string;
+  compressibleRanges: { startRef: string; endRef: string; tokens: number }[];
+  contextUsage: number; // 0..1
+  tier: 1 | 2 | 3 | null; // multi-tier trigger, if any
+  breakdown: Record<string, number>;
 };
 ```
 
@@ -194,9 +215,9 @@ The core needs two capabilities from the host, both injected (the core never imp
 
 ```ts
 interface Ports {
-    countTokens(text: string): number;   // default impl ships in core
-    // messages are PASSED IN to each call (never fetched) → no MessageStore port
-    // state persistence is the host's job (state is plain data) → no storage port
+  countTokens(text: string): number; // default impl ships in core
+  // messages are PASSED IN to each call (never fetched) → no MessageStore port
+  // state persistence is the host's job (state is plain data) → no storage port
 }
 ```
 
@@ -206,32 +227,32 @@ A default `countTokens` ships with the core (word-level + unicode CJK tokenizer,
 
 ## 6. Concept Mapping (nothing is lost)
 
-| ACP concept | Destination in acp-kernel |
-|---|---|
-| message-id ↔ ref mapping | **core** `processTurn` (pure) |
-| prune (range → summary block) | **core** `processTurn` (pure) |
-| boundary resolution / search | **core** `resolveBoundaries` (pure) |
-| block allocation / state mutation / tiers | **core** `applyCompression` (pure) |
-| compress **argument parsing** (lenient: fences, trailing commas, truncated-array salvage; field-name variants) | **core** `parseCompressArgs` (pure; diagnostics are data — adapters emit them) |
-| young→old promotion / batch merge | **core** `sync-blocks` node (`advanceSurvival`) + `merge-blocks` node (pure) |
-| emergency truncation (context near full) | **core** `emergency-truncate` node — the LAST safety valve; no age-based GC |
-| protected-tools filtering logic | **core** (pure: message + config → bool) |
-| `inject` **decision** (shouldNudge / growth / threshold) | **core** `decideNudge` (pure) |
-| `inject` **text rendering** (nudge → message string) | **adapter** (host message format) |
-| prompts (system / nudge text templates) | rules as **structured data** in core; text rendering in **adapter** |
-| compress/decompress/search/status **tool registration** | **adapter** (calls core pure fns) |
-| `/acp` commands | **adapter** |
-| opencode hooks | **OpenCode adapter** |
-| output-steering **decisions** (turn classification / verbosity level / effort clamp, #355) | **core** `decideOutputSteering` (pure; operates on a structural summary — role + block kinds, no content) |
-| output-steering **landing** (wire field write-back, system-prompt carrier selection, numeric budget floors) | **adapter** |
-| config three-layer merge | **adapter** (core only consumes its own `Config`) |
-| logger / auth / persistence / update | **adapter** (core does zero I/O) |
+| ACP concept                                                                                                    | Destination in acp-kernel                                                                                 |
+| -------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| message-id ↔ ref mapping                                                                                       | **core** `processTurn` (pure)                                                                             |
+| prune (range → summary block)                                                                                  | **core** `processTurn` (pure)                                                                             |
+| boundary resolution / search                                                                                   | **core** `resolveBoundaries` (pure)                                                                       |
+| block allocation / state mutation / tiers                                                                      | **core** `applyCompression` (pure)                                                                        |
+| compress **argument parsing** (lenient: fences, trailing commas, truncated-array salvage; field-name variants) | **core** `parseCompressArgs` (pure; diagnostics are data — adapters emit them)                            |
+| young→old promotion / batch merge                                                                              | **core** `sync-blocks` node (`advanceSurvival`) + `merge-blocks` node (pure)                              |
+| emergency truncation (context near full)                                                                       | **core** `emergency-truncate` node — the LAST safety valve; no age-based GC                               |
+| protected-tools filtering logic                                                                                | **core** (pure: message + config → bool)                                                                  |
+| `inject` **decision** (shouldNudge / growth / threshold)                                                       | **core** `decideNudge` (pure)                                                                             |
+| `inject` **text rendering** (nudge → message string)                                                           | **adapter** (host message format)                                                                         |
+| prompts (system / nudge text templates)                                                                        | rules as **structured data** in core; text rendering in **adapter**                                       |
+| compress/decompress/search/status **tool registration**                                                        | **adapter** (calls core pure fns)                                                                         |
+| `/acp` commands                                                                                                | **adapter**                                                                                               |
+| opencode hooks                                                                                                 | **OpenCode adapter**                                                                                      |
+| output-steering **decisions** (turn classification / verbosity level / effort clamp, #355)                     | **core** `decideOutputSteering` (pure; operates on a structural summary — role + block kinds, no content) |
+| output-steering **landing** (wire field write-back, system-prompt carrier selection, numeric budget floors)    | **adapter**                                                                                               |
+| config three-layer merge                                                                                       | **adapter** (core only consumes its own `Config`)                                                         |
+| logger / auth / persistence / update                                                                           | **adapter** (core does zero I/O)                                                                          |
 
 ---
 
 ## 7. Why the algorithm, but not the DCP-derived code, comes here
 
-Copyright protects *expression*, not ideas, methods, or algorithms (17 USC §102(b)). The compression *methods* (3-tier, growth cadence, protected filtering) are the author's. This core reimplements them in **fresh expression** — it is not a copy or refactor of DCP-derived files. See [PROVENANCE.md](./PROVENANCE.md) for the per-module origin classification (original-bring / DCP-derived-reimplement / adapter-only).
+Copyright protects _expression_, not ideas, methods, or algorithms (17 USC §102(b)). The compression _methods_ (3-tier, growth cadence, protected filtering) are the author's. This core reimplements them in **fresh expression** — it is not a copy or refactor of DCP-derived files. See [PROVENANCE.md](./PROVENANCE.md) for the per-module origin classification (original-bring / DCP-derived-reimplement / adapter-only).
 
 ---
 
@@ -241,10 +262,10 @@ Copyright protects *expression*, not ideas, methods, or algorithms (17 USC §102
 
 ### 8.1 First-user-message pin
 
-The session's **first user message survives prune unconditionally** — even when it is covered by an active block. In `rebuildMessages` (`src/prune.ts`) the pin check runs *before* the covered-by-active-block check, so after compressing a range that includes the first user message, the rebuilt wire contains **both** the rendered summary **and** the first user message verbatim; all other covered messages drop as usual. Only the *first* user message is pinned — later covered user messages are pruned normally.
+The session's **first user message survives prune unconditionally** — even when it is covered by an active block. In `rebuildMessages` (`src/prune.ts`) the pin check runs _before_ the covered-by-active-block check, so after compressing a range that includes the first user message, the rebuilt wire contains **both** the rendered summary **and** the first user message verbatim; all other covered messages drop as usual. Only the _first_ user message is pinned — later covered user messages are pruned normally.
 
 - **Why:** strict providers reject conversations with no user message (e.g., Anthropic requires the conversation to start from the user role). Pinning guarantees the rebuilt wire retains at least one user message whenever the input had one. Deliberate since prune's first implementation (v0.0.2) — the ordering of the two checks is part of the contract, not incidental. Regression-tested by `tests/state-prune.test.ts` ("prune preserves first user message even when covered") and `tests/orphan-fixes.test.ts` ("prune: first user message pruned when covered (no duplication)").
 - **Consequences for consumers:**
   - Consumers cannot assert byte-level disappearance of the first user message after compression; post-compress wire assertions must expect the rendered summary **plus** the pinned message verbatim.
   - Token-size and prefix-cache stability estimates must account for the pinned message staying verbatim (it is often the task description and can be long).
-  - Boundary resolution compensates: `blockVisibleInRange` (`src/boundaries.ts`) treats a block as present in a range via its rendered summary **or** its earliest surviving raw — required precisely because the summary anchors *before* the pinned raw.
+  - Boundary resolution compensates: `blockVisibleInRange` (`src/boundaries.ts`) treats a block as present in a range via its rendered summary **or** its earliest surviving raw — required precisely because the summary anchors _before_ the pinned raw.

package/PROVENANCE.md

@@ -2,17 +2,17 @@
 
 This document classifies **every** source file in `opencode-acp/lib/` (the donor) into one of three buckets, to determine what can be carried into the MIT `acp-kernel` and what must be reimplemented in fresh expression.
 
-**Method**: exact path comparison of `opencode-acp` (the ACP fork, 82 `lib/*.ts` files) against the upstream DCP repository (66 `lib/*.ts` files). A file that has **no DCP equivalent** is original work (bucket A). A file with a **DCP equivalent at the same path** is a DCP derivative — its *expression* is AGPL-bound regardless of how much it was later changed (derivation is judged by whether a file was created by transforming the original, not by % changed; per copyright law expression is protected, not ideas/methods/algorithms).
+**Method**: exact path comparison of `opencode-acp` (the ACP fork, 82 `lib/*.ts` files) against the upstream DCP repository (66 `lib/*.ts` files). A file that has **no DCP equivalent** is original work (bucket A). A file with a **DCP equivalent at the same path** is a DCP derivative — its _expression_ is AGPL-bound regardless of how much it was later changed (derivation is judged by whether a file was created by transforming the original, not by % changed; per copyright law expression is protected, not ideas/methods/algorithms).
 
 ---
 
 ## Legend
 
-| Bucket | Meaning | Action in acp-kernel |
-|---|---|---|
-| **A** | No DCP equivalent → original work of ranxianglei | **Bring verbatim** (the author's own code, MIT-safe). License header rewritten to MIT. |
-| **B** | DCP-derived file (same path exists upstream) → derivative expression is AGPL | **Reimplement in fresh expression** using the author's algorithm; do NOT copy/refactor the file's code. |
-| **N/A** | Adapter-only (framework-specific: opencode hooks, I/O, auth, commands, UI) | **Excluded** from the pure core. Stays in host adapters. Origin irrelevant. |
+| Bucket  | Meaning                                                                      | Action in acp-kernel                                                                                    |
+| ------- | ---------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
+| **A**   | No DCP equivalent → original work of ranxianglei                             | **Bring verbatim** (the author's own code, MIT-safe). License header rewritten to MIT.                  |
+| **B**   | DCP-derived file (same path exists upstream) → derivative expression is AGPL | **Reimplement in fresh expression** using the author's algorithm; do NOT copy/refactor the file's code. |
+| **N/A** | Adapter-only (framework-specific: opencode hooks, I/O, auth, commands, UI)   | **Excluded** from the pure core. Stays in host adapters. Origin irrelevant.                             |
 
 ---
 
@@ -21,26 +21,28 @@ This document classifies **every** source file in `opencode-acp/lib/` (the donor
 Quality gate intentionally omitted from acp-kernel (may be added later if needed).
 
 ### `compress/`
-| File | Notes |
-|---|---|
-| `compress/decompress.ts` | ACP-original (v1.11+); DCP has no decompress |
-| `compress/decompress-logic.ts` | ACP-original |
-| `compress/hide-consumed.ts` | ACP-original (v1.14+) |
-| `compress/hide-failed.ts` | ACP-original |
-| `compress/keep-markers.ts` | ACP-original (v1.12+) |
-| `compress/parts.ts` | ACP-original |
-| `compress/recap.ts` | ACP-original (v1.12.1) |
-| `compress/status.ts` | ACP-original (v1.11+) |
+
+| File                           | Notes                                        |
+| ------------------------------ | -------------------------------------------- |
+| `compress/decompress.ts`       | ACP-original (v1.11+); DCP has no decompress |
+| `compress/decompress-logic.ts` | ACP-original                                 |
+| `compress/hide-consumed.ts`    | ACP-original (v1.14+)                        |
+| `compress/hide-failed.ts`      | ACP-original                                 |
+| `compress/keep-markers.ts`     | ACP-original (v1.12+)                        |
+| `compress/parts.ts`            | ACP-original                                 |
+| `compress/recap.ts`            | ACP-original (v1.12.1)                       |
+| `compress/status.ts`           | ACP-original (v1.11+)                        |
 
 ### other
-| File | Notes |
-|---|---|
-| `config-validation.ts` | ACP-extracted for testability; no DCP equivalent |
-| `gc/merge.ts` | ACP-original (DCP has no `gc/` dir) |
-| `messages/truncate-tools.ts` | ACP-original (v1.14.5, replaced DCP's `gc/truncate.ts`) |
-| `messages/filter/*` (9 files) | ACP-original filtering subsystem |
+
+| File                                 | Notes                                                           |
+| ------------------------------------ | --------------------------------------------------------------- |
+| `config-validation.ts`               | ACP-extracted for testability; no DCP equivalent                |
+| `gc/merge.ts`                        | ACP-original (DCP has no `gc/` dir)                             |
+| `messages/truncate-tools.ts`         | ACP-original (v1.14.5, replaced DCP's `gc/truncate.ts`)         |
+| `messages/filter/*` (9 files)        | ACP-original filtering subsystem                                |
 | `messages/inject/policy/*` (3 files) | ACP-original (v1.13.1) — inject **policy** logic, not rendering |
-| `state/rebuild.ts` | ACP-original (v1.11+) |
+| `state/rebuild.ts`                   | ACP-original (v1.11+)                                           |
 
 ---
 
@@ -49,22 +51,25 @@ Quality gate intentionally omitted from acp-kernel (may be added later if needed
 Only the **algorithmic** subset is reimplemented into the pure core; the rest are adapter-only (persistence, config-merge, prompts-rendering) and excluded from the core. Listed by what they become.
 
 ### Reimplemented into acp-kernel (fresh expression, ~9 substantial files)
-| DCP-derived file | Becomes | What to reimplement |
-|---|---|---|
-| `compress/range.ts` | `core/applyCompression` (range mode) | block allocation, nested-block handling, boundary resolution |
-| `compress/search.ts` | `core/resolveBoundaries` | ref→index mapping, reversed-boundary swap, protected-gap detection |
-| `compress/state.ts` | `core/state` (mutation) | block id/run allocation, deactivation, byMessageId index |
-| `compress/pipeline.ts` | `core/processTurn` prep/finalize | permission (host-side), fetch (host-side), state wrap |
-| `messages/prune.ts` | `core/prune` | replace compressed ranges with summary blocks |
-| `messages/sync.ts` | `core/sync` | deactivate orphaned blocks when messages deleted |
-| `message-ids.ts` | `core/refs` | raw↔mNNNNN bidirectional map |
-| `messages/inject/inject.ts` + `inject/utils.ts` | `core/decideNudge` | **decision only** — shouldNudge, growth baseline, threshold, compressible ranges |
-| `config.ts` (core subset) | `core/Config` defaults | defaults + validation (use A-class `config-validation.ts`) |
+
+| DCP-derived file                                | Becomes                              | What to reimplement                                                              |
+| ----------------------------------------------- | ------------------------------------ | -------------------------------------------------------------------------------- |
+| `compress/range.ts`                             | `core/applyCompression` (range mode) | block allocation, nested-block handling, boundary resolution                     |
+| `compress/search.ts`                            | `core/resolveBoundaries`             | ref→index mapping, reversed-boundary swap, protected-gap detection               |
+| `compress/state.ts`                             | `core/state` (mutation)              | block id/run allocation, deactivation, byMessageId index                         |
+| `compress/pipeline.ts`                          | `core/processTurn` prep/finalize     | permission (host-side), fetch (host-side), state wrap                            |
+| `messages/prune.ts`                             | `core/prune`                         | replace compressed ranges with summary blocks                                    |
+| `messages/sync.ts`                              | `core/sync`                          | deactivate orphaned blocks when messages deleted                                 |
+| `message-ids.ts`                                | `core/refs`                          | raw↔mNNNNN bidirectional map                                                     |
+| `messages/inject/inject.ts` + `inject/utils.ts` | `core/decideNudge`                   | **decision only** — shouldNudge, growth baseline, threshold, compressible ranges |
+| `config.ts` (core subset)                       | `core/Config` defaults               | defaults + validation (use A-class `config-validation.ts`)                       |
 
 ### Supporting types/barrels (trivial, write fresh)
+
 `compress/{index,types,timing,range-utils}.ts`, `messages/{index,priority,query,reasoning-strip,shape,utils}.ts`, `state/{index,types,utils}.ts`, `token-utils.ts` (wrap `cc-alg` tokenizer), `protected-patterns.ts`, `compress/protected-content.ts`.
 
 ### Excluded from core (adapter-only despite B lineage)
+
 `state/persistence.ts` (filesystem I/O), `prompts/*` (text rendering → adapter), `compress-permission.ts` (permission = host concern).
 
 ---
@@ -79,14 +84,13 @@ All framework-specific; irrelevant to the pure core. Stay in the OpenCode adapte
 
 ## Summary
 
-| Bucket | Files | Disposition |
-|---|---|---|
-| **B** DCP-derived | 40 | ~9 substantial algorithms reimplemented fresh + ~12 types/barrels rewritten fresh; rest excluded (adapter) |
-| **N/A** adapter | 12 | excluded from core |
-
+| Bucket            | Files | Disposition                                                                                                |
+| ----------------- | ----- | ---------------------------------------------------------------------------------------------------------- |
+| **B** DCP-derived | 40    | ~9 substantial algorithms reimplemented fresh + ~12 types/barrels rewritten fresh; rest excluded (adapter) |
+| **N/A** adapter   | 12    | excluded from core                                                                                         |
 
 ---
 
 ## Compliance note
 
-This audit exists to ensure acp-kernel is **genuinely MIT**, not "MIT-labeled but AGPL-tainted." The rule applied throughout: an idea/algorithm is free regardless of source; a *file's code expression* is bound to the license of the file it descends from. A-class files descend from no DCP file. B-class files' code is NOT carried — the algorithms are reimplemented in new expression. Should any contributor question a classification, the comparison data above (and the upstream DCP tree) allow independent verification.
+This audit exists to ensure acp-kernel is **genuinely MIT**, not "MIT-labeled but AGPL-tainted." The rule applied throughout: an idea/algorithm is free regardless of source; a _file's code expression_ is bound to the license of the file it descends from. A-class files descend from no DCP file. B-class files' code is NOT carried — the algorithms are reimplemented in new expression. Should any contributor question a classification, the comparison data above (and the upstream DCP tree) allow independent verification.