@lexwdex-org/opencode-dcp 3.4.8 → 3.4.9

package/dist/index.js

@@ -912,7 +912,6 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "enabled",
   "autoUpdate",
   "debug",
-  "showUpdateToasts",
   "pruneNotification",
   "pruneNotificationType",
   "turnProtection",
@@ -944,6 +943,11 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "compress.protectTags",
   "compress.protectUserMessages",
   "compress.externalModel",
+  "compress.externalModel.url",
+  "compress.externalModel.model",
+  "compress.externalModel.apiKey",
+  "compress.externalModel.timeout",
+  "compress.externalModel.retries",
   "strategies",
   "strategies.deduplication",
   "strategies.deduplication.enabled",
@@ -1259,6 +1263,12 @@ function validateConfigTypes(config) {
               expected: "string",
               actual: typeof compress.externalModel.url
             });
+          } else if (compress.externalModel.url.trim().length === 0) {
+            errors.push({
+              key: "compress.externalModel.url",
+              expected: "non-empty string",
+              actual: "empty string"
+            });
           }
           if (typeof compress.externalModel.model !== "string") {
             errors.push({
@@ -1266,6 +1276,33 @@ function validateConfigTypes(config) {
               expected: "string",
               actual: typeof compress.externalModel.model
             });
+          } else if (compress.externalModel.model.trim().length === 0) {
+            errors.push({
+              key: "compress.externalModel.model",
+              expected: "non-empty string",
+              actual: "empty string"
+            });
+          }
+          if (compress.externalModel.apiKey !== void 0 && typeof compress.externalModel.apiKey !== "string") {
+            errors.push({
+              key: "compress.externalModel.apiKey",
+              expected: "string",
+              actual: typeof compress.externalModel.apiKey
+            });
+          }
+          if (compress.externalModel.timeout !== void 0 && (typeof compress.externalModel.timeout !== "number" || !Number.isFinite(compress.externalModel.timeout) || compress.externalModel.timeout <= 0)) {
+            errors.push({
+              key: "compress.externalModel.timeout",
+              expected: "positive finite number",
+              actual: JSON.stringify(compress.externalModel.timeout)
+            });
+          }
+          if (compress.externalModel.retries !== void 0 && (!Number.isInteger(compress.externalModel.retries) || compress.externalModel.retries < 0)) {
+            errors.push({
+              key: "compress.externalModel.retries",
+              expected: "non-negative integer",
+              actual: JSON.stringify(compress.externalModel.retries)
+            });
           }
         }
       }
@@ -1746,6 +1783,8 @@ function isProtectedUserMessage(config, message) {
 // lib/token-utils.ts
 var anthropicCountTokens = _anthropicTokenizer.countTokens ?? _anthropicTokenizer.default?.countTokens;
 function getCurrentTokenUsage(state, messages) {
+  let reportedTokens = 0;
+  let lastReportedIndex = -1;
   for (let i = messages.length - 1; i >= 0; i--) {
     const msg = messages[i];
     if (msg.info.role !== "assistant") {
@@ -1756,16 +1795,23 @@ function getCurrentTokenUsage(state, messages) {
       continue;
     }
     if (state.lastCompaction > 0 && (msg.info.time.created < state.lastCompaction || msg.info.summary === true && msg.info.time.created === state.lastCompaction)) {
-      return 0;
+      lastReportedIndex = i;
+      break;
     }
     const input = assistantInfo.tokens?.input || 0;
     const output = assistantInfo.tokens?.output || 0;
     const reasoning = assistantInfo.tokens?.reasoning || 0;
     const cacheRead = assistantInfo.tokens?.cache?.read || 0;
     const cacheWrite = assistantInfo.tokens?.cache?.write || 0;
-    return input + output + reasoning + cacheRead + cacheWrite;
+    reportedTokens = input + output + reasoning + cacheRead + cacheWrite;
+    lastReportedIndex = i;
+    break;
   }
-  return 0;
+  let unreportedTokens = 0;
+  for (let i = lastReportedIndex + 1; i < messages.length; i++) {
+    unreportedTokens += countAllMessageTokens(messages[i]);
+  }
+  return reportedTokens + unreportedTokens;
 }
 function getCurrentParams(state, messages, logger) {
   const userMsg = getLastUserMessage(messages);
@@ -1774,16 +1820,14 @@ function getCurrentParams(state, messages, logger) {
     return {
       providerId: void 0,
       modelId: void 0,
-      agent: void 0,
-      variant: void 0
+      agent: void 0
     };
   }
   const userInfo = userMsg.info;
   const agent = userInfo.agent;
   const providerId = userInfo.model.providerID;
   const modelId = userInfo.model.modelID;
-  const variant = userInfo.model.variant;
-  return { providerId, modelId, agent, variant };
+  return { providerId, modelId, agent };
 }
 function countTokens2(text) {
   if (!text) return 0;
@@ -1828,7 +1872,8 @@ function extractToolContent(part) {
 }
 function countToolTokens(part) {
   const contents = extractToolContent(part);
-  return estimateTokensBatch(contents);
+  if (contents.length === 0) return 0;
+  return Math.ceil(Buffer.byteLength(contents.join(" "), "utf-8") / 4);
 }
 function getTotalToolTokens(state, toolIds) {
   let total = 0;
@@ -1910,7 +1955,7 @@ var MESSAGE_REF_MAX_INDEX = 9999;
 function formatMessageRef(index) {
   if (!Number.isInteger(index) || index < MESSAGE_REF_MIN_INDEX || index > MESSAGE_REF_MAX_INDEX) {
     throw new Error(
-      `Message ID index out of bounds: ${index}. Supported range is 0-${MESSAGE_REF_MAX_INDEX}.`
+      `Message ID index out of bounds: ${index}. Supported range is ${MESSAGE_REF_MIN_INDEX}-${MESSAGE_REF_MAX_INDEX}.`
     );
   }
   return `m${index.toString().padStart(MESSAGE_REF_WIDTH, "0")}`;
@@ -2011,14 +2056,16 @@ function assignMessageRefs(state, messages) {
   return assigned;
 }
 function allocateNextMessageRef(state) {
-  let candidate = Number.isInteger(state.messageIds.nextRef) ? Math.max(MESSAGE_REF_MIN_INDEX, state.messageIds.nextRef) : MESSAGE_REF_MIN_INDEX;
-  while (candidate <= MESSAGE_REF_MAX_INDEX) {
+  const capacity = MESSAGE_REF_MAX_INDEX - MESSAGE_REF_MIN_INDEX + 1;
+  const requested = Number.isInteger(state.messageIds.nextRef) ? state.messageIds.nextRef : MESSAGE_REF_MIN_INDEX;
+  const start = requested >= MESSAGE_REF_MIN_INDEX && requested <= MESSAGE_REF_MAX_INDEX ? requested : MESSAGE_REF_MIN_INDEX;
+  for (let offset = 0; offset < capacity; offset++) {
+    const candidate = MESSAGE_REF_MIN_INDEX + (start - MESSAGE_REF_MIN_INDEX + offset) % capacity;
     const ref = formatMessageRef(candidate);
     if (!state.messageIds.byRef.has(ref)) {
-      state.messageIds.nextRef = candidate + 1;
+      state.messageIds.nextRef = candidate === MESSAGE_REF_MAX_INDEX ? MESSAGE_REF_MIN_INDEX : candidate + 1;
       return ref;
     }
-    candidate++;
   }
   throw new Error(
     `Message ID alias capacity exceeded. Cannot allocate more than ${formatMessageRef(MESSAGE_REF_MAX_INDEX)} aliases in this session.`
@@ -2694,6 +2741,7 @@ function resolveMessage(entry, searchContext, state, config) {
 // lib/state/persistence.ts
 import * as fs from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
+import { randomUUID } from "crypto";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
 
@@ -2932,78 +2980,148 @@ function getActiveSummaryTokenUsage(state) {
   }
   return total;
 }
+var MAX_SUBAGENT_CACHE_ENTRIES = 64;
+var MAX_SUBAGENT_CACHE_CHARS = 5e5;
+var MAX_SUBAGENT_CACHE_TOTAL_CHARS = 2e6;
+function getCachedSubAgentResult(state, callId) {
+  const cached = state.subAgentResultCache.get(callId);
+  if (cached === void 0) return void 0;
+  state.subAgentResultCache.delete(callId);
+  state.subAgentResultCache.set(callId, cached);
+  return cached;
+}
+function cacheSubAgentResult(state, callId, result) {
+  const cached = result.length <= MAX_SUBAGENT_CACHE_CHARS ? result : result.slice(0, MAX_SUBAGENT_CACHE_CHARS) + "\n[\u5B50\u4EE3\u7406\u7ED3\u679C\u56E0\u957F\u5EA6\u9650\u5236\u88AB\u622A\u65AD]";
+  state.subAgentResultCache.delete(callId);
+  state.subAgentResultCache.set(callId, cached);
+  let totalChars = Array.from(state.subAgentResultCache.values()).reduce(
+    (total, value) => total + value.length,
+    0
+  );
+  while (state.subAgentResultCache.size > MAX_SUBAGENT_CACHE_ENTRIES || totalChars > MAX_SUBAGENT_CACHE_TOTAL_CHARS) {
+    const oldest = state.subAgentResultCache.keys().next().value;
+    if (typeof oldest !== "string") break;
+    totalChars -= state.subAgentResultCache.get(oldest)?.length ?? 0;
+    state.subAgentResultCache.delete(oldest);
+  }
+  return cached;
+}
 function resetOnCompaction(state, messages = []) {
   state.toolParameters.clear();
   if (messages.length === 0) {
     return;
   }
   const liveMessageIds = new Set(messages.map((msg) => msg.info.id));
+  const liveToolIds = new Set(
+    messages.flatMap(
+      (message) => message.parts.flatMap(
+        (part) => part.type === "tool" && part.callID ? [part.callID] : []
+      )
+    )
+  );
   for (const [ref, rawId] of state.messageIds.byRef) {
     if (!liveMessageIds.has(rawId)) {
       state.messageIds.byRef.delete(ref);
       state.messageIds.byRawId.delete(rawId);
     }
   }
+  for (const callId of state.subAgentResultCache.keys()) {
+    if (!liveToolIds.has(callId)) state.subAgentResultCache.delete(callId);
+  }
+}
+
+// lib/concurrency.ts
+async function runWithConcurrency(items, concurrency, task) {
+  let nextIndex = 0;
+  const workerCount = Math.min(items.length, Math.max(1, Math.floor(concurrency)));
+  const workers = Array.from({ length: workerCount }, async () => {
+    for (; ; ) {
+      const index = nextIndex++;
+      if (index >= items.length) return;
+      await task(items[index]);
+    }
+  });
+  await Promise.all(workers);
 }
 
 // lib/state/persistence.ts
-var STORAGE_DIR = join2(
-  process.env.XDG_DATA_HOME || join2(homedir2(), ".local", "share"),
-  "opencode",
-  "storage",
-  "plugin",
-  "dcp"
-);
+var saveQueues = /* @__PURE__ */ new Map();
+function getStorageDir() {
+  return join2(
+    process.env.XDG_DATA_HOME || join2(homedir2(), ".local", "share"),
+    "opencode",
+    "storage",
+    "plugin",
+    "dcp"
+  );
+}
 async function ensureStorageDir() {
-  if (!existsSync2(STORAGE_DIR)) {
-    await fs.mkdir(STORAGE_DIR, { recursive: true });
+  const storageDir = getStorageDir();
+  if (!existsSync2(storageDir)) {
+    await fs.mkdir(storageDir, { recursive: true });
   }
 }
 function getSessionFilePath(sessionId) {
-  return join2(STORAGE_DIR, `${sessionId}.json`);
+  return join2(getStorageDir(), `${sessionId}.json`);
 }
 async function writePersistedSessionState(sessionId, state, logger) {
   await ensureStorageDir();
   const filePath = getSessionFilePath(sessionId);
+  const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
   const content = JSON.stringify(state, null, 2);
-  await fs.writeFile(filePath, content, "utf-8");
+  try {
+    await fs.writeFile(temporaryPath, content, "utf-8");
+    await fs.rename(temporaryPath, filePath);
+  } catch (error) {
+    await fs.unlink(temporaryPath).catch(() => void 0);
+    throw error;
+  }
   logger.info("Saved session state to disk", {
     sessionId,
     totalTokensSaved: state.stats.totalPruneTokens
   });
 }
 async function saveSessionState(sessionState, logger, sessionName) {
-  try {
-    if (!sessionState.sessionId) {
-      return;
+  if (!sessionState.sessionId) {
+    return;
+  }
+  const sessionId = sessionState.sessionId;
+  const state = {
+    sessionName,
+    manualMode: !!sessionState.manualMode,
+    prune: {
+      tools: Object.fromEntries(sessionState.prune.tools),
+      messages: serializePruneMessagesState(sessionState.prune.messages)
+    },
+    nudges: {
+      contextLimitAnchors: Array.from(sessionState.nudges.contextLimitAnchors),
+      turnNudgeAnchors: Array.from(sessionState.nudges.turnNudgeAnchors),
+      iterationNudgeAnchors: Array.from(sessionState.nudges.iterationNudgeAnchors)
+    },
+    stats: { ...sessionState.stats },
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    lastCompaction: sessionState.lastCompaction,
+    messageIds: {
+      byRawId: Object.fromEntries(sessionState.messageIds.byRawId),
+      byRef: Object.fromEntries(sessionState.messageIds.byRef),
+      nextRef: sessionState.messageIds.nextRef
     }
-    const state = {
-      sessionName,
-      manualMode: !!sessionState.manualMode,
-      prune: {
-        tools: Object.fromEntries(sessionState.prune.tools),
-        messages: serializePruneMessagesState(sessionState.prune.messages)
-      },
-      nudges: {
-        contextLimitAnchors: Array.from(sessionState.nudges.contextLimitAnchors),
-        turnNudgeAnchors: Array.from(sessionState.nudges.turnNudgeAnchors),
-        iterationNudgeAnchors: Array.from(sessionState.nudges.iterationNudgeAnchors)
-      },
-      stats: sessionState.stats,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-      lastCompaction: sessionState.lastCompaction,
-      messageIds: {
-        byRawId: Object.fromEntries(sessionState.messageIds.byRawId),
-        byRef: Object.fromEntries(sessionState.messageIds.byRef),
-        nextRef: sessionState.messageIds.nextRef
-      }
-    };
-    await writePersistedSessionState(sessionState.sessionId, state, logger);
+  };
+  const previous = saveQueues.get(sessionId) ?? Promise.resolve();
+  const current = previous.catch(() => void 0).then(() => writePersistedSessionState(sessionId, state, logger));
+  saveQueues.set(sessionId, current);
+  try {
+    await current;
   } catch (error) {
     logger.error("Failed to save session state", {
-      sessionId: sessionState.sessionId,
+      sessionId,
       error: error?.message
     });
+    throw error;
+  } finally {
+    if (saveQueues.get(sessionId) === current) {
+      saveQueues.delete(sessionId);
+    }
   }
 }
 async function loadSessionState(sessionId, logger) {
@@ -3082,14 +3200,15 @@ async function loadAllSessionStats(logger) {
     sessionCount: 0
   };
   try {
-    if (!existsSync2(STORAGE_DIR)) {
+    const storageDir = getStorageDir();
+    if (!existsSync2(storageDir)) {
       return result;
     }
-    const files = await fs.readdir(STORAGE_DIR);
+    const files = await fs.readdir(storageDir);
     const jsonFiles = files.filter((f) => f.endsWith(".json"));
-    for (const file of jsonFiles) {
+    await runWithConcurrency(jsonFiles, 16, async (file) => {
       try {
-        const filePath = join2(STORAGE_DIR, file);
+        const filePath = join2(storageDir, file);
         const content = await fs.readFile(filePath, "utf-8");
         const state = JSON.parse(content);
         if (state?.stats?.totalPruneTokens && state?.prune) {
@@ -3100,7 +3219,7 @@ async function loadAllSessionStats(logger) {
         }
       } catch {
       }
-    }
+    });
     logger.debug("Loaded all-time stats", result);
   } catch (error) {
     logger.warn("Failed to load all-time stats", { error: error?.message });
@@ -3109,6 +3228,8 @@ async function loadAllSessionStats(logger) {
 }
 
 // lib/compress/timing.ts
+var MAX_TIMING_ENTRIES = 2048;
+var TIMING_TTL_MS = 30 * 60 * 1e3;
 function buildCompressionTimingKey(messageId, callId) {
   return `${messageId}:${callId}`;
 }
@@ -3116,8 +3237,26 @@ function consumeCompressionStart(state, messageId, callId) {
   const key = buildCompressionTimingKey(messageId, callId);
   const start = state.compressionTiming.startsByCallId.get(key);
   state.compressionTiming.startsByCallId.delete(key);
+  state.compressionTiming.recordedAtByCallId.delete(key);
   return start;
 }
+function pruneCompressionTiming(state, now = Date.now()) {
+  const timing = state.compressionTiming;
+  const cutoff = now - TIMING_TTL_MS;
+  for (const [key, recordedAt] of timing.recordedAtByCallId) {
+    if (recordedAt >= cutoff) continue;
+    timing.recordedAtByCallId.delete(key);
+    timing.startsByCallId.delete(key);
+    timing.pendingByCallId.delete(key);
+  }
+  while (timing.recordedAtByCallId.size > MAX_TIMING_ENTRIES) {
+    const oldest = timing.recordedAtByCallId.keys().next().value;
+    if (typeof oldest !== "string") break;
+    timing.recordedAtByCallId.delete(oldest);
+    timing.startsByCallId.delete(oldest);
+    timing.pendingByCallId.delete(oldest);
+  }
+}
 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;
@@ -3141,24 +3280,165 @@ function applyPendingCompressionDurations(state) {
     if (applied > 0) {
       updates += applied;
       state.compressionTiming.pendingByCallId.delete(key);
+      state.compressionTiming.recordedAtByCallId.delete(key);
     }
   }
   return updates;
 }
 
+// lib/state/store.ts
+var MAX_RESIDENT_SESSIONS = 64;
+var MAX_MESSAGE_OWNERS = 2e4;
+var MAX_TIMING_ENTRIES2 = 2048;
+var TIMING_TTL_MS2 = 30 * 60 * 1e3;
+var SessionStateStore = class {
+  constructor(createState) {
+    this.createState = createState;
+  }
+  states = /* @__PURE__ */ new Map();
+  initializationQueues = /* @__PURE__ */ new Map();
+  messageOwners = /* @__PURE__ */ new Map();
+  orphanStarts = /* @__PURE__ */ new Map();
+  orphanPending = /* @__PURE__ */ new Map();
+  get(sessionId) {
+    const existing = this.states.get(sessionId);
+    if (existing) {
+      this.touch(sessionId, existing);
+      return existing;
+    }
+    const state = this.createState();
+    this.states.set(sessionId, state);
+    this.trimSessions();
+    return state;
+  }
+  peek(sessionId) {
+    return this.states.get(sessionId);
+  }
+  async initialize(sessionId, initializer) {
+    const state = this.get(sessionId);
+    const previous = this.initializationQueues.get(sessionId) ?? Promise.resolve();
+    const current = previous.catch(() => void 0).then(() => initializer(state));
+    this.initializationQueues.set(sessionId, current);
+    try {
+      await current;
+    } finally {
+      if (this.initializationQueues.get(sessionId) === current) {
+        this.initializationQueues.delete(sessionId);
+      }
+    }
+    return state;
+  }
+  registerMessages(sessionId, messages) {
+    const state = this.get(sessionId);
+    for (const message of messages) {
+      const messageId = message.info?.id;
+      if (typeof messageId !== "string") continue;
+      this.messageOwners.delete(messageId);
+      this.messageOwners.set(messageId, sessionId);
+      this.moveOrphanTiming(messageId, state.compressionTiming);
+    }
+    while (this.messageOwners.size > MAX_MESSAGE_OWNERS) {
+      const oldest = this.messageOwners.keys().next().value;
+      if (typeof oldest !== "string") break;
+      this.messageOwners.delete(oldest);
+    }
+    return state;
+  }
+  resolveEventState(sessionId, messageId) {
+    const resolvedSessionId = sessionId ?? this.messageOwners.get(messageId);
+    if (!resolvedSessionId) return void 0;
+    this.messageOwners.set(messageId, resolvedSessionId);
+    return this.get(resolvedSessionId);
+  }
+  recordOrphanStart(key, startedAt) {
+    this.pruneOrphanTiming();
+    if (this.orphanStarts.has(key)) return;
+    this.orphanStarts.set(key, { startedAt, recordedAt: Date.now() });
+    this.trimMap(this.orphanStarts);
+  }
+  consumeOrphanStart(key) {
+    const entry = this.orphanStarts.get(key);
+    this.orphanStarts.delete(key);
+    return entry?.startedAt;
+  }
+  recordOrphanPending(key, entry) {
+    this.pruneOrphanTiming();
+    this.orphanPending.set(key, { ...entry, recordedAt: Date.now() });
+    this.trimMap(this.orphanPending);
+  }
+  deleteOrphanStart(key) {
+    this.orphanStarts.delete(key);
+  }
+  moveOrphanTiming(messageId, timing) {
+    const prefix = `${messageId}:`;
+    for (const [key, entry] of this.orphanStarts) {
+      if (!key.startsWith(prefix)) continue;
+      if (!timing.startsByCallId.has(key)) {
+        timing.startsByCallId.set(key, entry.startedAt);
+      }
+      timing.recordedAtByCallId.set(key, entry.recordedAt);
+      this.orphanStarts.delete(key);
+    }
+    for (const [key, entry] of this.orphanPending) {
+      if (!key.startsWith(prefix)) continue;
+      timing.pendingByCallId.set(key, {
+        messageId: entry.messageId,
+        callId: entry.callId,
+        durationMs: entry.durationMs
+      });
+      timing.recordedAtByCallId.set(key, entry.recordedAt);
+      this.orphanPending.delete(key);
+    }
+  }
+  touch(sessionId, state) {
+    this.states.delete(sessionId);
+    this.states.set(sessionId, state);
+  }
+  trimSessions() {
+    while (this.states.size > MAX_RESIDENT_SESSIONS) {
+      const oldest = Array.from(this.states.keys()).find(
+        (sessionId) => !this.initializationQueues.has(sessionId)
+      );
+      if (!oldest) return;
+      this.states.delete(oldest);
+      for (const [messageId, owner] of this.messageOwners) {
+        if (owner === oldest) this.messageOwners.delete(messageId);
+      }
+    }
+  }
+  pruneOrphanTiming() {
+    const cutoff = Date.now() - TIMING_TTL_MS2;
+    for (const [key, entry] of this.orphanStarts) {
+      if (entry.recordedAt < cutoff) this.orphanStarts.delete(key);
+    }
+    for (const [key, entry] of this.orphanPending) {
+      if (entry.recordedAt < cutoff) this.orphanPending.delete(key);
+    }
+  }
+  trimMap(map) {
+    while (map.size > MAX_TIMING_ENTRIES2) {
+      const oldest = map.keys().next().value;
+      if (typeof oldest !== "string") return;
+      map.delete(oldest);
+    }
+  }
+};
+function resolveSessionState(target, sessionId) {
+  return target instanceof SessionStateStore ? target.get(sessionId) : target;
+}
+
 // lib/state/state.ts
-var checkSession = async (client, state, logger, messages, manualModeDefault) => {
+var checkSession = async (client, target, logger, messages, manualModeDefault) => {
   const lastUserMessage = getLastUserMessage(messages);
-  if (!lastUserMessage) {
-    return;
-  }
-  const lastSessionId = lastUserMessage.info.sessionID;
+  const lastSessionId = lastUserMessage?.info.sessionID ?? messages.findLast((message) => typeof message.info?.sessionID === "string")?.info.sessionID;
+  if (!lastSessionId) return target instanceof SessionStateStore ? void 0 : target;
+  const state = target instanceof SessionStateStore ? target.registerMessages(lastSessionId, messages) : resolveSessionState(target, lastSessionId);
   if (state.sessionId === null || state.sessionId !== lastSessionId) {
     logger.info(`Session changed: ${state.sessionId} -> ${lastSessionId}`);
     try {
-      await ensureSessionInitialized(
+      await initializeSessionState(
         client,
-        state,
+        target,
         lastSessionId,
         logger,
         messages,
@@ -3182,6 +3462,7 @@ var checkSession = async (client, state, logger, messages, manualModeDefault) =>
     });
   }
   state.currentTurn = countTurns(state, messages);
+  return state;
 };
 function createSessionState() {
   return {
@@ -3205,7 +3486,8 @@ function createSessionState() {
     },
     compressionTiming: {
       startsByCallId: /* @__PURE__ */ new Map(),
-      pendingByCallId: /* @__PURE__ */ new Map()
+      pendingByCallId: /* @__PURE__ */ new Map(),
+      recordedAtByCallId: /* @__PURE__ */ new Map()
     },
     toolParameters: /* @__PURE__ */ new Map(),
     subAgentResultCache: /* @__PURE__ */ new Map(),
@@ -3222,6 +3504,7 @@ function createSessionState() {
   };
 }
 function resetSessionState(state) {
+  const modelContextLimit = state.modelContextLimit;
   state.sessionId = null;
   state.isSubAgent = false;
   state.manualMode = false;
@@ -3250,9 +3533,20 @@ function resetSessionState(state) {
   };
   state.lastCompaction = 0;
   state.currentTurn = 0;
-  state.modelContextLimit = void 0;
+  state.modelContextLimit = modelContextLimit;
   state.systemPromptTokens = void 0;
 }
+async function initializeSessionState(client, target, sessionId, logger, messages, manualModeEnabled) {
+  if (target instanceof SessionStateStore) {
+    target.registerMessages(sessionId, messages);
+    return target.initialize(
+      sessionId,
+      (state) => ensureSessionInitialized(client, state, sessionId, logger, messages, manualModeEnabled)
+    );
+  }
+  await ensureSessionInitialized(client, target, sessionId, logger, messages, manualModeEnabled);
+  return target;
+}
 async function ensureSessionInitialized(client, state, sessionId, logger, messages, manualModeEnabled) {
   if (state.sessionId === sessionId) {
     return;
@@ -3316,6 +3610,7 @@ function syncToolCache(state, config, logger, messages) {
   try {
     logger.info("Syncing tool parameters from OpenCode messages");
     let turnCounter = 0;
+    const candidates = /* @__PURE__ */ new Map();
     for (const msg of messages) {
       if (isMessageCompacted(state, msg)) {
         continue;
@@ -3329,26 +3624,35 @@ function syncToolCache(state, config, logger, messages) {
         if (part.type !== "tool" || !part.callID) {
           continue;
         }
-        const turnProtectionEnabled = config.turnProtection.enabled;
-        const turnProtectionTurns = config.turnProtection.turns;
-        const isProtectedByTurn = turnProtectionEnabled && turnProtectionTurns > 0 && state.currentTurn - turnCounter < turnProtectionTurns;
-        if (state.toolParameters.has(part.callID)) {
-          continue;
-        }
-        if (isProtectedByTurn) {
-          continue;
-        }
-        const tokenCount = countToolTokens(part);
-        state.toolParameters.set(part.callID, {
-          tool: part.tool,
-          parameters: part.state?.input ?? {},
-          status: part.state.status,
-          error: part.state.status === "error" ? part.state.error : void 0,
-          turn: turnCounter,
-          tokenCount
-        });
+        candidates.delete(part.callID);
+        candidates.set(part.callID, { part, turn: turnCounter });
+      }
+    }
+    const recentCandidates = Array.from(candidates.entries()).filter(([, candidate]) => {
+      const turnProtectionEnabled = config.turnProtection.enabled;
+      const turnProtectionTurns = config.turnProtection.turns;
+      return !(turnProtectionEnabled && turnProtectionTurns > 0 && state.currentTurn - candidate.turn < turnProtectionTurns);
+    }).slice(-MAX_TOOL_CACHE_SIZE);
+    const retainedIds = new Set(recentCandidates.map(([callId]) => callId));
+    for (const callId of state.toolParameters.keys()) {
+      if (!retainedIds.has(callId)) state.toolParameters.delete(callId);
+    }
+    for (const [callId, { part, turn }] of recentCandidates) {
+      const status = part.state.status;
+      const cached = state.toolParameters.get(callId);
+      if (cached?.status === status) continue;
+      const tokenCount = countToolTokens(part);
+      state.toolParameters.set(callId, {
+        tool: part.tool,
+        parameters: part.state?.input ?? {},
+        status,
+        error: part.state.status === "error" ? part.state.error : void 0,
+        turn,
+        tokenCount
+      });
+      if (!cached) {
         logger.info(
-          `Cached tool id: ${part.callID} (turn ${turnCounter}${tokenCount !== void 0 ? `, ${tokenCount} tokens` : ""})`
+          `Cached tool id: ${callId} (turn ${turn}${tokenCount !== void 0 ? `, ${tokenCount} tokens` : ""})`
         );
       }
     }
@@ -3494,6 +3798,9 @@ var deduplicate = (state, logger, config, messages) => {
     if (!metadata) {
       continue;
     }
+    if (metadata.status !== void 0 && metadata.status !== "completed" && metadata.status !== "success") {
+      continue;
+    }
     if (isToolNameProtected(metadata.tool, protectedTools)) {
       continue;
     }
@@ -3991,7 +4298,6 @@ ${progressBar}`;
 }
 async function sendIgnoredMessage(client, sessionID, text, params, logger) {
   const agent = params.agent || void 0;
-  const variant = params.variant || void 0;
   const model = params.providerId && params.modelId ? {
     providerID: params.providerId,
     modelID: params.modelId
@@ -4005,7 +4311,6 @@ async function sendIgnoredMessage(client, sessionID, text, params, logger) {
         noReply: true,
         agent,
         model,
-        variant,
         parts: [
           {
             type: "text",
@@ -4022,7 +4327,18 @@ async function sendIgnoredMessage(client, sessionID, text, params, logger) {
 
 // lib/compress/pipeline.ts
 async function prepareSession(ctx, toolCtx, title) {
-  if (ctx.state.manualMode && ctx.state.manualMode !== "compress-pending") {
+  const state = resolveSessionState(ctx.state, toolCtx.sessionID);
+  toolCtx.metadata({ title });
+  const rawMessages = await fetchSessionMessages(ctx.client, toolCtx.sessionID);
+  await initializeSessionState(
+    ctx.client,
+    ctx.state,
+    toolCtx.sessionID,
+    ctx.logger,
+    rawMessages,
+    ctx.config.manualMode.enabled
+  );
+  if (state.manualMode && state.manualMode !== "compress-pending") {
     throw new Error(
       "Manual mode: compress blocked. Do not retry until `<compress triggered manually>` appears in user context."
     );
@@ -4033,35 +4349,26 @@ async function prepareSession(ctx, toolCtx, title) {
     always: ["*"],
     metadata: {}
   });
-  toolCtx.metadata({ title });
-  const rawMessages = await fetchSessionMessages(ctx.client, toolCtx.sessionID);
-  await ensureSessionInitialized(
-    ctx.client,
-    ctx.state,
-    toolCtx.sessionID,
-    ctx.logger,
-    rawMessages,
-    ctx.config.manualMode.enabled
-  );
-  assignMessageRefs(ctx.state, rawMessages);
-  deduplicate(ctx.state, ctx.logger, ctx.config, rawMessages);
-  purgeErrors(ctx.state, ctx.logger, ctx.config, rawMessages);
+  assignMessageRefs(state, rawMessages);
+  deduplicate(state, ctx.logger, ctx.config, rawMessages);
+  purgeErrors(state, ctx.logger, ctx.config, rawMessages);
   return {
+    state,
     rawMessages,
-    searchContext: buildSearchContext(ctx.state, rawMessages)
+    searchContext: buildSearchContext(state, rawMessages)
   };
 }
-async function finalizeSession(ctx, toolCtx, rawMessages, entries, batchTopic) {
-  ctx.state.manualMode = ctx.state.manualMode ? "active" : false;
-  applyPendingCompressionDurations(ctx.state);
-  await saveSessionState(ctx.state, ctx.logger);
-  const params = getCurrentParams(ctx.state, rawMessages, ctx.logger);
+async function finalizeSession(ctx, state, toolCtx, rawMessages, entries, batchTopic) {
+  state.manualMode = state.manualMode ? "active" : false;
+  applyPendingCompressionDurations(state);
+  await saveSessionState(state, ctx.logger);
+  const params = getCurrentParams(state, rawMessages, ctx.logger);
   const sessionMessageIds = rawMessages.filter((msg) => !isIgnoredUserMessage(msg)).map((msg) => msg.info.id);
   await sendCompressNotification(
     ctx.client,
     ctx.logger,
     ctx.config,
-    ctx.state,
+    state,
     toolCtx.sessionID,
     entries,
     batchTopic,
@@ -4220,7 +4527,7 @@ async function appendProtectedTools(client, state, allowSubAgents, summary, sele
             output = typeof part.state.output === "string" ? part.state.output : JSON.stringify(part.state.output);
           }
           if (allowSubAgents && part.tool === "task" && part.state?.status === "completed" && typeof part.state?.output === "string") {
-            const cachedSubAgentResult = state.subAgentResultCache.get(part.callID);
+            const cachedSubAgentResult = getCachedSubAgentResult(state, part.callID);
             if (cachedSubAgentResult !== void 0) {
               if (cachedSubAgentResult) {
                 output = mergeSubagentResult(
@@ -4242,7 +4549,11 @@ async function appendProtectedTools(client, state, allowSubAgents, summary, sele
                   subAgentResultText = "";
                 }
                 if (subAgentResultText) {
-                  state.subAgentResultCache.set(part.callID, subAgentResultText);
+                  subAgentResultText = cacheSubAgentResult(
+                    state,
+                    part.callID,
+                    subAgentResultText
+                  );
                   output = mergeSubagentResult(
                     part.state.output,
                     subAgentResultText
@@ -4350,6 +4661,21 @@ async function callExternalModel(endpoint, cfg, req) {
   return content;
 }
 async function generateSummaryViaExternal(cfg, req) {
+  if (typeof cfg.url !== "string" || cfg.url.trim().length === 0) {
+    throw new Error("\u5916\u90E8\u538B\u7F29\u6A21\u578B url \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+  }
+  if (typeof cfg.model !== "string" || cfg.model.trim().length === 0) {
+    throw new Error("\u5916\u90E8\u538B\u7F29\u6A21\u578B model \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+  }
+  if (cfg.apiKey !== void 0 && typeof cfg.apiKey !== "string") {
+    throw new Error("\u5916\u90E8\u538B\u7F29\u6A21\u578B apiKey \u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+  }
+  if (cfg.timeout !== void 0 && (!Number.isFinite(cfg.timeout) || cfg.timeout <= 0)) {
+    throw new Error("\u5916\u90E8\u538B\u7F29\u6A21\u578B timeout \u5FC5\u987B\u662F\u6B63\u6570");
+  }
+  if (cfg.retries !== void 0 && (!Number.isInteger(cfg.retries) || cfg.retries < 0)) {
+    throw new Error("\u5916\u90E8\u538B\u7F29\u6A21\u578B retries \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570");
+  }
   const endpoint = resolveCompressBaseUrl(cfg.url);
   const maxRetries = cfg.retries ?? 1;
   let lastError;
@@ -4363,18 +4689,57 @@ async function generateSummaryViaExternal(cfg, req) {
   throw lastError;
 }
 
-// lib/compress/message.ts
-function extractMessageText(messageId, searchContext) {
-  const msg = searchContext.rawMessagesById.get(messageId);
-  if (!msg) return "";
-  const parts = [];
-  for (const part of msg.parts) {
-    if (part.type === "text" && typeof part.text === "string") {
-      parts.push(part.text);
+// lib/compress/external-content.ts
+var MAX_PART_CHARS = 1e5;
+var MAX_TOTAL_CHARS = 1e6;
+var TRUNCATED_MARKER = "\n[\u5185\u5BB9\u56E0\u957F\u5EA6\u9650\u5236\u88AB\u622A\u65AD]";
+function stringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value, null, 2) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function truncate2(value, limit = MAX_PART_CHARS) {
+  if (value.length <= limit) return value;
+  return value.slice(0, limit) + TRUNCATED_MARKER;
+}
+function serializePart(part) {
+  if (part.type === "text" && typeof part.text === "string") {
+    return [truncate2(part.text)];
+  }
+  if (part.type !== "tool") return [];
+  const chunks = [`[\u5DE5\u5177\uFF1A${part.tool}\uFF1B\u72B6\u6001\uFF1A${part.state.status}]`];
+  if (part.state.input !== void 0) {
+    chunks.push("\u8F93\u5165\uFF1A\n" + truncate2(stringify(part.state.input)));
+  }
+  if (part.state.status === "completed" && part.state.output !== void 0) {
+    chunks.push("\u8F93\u51FA\uFF1A\n" + truncate2(stringify(part.state.output)));
+  } else if (part.state.status === "error" && part.state.error !== void 0) {
+    chunks.push("\u9519\u8BEF\uFF1A\n" + truncate2(stringify(part.state.error)));
+  }
+  return chunks;
+}
+function serializeMessagesForExternalSummary(messages) {
+  const chunks = [];
+  let length = 0;
+  for (const message of messages) {
+    const header = `[\u6D88\u606F\uFF1A${message.info.id}\uFF1B\u89D2\u8272\uFF1A${message.info.role}]`;
+    const content = [header, ...message.parts.flatMap(serializePart)].join("\n");
+    if (length + content.length > MAX_TOTAL_CHARS) {
+      const remaining = Math.max(0, MAX_TOTAL_CHARS - length);
+      if (remaining > 0) chunks.push(content.slice(0, remaining));
+      chunks.push(TRUNCATED_MARKER.trim());
+      break;
     }
+    chunks.push(content);
+    length += content.length;
   }
-  return parts.join("\n\n");
+  return chunks.join("\n\n");
 }
+
+// lib/compress/message.ts
 function buildSchema(externalModelEnabled) {
   const summaryField = externalModelEnabled ? tool.schema.string().optional().describe(
     "Complete technical summary replacing that one message (optional when external model is configured)"
@@ -4403,7 +4768,7 @@ function createCompressMessageTool(ctx) {
       const input = args;
       validateArgs(input);
       const callId = typeof toolCtx.callID === "string" ? toolCtx.callID : void 0;
-      const { rawMessages, searchContext } = await prepareSession(
+      const { state, rawMessages, searchContext } = await prepareSession(
         ctx,
         toolCtx,
         `Compress Message: ${input.topic}`
@@ -4411,26 +4776,27 @@ function createCompressMessageTool(ctx) {
       const { plans, skippedIssues, skippedCount } = resolveMessages(
         input,
         searchContext,
-        ctx.state,
+        state,
         ctx.config
       );
       if (plans.length === 0 && skippedCount > 0) {
         throw new Error(formatIssues(skippedIssues, skippedCount));
       }
-      if (ctx.config.compress.externalModel) {
-        for (const plan of plans) {
+      const externalModel = ctx.config.compress.externalModel;
+      if (externalModel) {
+        await runWithConcurrency(plans, 3, async (plan) => {
           if (plan.entry.summary === void 0) {
-            const userContent = extractMessageText(plan.entry.messageId, searchContext);
-            const generated = await generateSummaryViaExternal(
-              ctx.config.compress.externalModel,
-              {
-                systemPrompt: runtimePrompts.compressMessage,
-                userContent
-              }
+            const message = searchContext.rawMessagesById.get(plan.entry.messageId);
+            const userContent = serializeMessagesForExternalSummary(
+              message ? [message] : []
             );
+            const generated = await generateSummaryViaExternal(externalModel, {
+              systemPrompt: runtimePrompts.compressMessage,
+              userContent
+            });
             plan.entry.summary = generated;
           }
-        }
+        });
       }
       const notifications = [];
       const preparedPlans = [];
@@ -4444,12 +4810,12 @@ function createCompressMessageTool(ctx) {
           plan.entry.summary,
           plan.selection,
           searchContext,
-          ctx.state,
+          state,
           ctx.config.compress.protectTags
         );
         const summaryWithTools = await appendProtectedTools(
           ctx.client,
-          ctx.state,
+          state,
           ctx.config.experimental.allowSubAgents,
           summaryWithPromptInfo,
           plan.selection,
@@ -4462,13 +4828,13 @@ function createCompressMessageTool(ctx) {
           summaryWithTools
         });
       }
-      const runId = allocateRunId(ctx.state);
+      const runId = allocateRunId(state);
       for (const { plan, summaryWithTools } of preparedPlans) {
-        const blockId = allocateBlockId(ctx.state);
+        const blockId = allocateBlockId(state);
         const storedSummary = wrapCompressedSummary(blockId, summaryWithTools);
         const summaryTokens = countTokens2(storedSummary);
         applyCompressionState(
-          ctx.state,
+          state,
           {
             topic: plan.entry.topic,
             batchTopic: input.topic,
@@ -4493,7 +4859,7 @@ function createCompressMessageTool(ctx) {
           summaryTokens
         });
       }
-      await finalizeSession(ctx, toolCtx, rawMessages, notifications, input.topic);
+      await finalizeSession(ctx, state, toolCtx, rawMessages, notifications, input.topic);
       return formatResult(plans.length, skippedIssues, skippedCount);
     }
   });
@@ -4729,19 +5095,6 @@ ${right}`;
 }
 
 // lib/compress/range.ts
-function extractRangeText(selection, searchContext) {
-  const parts = [];
-  for (const messageId of selection.messageIds) {
-    const msg = searchContext.rawMessagesById.get(messageId);
-    if (!msg) continue;
-    for (const part of msg.parts) {
-      if (part.type === "text" && typeof part.text === "string") {
-        parts.push(part.text);
-      }
-    }
-  }
-  return parts.join("\n\n");
-}
 function buildSchema2(externalModelEnabled) {
   const summaryField = externalModelEnabled ? tool2.schema.string().optional().describe(
     "Complete technical summary replacing all content in range (optional when external model is configured)"
@@ -4774,27 +5127,29 @@ function createCompressRangeTool(ctx) {
       const input = args;
       validateArgs2(input);
       const callId = typeof toolCtx.callID === "string" ? toolCtx.callID : void 0;
-      const { rawMessages, searchContext } = await prepareSession(
+      const { state, rawMessages, searchContext } = await prepareSession(
         ctx,
         toolCtx,
         `Compress Range: ${input.topic}`
       );
-      const resolvedPlans = resolveRanges(input, searchContext, ctx.state);
+      const resolvedPlans = resolveRanges(input, searchContext, state);
       validateNonOverlapping(resolvedPlans);
-      if (ctx.config.compress.externalModel) {
-        for (const plan of resolvedPlans) {
+      const externalModel = ctx.config.compress.externalModel;
+      if (externalModel) {
+        await runWithConcurrency(resolvedPlans, 3, async (plan) => {
           if (plan.entry.summary === void 0) {
-            const userContent = extractRangeText(plan.selection, searchContext);
-            const generated = await generateSummaryViaExternal(
-              ctx.config.compress.externalModel,
-              {
-                systemPrompt: runtimePrompts.compressRange,
-                userContent
-              }
-            );
+            const selectedMessages = plan.selection.messageIds.flatMap((messageId) => {
+              const message = searchContext.rawMessagesById.get(messageId);
+              return message ? [message] : [];
+            });
+            const userContent = serializeMessagesForExternalSummary(selectedMessages);
+            const generated = await generateSummaryViaExternal(externalModel, {
+              systemPrompt: runtimePrompts.compressRange,
+              userContent
+            });
             plan.entry.summary = generated;
           }
-        }
+        });
       }
       const notifications = [];
       const preparedPlans = [];
@@ -4824,19 +5179,19 @@ function createCompressRangeTool(ctx) {
           injected.expandedSummary,
           plan.selection,
           searchContext,
-          ctx.state,
+          state,
           ctx.config.compress.protectUserMessages
         );
         const summaryWithPromptInfo = appendProtectedPromptInfo(
           summaryWithUsers,
           plan.selection,
           searchContext,
-          ctx.state,
+          state,
           ctx.config.compress.protectTags
         );
         const summaryWithTools = await appendProtectedTools(
           ctx.client,
-          ctx.state,
+          state,
           ctx.config.experimental.allowSubAgents,
           summaryWithPromptInfo,
           plan.selection,
@@ -4858,13 +5213,13 @@ function createCompressRangeTool(ctx) {
           consumedBlockIds: completedSummary.consumedBlockIds
         });
       }
-      const runId = allocateRunId(ctx.state);
+      const runId = allocateRunId(state);
       for (const preparedPlan of preparedPlans) {
-        const blockId = allocateBlockId(ctx.state);
+        const blockId = allocateBlockId(state);
         const storedSummary = wrapCompressedSummary(blockId, preparedPlan.finalSummary);
         const summaryTokens = countTokens2(storedSummary);
         const applied = applyCompressionState(
-          ctx.state,
+          state,
           {
             topic: input.topic,
             batchTopic: input.topic,
@@ -4890,7 +5245,7 @@ function createCompressRangeTool(ctx) {
           summaryTokens
         });
       }
-      await finalizeSession(ctx, toolCtx, rawMessages, notifications, input.topic);
+      await finalizeSession(ctx, state, toolCtx, rawMessages, notifications, input.topic);
       return `Compressed ${totalCompressedMessages} messages into ${COMPRESSED_BLOCK_HEADER}.`;
     }
   });
@@ -5156,51 +5511,51 @@ import { homedir as homedir4 } from "os";
 
 // lib/prompts/system.ts
 var SYSTEM = `
-You run in a context-limited environment. Manage context actively to avoid accumulation and keep retrieval quality high.
+\u4F60\u5728\u4E0A\u4E0B\u6587\u957F\u5EA6\u53D7\u9650\u7684\u73AF\u5883\u4E2D\u8FD0\u884C\u3002\u4E3B\u52A8\u7BA1\u7406\u4E0A\u4E0B\u6587\uFF0C\u907F\u514D\u65E0\u6548\u7D2F\u79EF\u5E76\u4FDD\u6301\u8F83\u9AD8\u7684\u68C0\u7D22\u8D28\u91CF\u3002
 
-Your only context-management tool is \`compress\`. It replaces older conversation content with a technical summary you generate.
+\u552F\u4E00\u7684\u4E0A\u4E0B\u6587\u7BA1\u7406\u5DE5\u5177\u662F \`compress\`\u3002\u5B83\u4F1A\u7528\u4F60\u751F\u6210\u7684\u6280\u672F\u6458\u8981\u66FF\u6362\u8F83\u65E9\u7684\u5BF9\u8BDD\u5185\u5BB9\u3002
 
-Hard constraints
-- Context management is done ONLY by calling \`compress\`. Never produce summaries in plain text.
-- NEVER output \`<summary>\` or \`<analysis>\` XML tags in text responses \u2014 they cause system errors.
-- If context needs compression, call \`compress\`. Do not write summaries inline.
-- Use Markdown headings (e.g. \`## Analysis\`, \`## Summary\`) to organize information. Never use XML tags.
+\u786C\u6027\u7EA6\u675F
+- \u53EA\u80FD\u901A\u8FC7\u8C03\u7528 \`compress\` \u7BA1\u7406\u4E0A\u4E0B\u6587\uFF0C\u7EDD\u4E0D\u80FD\u5728\u666E\u901A\u6587\u672C\u4E2D\u76F4\u63A5\u751F\u6210\u538B\u7F29\u6458\u8981\u3002
+- \u6587\u672C\u56DE\u590D\u4E2D\u7EDD\u4E0D\u80FD\u8F93\u51FA \`<summary>\` \u6216 \`<analysis>\` XML \u6807\u7B7E\uFF0C\u5B83\u4EEC\u4F1A\u5BFC\u81F4\u7CFB\u7EDF\u9519\u8BEF\u3002
+- \u9700\u8981\u538B\u7F29\u65F6\u8C03\u7528 \`compress\`\uFF0C\u4E0D\u8981\u5728\u56DE\u590D\u4E2D\u5185\u8054\u7F16\u5199\u6458\u8981\u3002
+- \u4F7F\u7528 Markdown \u6807\u9898\uFF08\u4F8B\u5982 \`## \u5206\u6790\`\u3001\`## \u6458\u8981\`\uFF09\u7EC4\u7EC7\u4FE1\u606F\uFF0C\u7EDD\u4E0D\u80FD\u4F7F\u7528 XML \u6807\u7B7E\u3002
 
-\`<dcp-message-id>\` and \`<dcp-system-reminder>\` are environment-injected metadata. Do not output them.
+\`<dcp-message-id>\` \u548C \`<dcp-system-reminder>\` \u662F\u73AF\u5883\u6CE8\u5165\u7684\u5143\u6570\u636E\uFF0C\u4E0D\u8981\u8F93\u51FA\u5B83\u4EEC\u3002
 
-When to compress
+\u4F55\u65F6\u538B\u7F29
 
-HIGHEST-PRIORITY HARD TRIGGER \u2014 call \`compress\` immediately whenever the conversation TOPIC changes. Compress the previous topic's finished context into a summary.
+\u6700\u9AD8\u4F18\u5148\u7EA7\u7684\u5F3A\u5236\u89E6\u53D1\u6761\u4EF6\uFF1A\u53EA\u8981\u5BF9\u8BDD\u4E3B\u9898\u53D1\u751F\u53D8\u5316\uFF0C\u7ACB\u5373\u8C03\u7528 \`compress\`\uFF0C\u628A\u4E0A\u4E00\u4E3B\u9898\u5DF2\u7ECF\u5B8C\u6210\u7684\u4E0A\u4E0B\u6587\u538B\u7F29\u4E3A\u6458\u8981\u3002
 
-A topic change is an objective, low-judgment signal, not a subjective call. Any of these counts:
+\u4E3B\u9898\u53D8\u5316\u662F\u5BA2\u89C2\u4E14\u4E0D\u9700\u8981\u590D\u6742\u5224\u65AD\u7684\u4FE1\u53F7\u3002\u4EE5\u4E0B\u4EFB\u4E00\u60C5\u51B5\u90FD\u7B97\u4E3B\u9898\u53D8\u5316\uFF1A
 
-- The user raises a task or question unrelated to the previous one
-- The focus shifts from one module/file/feature to another
-- The goal shifts from explore/research \u2192 implement, or implement \u2192 debug/verify
-- A distinct problem is resolved and you move to the next
+- \u7528\u6237\u63D0\u51FA\u4E0E\u4E0A\u4E00\u4EFB\u52A1\u65E0\u5173\u7684\u95EE\u9898
+- \u5DE5\u4F5C\u91CD\u70B9\u4ECE\u4E00\u4E2A\u6A21\u5757\u3001\u6587\u4EF6\u6216\u529F\u80FD\u8F6C\u79FB\u5230\u53E6\u4E00\u4E2A
+- \u76EE\u6807\u4ECE\u63A2\u7D22/\u7814\u7A76\u8F6C\u4E3A\u5B9E\u73B0\uFF0C\u6216\u4ECE\u5B9E\u73B0\u8F6C\u4E3A\u8C03\u8BD5/\u9A8C\u8BC1
+- \u4E00\u4E2A\u72EC\u7ACB\u95EE\u9898\u5DF2\u7ECF\u89E3\u51B3\uFF0C\u5F00\u59CB\u5904\u7406\u4E0B\u4E00\u4E2A\u95EE\u9898
 
-When any occurs, compress the finished range of the previous topic at once. Do not wait. This is the single most effective way to keep context clear.
+\u51FA\u73B0\u4EFB\u4E00\u60C5\u51B5\u65F6\uFF0C\u7ACB\u5373\u538B\u7F29\u4E0A\u4E00\u4E3B\u9898\u5DF2\u7ECF\u5B8C\u6210\u7684\u8303\u56F4\uFF0C\u4E0D\u8981\u7B49\u5F85\u3002\u8FD9\u662F\u4FDD\u6301\u4E0A\u4E0B\u6587\u6E05\u6670\u6700\u6709\u6548\u7684\u65B9\u6CD5\u3002
 
-Also compress (when a section genuinely closes even without a topic change):
+\u5373\u4F7F\u4E3B\u9898\u6CA1\u6709\u53D8\u5316\uFF0C\u5728\u4EE5\u4E0B\u9636\u6BB5\u786E\u5B9E\u7ED3\u675F\u65F6\u4E5F\u5E94\u538B\u7F29\uFF1A
 
-- Research is done and findings are settled
-- Implementation is complete and verified
-- Exploration is exhausted and patterns understood
-- Dead-end noise can be dropped without waiting for the whole section to close
+- \u7814\u7A76\u5B8C\u6210\uFF0C\u7ED3\u8BBA\u5DF2\u7ECF\u786E\u5B9A
+- \u5B9E\u73B0\u5B8C\u6210\u5E76\u901A\u8FC7\u9A8C\u8BC1
+- \u63A2\u7D22\u5DF2\u7ECF\u5145\u5206\uFF0C\u76F8\u5173\u89C4\u5F8B\u5DF2\u7ECF\u660E\u786E
+- \u5DF2\u786E\u8BA4\u65E0\u6548\u7684\u65B9\u5411\u53EF\u4EE5\u4E22\u5F03\uFF0C\u65E0\u9700\u7B49\u5F85\u6574\u4E2A\u9636\u6BB5\u7ED3\u675F
 
-Do NOT compress when:
+\u4EE5\u4E0B\u60C5\u51B5\u4E0D\u8981\u538B\u7F29\uFF1A
 
-- Raw context is still needed for editing or exact reference
-- The target work is actively in progress
-- You may need the exact code, error message, or file content in the next steps
+- \u7F16\u8F91\u6216\u7CBE\u786E\u5F15\u7528\u4ECD\u9700\u8981\u539F\u59CB\u4E0A\u4E0B\u6587
+- \u76EE\u6807\u5DE5\u4F5C\u4ECD\u5728\u8FDB\u884C
+- \u540E\u7EED\u6B65\u9AA4\u53EF\u80FD\u9700\u8981\u7CBE\u786E\u7684\u4EE3\u7801\u3001\u9519\u8BEF\u4FE1\u606F\u6216\u6587\u4EF6\u5185\u5BB9
 
-Ask yourself before compressing: _"Is this section closed enough to be summary-only?"_
+\u538B\u7F29\u524D\u5148\u95EE\u81EA\u5DF1\uFF1A_\u201C\u8FD9\u4E00\u90E8\u5206\u662F\u5426\u5DF2\u7ECF\u7ED3\u675F\uFF0C\u53EF\u4EE5\u53EA\u4FDD\u7559\u6458\u8981\uFF1F\u201D_
 
-If the answer is "the topic switched, the old content is no longer needed" \u2014 the answer is always yes.
+\u5982\u679C\u60C5\u51B5\u662F\u201C\u4E3B\u9898\u5DF2\u7ECF\u5207\u6362\uFF0C\u4E0D\u518D\u9700\u8981\u65E7\u5185\u5BB9\u201D\uFF0C\u7B54\u6848\u59CB\u7EC8\u662F\u201C\u53EF\u4EE5\u201D\u3002
 
-Periodically assess the conversation's signal-to-noise ratio. Use \`compress\` deliberately and provide high-quality summaries. Prioritize stale content to maintain a high-signal context window.
+\u5B9A\u671F\u8BC4\u4F30\u5BF9\u8BDD\u7684\u6709\u6548\u4FE1\u606F\u6BD4\u4F8B\u3002\u8C28\u614E\u4F7F\u7528 \`compress\` \u5E76\u751F\u6210\u9AD8\u8D28\u91CF\u6458\u8981\uFF0C\u4F18\u5148\u5904\u7406\u8FC7\u671F\u5185\u5BB9\uFF0C\u4FDD\u6301\u9AD8\u8D28\u91CF\u4E0A\u4E0B\u6587\u3002
 
-Keeping a sharp, high-quality context window for best performance is your responsibility.
+\u4F60\u6709\u8D23\u4EFB\u7EF4\u62A4\u7CBE\u786E\u3001\u9AD8\u8D28\u91CF\u7684\u4E0A\u4E0B\u6587\uFF0C\u4EE5\u83B7\u5F97\u6700\u4F73\u8868\u73B0\u3002
 `;
 
 // lib/prompts/compress-range.ts
@@ -5337,44 +5692,44 @@ var COMPRESS_MESSAGE = `\u5C06\u5BF9\u8BDD\u4E2D\u9009\u5B9A\u7684\u5355\u6761\u
 
 // lib/prompts/context-limit-nudge.ts
 var CONTEXT_LIMIT_NUDGE = `<dcp-system-reminder>
-CRITICAL: max context limit reached.
+\u7D27\u6025\uFF1A\u5DF2\u8FBE\u5230\u4E0A\u4E0B\u6587\u4E0A\u9650\u3002
 
-You are at or beyond the configured max context threshold. This is an emergency context-recovery moment.
+\u5F53\u524D\u4E0A\u4E0B\u6587\u5DF2\u8FBE\u5230\u6216\u8D85\u8FC7\u914D\u7F6E\u7684\u6700\u5927\u9608\u503C\uFF0C\u5FC5\u987B\u7ACB\u5373\u56DE\u6536\u4E0A\u4E0B\u6587\u3002
 
-You MUST call \`compress\` now. Do not continue normal exploration until compression is done.
+\u4F60\u5FC5\u987B\u73B0\u5728\u8C03\u7528 \`compress\`\u3002\u538B\u7F29\u5B8C\u6210\u524D\u4E0D\u8981\u7EE7\u7EED\u5E38\u89C4\u63A2\u7D22\u3002
 
-If mid-atomic-step, finish that one step, then compress immediately.
+\u5982\u679C\u6B63\u5728\u6267\u884C\u4E00\u4E2A\u4E0D\u53EF\u4E2D\u65AD\u7684\u6B65\u9AA4\uFF0C\u53EA\u5B8C\u6210\u8BE5\u6B65\u9AA4\uFF0C\u968F\u540E\u7ACB\u523B\u538B\u7F29\u3002
 
-Selection
-Start from older, already-finished history and capture as much stale context as possible in one pass.
-Do not select the latest working messages unless they are clearly concluded.
+\u9009\u62E9\u8303\u56F4
+\u4ECE\u8F83\u65E9\u4E14\u5DF2\u7ECF\u5B8C\u6210\u7684\u5386\u53F2\u5F00\u59CB\uFF0C\u4E00\u6B21\u8986\u76D6\u5C3D\u53EF\u80FD\u591A\u7684\u8FC7\u671F\u4E0A\u4E0B\u6587\u3002
+\u9664\u975E\u6700\u65B0\u5DE5\u4F5C\u5DF2\u7ECF\u660E\u786E\u7ED3\u675F\uFF0C\u5426\u5219\u4E0D\u8981\u9009\u62E9\u6700\u8FD1\u7684\u5DE5\u4F5C\u6D88\u606F\u3002
 
-Summary requirements
-Your summary must cover all key details in the selected messages so work can continue.
-If the range contains user messages, preserve their intent fully. For short user messages, prefer direct quotes to avoid semantic drift.
+\u6458\u8981\u8981\u6C42
+\u6458\u8981\u5FC5\u987B\u8986\u76D6\u6240\u9009\u6D88\u606F\u4E2D\u7684\u6240\u6709\u5173\u952E\u4FE1\u606F\uFF0C\u786E\u4FDD\u540E\u7EED\u5DE5\u4F5C\u53EF\u4EE5\u7EE7\u7EED\u3002
+\u5982\u679C\u8303\u56F4\u5305\u542B\u7528\u6237\u6D88\u606F\uFF0C\u5FC5\u987B\u5B8C\u6574\u4FDD\u7559\u7528\u6237\u610F\u56FE\u3002\u5BF9\u4E8E\u8F83\u77ED\u7684\u7528\u6237\u6D88\u606F\uFF0C\u4F18\u5148\u76F4\u63A5\u5F15\u7528\uFF0C\u907F\u514D\u8BED\u4E49\u504F\u79FB\u3002
 </dcp-system-reminder>
 `;
 
 // lib/prompts/turn-nudge.ts
 var TURN_NUDGE = `
-New user turn. This is the moment topic changes are most likely.
+\u7528\u6237\u5F00\u59CB\u4E86\u65B0\u4E00\u8F6E\u5BF9\u8BDD\uFF0C\u6B64\u65F6\u6700\u5BB9\u6613\u53D1\u751F\u4E3B\u9898\u53D8\u5316\u3002
 
-Is this turn's request a different topic/task from the previous one?
-- New or independent topic: call \`compress\` now to fold the previous topic's finished context into a summary. Its details no longer need verbatim retention.
-- Continuation of the same topic: you may keep it, but still watch for stale accumulation.
+\u672C\u8F6E\u8BF7\u6C42\u662F\u5426\u4E0E\u4E0A\u4E00\u8F6E\u5C5E\u4E8E\u4E0D\u540C\u4E3B\u9898\u6216\u4EFB\u52A1\uFF1F
+- \u65B0\u4E3B\u9898\u6216\u72EC\u7ACB\u4EFB\u52A1\uFF1A\u73B0\u5728\u8C03\u7528 \`compress\`\uFF0C\u628A\u4E0A\u4E00\u4E3B\u9898\u5DF2\u7ECF\u5B8C\u6210\u7684\u4E0A\u4E0B\u6587\u538B\u7F29\u4E3A\u6458\u8981\uFF0C\u4E0D\u518D\u9010\u5B57\u4FDD\u7559\u7EC6\u8282\u3002
+- \u540C\u4E00\u4E3B\u9898\u7684\u5EF6\u7EED\uFF1A\u53EF\u4EE5\u4FDD\u7559\uFF0C\u4F46\u4ECD\u9700\u6CE8\u610F\u8FC7\u671F\u5185\u5BB9\u7684\u7D2F\u79EF\u3002
 
-Topic change is the clearest, most objective compression trigger \u2014 do not miss it.
+\u4E3B\u9898\u53D8\u5316\u662F\u6700\u660E\u786E\u3001\u6700\u5BA2\u89C2\u7684\u538B\u7F29\u89E6\u53D1\u6761\u4EF6\uFF0C\u4E0D\u8981\u9057\u6F0F\u3002
 `;
 
 // lib/prompts/iteration-nudge.ts
 var ITERATION_NUDGE = `
-Many iterations elapsed without new user input.
+\u5728\u6CA1\u6709\u65B0\u7528\u6237\u8F93\u5165\u7684\u60C5\u51B5\u4E0B\u5DF2\u7ECF\u6267\u884C\u4E86\u591A\u8F6E\u3002
 
-Has the current iteration's task effectively finished, or has its topic drifted away from earlier steps?
-- If earlier steps belong to a resolved problem or a superseded exploration, call \`compress\` now to fold them into a summary.
-- If the iteration still continues the same unfinished goal and early context is still needed, keep it.
+\u5F53\u524D\u4EFB\u52A1\u662F\u5426\u5DF2\u7ECF\u5B8C\u6210\uFF0C\u6216\u8005\u5F53\u524D\u4E3B\u9898\u662F\u5426\u5DF2\u7ECF\u504F\u79BB\u65E9\u671F\u6B65\u9AA4\uFF1F
+- \u5982\u679C\u65E9\u671F\u6B65\u9AA4\u5C5E\u4E8E\u5DF2\u7ECF\u89E3\u51B3\u7684\u95EE\u9898\u6216\u5DF2\u88AB\u66FF\u4EE3\u7684\u63A2\u7D22\uFF0C\u73B0\u5728\u8C03\u7528 \`compress\` \u5C06\u5B83\u4EEC\u538B\u7F29\u4E3A\u6458\u8981\u3002
+- \u5982\u679C\u4ECD\u5728\u7EE7\u7EED\u540C\u4E00\u4E2A\u672A\u5B8C\u6210\u76EE\u6807\uFF0C\u800C\u4E14\u8FD8\u9700\u8981\u65E9\u671F\u4E0A\u4E0B\u6587\uFF0C\u5219\u4FDD\u7559\u8FD9\u4E9B\u5185\u5BB9\u3002
 
-Do not let finished exploration directions keep occupying context. Topic drift is the best moment to compress.
+\u4E0D\u8981\u8BA9\u5DF2\u7ECF\u7ED3\u675F\u7684\u63A2\u7D22\u65B9\u5411\u7EE7\u7EED\u5360\u7528\u4E0A\u4E0B\u6587\u3002\u4E3B\u9898\u53D1\u751F\u504F\u79FB\u65F6\u6700\u9002\u5408\u538B\u7F29\u3002
 `;
 
 // lib/prompts/extensions/system.ts
@@ -5613,6 +5968,7 @@ var PromptStore = class {
   paths;
   customPromptsEnabled;
   runtimePrompts;
+  lastReloadAt = 0;
   constructor(logger, workingDirectory, customPromptsEnabled = false) {
     this.logger = logger;
     this.paths = resolvePromptPaths(workingDirectory);
@@ -5627,6 +5983,9 @@ var PromptStore = class {
     return { ...this.runtimePrompts };
   }
   reload() {
+    const now = Date.now();
+    if (now - this.lastReloadAt < 1e3) return;
+    this.lastReloadAt = now;
     const nextPrompts = createBundledRuntimePrompts();
     if (!this.customPromptsEnabled) {
       this.runtimePrompts = nextPrompts;
@@ -5865,13 +6224,13 @@ var stripHallucinationsFromString = (text) => {
 };
 var stripHallucinations = (messages) => {
   for (const message of messages) {
+    if (message.info.role !== "assistant") {
+      continue;
+    }
     for (const part of message.parts) {
       if (part.type === "text" && typeof part.text === "string") {
         part.text = stripHallucinationsFromString(part.text);
       }
-      if (part.type === "tool" && part.state?.status === "completed" && typeof part.state.output === "string") {
-        part.state.output = stripHallucinationsFromString(part.state.output);
-      }
     }
   }
 };
@@ -5966,7 +6325,8 @@ var filterCompressedRanges = (state, logger, config, messages) => {
     return;
   }
   const result = [];
-  for (const msg of messages) {
+  for (let msgIndex = 0; msgIndex < messages.length; msgIndex++) {
+    const msg = messages[msgIndex];
     const msgId = msg.info.id;
     const blockId = state.prune.messages.activeByAnchorMessageId.get(msgId);
     const summary = blockId !== void 0 ? state.prune.messages.blocksById.get(blockId) : void 0;
@@ -5978,7 +6338,6 @@ var filterCompressedRanges = (state, logger, config, messages) => {
           blockId: summary.blockId
         });
       } else {
-        const msgIndex = messages.indexOf(msg);
         const userMessage = getLastUserMessage(messages, msgIndex);
         if (userMessage) {
           const userInfo = userMessage.info;
@@ -6105,7 +6464,7 @@ var compressPermission = (state, config) => {
   return state.compressPermission ?? config.compress.permission;
 };
 var syncCompressPermissionState = (state, config, hostPermissions, messages) => {
-  const activeAgent = getLastUserMessage(messages)?.info.agent;
+  const activeAgent = getLastUserMessage(messages)?.info?.agent;
   state.compressPermission = resolveEffectiveCompressPermission(
     config.compress.permission,
     hostPermissions,
@@ -6243,11 +6602,13 @@ function listPriorityRefsBeforeIndex(messages, priorities, anchorIndex, priority
 
 // lib/messages/inject/utils.ts
 var MESSAGE_MODE_NUDGE_PRIORITY = "high";
-function getNudgeFrequency(_config) {
-  return 1;
+function getNudgeFrequency(config) {
+  const value = config.compress.nudgeFrequency;
+  return Number.isFinite(value) ? Math.max(1, Math.floor(value)) : 1;
 }
-function getIterationNudgeThreshold(_config) {
-  return 1;
+function getIterationNudgeThreshold(config) {
+  const value = config.compress.iterationNudgeThreshold;
+  return Number.isFinite(value) ? Math.max(1, Math.floor(value)) : 1;
 }
 function findLastNonIgnoredMessage(messages) {
   for (let i = messages.length - 1; i >= 0; i--) {
@@ -6523,7 +6884,11 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
     state.nudges.contextLimitAnchors.clear();
     state.nudges.turnNudgeAnchors.clear();
     state.nudges.iterationNudgeAnchors.clear();
-    void saveSessionState(state, logger);
+    void saveSessionState(state, logger).catch(
+      (error) => logger.warn("Failed to persist context-limit nudge", {
+        error: error instanceof Error ? error.message : String(error)
+      })
+    );
     return;
   }
   const { providerId, modelId } = getModelInfo(messages);
@@ -6594,7 +6959,11 @@ var injectCompressNudges = (state, config, logger, messages, prompts, compressio
   }
   applyAnchoredNudges(state, config, messages, prompts, compressionPriorities);
   if (anchorsChanged) {
-    void saveSessionState(state, logger);
+    void saveSessionState(state, logger).catch(
+      (error) => logger.warn("Failed to persist compression nudge", {
+        error: error instanceof Error ? error.message : String(error)
+      })
+    );
   }
 };
 var injectMessageIds = (state, config, messages, compressionPriorities) => {
@@ -6661,6 +7030,7 @@ var injectExtendedSubAgentResults = async (client, state, logger, messages, allo
   if (!allowSubAgents) {
     return;
   }
+  const tasks = [];
   for (const message of messages) {
     const parts = Array.isArray(message.parts) ? message.parts : [];
     for (const part of parts) {
@@ -6673,40 +7043,43 @@ var injectExtendedSubAgentResults = async (client, state, logger, messages, allo
       if (part.state?.status !== "completed" || typeof part.state.output !== "string") {
         continue;
       }
-      const cachedResult = state.subAgentResultCache.get(part.callID);
-      if (cachedResult !== void 0) {
-        if (cachedResult) {
-          part.state.output = stripHallucinationsFromString(
-            mergeSubagentResult(part.state.output, cachedResult)
-          );
-        }
-        continue;
-      }
-      const subAgentSessionId = getSubAgentId(part);
-      if (!subAgentSessionId) {
-        continue;
-      }
-      let subAgentMessages = [];
-      try {
-        subAgentMessages = await fetchSubAgentMessages(client, subAgentSessionId);
-      } catch (error) {
-        logger.warn("Failed to fetch subagent session for output expansion", {
-          subAgentSessionId,
-          callID: part.callID,
-          error: error instanceof Error ? error.message : String(error)
-        });
-        continue;
-      }
-      const subAgentResultText = buildSubagentResultText(subAgentMessages);
-      if (!subAgentResultText) {
-        continue;
-      }
-      state.subAgentResultCache.set(part.callID, subAgentResultText);
-      part.state.output = stripHallucinationsFromString(
-        mergeSubagentResult(part.state.output, subAgentResultText)
-      );
+      tasks.push({ part });
     }
   }
+  await runWithConcurrency(tasks, 4, async ({ part }) => {
+    const cachedResult = getCachedSubAgentResult(state, part.callID);
+    if (cachedResult !== void 0) {
+      if (cachedResult) {
+        part.state.output = stripHallucinationsFromString(
+          mergeSubagentResult(part.state.output, cachedResult)
+        );
+      }
+      return;
+    }
+    const subAgentSessionId = getSubAgentId(part);
+    if (!subAgentSessionId) {
+      return;
+    }
+    let subAgentMessages = [];
+    try {
+      subAgentMessages = await fetchSubAgentMessages(client, subAgentSessionId);
+    } catch (error) {
+      logger.warn("Failed to fetch subagent session for output expansion", {
+        subAgentSessionId,
+        callID: part.callID,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return;
+    }
+    const subAgentResultText = buildSubagentResultText(subAgentMessages);
+    if (!subAgentResultText) {
+      return;
+    }
+    const cached = cacheSubAgentResult(state, part.callID, subAgentResultText);
+    part.state.output = stripHallucinationsFromString(
+      mergeSubagentResult(part.state.output, cached)
+    );
+  });
 };
 
 // lib/messages/reasoning-strip.ts
@@ -7294,11 +7667,7 @@ var COMPRESS_TRIGGER_PROMPT = [
 function getTriggerPrompt(tool3, state, config, messages, userFocus) {
   const base = COMPRESS_TRIGGER_PROMPT;
   const compressedBlockGuidance = config.compress.mode === "message" ? "" : buildCompressedBlockGuidance(state);
-  const availableMessageIdGuidance = buildAvailableMessageIdGuidance(
-    state,
-    config,
-    messages
-  );
+  const availableMessageIdGuidance = buildAvailableMessageIdGuidance(state, config, messages);
   const sections = [base, availableMessageIdGuidance, compressedBlockGuidance];
   if (userFocus && userFocus.trim().length > 0) {
     sections.push(`Additional user focus:
@@ -7811,13 +8180,14 @@ var INTERNAL_AGENT_SIGNATURES = [
   "You are an anchored context summarization assistant for coding sessions",
   "Summarize what was done in this conversation"
 ];
-function createSystemPromptHandler(state, logger, config, prompts) {
+function createSystemPromptHandler(target, logger, config, prompts) {
   return async (input, output) => {
-    if (input.model?.limit?.context) {
+    const state = input.sessionID ? resolveSessionState(target, input.sessionID) : target instanceof SessionStateStore ? void 0 : target;
+    if (state && input.model?.limit?.context) {
       state.modelContextLimit = input.model.limit.context;
       logger.debug("Cached model context limit", { limit: state.modelContextLimit });
     }
-    if (state.isSubAgent && !config.experimental.allowSubAgents) {
+    if (state?.isSubAgent && !config.experimental.allowSubAgents) {
       return;
     }
     const systemText = output.system.join("\n");
@@ -7825,7 +8195,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 = input.sessionID && state?.sessionId === input.sessionID ? compressPermission(state, config) : config.compress.permission;
     if (effectivePermission === "deny") {
       return;
     }
@@ -7834,8 +8204,8 @@ function createSystemPromptHandler(state, logger, config, prompts) {
     const newPrompt = renderSystemPrompt(
       runtimePrompts,
       buildProtectedToolsExtension(config.compress.protectedTools),
-      !!state.manualMode,
-      state.isSubAgent && config.experimental.allowSubAgents
+      !!state?.manualMode,
+      !!state?.isSubAgent && config.experimental.allowSubAgents
     );
     if (output.system.length > 0) {
       output.system[output.system.length - 1] += "\n\n" + newPrompt;
@@ -7844,7 +8214,7 @@ function createSystemPromptHandler(state, logger, config, prompts) {
     }
   };
 }
-function createChatMessageTransformHandler(client, state, logger, config, prompts, hostPermissions) {
+function createChatMessageTransformHandler(client, target, logger, config, prompts, hostPermissions) {
   return async (input, output) => {
     const receivedMessages = Array.isArray(output.messages) ? output.messages.length : 0;
     const messages = filterMessagesInPlace(output.messages);
@@ -7854,7 +8224,14 @@ function createChatMessageTransformHandler(client, state, logger, config, prompt
         usable: messages.length
       });
     }
-    await checkSession(client, state, logger, output.messages, config.manualMode.enabled);
+    const state = await checkSession(
+      client,
+      target,
+      logger,
+      output.messages,
+      config.manualMode.enabled
+    );
+    if (!state) return;
     syncCompressPermissionState(state, config, hostPermissions, output.messages);
     if (state.isSubAgent && !config.experimental.allowSubAgents) {
       return;
@@ -7900,7 +8277,7 @@ function createChatMessageTransformHandler(client, state, logger, config, prompt
     }
   };
 }
-function createCommandExecuteHandler(client, state, logger, config, workingDirectory, hostPermissions) {
+function createCommandExecuteHandler(client, target, logger, config, workingDirectory, hostPermissions) {
   return async (input, output) => {
     if (!config.commands.enabled) {
       return;
@@ -7910,9 +8287,9 @@ function createCommandExecuteHandler(client, state, logger, config, workingDirec
         path: { id: input.sessionID }
       });
       const messages = filterMessages(messagesResponse.data || messagesResponse);
-      await ensureSessionInitialized(
+      const state = await initializeSessionState(
         client,
-        state,
+        target,
         input.sessionID,
         logger,
         messages,
@@ -7997,7 +8374,7 @@ function createTextCompleteHandler() {
     output.text = stripHallucinationsFromString(output.text);
   };
 }
-function createEventHandler(state, logger) {
+function createEventHandler(target, 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") {
@@ -8007,16 +8384,25 @@ function createEventHandler(state, logger) {
     if (part?.type !== "tool" || part.tool !== "compress") {
       return;
     }
+    if (typeof part.callID !== "string" || typeof part.messageID !== "string") {
+      return;
+    }
+    const eventSessionId = typeof input.event.properties?.sessionID === "string" ? input.event.properties.sessionID : typeof part.sessionID === "string" ? part.sessionID : void 0;
+    const state = target instanceof SessionStateStore ? target.resolveEventState(eventSessionId, part.messageID) : target;
+    const key = buildCompressionTimingKey(part.messageID, part.callID);
+    if (state) pruneCompressionTiming(state);
     if (part.state.status === "pending") {
-      if (typeof part.callID !== "string" || typeof part.messageID !== "string") {
+      const startedAt = eventTime ?? Date.now();
+      if (!state && target instanceof SessionStateStore) {
+        target.recordOrphanStart(key, startedAt);
         return;
       }
-      const startedAt = eventTime ?? Date.now();
-      const key = buildCompressionTimingKey(part.messageID, part.callID);
+      if (!state) return;
       if (state.compressionTiming.startsByCallId.has(key)) {
         return;
       }
       state.compressionTiming.startsByCallId.set(key, startedAt);
+      state.compressionTiming.recordedAtByCallId.set(key, Date.now());
       logger.debug("Recorded compression start", {
         messageID: part.messageID,
         callID: part.callID,
@@ -8025,20 +8411,26 @@ function createEventHandler(state, logger) {
       return;
     }
     if (part.state.status === "completed") {
-      if (typeof part.callID !== "string" || typeof part.messageID !== "string") {
-        return;
-      }
-      const key = buildCompressionTimingKey(part.messageID, part.callID);
-      const start = consumeCompressionStart(state, part.messageID, part.callID);
+      const start = state ? consumeCompressionStart(state, part.messageID, part.callID) : target instanceof SessionStateStore ? target.consumeOrphanStart(key) : void 0;
       const durationMs = resolveCompressionDuration(start, eventTime, part.state.time);
       if (typeof durationMs !== "number") {
         return;
       }
+      if (!state && target instanceof SessionStateStore) {
+        target.recordOrphanPending(key, {
+          messageId: part.messageID,
+          callId: part.callID,
+          durationMs
+        });
+        return;
+      }
+      if (!state) return;
       state.compressionTiming.pendingByCallId.set(key, {
         messageId: part.messageID,
         callId: part.callID,
         durationMs
       });
+      state.compressionTiming.recordedAtByCallId.set(key, Date.now());
       const updates = applyPendingCompressionDurations(state);
       if (updates === 0) {
         return;
@@ -8055,44 +8447,19 @@ function createEventHandler(state, logger) {
     if (part.state.status === "running") {
       return;
     }
-    if (typeof part.callID === "string" && typeof part.messageID === "string") {
+    if (state) {
       state.compressionTiming.startsByCallId.delete(
         buildCompressionTimingKey(part.messageID, part.callID)
       );
+      state.compressionTiming.recordedAtByCallId.delete(key);
+    } else if (target instanceof SessionStateStore) {
+      target.deleteOrphanStart(key);
     }
   };
 }
 
-// lib/auth.ts
-function isSecureMode() {
-  return !!process.env.OPENCODE_SERVER_PASSWORD;
-}
-function getAuthorizationHeader() {
-  const password = process.env.OPENCODE_SERVER_PASSWORD;
-  if (!password) return void 0;
-  const username = process.env.OPENCODE_SERVER_USERNAME ?? "opencode";
-  const credentials = Buffer.from(`${username}:${password}`).toString("base64");
-  return `Basic ${credentials}`;
-}
-function configureClientAuth(client) {
-  const authHeader = getAuthorizationHeader();
-  if (!authHeader) {
-    return client;
-  }
-  const innerClient = client._client || client.client;
-  if (innerClient?.interceptors?.request) {
-    innerClient.interceptors.request.use((request) => {
-      if (!request.headers.has("Authorization")) {
-        request.headers.set("Authorization", authHeader);
-      }
-      return request;
-    });
-  }
-  return client;
-}
-
 // lib/update.ts
-import { readFile as readFile2, rm } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import { basename, dirname as dirname3, join as join5 } from "path";
 import { fileURLToPath } from "url";
 var PACKAGE_NAME = "@lexwdex-org/opencode-dcp";
@@ -8101,15 +8468,16 @@ function startAutoUpdate(ctx, enabled) {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), 1e4);
   void checkAutoUpdate(controller.signal).then((result) => {
-    if (!result.updated) return;
+    if (!result.available) return;
     setTimeout(() => {
-      ctx.client.tui.showToast({
+      void ctx.client.tui.showToast({
         body: {
-          title: "DCP update ready",
-          message: `Updated ${result.name} from ${result.current} to ${result.latest}. Restart OpenCode to finish.`,
+          title: "DCP update available",
+          message: `${result.name} ${result.latest} is available (current ${result.current}). Reinstall the plugin to update.`,
           variant: "info",
           duration: 7e3
         }
+      }).catch(() => {
       });
     }, 5e3);
   }).catch(() => {
@@ -8117,25 +8485,14 @@ function startAutoUpdate(ctx, enabled) {
 }
 async function checkAutoUpdate(signal) {
   const packageDir = await findPackageDir(PACKAGE_NAME);
-  if (!packageDir) return { updated: false };
+  if (!packageDir) return { available: false };
   const pkg = await readPackageJson(join5(packageDir, "package.json"));
-  if (!pkg?.name || !pkg.version) return { updated: false };
+  if (!pkg?.name || !pkg.version) return { available: false };
   const latest = await fetchLatestVersion(pkg.name, signal);
-  if (!latest || !isVersionNewer(latest, pkg.version)) return { updated: false };
-  const removeDir = await updateRemoveDir(packageDir, pkg.name);
-  if (!removeDir) return { updated: false };
-  try {
-    await rm(removeDir, { recursive: true, force: true });
-  } catch {
-    return {
-      updated: false,
-      error: "remove_failed",
-      name: pkg.name,
-      current: pkg.version,
-      latest
-    };
-  }
-  return { updated: true, name: pkg.name, current: pkg.version, latest };
+  if (!latest || !isVersionNewer(latest, pkg.version)) return { available: false };
+  const wrapperDir = await findAutoUpdateWrapperDir(packageDir, pkg.name);
+  if (!wrapperDir) return { available: false };
+  return { available: true, name: pkg.name, current: pkg.version, latest };
 }
 async function findPackageDir(name) {
   let dir = dirname3(fileURLToPath(import.meta.url));
@@ -8147,7 +8504,7 @@ async function findPackageDir(name) {
     dir = parent;
   }
 }
-async function updateRemoveDir(packageDir, name) {
+async function findAutoUpdateWrapperDir(packageDir, name) {
   const packageParent = dirname3(packageDir);
   const nodeModulesDir = basename(packageParent).startsWith("@") ? dirname3(packageParent) : packageParent;
   if (basename(nodeModulesDir) !== "node_modules") return void 0;
@@ -8243,36 +8600,33 @@ var server = (async (ctx) => {
     return {};
   }
   const logger = new Logger(config.debug);
-  const state = createSessionState();
+  const states = new SessionStateStore(createSessionState);
   const prompts = new PromptStore(logger, ctx.directory, config.experimental.customPrompts);
   const hostPermissions = {
     global: void 0,
     agents: {}
   };
-  if (isSecureMode()) {
-    configureClientAuth(ctx.client);
-  }
   logger.info("DCP initialized", {
     strategies: config.strategies
   });
   startAutoUpdate(ctx, config.autoUpdate);
   const compressToolContext = {
     client: ctx.client,
-    state,
+    state: states,
     logger,
     config,
     prompts
   };
   return {
     "experimental.chat.system.transform": createSystemPromptHandler(
-      state,
+      states,
       logger,
       config,
       prompts
     ),
     "experimental.chat.messages.transform": createChatMessageTransformHandler(
       ctx.client,
-      state,
+      states,
       logger,
       config,
       prompts,
@@ -8281,13 +8635,13 @@ var server = (async (ctx) => {
     "experimental.text.complete": createTextCompleteHandler(),
     "command.execute.before": createCommandExecuteHandler(
       ctx.client,
-      state,
+      states,
       logger,
       config,
       ctx.directory,
       hostPermissions
     ),
-    event: createEventHandler(state, logger),
+    event: createEventHandler(states, logger),
     tool: {
       ...config.compress.permission !== "deny" && {
         compress: config.compress.mode === "message" ? createCompressMessageTool(compressToolContext) : createCompressRangeTool(compressToolContext)