opencode-acp 1.14.27-pr.370.111 → 1.14.27-pr.376.109

package/README.md

@@ -381,13 +381,6 @@ Each level overrides the previous, so project settings take priority over global
         // Preserve your messages during compression.
         // Warning: large copy-pasted prompts will never be compressed away
         "protectUserMessages": false,
-        // Closed-turn thinking stripping on protected-exempt messages (#368).
-        // "reasoning" parts of compress/skill tool calls in closed historical
-        // turns are dropped at request time; the active turn is never touched.
-        "stripProtectedReasoning": true,
-        "stripProtectedReasoningThreshold": 0,
-        "stripProtectedReasoningProviders": ["anthropic", "gemini"],
-        "stripProtectedReasoningMinMessages": 100
     },
     // Garbage collection — hardcoded 100% fallback only
     "gc": {

package/README.zh-CN.md

@@ -334,13 +334,6 @@ ACP 使用自己的配置文件，按以下顺序搜索：
         // Preserve your messages during compression.
         // Warning: large copy-pasted prompts will never be compressed away
         "protectUserMessages": false,
-        // 受保护豁免消息的闭轮思考剥离（#368）。
-        // 请求时丢弃已关闭历史轮次中 compress/skill 工具调用的
-        // "reasoning" 部分；当前活跃轮次永不受影响。
-        "stripProtectedReasoning": true,
-        "stripProtectedReasoningThreshold": 0,
-        "stripProtectedReasoningProviders": ["anthropic", "gemini"],
-        "stripProtectedReasoningMinMessages": 100
     },
     // 垃圾回收与批量清理
     "gc": {

package/dist/index.js

@@ -909,10 +909,6 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "compress.preserveRecentMessages",
   "compress.preserveRecentTokens",
   "compress.preserveLastUserMessage",
-  "compress.stripProtectedReasoning",
-  "compress.stripProtectedReasoningThreshold",
-  "compress.stripProtectedReasoningProviders",
-  "compress.stripProtectedReasoningMinMessages",
   "gc",
   "gc.algorithm",
   "gc.promotionThreshold",
@@ -1266,36 +1262,6 @@ function validateConfigTypes(config) {
           actual: typeof compress.preserveLastUserMessage
         });
       }
-      if (compress.stripProtectedReasoning !== void 0 && typeof compress.stripProtectedReasoning !== "boolean") {
-        errors.push({
-          key: "compress.stripProtectedReasoning",
-          expected: "boolean",
-          actual: typeof compress.stripProtectedReasoning
-        });
-      }
-      if (compress.stripProtectedReasoningThreshold !== void 0 && (typeof compress.stripProtectedReasoningThreshold !== "number" || !Number.isFinite(compress.stripProtectedReasoningThreshold) || compress.stripProtectedReasoningThreshold < 0)) {
-        errors.push({
-          key: "compress.stripProtectedReasoningThreshold",
-          expected: "number (>= 0)",
-          actual: JSON.stringify(compress.stripProtectedReasoningThreshold)
-        });
-      }
-      if (compress.stripProtectedReasoningProviders !== void 0 && (!Array.isArray(compress.stripProtectedReasoningProviders) || !compress.stripProtectedReasoningProviders.every(
-        (entry) => typeof entry === "string" && entry.trim() !== ""
-      ))) {
-        errors.push({
-          key: "compress.stripProtectedReasoningProviders",
-          expected: 'string[] (non-empty strings; "*" = all providers)',
-          actual: JSON.stringify(compress.stripProtectedReasoningProviders)
-        });
-      }
-      if (compress.stripProtectedReasoningMinMessages !== void 0 && (typeof compress.stripProtectedReasoningMinMessages !== "number" || !Number.isInteger(compress.stripProtectedReasoningMinMessages) || compress.stripProtectedReasoningMinMessages < 0)) {
-        errors.push({
-          key: "compress.stripProtectedReasoningMinMessages",
-          expected: "integer (>= 0)",
-          actual: JSON.stringify(compress.stripProtectedReasoningMinMessages)
-        });
-      }
       if (typeof compress.iterationNudgeThreshold === "number" && compress.iterationNudgeThreshold < 1) {
         errors.push({
           key: "compress.iterationNudgeThreshold",
@@ -1693,11 +1659,7 @@ var defaultConfig = {
     lastSegmentSoftBlock: true,
     preserveRecentMessages: 5,
     preserveRecentTokens: 5e3,
-    preserveLastUserMessage: true,
-    stripProtectedReasoning: true,
-    stripProtectedReasoningThreshold: 0,
-    stripProtectedReasoningProviders: ["anthropic", "gemini"],
-    stripProtectedReasoningMinMessages: 100
+    preserveLastUserMessage: true
   },
   gc: {
     algorithm: "truncate",
@@ -1867,11 +1829,7 @@ function mergeCompress(base, override) {
     lastSegmentSoftBlock: override.lastSegmentSoftBlock ?? base.lastSegmentSoftBlock,
     preserveRecentMessages: override.preserveRecentMessages ?? base.preserveRecentMessages,
     preserveRecentTokens: override.preserveRecentTokens ?? base.preserveRecentTokens,
-    preserveLastUserMessage: override.preserveLastUserMessage ?? base.preserveLastUserMessage,
-    stripProtectedReasoning: override.stripProtectedReasoning ?? base.stripProtectedReasoning,
-    stripProtectedReasoningThreshold: override.stripProtectedReasoningThreshold ?? base.stripProtectedReasoningThreshold,
-    stripProtectedReasoningProviders: Array.isArray(override.stripProtectedReasoningProviders) ? [...override.stripProtectedReasoningProviders] : base.stripProtectedReasoningProviders,
-    stripProtectedReasoningMinMessages: override.stripProtectedReasoningMinMessages ?? base.stripProtectedReasoningMinMessages
+    preserveLastUserMessage: override.preserveLastUserMessage ?? base.preserveLastUserMessage
   };
 }
 function mergeCommands(base, override) {
@@ -2365,12 +2323,12 @@ function serializePruneMessagesState(messagesState) {
     markedForCleanup: Array.from(messagesState.markedForCleanup)
   };
 }
-async function isSubAgentSession(client, sessionID) {
+async function getForkParentId(client, sessionID) {
   try {
     const result = await client.session.get({ path: { id: sessionID } });
-    return !!result.data?.parentID;
+    return result.data?.parentID ?? null;
   } catch (error) {
-    return false;
+    return null;
   }
 }
 function findLastCompactionTimestamp(messages) {
@@ -4407,6 +4365,205 @@ function rebuildCompressionState(state, messages, config, logger) {
   return rebuilt;
 }
 
+// lib/state/fork-transfer.ts
+function extractIdentity(message) {
+  const id = message?.info?.id;
+  if (typeof id !== "string" || id.length === 0) {
+    return null;
+  }
+  if (isSyntheticMessage(message)) {
+    return null;
+  }
+  const role = message.info.role;
+  const created = message.info.time?.created;
+  if (typeof created !== "number") {
+    return null;
+  }
+  return { id, role, created };
+}
+function buildSharedPrefixMapping(parentMessages, forkMessages) {
+  const parentIds = parentMessages.map(extractIdentity).filter((x) => x !== null);
+  const forkIds = forkMessages.map(extractIdentity).filter((x) => x !== null);
+  const mapping = /* @__PURE__ */ new Map();
+  const limit = Math.min(parentIds.length, forkIds.length);
+  for (let i = 0; i < limit; i++) {
+    const p = parentIds[i];
+    const f = forkIds[i];
+    if (p.created === f.created && p.role === f.role) {
+      mapping.set(p.id, f.id);
+    } else {
+      break;
+    }
+  }
+  return mapping;
+}
+function remapBoundaryRef(ref, mapping, forkByRawId, parentByRef) {
+  const parsed = parseBoundaryId(ref);
+  if (!parsed) {
+    return ref;
+  }
+  if (parsed.kind === "compressed-block") {
+    return parsed.ref;
+  }
+  const parentRawId = parentByRef.get(parsed.ref);
+  if (!parentRawId) {
+    return ref;
+  }
+  const forkRawId = mapping.get(parentRawId);
+  if (!forkRawId) {
+    return ref;
+  }
+  const forkRef = forkByRawId.get(forkRawId);
+  return forkRef ?? ref;
+}
+function translateBlock(block, mapping, forkByRawId, parentByRef) {
+  const anchorForkId = mapping.get(block.anchorMessageId);
+  if (!anchorForkId) {
+    return null;
+  }
+  const compressForkId = mapping.get(block.compressMessageId);
+  if (!compressForkId) {
+    return null;
+  }
+  const translateList = (ids) => ids.map((id) => mapping.get(id)).filter((id) => id !== void 0);
+  const preserveList = (ids) => [...new Set(ids)];
+  return {
+    ...block,
+    anchorMessageId: anchorForkId,
+    compressMessageId: compressForkId,
+    directMessageIds: translateList(block.directMessageIds),
+    effectiveMessageIds: translateList(block.effectiveMessageIds),
+    directToolIds: preserveList(block.directToolIds),
+    effectiveToolIds: preserveList(block.effectiveToolIds),
+    startId: remapBoundaryRef(block.startId, mapping, forkByRawId, parentByRef),
+    endId: remapBoundaryRef(block.endId, mapping, forkByRawId, parentByRef)
+  };
+}
+function translateByMessageId(parentByMessageId, mapping, translatedBlockIds) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [parentMsgId, entry] of Object.entries(parentByMessageId)) {
+    if (!entry || typeof entry !== "object") {
+      continue;
+    }
+    const forkMsgId = mapping.get(parentMsgId);
+    if (!forkMsgId) {
+      continue;
+    }
+    const allBlockIds = (entry.allBlockIds ?? []).filter((id) => translatedBlockIds.has(id));
+    const activeBlockIds = (entry.activeBlockIds ?? []).filter(
+      (id) => translatedBlockIds.has(id)
+    );
+    result.set(forkMsgId, {
+      tokenCount: typeof entry.tokenCount === "number" ? entry.tokenCount : 0,
+      allBlockIds,
+      activeBlockIds
+    });
+  }
+  return result;
+}
+async function recoverFromParentState(client, state, forkMessages, parentId, logger) {
+  const parentState = await loadSessionState(parentId, logger);
+  if (!parentState) {
+    logger.info("fork-transfer: no parent state found, falling back to replay", {
+      parentId
+    });
+    return 0;
+  }
+  const parentMessagesState = parentState.prune?.messages;
+  const parentBlocks = parentMessagesState?.blocksById;
+  if (!parentBlocks) {
+    logger.info("fork-transfer: parent state has no blocks, falling back to replay", {
+      parentId
+    });
+    return 0;
+  }
+  const parentBlockEntries = Object.entries(parentBlocks).filter(
+    ([id, block]) => Number.isInteger(Number.parseInt(id, 10)) && Number.parseInt(id, 10) >= 1 && !!block
+  );
+  if (parentBlockEntries.length === 0) {
+    logger.info("fork-transfer: parent state has no blocks, falling back to replay", {
+      parentId
+    });
+    return 0;
+  }
+  let parentMessages;
+  try {
+    const response = await client.session.messages({ path: { id: parentId } });
+    parentMessages = filterMessages(response?.data || response);
+  } catch (error) {
+    logger.warn("fork-transfer: failed to fetch parent messages, falling back to replay", {
+      parentId,
+      error: error?.message || String(error)
+    });
+    return 0;
+  }
+  const mapping = buildSharedPrefixMapping(parentMessages, forkMessages);
+  if (mapping.size === 0) {
+    logger.info("fork-transfer: no shared prefix detected, falling back to replay", {
+      parentId
+    });
+    return 0;
+  }
+  assignMessageRefs(state, forkMessages);
+  const forkByRawId = state.messageIds.byRawId;
+  const parentByRef = new Map(Object.entries(parentState.messageIds?.byRef ?? {}));
+  const translatedBlocks = /* @__PURE__ */ new Map();
+  let skipped = 0;
+  for (const [blockIdStr, block] of parentBlockEntries) {
+    const blockId = Number.parseInt(blockIdStr, 10);
+    const translated = translateBlock(block, mapping, forkByRawId, parentByRef);
+    if (translated) {
+      translatedBlocks.set(blockId, translated);
+    } else {
+      skipped++;
+    }
+  }
+  if (translatedBlocks.size === 0) {
+    logger.info("fork-transfer: no blocks translatable, falling back to replay", {
+      parentId,
+      parentBlockCount: parentBlockEntries.length,
+      mappingSize: mapping.size
+    });
+    return 0;
+  }
+  const activeCount = Array.from(translatedBlocks.values()).filter((b) => b.active).length;
+  if (activeCount === 0) {
+    logger.info("fork-transfer: no active blocks translatable, falling back to replay", {
+      parentId,
+      recoveredBlocks: translatedBlocks.size,
+      skippedBlocks: skipped,
+      mappingSize: mapping.size
+    });
+    return 0;
+  }
+  const translatedByMessageId = translateByMessageId(
+    parentMessagesState.byMessageId ?? {},
+    mapping,
+    new Set(translatedBlocks.keys())
+  );
+  state.prune.messages = loadPruneMessagesState({
+    byMessageId: Object.fromEntries(translatedByMessageId),
+    blocksById: Object.fromEntries(
+      Array.from(translatedBlocks.entries()).map(
+        ([id, block]) => [String(id), block]
+      )
+    ),
+    activeBlockIds: [],
+    activeByAnchorMessageId: {},
+    nextBlockId: 1,
+    nextRunId: 1,
+    markedForCleanup: []
+  });
+  logger.info("fork-transfer: recovered compression state from parent", {
+    parentId,
+    recoveredBlocks: translatedBlocks.size,
+    activeBlocks: activeCount,
+    skippedBlocks: skipped,
+    mappingSize: mapping.size
+  });
+  return activeCount;
+}
+
 // lib/state/state.ts
 async function updatePerTurnState(state, logger, messages) {
   const lastCompactionTimestamp = findLastCompactionTimestamp(messages);
@@ -4595,16 +4752,22 @@ async function ensureSessionInitialized(client, state, sessionId, logger, messag
   }
   resetSessionState(state);
   state.sessionId = sessionId;
-  const isSubAgent = await isSubAgentSession(client, sessionId);
-  state.isSubAgent = isSubAgent;
+  const parentId = await getForkParentId(client, sessionId);
+  state.isSubAgent = parentId !== null;
   state.lastCompaction = findLastCompactionTimestamp(messages);
   state.currentTurn = countTurns(state, messages);
   state.nudges.turnNudgeAnchors = collectTurnNudgeAnchors(messages);
   const persisted = await loadSessionState(sessionId, logger);
   if (persisted === null) {
     if (config) {
-      const rebuilt = rebuildCompressionState(state, messages, config, logger);
-      if (rebuilt > 0) {
+      let recovered = 0;
+      if (parentId) {
+        recovered = await recoverFromParentState(client, state, messages, parentId, logger);
+      }
+      if (recovered === 0) {
+        recovered = rebuildCompressionState(state, messages, config, logger);
+      }
+      if (recovered > 0) {
         await saveSessionState(state, logger);
       }
     }
@@ -8304,76 +8467,6 @@ function stripStaleMetadata(messages) {
     });
   });
 }
-function stripProtectedReasoning(messages, protectedTools, threshold, options) {
-  if (protectedTools.length === 0) {
-    return 0;
-  }
-  const allowedProviders = options?.allowedProviders;
-  if (allowedProviders !== void 0) {
-    if (allowedProviders.length === 0) {
-      return 0;
-    }
-    if (!allowedProviders.some((entry) => entry.trim() === "*")) {
-      const providerID = options?.providerID;
-      if (providerID === void 0 || !allowedProviders.some(
-        (entry) => providerID.toLowerCase().includes(entry.trim().toLowerCase())
-      )) {
-        return 0;
-      }
-    }
-  }
-  const minMessages = options?.minMessages;
-  if (minMessages !== void 0 && minMessages > 0 && messages.length < minMessages) {
-    return 0;
-  }
-  const lastUserMessage = getLastUserMessage(messages);
-  if (!lastUserMessage || lastUserMessage.info.role !== "user") {
-    return 0;
-  }
-  let lastUserIndex = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i] === lastUserMessage) {
-      lastUserIndex = i;
-      break;
-    }
-  }
-  if (lastUserIndex <= 0) {
-    return 0;
-  }
-  const protectedSet = new Set(protectedTools);
-  let removed = 0;
-  for (let i = 0; i < lastUserIndex; i++) {
-    const message = messages[i];
-    if (!message || message.info.role !== "assistant") {
-      continue;
-    }
-    const parts = Array.isArray(message.parts) ? message.parts : [];
-    let hasProtectedTool = false;
-    let reasoningLength = 0;
-    for (const part of parts) {
-      if (part.type === "tool") {
-        if (protectedSet.has(part.tool)) {
-          hasProtectedTool = true;
-        }
-      } else if (part.type === "reasoning") {
-        reasoningLength += part.text.length;
-      }
-    }
-    if (!hasProtectedTool) {
-      continue;
-    }
-    if (reasoningLength <= threshold) {
-      continue;
-    }
-    const filtered = parts.filter((part) => part.type !== "reasoning");
-    if (filtered.length === parts.length) {
-      continue;
-    }
-    message.parts = filtered;
-    removed += parts.length - filtered.length;
-  }
-  return removed;
-}
 
 // lib/messages/priority.ts
 function buildPriorityMap(_config, _state, _messages) {
@@ -9490,7 +9583,7 @@ import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { join as join3 } from "path";
 import { existsSync as existsSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-var LOG_VERSION = true ? "1.14.27-pr.370.111" : "dev";
+var LOG_VERSION = true ? "1.14.27-pr.376.109" : "dev";
 var LEVEL_RANK = {
   debug: 10,
   info: 20,
@@ -11432,7 +11525,6 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
       return;
     }
     const lastUserMessage = getLastUserMessage(messages);
-    const requestModel = lastUserMessage?.info?.model;
     let state;
     if (!lastUserMessage) {
       state = createSessionState();
@@ -11443,6 +11535,7 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
         messages,
         config
       );
+      const requestModel = lastUserMessage.info.model;
       const requestModelLimit = registry4.resolveModelLimit(
         requestModel?.providerID,
         requestModel?.modelID
@@ -11507,30 +11600,6 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
     prune(state, logger, config, output.messages);
     truncateLargeToolOutputs(state, config, logger, output.messages);
     hideConsumedCompressCalls(state, output.messages);
-    if (config.compress.stripProtectedReasoning !== false) {
-      const removedReasoning = stripProtectedReasoning(
-        output.messages,
-        config.compress.protectedTools,
-        config.compress.stripProtectedReasoningThreshold ?? 0,
-        {
-          // Prefer this request's provider from the user-message
-          // model metadata; fall back to the cached identity pair
-          // (undefined on the first request of a fresh session →
-          // fail-closed).
-          providerID: requestModel?.providerID ?? state.modelProviderID,
-          allowedProviders: config.compress.stripProtectedReasoningProviders ?? [
-            "anthropic",
-            "gemini"
-          ],
-          minMessages: config.compress.stripProtectedReasoningMinMessages ?? 100
-        }
-      );
-      if (removedReasoning > 0) {
-        logger.debug("stripProtectedReasoning: removed reasoning parts from historical protected messages", {
-          removed: removedReasoning
-        });
-      }
-    }
     assignMessageRefs(state, output.messages);
     const compressionPriorities = buildPriorityMap(config, state, output.messages);
     prompts.reload();
@@ -11987,7 +12056,7 @@ var server = (async (ctx) => {
   }
   const logger = new Logger(config.debug, config.debug ? "debug" : config.logLevel);
   logger.info("ACP plugin initialized", {
-    version: true ? "1.14.27-pr.370.111" : "dev",
+    version: true ? "1.14.27-pr.376.109" : "dev",
     workspace: ctx.directory,
     logLevel: logger.level,
     debug: config.debug,