chainlesschain 0.163.3 → 0.163.4

package/src/data/changelog.json

@@ -1,6 +1,19 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.163.4",
+      "cliVersions": ["0.163.3", "0.163.4"],
+      "date": "2026-08-11",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Added — cc CLI 0.163.4: immutable MCP capsules and durable scheduler storage",
+          "body": "> `chainlesschain` **0.163.3 → 0.163.4** (candidate; not yet published,\n> 2026-08-11).\n> CLI-only candidate; `@chainlesschain/personal-data-hub` remains **0.4.57**\n> and `@chainlesschain/agent-sdk` remains **0.1.7**.\n\n- **Immutable MCP capsule build inputs**: the capsule builder now executes in a\n  bounded worker against an in-memory WASM virtual filesystem populated from\n  verified bytes. Package sources and native builder assets are canonicalized,\n  identity-bound, and no longer reopened from mutable host paths during the\n  build.\n- **Platform-bound live capsule evidence**: materialized stdio MCP capsules are\n  exercised through the production Process Broker and child contract on Linux,\n  Windows, and macOS. Framed reports, exact asset identity, deferred host-path\n  resolution, and shared CJS/ESM trace context prevent warning or path-alias\n  drift from weakening the evidence chain.\n- **Bounded failure behavior**: worker memory, output, timeout, and cleanup are\n  bounded; partial or malformed child evidence, post-verification replacement,\n  unapproved effects, and unsupported strict boundaries fail closed.\n- **Command lifecycle evidence and alias decision**: report v2 binds exact\n  coverage, approval, scope, and repository evidence and summarizes command\n  telemetry without silently accepting zero-data input. All 25 deprecated\n  aliases remain retained until representative opt-in telemetry exists and the\n  documented `0.164.0` removal floor is reached.\n- **Scheduler kernel storage foundation**: a versioned SQLite store adds strict\n  schema verification, expected-revision CAS, logical-occurrence deduplication,\n  durable claims, and two-handle race coverage. This is the first P2-4 storage\n  milestone, not completion of the scheduling kernel or orchestration runtime.\n- **Delivery and recovery hardening**: production delivery adapters, durable\n  provider-backed compaction, MCP recovery admission, session ownership fences,\n  and exact Windows write checks close additional internal consistency gaps.\n- **Native release readback hardening**: release evidence now verifies public\n  bytes, checksums, manifests, signatures, and provenance contracts more\n  strictly. Signed native distribution is still blocked until real signed\n  artifacts and public package-manager readback are available.\n- **Known residuals**: full P2-4 scheduling orchestration, signed native\n  distribution, representative alias telemetry, and the remaining documented\n  long-soak/host-boundary follow-ups are not claimed by this release.\n- **Release status**: final tag, exact source SHA, workflow run IDs, package\n  digest, provenance, and public registry readback are intentionally omitted\n  until the exact `0.163.4` release commit passes the Linux, Windows, and macOS\n  `CLI CI` and `CLI Strict Sandbox` gates and the npm release/readback workflows\n  complete successfully."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.163.3",
@@ -10,7 +23,7 @@
       "sections": [
         {
           "heading": "Added — cc CLI 0.163.3: isolated background agents and policy-bound runtimes",
-          "body": "> `chainlesschain` **0.163.2 → 0.163.3** (candidate; not yet published,\n> 2026-08-10).\n> CLI-only candidate; `@chainlesschain/personal-data-hub` remains **0.4.57**\n> and `@chainlesschain/agent-sdk` remains **0.1.7**.\n\n- **Git background isolation by default**: `cc agent --bg` runs started from a\n  clean Git checkout and not using `--input-format stream-json` now create a\n  worktree at committed `HEAD`; `--worktree` requests the same path and only\n  `--no-worktree` opts into the shared checkout. Foreground runs, runs using\n  `--input-format stream-json`, and non-Git runs retain their prior behavior,\n  while a dirty Git source is rejected instead of silently omitting uncommitted\n  changes.\n- **Generation- and token-fenced ownership**: locked atomic state, immutable\n  worktree/profile identity, worker-generation claims, terminal-absorbing\n  updates, durable turn intents, and stop/cleanup fences prevent stale\n  cooperative workers from reviving or deleting live work. Versioned,\n  secret-free launch profiles preserve compatible resume settings.\n- **Grammar-safe detached arguments**: new background launches preserve option\n  values and `--` literals, pass prompts as one `--print=<text>` token,\n  canonicalize resume/continue/fork to one session, and remap repository\n  `--add-dir` roots into the worktree. Canonical external roots remain shared\n  and produce a warning.\n- **Policy-bearing stdio MCP sources**: explicit `--mcp-config`, managed and\n  registered local/project/user sources, trusted project configuration, Skill,\n  and Cowork definitions propagate normalized `filesystem`/`network`\n  requirements plus separately validated working-directory/workspace authority\n  to the Process Broker. Unprovable requirements fail closed, and invalid named\n  higher-precedence entries do not fall through to a weaker source.\n- **Sealed Linux plugin file sets**: strict direct Plugin Node and supported\n  narrow native ELF launches snapshot every pinned regular plugin file into\n  sealed anonymous data-bind mounts. Dynamic native evidence covers only\n  `PT_INTERP` and direct `DT_NEEDED`; tree attestation remains per-file rather\n  than one atomic filesystem snapshot.\n- **Contained Windows adapter artifacts**: helper, cache, and test artifacts use\n  an attested non-reparse local temporary root, identity/content rechecks,\n  randomized materialization, and bounded retirement. Unknown or unverifiable\n  leftovers are preserved and make cleanup fail closed.\n- **Fail-closed CI routing**: the generic selector routes the defined Windows\n  helper-support paths to their CLI contract tests, supports multi-suite\n  execution, and cannot turn selected-test or primary-run failure into a\n  fallback/diagnostic pass. Full-suite workflows provision their required\n  dependencies explicitly; this routing does not replace the exact-SHA release\n  matrices.\n- **Known residuals**: non-Git, `--input-format stream-json`, `--no-worktree`,\n  and external `add-dir` roots are not worktree-isolated. Spawn-to-PID\n  hard-crash recovery and long-soak closure remain open; Linux native\n  dependency evidence is non-transitive and has no `dlopen` closure; Windows\n  path operations are\n  re-attested but not handle-atomic. macOS atomic runtime execution, arbitrary\n  shared-library closure, remote revocation, signed native distribution, and\n  alias telemetry/removal remain out of scope, so this release does not claim\n  complete P1-2 closure.\n- **Release status**: final tag, exact source SHA, workflow run IDs, package\n  digest, provenance, and public registry readback are intentionally omitted\n  until the exact `0.163.3` release commit passes the required Linux, Windows,\n  and macOS `CLI CI` and `CLI Strict Sandbox` gates and the npm release/readback\n  workflows complete successfully."
+          "body": "> `chainlesschain` **0.163.2 → 0.163.3** (published from exact SHA\n> `17fcf6aa7917dd0fcc83b3ab5204c196bbb81758`, 2026-08-10).\n> CLI-only release; `@chainlesschain/personal-data-hub` remains **0.4.57**\n> and `@chainlesschain/agent-sdk` remains **0.1.7**.\n\n- **Git background isolation by default**: `cc agent --bg` runs started from a\n  clean Git checkout and not using `--input-format stream-json` now create a\n  worktree at committed `HEAD`; `--worktree` requests the same path and only\n  `--no-worktree` opts into the shared checkout. Foreground runs, runs using\n  `--input-format stream-json`, and non-Git runs retain their prior behavior,\n  while a dirty Git source is rejected instead of silently omitting uncommitted\n  changes.\n- **Generation- and token-fenced ownership**: locked atomic state, immutable\n  worktree/profile identity, worker-generation claims, terminal-absorbing\n  updates, durable turn intents, and stop/cleanup fences prevent stale\n  cooperative workers from reviving or deleting live work. Versioned,\n  secret-free launch profiles preserve compatible resume settings.\n- **Grammar-safe detached arguments**: new background launches preserve option\n  values and `--` literals, pass prompts as one `--print=<text>` token,\n  canonicalize resume/continue/fork to one session, and remap repository\n  `--add-dir` roots into the worktree. Canonical external roots remain shared\n  and produce a warning.\n- **Policy-bearing stdio MCP sources**: explicit `--mcp-config`, managed and\n  registered local/project/user sources, trusted project configuration, Skill,\n  and Cowork definitions propagate normalized `filesystem`/`network`\n  requirements plus separately validated working-directory/workspace authority\n  to the Process Broker. Unprovable requirements fail closed, and invalid named\n  higher-precedence entries do not fall through to a weaker source.\n- **Sealed Linux plugin file sets**: strict direct Plugin Node and supported\n  narrow native ELF launches snapshot every pinned regular plugin file into\n  sealed anonymous data-bind mounts. Dynamic native evidence covers only\n  `PT_INTERP` and direct `DT_NEEDED`; tree attestation remains per-file rather\n  than one atomic filesystem snapshot.\n- **Contained Windows adapter artifacts**: helper, cache, and test artifacts use\n  an attested non-reparse local temporary root, identity/content rechecks,\n  randomized materialization, and bounded retirement. Unknown or unverifiable\n  leftovers are preserved and make cleanup fail closed.\n- **Fail-closed CI routing**: the generic selector routes the defined Windows\n  helper-support paths to their CLI contract tests, supports multi-suite\n  execution, and cannot turn selected-test or primary-run failure into a\n  fallback/diagnostic pass. Full-suite workflows provision their required\n  dependencies explicitly; this routing does not replace the exact-SHA release\n  matrices.\n- **Known residuals**: non-Git, `--input-format stream-json`, `--no-worktree`,\n  and external `add-dir` roots are not worktree-isolated. Spawn-to-PID\n  hard-crash recovery and long-soak closure remain open; Linux native\n  dependency evidence is non-transitive and has no `dlopen` closure; Windows\n  path operations are\n  re-attested but not handle-atomic. macOS atomic runtime execution, arbitrary\n  shared-library closure, remote revocation, signed native distribution, and\n  alias telemetry/removal remain out of scope, so this release does not claim\n  complete P1-2 closure.\n- **Published release evidence**: immutable tag `v-npm-0-163-3` resolves to\n  exact source commit `17fcf6aa7917dd0fcc83b3ab5204c196bbb81758`.\n  Its Linux, Windows, and macOS `CLI CI` (`31329476135`) and `CLI Strict\nSandbox` (`31329476020`) matrices passed; the formal two-hour\n  reliability/malicious-MCP soak (`31329539092`) completed 7/7 jobs with 300\n  host cycles, 900 unapproved effects, 100 Linux races, 100 macOS fail-closed\n  probes, and zero escapes. The npm release (`31335579227`) and independent\n  public readback (`31336362525`) completed the exact-SHA gate, immutable\n  tarball/CycloneDX SBOM, Trusted Publishing, SLSA/Sigstore provenance,\n  registry byte comparison, and npmmirror synchronization. The public tarball\n  SHA-256 is\n  `68396c418029fc314403c9882c92fb9bef5ec6e9a61bb186333209884d410a92`."
         }
       ]
     },

package/src/gateways/ws/ws-agent-handler.js

@@ -34,12 +34,17 @@ import {
 import { createWsApprovalGate } from "./ws-approval-gate.js";
 import { createSessionMcpLedgerSink } from "../../lib/mcp-call-ledger-store.js";
 import { createMcpHostRecoveryRuntime } from "../../lib/mcp-host-recovery-runtime.js";
+import { compactConversationWithProvider } from "../../harness/provider-backed-compaction.js";
+import { projectCanonicalResumeMessages } from "../../lib/session-message-provenance.js";
+import { feature } from "../../lib/feature-flags.js";
 import {
+  appendCompactEventIfMessagesMatch,
   claimWsTurnIfHead,
   computeWsTurnInputDigest,
   createWsTurnClaimId,
   normalizeWsTurnRequestId,
   readVerifiedWsTurnState,
+  readVerifiedMessages,
   settleWsTurnClaim,
 } from "../../harness/jsonl-session-store.js";
 
@@ -78,6 +83,8 @@ export class WSAgentHandler {
     db,
     approvalGate,
     agentLoop: runAgentLoop,
+    compactionLlmQuery,
+    compactionChatFn,
     canonicalSessionStore,
     sessionHostLease = null,
   }) {
@@ -122,12 +129,22 @@ export class WSAgentHandler {
     this._mcpRecoveryRevision = null;
     this._mcpRecoveryClient = null;
     this._agentLoop = runAgentLoop || agentLoop;
+    this._compactionLlmQuery = compactionLlmQuery || null;
+    this._compactionSettlementBlock = null;
+    this._compactionChatFn =
+      compactionChatFn ||
+      (async (...args) => {
+        const { chatWithTools } = await import("../../runtime/agent-core.js");
+        return chatWithTools(...args);
+      });
     this._canonicalSessionStore = {
+      appendCompactEventIfMessagesMatch,
       claimWsTurnIfHead,
       computeWsTurnInputDigest,
       createWsTurnClaimId,
       normalizeWsTurnRequestId,
       readVerifiedWsTurnState,
+      readVerifiedMessages,
       settleWsTurnClaim,
       ...(canonicalSessionStore || {}),
     };
@@ -171,9 +188,56 @@ export class WSAgentHandler {
     return this.session.messages;
   }
 
+  _latchCompactionSettlement({
+    code,
+    reason,
+    commitState = "unknown",
+    usageOutcome = null,
+  }) {
+    this._compactionSettlementBlock = Object.freeze({
+      code: code || "CC_COMPACTION_SETTLEMENT_UNKNOWN",
+      reason: reason || "canonical_compaction_settlement_failed",
+      commitState,
+      ...(usageOutcome ? { usageOutcome } : {}),
+    });
+    return this._compactionSettlementBlock;
+  }
+
+  _reconcileCompactionSettlementBlock() {
+    if (
+      this._compactionSettlementBlock?.commitState !== "provider-usage-unknown"
+    ) {
+      this._compactionSettlementBlock = null;
+    }
+  }
+
+  _emitCompactionUsage(requestId, usageEvent) {
+    if (!usageEvent) return;
+    this.interaction.emit("token-usage", {
+      requestId,
+      ...usageEvent,
+    });
+  }
+
+  _emitCompactionUsageUnknown(requestId, usageUnknownEvent) {
+    const block = this._latchCompactionSettlement({
+      code: "CC_COMPACTION_USAGE_UNKNOWN",
+      reason: usageUnknownEvent?.reason || "provider_transport_outcome_unknown",
+      commitState: "provider-usage-unknown",
+      usageOutcome: "unknown",
+    });
+    this.interaction.emit("compaction-usage-unknown", {
+      requestId,
+      ...usageUnknownEvent,
+      code: block.code,
+    });
+    return block;
+  }
+
   _canonicalTurnFromAuthority(state, requestId, userMessage, inputDigest) {
     const status = state?.status || (state?.turn ? "completed" : "none");
     this._applyCanonicalMessages(state?.messages || []);
+    this._reconcileCompactionSettlementBlock();
     if (status === "completed" && state.turn) {
       return {
         requestId,
@@ -210,6 +274,193 @@ export class WSAgentHandler {
     return null;
   }
 
+  async _compactCanonicalHistoryBeforeClaim(requestId) {
+    const { session } = this;
+    if (
+      session.autoCompact === false ||
+      !feature("PROMPT_COMPRESSOR") ||
+      this._compactionSettlementBlock?.commitState === "provider-usage-unknown"
+    ) {
+      return true;
+    }
+
+    const before = session.messages.length;
+    const expectedMessages = [...session.messages];
+    let result;
+    try {
+      this._sessionHostLease?.assert?.();
+      result = await compactConversationWithProvider(session.messages, {
+        provider: session.provider,
+        model: session.model,
+        baseUrl: session.baseUrl,
+        apiKey: session.apiKey,
+        signal: this._sessionHostLease?.signal,
+        onlyIfNeeded: true,
+        preserveCompletedExchange: true,
+        llmQuery: this._compactionLlmQuery,
+        chatFn: this._compactionChatFn,
+        chatOptions: {
+          cwd: session.projectRoot,
+          sessionId: session.id,
+        },
+        maxMessages: session.compactionMaxMessages,
+        maxTokens: session.compactionMaxTokens,
+        maxOutputTokens: session.compactionMaxOutputTokens,
+        summaryInputMaxChars: session.compactionInputMaxChars,
+      });
+      this._sessionHostLease?.assert?.();
+    } catch (error) {
+      if (isAbortError(error) || this._sessionHostLease?.signal?.aborted) {
+        throw error;
+      }
+      const block = this._latchCompactionSettlement({
+        code: error?.code || "CC_COMPACTION_FAILED",
+        reason: `compaction_failed:${String(error?.message || error).slice(0, 240)}`,
+        commitState: "provider-outcome-unknown",
+      });
+      this.interaction.emit("compaction-degraded", {
+        requestId,
+        reason: block.reason,
+        summaryMode: "none",
+        code: block.code,
+      });
+      this.interaction.emit("error", {
+        requestId,
+        code: block.code,
+        message: "Canonical history could not be compacted before turn claim",
+      });
+      return false;
+    }
+
+    const {
+      messages: compacted,
+      stats,
+      degradedEvent,
+      usageEvent,
+      usageUnknownEvent,
+    } = result;
+    if (degradedEvent) {
+      this.interaction.emit("compaction-degraded", {
+        requestId,
+        ...degradedEvent,
+      });
+    }
+    if (usageUnknownEvent) {
+      const block = this._emitCompactionUsageUnknown(
+        requestId,
+        usageUnknownEvent,
+      );
+      this.interaction.emit("error", {
+        requestId,
+        code: block.code,
+        message:
+          "Compaction provider usage is unknown; the paid compaction is not retried",
+      });
+      return false;
+    }
+
+    const messagesChanged =
+      session.messages.length !== expectedMessages.length ||
+      session.messages.some(
+        (message, index) => message !== expectedMessages[index],
+      );
+    const shouldSettle = stats?.strategy !== "none" && stats?.saved > 0;
+    let settlementError = null;
+    if (!messagesChanged && shouldSettle) {
+      try {
+        const settlement =
+          this._canonicalSessionStore.appendCompactEventIfMessagesMatch(
+            session.id,
+            {
+              ...stats,
+              trigger: "auto",
+              messages: projectCanonicalResumeMessages(compacted, {
+                strict: true,
+              }),
+            },
+            expectedMessages,
+          );
+        if (settlement && typeof settlement.then === "function") {
+          void Promise.resolve(settlement).catch(() => {});
+          const error = new TypeError(
+            "Canonical compact settlement must be synchronous",
+          );
+          error.code = "CC_COMPACTION_SETTLEMENT_ASYNC";
+          throw error;
+        }
+      } catch (error) {
+        settlementError = error;
+      }
+    }
+
+    this._emitCompactionUsage(requestId, usageEvent);
+    if (messagesChanged || settlementError) {
+      const stale = settlementError?.code === "SESSION_REVISION_STALE";
+      let reconciled = false;
+      if (stale) {
+        try {
+          const authoritativeMessages =
+            this._canonicalSessionStore.readVerifiedMessages(session.id);
+          if (!Array.isArray(authoritativeMessages)) {
+            throw new TypeError(
+              "Canonical message refresh must be synchronous",
+            );
+          }
+          this._applyCanonicalMessages(authoritativeMessages);
+          this._reconcileCompactionSettlementBlock();
+          reconciled = true;
+        } catch {
+          // Latch below until a later verified canonical refresh succeeds.
+        }
+      }
+      const block =
+        reconciled && stale
+          ? {
+              code: "CC_COMPACTION_REVISION_STALE",
+              reason: "session_messages_changed_during_compaction",
+              commitState: "reconciled-stale",
+            }
+          : this._latchCompactionSettlement({
+              code:
+                settlementError?.code ||
+                (messagesChanged
+                  ? "CC_COMPACTION_LOCAL_STATE_CHANGED"
+                  : "CC_COMPACTION_SETTLEMENT_UNKNOWN"),
+              reason:
+                messagesChanged || stale
+                  ? "session_messages_changed_during_compaction"
+                  : "canonical_compaction_settlement_failed",
+              commitState: "unknown",
+            });
+      this.interaction.emit("compaction-degraded", {
+        requestId,
+        reason: block.reason,
+        summaryMode: "none",
+        code: block.code,
+      });
+      this.interaction.emit("error", {
+        requestId,
+        code: block.code,
+        message:
+          "Canonical compaction did not settle; the paid compaction is not retried",
+      });
+      return false;
+    }
+
+    if (shouldSettle) {
+      session.messages.length = 0;
+      session.messages.push(...compacted);
+      this.interaction.emit("compaction", {
+        requestId,
+        stats,
+        trigger: "auto",
+        messagesBefore: before,
+        messagesAfter: session.messages.length,
+      });
+    }
+    return true;
+  }
+
   _claimCanonicalTurn(userMessage, requestId) {
     const inputDigest =
       this._canonicalSessionStore.computeWsTurnInputDigest(userMessage);
@@ -396,6 +647,7 @@ export class WSAgentHandler {
         sink: this._mcpRecoverySink,
         recovery: session.mcpLedgerRecovery || null,
         controller,
+        dispatchAdmission: this._sessionHostLease?.admitMcpDispatch || null,
       });
       this._mcpRecoveryClient = rawClient;
       this._mcpRecoveryRevision = revision;
@@ -509,7 +761,26 @@ export class WSAgentHandler {
       this._sessionHostLease?.assert?.();
 
       if (session.canonicalJsonlSession === true) {
-        canonicalTurn = this._claimCanonicalTurn(userMessage, requestId);
+        const inputDigest =
+          this._canonicalSessionStore.computeWsTurnInputDigest(userMessage);
+        const preflightState =
+          this._canonicalSessionStore.readVerifiedWsTurnState(
+            session.id,
+            requestId,
+            { inputDigest },
+          );
+        canonicalTurn = this._canonicalTurnFromAuthority(
+          preflightState,
+          requestId,
+          userMessage,
+          inputDigest,
+        );
+        if (!canonicalTurn) {
+          const compacted =
+            await this._compactCanonicalHistoryBeforeClaim(requestId);
+          if (!compacted) return;
+        }
+        canonicalTurn ||= this._claimCanonicalTurn(userMessage, requestId);
         if (canonicalTurn.status === "completed") {
           this.interaction.emit("response-complete", {
             requestId,
@@ -601,6 +872,7 @@ export class WSAgentHandler {
         // headless and REPL sessions. For unknown/write/destructive effects a
         // failed prewrite blocks the network call inside agent-core.
         mcpCallLedger: mcpRecoveryRuntime.ledger,
+        mcpDispatchAdmission: this._sessionHostLease?.admitMcpDispatch || null,
         shellPolicyOverrides: session.shellPolicyOverrides || null,
         slotFiller,
         interaction: this.interaction,
@@ -608,6 +880,12 @@ export class WSAgentHandler {
         // P0 authority: null unless opted in (byte-identical default — agent
         // core already defaults `options.approvalGate || null`).
         approvalGate: await this._ensureApprovalGate(),
+        // Canonical WS history is compacted before ws_turn_prepare. Compaction
+        // inside agent-core would include the staged pending user, which is not
+        // part of the canonical message projection until turn settlement.
+        ...(session.canonicalJsonlSession === true
+          ? { autoCompact: false }
+          : {}),
       };
 
       // P0-2: crash-safe side-effect ledger for the IDE/bridge path — mirrors
@@ -718,6 +996,37 @@ export class WSAgentHandler {
               }
               break;
 
+            case "compaction-degraded":
+              this.interaction.emit("compaction-degraded", {
+                requestId,
+                reason: event.reason,
+                summaryMode: event.summaryMode,
+                ...(event.code ? { code: event.code } : {}),
+                stats: event.stats,
+              });
+              break;
+
+            case "compaction-usage-unknown":
+              this._emitCompactionUsageUnknown(requestId, event);
+              break;
+
+            case "compaction":
+              this.interaction.emit("compaction", {
+                requestId,
+                stats: event.stats,
+              });
+              break;
+
+            case "token-usage":
+              this.interaction.emit("token-usage", {
+                requestId,
+                provider: event.provider,
+                model: event.model,
+                usage: event.usage,
+                ...(event.source ? { source: event.source } : {}),
+              });
+              break;
+
             case "response-complete":
               if (session.canonicalJsonlSession === true) {
                 const settled = this._settleCanonicalSuccess(
@@ -983,25 +1292,194 @@ export class WSAgentHandler {
         });
         break;
 
-      case "/compact":
-        if (session.contextEngine && session.messages.length > 5) {
-          const compacted = session.contextEngine.smartCompact(
-            session.messages,
-          );
-          session.messages.length = 0;
-          session.messages.push(...compacted);
-        } else if (session.messages.length > 5) {
-          const systemMsg = session.messages[0];
-          const recent = session.messages.slice(-4);
-          session.messages.length = 0;
-          session.messages.push(systemMsg, ...recent);
+      case "/compact": {
+        if (this._compactionSettlementBlock) {
+          const block = this._compactionSettlementBlock;
+          this.interaction.emit("compaction-degraded", {
+            requestId,
+            reason: block.reason,
+            summaryMode: "none",
+            code: block.code,
+          });
+          this.interaction.emit("command-response", {
+            requestId,
+            command: cmd,
+            result: {
+              messageCount: session.messages.length,
+              error: block,
+            },
+          });
+          break;
+        }
+
+        const before = session.messages.length;
+        const expectedMessages = [...session.messages];
+        let result = null;
+        let commandError = null;
+        try {
+          this._sessionHostLease?.assert?.();
+          result = await compactConversationWithProvider(session.messages, {
+            provider: session.provider,
+            model: session.model,
+            baseUrl: session.baseUrl,
+            apiKey: session.apiKey,
+            signal: this._sessionHostLease?.signal,
+            force: true,
+            preserveCompletedExchange: true,
+            llmQuery: this._compactionLlmQuery,
+            chatFn: this._compactionChatFn,
+            chatOptions: {
+              cwd: session.projectRoot,
+              sessionId: session.id,
+            },
+            maxOutputTokens: session.compactionMaxOutputTokens,
+            summaryInputMaxChars: session.compactionInputMaxChars,
+          });
+          this._sessionHostLease?.assert?.();
+        } catch (error) {
+          if (isAbortError(error) || this._sessionHostLease?.signal?.aborted) {
+            throw error;
+          }
+          commandError = this._latchCompactionSettlement({
+            code: error?.code || "CC_COMPACTION_FAILED",
+            reason: `compaction_failed:${String(error?.message || error).slice(0, 240)}`,
+            commitState: "provider-outcome-unknown",
+          });
+          this.interaction.emit("compaction-degraded", {
+            requestId,
+            reason: commandError.reason,
+            summaryMode: "none",
+            code: commandError.code,
+          });
+        }
+        if (result) {
+          const {
+            messages,
+            stats,
+            degradedEvent,
+            usageEvent,
+            usageUnknownEvent,
+          } = result;
+          if (degradedEvent) {
+            this.interaction.emit("compaction-degraded", {
+              requestId,
+              ...degradedEvent,
+            });
+          }
+          if (usageUnknownEvent) {
+            commandError = this._emitCompactionUsageUnknown(
+              requestId,
+              usageUnknownEvent,
+            );
+          }
+          const messagesChanged =
+            session.messages.length !== expectedMessages.length ||
+            session.messages.some(
+              (message, index) => message !== expectedMessages[index],
+            );
+          let settlementError = null;
+          if (
+            !commandError &&
+            !messagesChanged &&
+            session.canonicalJsonlSession === true
+          ) {
+            if (stats?.strategy !== "none") {
+              try {
+                const settlement =
+                  this._canonicalSessionStore.appendCompactEventIfMessagesMatch(
+                    session.id,
+                    {
+                      ...stats,
+                      trigger: "manual",
+                      messages: projectCanonicalResumeMessages(messages, {
+                        strict: true,
+                      }),
+                    },
+                    expectedMessages,
+                  );
+                if (settlement && typeof settlement.then === "function") {
+                  void Promise.resolve(settlement).catch(() => {});
+                  const error = new TypeError(
+                    "Canonical compact settlement must be synchronous",
+                  );
+                  error.code = "CC_COMPACTION_SETTLEMENT_ASYNC";
+                  throw error;
+                }
+              } catch (error) {
+                settlementError = error;
+              }
+            }
+          }
+
+          if (!commandError && !messagesChanged && !settlementError) {
+            session.messages.length = 0;
+            session.messages.push(...messages);
+            this.interaction.emit("compaction", {
+              requestId,
+              stats,
+              messagesBefore: before,
+              messagesAfter: session.messages.length,
+            });
+          } else if (!commandError) {
+            const stale = settlementError?.code === "SESSION_REVISION_STALE";
+            let reconciled = false;
+            if (stale) {
+              try {
+                const authoritativeMessages =
+                  this._canonicalSessionStore.readVerifiedMessages(session.id);
+                if (!Array.isArray(authoritativeMessages)) {
+                  throw new TypeError(
+                    "Canonical message refresh must be synchronous",
+                  );
+                }
+                this._applyCanonicalMessages(authoritativeMessages);
+                this._reconcileCompactionSettlementBlock();
+                reconciled = true;
+              } catch {
+                // Latch below until a later verified canonical refresh.
+              }
+            }
+            commandError =
+              reconciled && stale
+                ? {
+                    code: "CC_COMPACTION_REVISION_STALE",
+                    reason: "session_messages_changed_during_compaction",
+                    commitState: "reconciled-stale",
+                  }
+                : this._latchCompactionSettlement({
+                    code:
+                      settlementError?.code ||
+                      (messagesChanged
+                        ? "CC_COMPACTION_LOCAL_STATE_CHANGED"
+                        : "CC_COMPACTION_SETTLEMENT_UNKNOWN"),
+                    reason:
+                      messagesChanged || stale
+                        ? "session_messages_changed_during_compaction"
+                        : "canonical_compaction_settlement_failed",
+                    commitState: "unknown",
+                  });
+            this.interaction.emit("compaction-degraded", {
+              requestId,
+              reason: commandError.reason,
+              summaryMode: "none",
+              code: commandError.code,
+            });
+          }
+          // Provider usage is emitted exactly once even when the message CAS
+          // rejects the candidate; the paid request already happened and is
+          // never retried by this command.
+          this._emitCompactionUsage(requestId, usageEvent);
         }
         this.interaction.emit("command-response", {
           requestId,
           command: cmd,
-          result: { messageCount: session.messages.length },
+          result: {
+            messageCount: session.messages.length,
+            ...(commandError ? { error: commandError } : {}),
+          },
         });
         break;
+      }
 
       case "/task":
         if (arg === "clear") {