opencode-acp 1.13.6 → 1.13.7

package/README.md

@@ -475,6 +475,22 @@ For the complete list with root cause analysis, see the [bug tracker](https://gi
 
 ## Changelog
 
+### v1.13.7 — Per-Session State + Inactive Block Fixes + Preserve First User Message (PRs #184, #193, #196)
+
+**Problem**: Three bugs since v1.13.6. (1) **Subagent state isolation failure** (PR #184): ACP stored a single global `SessionState` per plugin instance. When subagent (child) sessions ran interleaved with the parent, the child's state overwrote the parent's `modelContextLimit` — losing the 1M context window and falling back to the 6K adaptive floor, causing over-aggressive nudging in the parent. The `compressionTiming` tracker was also shared across sessions, risking cross-session collision. (2) **Inactive block opacity** (PR #193): `decompress` rejected inactive blocks with "not active — may have already been decompressed", and `acp_status` hid consumed/inactive blocks entirely. Users could not decompress blocks that were GC'd or consumed by secondary compression, and could not see them in status output. (3) **Zero-user session freeze** (PR #196): When compression pruned all user-role messages (all fell inside compressed ranges), zhipuai-lb rejected the request with HTTP 400 code 1214 (`"messages 参数非法"`, `isRetryable: false`), freezing the session. The v1.13.2 `preserve-last-user` fix searched the messages array for a pruned user to restore — but after OpenCode compaction removes pruned messages from the array, the search finds nothing and zero-user requests slip through.
+
+**Fix**: (1) PR #184 — Introduced `SessionStateRegistry` in `lib/state/state.ts`: a `Map<sessionID, SessionState>` with a shared `compressionTiming` tracker and soft-cap eviction (32 sessions). Each session now resolves its own state via `registry.getOrCreate(sessionID)`, isolating subagent state from the parent. The system-prompt hook gracefully handles missing state (returns early). Also reverted the over-aggressive `baseline = 0` change back to `baseline = currentTokens` (system prompt is not growth). 851 tests pass. (2) PR #193 — Removed the "not active" rejection from `lib/compress/decompress.ts` and the `/acp decompress` slash command; standalone inactive blocks (user-decompressed, GC'd, orphaned) now decompress successfully. `acp_status` compressed scope now lists ALL blocks (active + inactive) with an `[inactive]` marker and "N active, M inactive/consumed" summary line. Fixed `toFile` fallback to use `targets[0].blocks[0].summary` instead of the undefined `activeBlocks[0].summary`. 859 tests pass after 3 rounds of dual-agent review. (3) PR #196 — Replaced `preserve-last-user` with `preserve-first-user` in `lib/messages/prune.ts`: the first user message (session's original task, always present in the array) is unconditionally force-preserved (`survive[firstUserIdx] = true`) regardless of prune state. Simpler and more reliable — does not depend on pruned messages remaining in the array after OpenCode compaction. Trade-off: may produce two adjacent user messages (first user + a later surviving user), which all major providers accept. Dual-agent reviewed (Oracle + General, both APPROVE). 846 tests pass.
+
+Files: `lib/state/state.ts`, `lib/hooks.ts`, `lib/compress/types.ts`, `lib/compress/decompress.ts`, `lib/compress/status.ts`, `lib/commands/decompress.ts`, `lib/messages/prune.ts`, `lib/messages/inject/inject.ts`. Tests: `tests/registry.test.ts`, `tests/inactive-block-decompress.test.ts`, `tests/acp-status.test.ts`, `tests/decompress-logic.test.ts`, `tests/prune.test.ts`, `tests/e2e-message-transform.test.ts`.
+
+### v1.13.7-dev.1 — Dev Prerelease Sync (master @ v1.13.6)
+
+**Purpose**: Sync the `dev` npm tag (stuck at `1.12.10-dev.1`) with current master. The `dev` tag had fallen far behind `latest` (1.13.6), making it impossible for early adopters to test the latest fixes via `opencode-acp@dev`.
+
+**Content**: Identical to v1.13.6 stable (master HEAD `5d67b84`). No new code changes. This is a dev-tag-only release to bring `opencode-acp@dev` up to parity with `opencode-acp@latest`.
+
+Files: `package.json`, `README.md`, `README.zh-CN.md`. 846 tests pass (no source changes).
+
 ### v1.13.6 — Force-Protect Compress Tool Regardless of User Config (PR #188)
 
 **Problem**: `compress.protectedTools` uses a replace merge policy (PR #177): a user setting `protectedTools: ["skill"]` or `protectedTools: []` silently removed `"compress"` from the protected list. This made compress summaries — the sole record of compressed conversation — vulnerable to being pruned by subsequent sequential compressions, causing irreversible data loss.

package/README.zh-CN.md

@@ -443,6 +443,22 @@ ACP 在首次启动时自动将配置从 `dcp.jsonc` 迁移到 `acp.jsonc`，将
 
 ## 更新日志
 
+### v1.13.7 — 每会话状态隔离 + 失活块修复 + 保留首条用户消息（PR #184、#193、#196）
+
+**问题**：v1.13.6 之后的三个 bug。（1）**子代理状态隔离失败**（PR #184）：ACP 为每个插件实例存储单个全局 `SessionState`。当子代理（child）会话与父会话交替运行时，子会话的状态覆盖了父会话的 `modelContextLimit` —— 丢失 1M 上下文窗口，回退到 6K 自适应下限，导致父会话中过度触发压缩提醒。`compressionTiming` 追踪器也跨会话共享，存在跨会话碰撞风险。（2）**失活块不可见**（PR #193）：`decompress` 拒绝失活块（"not active — may have already been decompressed"），`acp_status` 完全隐藏被消费/失活的块。用户无法解压被 GC 回收或被二次压缩消费的块，也无法在状态输出中看到它们。（3）**零用户消息会话冻结**（PR #196）：当压缩剪枝了所有 user 角色消息（全部落在压缩范围内）时，zhipuai-lb 拒绝请求（HTTP 400，code 1214，`"messages 参数非法"`，`isRetryable: false`），冻结会话。v1.13.2 的 `preserve-last-user` 修复在消息数组中搜索被剪枝的用户消息来恢复 —— 但 OpenCode 压缩移除被剪枝的消息后，搜索找不到任何内容，零用户请求仍然漏过。
+
+**修复**：（1）PR #184 —— 在 `lib/state/state.ts` 引入 `SessionStateRegistry`：一个 `Map<sessionID, SessionState>`，带共享 `compressionTiming` 追踪器和软上限驱逐（32 个会话）。每个会话通过 `registry.getOrCreate(sessionID)` 解析自己的状态，将子代理状态与父会话隔离。系统提示钩子优雅处理缺失状态（提前返回）。同时将过于激进的 `baseline = 0` 改回 `baseline = currentTokens`（系统提示不算增长）。851 项测试通过。（2）PR #193 —— 移除 `lib/compress/decompress.ts` 和 `/acp decompress` 斜杠命令中的 "not active" 拒绝；独立的失活块（用户解压、GC 回收、孤立）现在可以成功解压。`acp_status` 压缩作用域现在列出所有块（活跃 + 失活），带 `[inactive]` 标记和"N active, M inactive/consumed"汇总行。修复 `toFile` 回退使用 `targets[0].blocks[0].summary` 而非未定义的 `activeBlocks[0].summary`。经 3 轮双 Agent 审查后 859 项测试通过。（3）PR #196 —— 在 `lib/messages/prune.ts` 用 `preserve-first-user` 替换 `preserve-last-user`：首条用户消息（会话的原始任务，始终存在于数组中）被无条件强制保留（`survive[firstUserIdx] = true`），无论剪枝状态如何。更简单、更可靠 —— 不依赖于被剪枝消息在 OpenCode 压缩后仍留在数组中。权衡：可能产生两个相邻的用户消息（首条用户 + 后续存活的用户），所有主流 provider 均可接受。经双 Agent 审查（Oracle + General，均 APPROVE）。846 项测试通过。
+
+文件：`lib/state/state.ts`、`lib/hooks.ts`、`lib/compress/types.ts`、`lib/compress/decompress.ts`、`lib/compress/status.ts`、`lib/commands/decompress.ts`、`lib/messages/prune.ts`、`lib/messages/inject/inject.ts`。测试：`tests/registry.test.ts`、`tests/inactive-block-decompress.test.ts`、`tests/acp-status.test.ts`、`tests/decompress-logic.test.ts`、`tests/prune.test.ts`、`tests/e2e-message-transform.test.ts`。
+
+### v1.13.7-dev.1 — Dev 预发布同步（master @ v1.13.6）
+
+**目的**：将 npm `dev` 标签（卡在 `1.12.10-dev.1`）同步到当前 master。`dev` 标签已远远落后于 `latest`（1.13.6），导致早期采用者无法通过 `opencode-acp@dev` 测试最新修复。
+
+**内容**：与 v1.13.6 稳定版完全相同（master HEAD `5d67b84`）。无新代码变更。仅为 dev 标签发布，使 `opencode-acp@dev` 与 `opencode-acp@latest` 保持一致。
+
+文件：`package.json`、`README.md`、`README.zh-CN.md`。846 项测试通过（无源码变更）。
+
 ### v1.13.6 — 强制保护 compress 工具，无视用户配置（PR #188）
 
 **问题**：`compress.protectedTools` 使用替换式合并策略（PR #177）：用户设置 `protectedTools: ["skill"]` 或 `protectedTools: []` 会静默地从保护列表中移除 `"compress"`。这使得 compress 摘要 — 压缩对话的唯一记录 — 容易被后续的顺序压缩裁剪，导致不可恢复的数据丢失。

package/dist/index.js

@@ -1948,6 +1948,23 @@ Using previous/default values`
   return config;
 }
 
+// lib/compress/types.ts
+function resolveToolContext(factoryCtx, sessionID) {
+  const state = factoryCtx.registry.get(sessionID);
+  if (!state) {
+    throw new Error(
+      `ACP: session ${sessionID} has no initialized state. messages.transform must run before a compress tool call.`
+    );
+  }
+  return {
+    client: factoryCtx.client,
+    state,
+    logger: factoryCtx.logger,
+    config: factoryCtx.config,
+    prompts: factoryCtx.prompts
+  };
+}
+
 // lib/compress/message.ts
 import { tool as tool2 } from "@opencode-ai/plugin";
 
@@ -2648,8 +2665,8 @@ function buildSearchPreview(text, firstTerm) {
   }
   return text.substring(0, 200) + (text.length > 200 ? "..." : "");
 }
-function createSearchContextTool(ctx) {
-  ctx.prompts.reload();
+function createSearchContextTool(factoryCtx) {
+  factoryCtx.prompts.reload();
   return tool({
     description: SEARCH_CONTEXT_TOOL_DESCRIPTION,
     args: {
@@ -2657,7 +2674,8 @@ function createSearchContextTool(ctx) {
       limit: tool.schema.number().optional().describe("Maximum results to return (default: 10)"),
       deep: tool.schema.boolean().optional().describe("If true, also search visible (uncompressed) messages. Slower but more thorough (default: false)")
     },
-    async execute(args) {
+    async execute(args, toolCtx) {
+      const ctx = resolveToolContext(factoryCtx, toolCtx.sessionID);
       const query = (args.query || "").toLowerCase().trim();
       const limit = args.limit ?? 10;
       if (!query) {
@@ -3976,12 +3994,6 @@ async function loadAllSessionStats(logger) {
 function buildCompressionTimingKey(messageId, callId) {
   return `${messageId}:${callId}`;
 }
-function consumeCompressionStart(state, messageId, callId) {
-  const key = buildCompressionTimingKey(messageId, callId);
-  const start = state.compressionTiming.startsByCallId.get(key);
-  state.compressionTiming.startsByCallId.delete(key);
-  return start;
-}
 function resolveCompressionDuration(startedAt, eventTime, partTime) {
   const runningAt = typeof partTime?.start === "number" && Number.isFinite(partTime.start) ? partTime.start : eventTime;
   const pendingToRunningMs = typeof startedAt === "number" && typeof runningAt === "number" ? Math.max(0, runningAt - startedAt) : void 0;
@@ -4368,28 +4380,7 @@ function rebuildCompressionState(state, messages, config, logger) {
 }
 
 // lib/state/state.ts
-var checkSession = async (client, state, logger, messages, manualModeDefault, config) => {
-  const lastUserMessage = getLastUserMessage(messages);
-  if (!lastUserMessage) {
-    return;
-  }
-  const lastSessionId = lastUserMessage.info.sessionID;
-  if (state.sessionId === null || state.sessionId !== lastSessionId) {
-    logger.info(`Session changed: ${state.sessionId} -> ${lastSessionId}`);
-    try {
-      await ensureSessionInitialized(
-        client,
-        state,
-        lastSessionId,
-        logger,
-        messages,
-        manualModeDefault,
-        config
-      );
-    } catch (err) {
-      logger.error("Failed to initialize session state", { error: err.message });
-    }
-  }
+async function updatePerTurnState(state, logger, messages) {
   const lastCompactionTimestamp = findLastCompactionTimestamp(messages);
   if (lastCompactionTimestamp > state.lastCompaction) {
     state.lastCompaction = lastCompactionTimestamp;
@@ -4404,6 +4395,66 @@ var checkSession = async (client, state, logger, messages, manualModeDefault, co
     });
   }
   state.currentTurn = countTurns(state, messages);
+}
+var REGISTRY_SOFT_CAP = 32;
+var SessionStateRegistry = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  logger;
+  states = /* @__PURE__ */ new Map();
+  compressionTiming = {
+    startsByCallId: /* @__PURE__ */ new Map(),
+    pendingByCallId: /* @__PURE__ */ new Map()
+  };
+  get(sessionId) {
+    return this.states.get(sessionId);
+  }
+  all() {
+    return Array.from(this.states.values());
+  }
+  get size() {
+    return this.states.size;
+  }
+  // Idempotent: ensureSessionInitialized returns immediately once
+  // state.sessionId === sessionId (assigned synchronously before any await),
+  // so repeat calls for the same session never re-reset.
+  async getOrCreate(client, sessionId, messages, manualModeDefault, config) {
+    let state = this.states.get(sessionId);
+    if (!state) {
+      state = createSessionState();
+      state.compressionTiming = this.compressionTiming;
+      this.states.set(sessionId, state);
+      this.enforceSoftCap();
+    }
+    try {
+      await ensureSessionInitialized(
+        client,
+        state,
+        sessionId,
+        this.logger,
+        messages,
+        manualModeDefault,
+        config
+      );
+    } catch (err) {
+      this.logger.error("Failed to initialize session state", {
+        error: err.message
+      });
+    }
+    return state;
+  }
+  enforceSoftCap() {
+    if (this.states.size <= REGISTRY_SOFT_CAP) return;
+    const oldest = this.states.keys().next().value;
+    if (oldest !== void 0) {
+      this.states.delete(oldest);
+      this.logger.info("SessionStateRegistry evicted session (soft cap)", {
+        sessionId: oldest,
+        remaining: this.states.size
+      });
+    }
+  }
 };
 function createSessionState() {
   return {
@@ -6407,13 +6458,14 @@ function buildSchema(maxSummaryLengthHard) {
     acknowledgeRisk: tool2.schema.boolean().optional()
   };
 }
-function createCompressMessageTool(ctx) {
-  ctx.prompts.reload();
-  const runtimePrompts = ctx.prompts.getRuntimePrompts();
+function createCompressMessageTool(factoryCtx) {
+  factoryCtx.prompts.reload();
+  const runtimePrompts = factoryCtx.prompts.getRuntimePrompts();
   return tool2({
     description: runtimePrompts.compressMessage + MESSAGE_FORMAT_EXTENSION,
-    args: buildSchema(ctx.config.compress.maxSummaryLengthHard),
+    args: buildSchema(factoryCtx.config.compress.maxSummaryLengthHard),
     async execute(args, toolCtx) {
+      const ctx = resolveToolContext(factoryCtx, toolCtx.sessionID);
       const input = args;
       validateArgs(input);
       const maxLen = args.summaryMaxChars ?? ctx.config.compress.maxSummaryLengthHard;
@@ -6620,13 +6672,14 @@ function buildSchema2(maxSummaryLengthHard) {
     acknowledgeRisk: tool3.schema.boolean().optional()
   };
 }
-function createCompressRangeTool(ctx) {
-  ctx.prompts.reload();
-  const runtimePrompts = ctx.prompts.getRuntimePrompts();
+function createCompressRangeTool(factoryCtx) {
+  factoryCtx.prompts.reload();
+  const runtimePrompts = factoryCtx.prompts.getRuntimePrompts();
   return tool3({
     description: runtimePrompts.compressRange + RANGE_FORMAT_EXTENSION,
-    args: buildSchema2(ctx.config.compress.maxSummaryLengthHard),
+    args: buildSchema2(factoryCtx.config.compress.maxSummaryLengthHard),
     async execute(args, toolCtx) {
+      const ctx = resolveToolContext(factoryCtx, toolCtx.sessionID);
       const input = args;
       validateArgs2(input);
       const maxLen = args.summaryMaxChars ?? ctx.config.compress.maxSummaryLengthHard;
@@ -6922,16 +6975,9 @@ var filterCompressedRanges = (state, messages) => {
     }
     return false;
   });
-  const anyUserSurvives = messages.some(
-    (msg, i) => survive[i] && msg.info.role === "user"
-  );
-  if (!anyUserSurvives) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-      if (messages[i].info.role === "user" && !survive[i]) {
-        survive[i] = true;
-        break;
-      }
-    }
+  const firstUserIdx = messages.findIndex((msg) => msg.info.role === "user");
+  if (firstUserIdx >= 0) {
+    survive[firstUserIdx] = true;
   }
   const result = [];
   for (let i = 0; i < messages.length; i++) {
@@ -9080,11 +9126,12 @@ function extractMessageText2(m) {
   return `[${role}]
 ${content}`;
 }
-function createDecompressTool(ctx) {
+function createDecompressTool(factoryCtx) {
   return tool4({
     description: TOOL_DESCRIPTION,
     args: buildSchema3(),
     async execute(args, toolCtx) {
+      const ctx = resolveToolContext(factoryCtx, toolCtx.sessionID);
       const { rawMessages } = await prepareDecompressSession(ctx, toolCtx);
       const contextUsageBefore = ctx.state.modelContextLimit ? Math.round(
         getCurrentTokenUsage(ctx.state, rawMessages) / ctx.state.modelContextLimit * 100
@@ -9437,8 +9484,8 @@ function renderCompressedDrilldown(blocks, sort, limit) {
   );
   return lines;
 }
-function createAcpStatusTool(ctx) {
-  ctx.prompts.reload();
+function createAcpStatusTool(factoryCtx) {
+  factoryCtx.prompts.reload();
   return tool5({
     description: ACP_STATUS_TOOL_DESCRIPTION,
     args: {
@@ -9453,6 +9500,7 @@ function createAcpStatusTool(ctx) {
       limit: tool5.schema.number().optional().describe("Max items to list (default 30)")
     },
     async execute(args, toolCtx) {
+      const ctx = resolveToolContext(factoryCtx, toolCtx.sessionID);
       const scope = args.scope === "compressed" || args.scope === "uncompressed" ? args.scope : void 0;
       const view = args.view === "messages" ? "messages" : "ranges";
       const toolFilter = typeof args.tool === "string" ? args.tool : void 0;
@@ -9514,13 +9562,14 @@ Call this tool to re-fetch a specific block's summary without decompressing the
 
 Args:
 - blockId: optional block number (e.g., 5). If omitted, lists all active blocks with brief info.`;
-function createAcpContextRecapTool(ctx) {
+function createAcpContextRecapTool(factoryCtx) {
   return tool6({
     description: RECAP_TOOL_DESCRIPTION,
     args: {
       blockId: tool6.schema.number().optional().describe("Block number to retrieve (e.g., 5). If omitted, lists all active blocks.")
     },
-    async execute(args) {
+    async execute(args, toolCtx) {
+      const ctx = resolveToolContext(factoryCtx, toolCtx.sessionID);
       const msgState = ctx.state.prune.messages;
       const activeIds = Array.from(msgState.activeBlockIds).sort((a, b) => a - b);
       if (activeIds.length === 0) {
@@ -9567,8 +9616,8 @@ Unlike compress (which creates summaries), prune directly strips tool call outpu
 Args:
 - toolType: tool name to prune (e.g., "todowrite", "bash", "edit")
 - keepLatest: how many recent calls to keep visible (default 3)`;
-function createPruneTool(ctx) {
-  ctx.prompts.reload();
+function createPruneTool(factoryCtx) {
+  factoryCtx.prompts.reload();
   return tool7({
     description: PRUNE_TOOL_DESCRIPTION,
     args: {
@@ -9576,6 +9625,7 @@ function createPruneTool(ctx) {
       keepLatest: tool7.schema.number().optional().describe("How many recent calls to keep visible (default 3)")
     },
     async execute(args, toolCtx) {
+      const ctx = resolveToolContext(factoryCtx, toolCtx.sessionID);
       const keepLatest = args.keepLatest ?? 3;
       const { rawMessages } = await prepareSession(
         ctx,
@@ -11617,12 +11667,13 @@ function isInternalAgentRequest(messages) {
   const agent = lastUserMessage.info.agent;
   return typeof agent === "string" && INTERNAL_AGENT_NAMES.has(agent);
 }
-function createSystemPromptHandler(state, logger, config, prompts) {
+function createSystemPromptHandler(registry3, logger, config, prompts) {
   return async (input, output) => {
-    if (input.model?.limit?.context) {
+    const state = input.sessionID ? registry3.get(input.sessionID) : void 0;
+    if (state && input.model?.limit?.context) {
       state.modelContextLimit = input.model.limit.context;
     }
-    if (state.isSubAgent && !config.experimental.allowSubAgents) {
+    if (!state || state.isSubAgent && !config.experimental.allowSubAgents) {
       return;
     }
     const systemText = output.system.join("\n");
@@ -11630,7 +11681,7 @@ function createSystemPromptHandler(state, logger, config, prompts) {
       logger.info("Skipping DCP system prompt injection for internal agent");
       return;
     }
-    const effectivePermission = input.sessionID && state.sessionId === input.sessionID ? compressPermission(state, config) : config.compress.permission;
+    const effectivePermission = compressPermission(state, config);
     if (effectivePermission === "deny") {
       return;
     }
@@ -11674,7 +11725,7 @@ function runMajorGC(state, config, logger, messages) {
     });
   }
 }
-function createChatMessageTransformHandler(client, state, logger, config, prompts, hostPermissions) {
+function createChatMessageTransformHandler(client, registry3, logger, config, prompts, hostPermissions) {
   return async (input, output) => {
     const receivedMessages = Array.isArray(output.messages) ? output.messages.length : 0;
     const messages = filterMessagesInPlace(output.messages);
@@ -11688,7 +11739,20 @@ function createChatMessageTransformHandler(client, state, logger, config, prompt
       logger.debug("Skipping message transform for internal agent request");
       return;
     }
-    await checkSession(client, state, logger, output.messages, config.manualMode.enabled, config);
+    const lastUserMessage = getLastUserMessage(messages);
+    let state;
+    if (!lastUserMessage) {
+      state = createSessionState();
+    } else {
+      state = await registry3.getOrCreate(
+        client,
+        lastUserMessage.info.sessionID,
+        messages,
+        config.manualMode.enabled,
+        config
+      );
+      await updatePerTurnState(state, logger, messages);
+    }
     syncCompressPermissionState(state, config, hostPermissions, output.messages);
     if (state.isSubAgent && !config.experimental.allowSubAgents) {
       return;
@@ -11753,7 +11817,7 @@ ${text}`);
     }
   };
 }
-function createCommandExecuteHandler(client, state, logger, config, workingDirectory, hostPermissions) {
+function createCommandExecuteHandler(client, registry3, logger, config, workingDirectory, hostPermissions) {
   return async (input, output) => {
     if (!config.commands.enabled) {
       return;
@@ -11763,11 +11827,9 @@ function createCommandExecuteHandler(client, state, logger, config, workingDirec
         path: { id: input.sessionID }
       });
       const messages = filterMessages(messagesResponse.data || messagesResponse);
-      await ensureSessionInitialized(
+      const state = await registry3.getOrCreate(
         client,
-        state,
         input.sessionID,
-        logger,
         messages,
         config.manualMode.enabled,
         config
@@ -11851,7 +11913,7 @@ function createTextCompleteHandler() {
     output.text = stripHallucinationsFromString(output.text);
   };
 }
-function createEventHandler(state, logger) {
+function createEventHandler(registry3, logger) {
   return async (input) => {
     const eventTime = typeof input.event?.time === "number" && Number.isFinite(input.event.time) ? input.event.time : typeof input.event?.properties?.time === "number" && Number.isFinite(input.event.properties.time) ? input.event.properties.time : void 0;
     if (input.event.type !== "message.part.updated") {
@@ -11861,16 +11923,17 @@ function createEventHandler(state, logger) {
     if (part?.type !== "tool" || part.tool !== "compress") {
       return;
     }
+    const timing = registry3.compressionTiming;
     if (part.state.status === "pending") {
       if (typeof part.callID !== "string" || typeof part.messageID !== "string") {
         return;
       }
       const startedAt = eventTime ?? Date.now();
       const key = buildCompressionTimingKey(part.messageID, part.callID);
-      if (state.compressionTiming.startsByCallId.has(key)) {
+      if (timing.startsByCallId.has(key)) {
         return;
       }
-      state.compressionTiming.startsByCallId.set(key, startedAt);
+      timing.startsByCallId.set(key, startedAt);
       logger.debug("Recorded compression start", {
         messageID: part.messageID,
         callID: part.callID,
@@ -11883,34 +11946,36 @@ function createEventHandler(state, logger) {
         return;
       }
       const key = buildCompressionTimingKey(part.messageID, part.callID);
-      const start = consumeCompressionStart(state, part.messageID, part.callID);
+      const start = timing.startsByCallId.get(key);
+      timing.startsByCallId.delete(key);
       const durationMs = resolveCompressionDuration(start, eventTime, part.state.time);
       if (typeof durationMs !== "number") {
         return;
       }
-      state.compressionTiming.pendingByCallId.set(key, {
+      timing.pendingByCallId.set(key, {
         messageId: part.messageID,
         callId: part.callID,
         durationMs
       });
-      const updates = applyPendingCompressionDurations(state);
-      if (updates === 0) {
-        return;
+      for (const state of registry3.all()) {
+        const updates = applyPendingCompressionDurations(state);
+        if (updates > 0) {
+          await saveSessionState(state, logger);
+          logger.info("Attached compression time to blocks", {
+            messageID: part.messageID,
+            callID: part.callID,
+            blocks: updates,
+            durationMs
+          });
+        }
       }
-      await saveSessionState(state, logger);
-      logger.info("Attached compression time to blocks", {
-        messageID: part.messageID,
-        callID: part.callID,
-        blocks: updates,
-        durationMs
-      });
       return;
     }
     if (part.state.status === "running") {
       return;
     }
     if (typeof part.callID === "string" && typeof part.messageID === "string") {
-      state.compressionTiming.startsByCallId.delete(
+      timing.startsByCallId.delete(
         buildCompressionTimingKey(part.messageID, part.callID)
       );
     }
@@ -12097,7 +12162,7 @@ var server = (async (ctx) => {
     return {};
   }
   const logger = new Logger(config.debug);
-  const state = createSessionState();
+  const registry3 = new SessionStateRegistry(logger);
   const prompts = new PromptStore(logger, ctx.directory, config.experimental.customPrompts);
   const hostPermissions = {
     global: void 0,
@@ -12112,21 +12177,21 @@ var server = (async (ctx) => {
   startAutoUpdate(ctx, config.autoUpdate);
   const compressToolContext = {
     client: ctx.client,
-    state,
+    registry: registry3,
     logger,
     config,
     prompts
   };
   return {
     "experimental.chat.system.transform": createSystemPromptHandler(
-      state,
+      registry3,
       logger,
       config,
       prompts
     ),
     "experimental.chat.messages.transform": createChatMessageTransformHandler(
       ctx.client,
-      state,
+      registry3,
       logger,
       config,
       prompts,
@@ -12135,13 +12200,13 @@ var server = (async (ctx) => {
     "experimental.text.complete": createTextCompleteHandler(),
     "command.execute.before": createCommandExecuteHandler(
       ctx.client,
-      state,
+      registry3,
       logger,
       config,
       ctx.directory,
       hostPermissions
     ),
-    event: createEventHandler(state, logger),
+    event: createEventHandler(registry3, logger),
     tool: {
       ...config.compress.permission !== "deny" && {
         compress: config.compress.mode === "message" ? createCompressMessageTool(compressToolContext) : createCompressRangeTool(compressToolContext),