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

package/dist/index.js

@@ -2323,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) {
@@ -4365,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);
@@ -4553,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);
       }
     }
@@ -6819,7 +7024,6 @@ function estimateContextComposition(messages, state, protectedTools = [], protec
   let summaryTokens = 0;
   let messageTokens = 0;
   let protectedTokens = 0;
-  let reasoningTokens = 0;
   const perMessage = [];
   const perTool = [];
   const perCode = [];
@@ -6873,10 +7077,6 @@ function estimateContextComposition(messages, state, protectedTools = [], protec
         summaryTokens += summaryPartTokens;
         toolTypeMap.set(toolName, (toolTypeMap.get(toolName) || 0) + toolPartTokens);
         if (!msgToolName) msgToolName = toolName;
-      } else if (part.type === "reasoning" && typeof part.text === "string") {
-        const tokens = Math.round(part.text.length / 4);
-        msgTotal += tokens;
-        reasoningTokens += tokens;
       }
     }
     if (isProtected && !isSummary) {
@@ -6904,8 +7104,7 @@ function estimateContextComposition(messages, state, protectedTools = [], protec
     textTokens: Math.max(0, messageTokens - codeTokens),
     systemTokens,
     protectedTokens,
-    reasoningTokens,
-    total: systemTokens + toolTokens + summaryTokens + messageTokens + reasoningTokens,
+    total: systemTokens + toolTokens + summaryTokens + messageTokens,
     largestRanges: perMessage.slice(0, 15),
     largestToolRanges: perTool.slice(0, 15),
     largestCodeRanges: perCode.slice(0, 5),
@@ -8100,7 +8299,7 @@ This is an efficiency nudge to compress early and keep context lean \u2014 not a
 ${COMPRESS_PHILOSOPHY}` : "";
       const sysPart = composition.systemTokens > 0 ? `${fmt(composition.systemTokens)} system (${pct2(composition.systemTokens)}%) | ` : "";
       let breakdown = `${efficiencyNote}
-Breakdown: ${sysPart}${fmt(composition.toolTokens)} tool (${pct2(composition.toolTokens)}%) | ${fmt(composition.summaryTokens)} summaries (${pct2(composition.summaryTokens)}%) | ${fmt(composition.codeTokens)} code (${pct2(composition.codeTokens)}%) | ${fmt(plainTextTokens)} text (${pct2(plainTextTokens)}%) | ${fmt(composition.reasoningTokens)} reasoning (${pct2(composition.reasoningTokens)}%)${growthStr}`;
+Breakdown: ${sysPart}${fmt(composition.toolTokens)} tool (${pct2(composition.toolTokens)}%) | ${fmt(composition.summaryTokens)} summaries (${pct2(composition.summaryTokens)}%) | ${fmt(composition.codeTokens)} code (${pct2(composition.codeTokens)}%) | ${fmt(plainTextTokens)} text (${pct2(plainTextTokens)}%)${growthStr}`;
       const compressibleTokens = composition.total - composition.systemTokens - composition.protectedTokens - composition.summaryTokens;
       if (composition.protectedTokens > 0) {
         breakdown += `
@@ -8948,7 +9147,6 @@ function collectVisibleMessages(rawMessages, ctx) {
     const ref = byRawId.get(msgId);
     if (!ref) return;
     let tokens = 0;
-    let reasoning = 0;
     let toolName = "";
     for (const part of msg.parts || []) {
       if (part.type === "text" && typeof part.text === "string") {
@@ -8959,12 +9157,10 @@ function collectVisibleMessages(rawMessages, ctx) {
         if (!toolName) {
           toolName = part?.tool || "unknown";
         }
-      } else if (part.type === "reasoning" && typeof part.text === "string") {
-        reasoning += Math.round(part.text.length / 4);
       }
     }
-    if (tokens > 0 || reasoning > 0) {
-      result.push({ ref, tokens, tool: toolName || "text", index: idx, reasoning });
+    if (tokens > 0) {
+      result.push({ ref, tokens, tool: toolName || "text", index: idx });
     }
   });
   return {
@@ -8986,16 +9182,14 @@ function renderOverview(visibleMessages, summaryTokens, systemTokens, blocks, fe
   } else {
     const totalTool = visibleMessages.filter((m) => m.tool !== "text" && m.tool !== "step-finish").reduce((s, m) => s + m.tokens, 0);
     const totalText = visibleMessages.filter((m) => m.tool === "text").reduce((s, m) => s + m.tokens, 0);
-    const totalReasoning = visibleMessages.reduce((s, m) => s + m.reasoning, 0);
-    const total = systemTokens + totalTool + totalText + summaryTokens + totalReasoning;
+    const total = systemTokens + totalTool + totalText + summaryTokens;
     const sysPct = pct(systemTokens, total);
     const toolPct = pct(totalTool, total);
     const textPct = pct(totalText, total);
     const summaryPct = pct(summaryTokens, total);
-    const reasoningPct = pct(totalReasoning, total);
     lines.push("CONTEXT BREAKDOWN");
     lines.push(
-      `  ${formatTokens(systemTokens)} system (${sysPct}%) | ${formatTokens(totalTool)} tool (${toolPct}%) | ${formatTokens(totalText)} text (${textPct}%) | ${formatTokens(summaryTokens)} summaries (${summaryPct}%) | ${formatTokens(totalReasoning)} reasoning (${reasoningPct}%)`
+      `  ${formatTokens(systemTokens)} system (${sysPct}%) | ${formatTokens(totalTool)} tool (${toolPct}%) | ${formatTokens(totalText)} text (${textPct}%) | ${formatTokens(summaryTokens)} summaries (${summaryPct}%)`
     );
     const topTypes = Array.from(toolTypeMap.entries()).map(([tool6, tokens]) => ({ tool: tool6, tokens })).sort((a, b) => b.tokens - a.tokens).slice(0, 3);
     if (topTypes.length > 0) {
@@ -9106,23 +9300,22 @@ function renderUncompressedDrilldown(visibleMessages, toolFilter, sort, limit) {
   if (toolFilter) {
     filtered = filtered.filter((m) => m.tool === toolFilter);
   }
-  const sizeOf = (m) => m.tokens + m.reasoning;
   if (sort === "time") {
     filtered.sort((a, b) => a.index - b.index);
   } else if (sort === "tool") {
-    filtered.sort((a, b) => a.tool.localeCompare(b.tool) || sizeOf(b) - sizeOf(a));
+    filtered.sort((a, b) => a.tool.localeCompare(b.tool) || b.tokens - a.tokens);
   } else {
-    filtered.sort((a, b) => sizeOf(b) - sizeOf(a));
+    filtered.sort((a, b) => b.tokens - a.tokens);
   }
-  const totalTokens = filtered.reduce((s, m) => s + sizeOf(m), 0);
-  const allTokens = visibleMessages.reduce((s, m) => s + sizeOf(m), 0);
+  const totalTokens = filtered.reduce((s, m) => s + m.tokens, 0);
+  const allTokens = visibleMessages.reduce((s, m) => s + m.tokens, 0);
   const header = toolFilter ? `UNCOMPRESSED \u2014 ${toolFilter}: ${formatTokens(totalTokens)} | ${filtered.length} msgs | ${pct(totalTokens, allTokens)}% of visible` : `UNCOMPRESSED \u2014 ${formatTokens(totalTokens)} | ${filtered.length} msgs`;
   lines.push(header);
   lines.push(`Sorted by ${sort}`);
   lines.push("");
   const shown = filtered.slice(0, limit);
   for (const m of shown) {
-    lines.push(`  ${m.ref} (${formatTokens(sizeOf(m))}) ${m.tool}`);
+    lines.push(`  ${m.ref} (${formatTokens(m.tokens)}) ${m.tool}`);
   }
   if (filtered.length > shown.length) {
     lines.push("");
@@ -9390,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.374.107" : "dev";
+var LOG_VERSION = true ? "1.14.27-pr.376.109" : "dev";
 var LEVEL_RANK = {
   debug: 10,
   info: 20,
@@ -9686,14 +9879,13 @@ CONTEXT BREAKDOWN
 
 When context usage passes a threshold, the system appends a breakdown showing where your context tokens are spent:
 
-Breakdown: 4.2K system (21%) | 8.0K tool (40%) | 2.0K summaries (10%) | 2.6K code (13%) | 2.2K text (11%) | 1.0K reasoning (5%)
+Breakdown: 5.2K system (21%) | 12.3K tool (40%) | 3.1K summaries (10%) | 8.5K code (28%) | 6.5K text (22%)
 
 - "system" = system prompt tokens (AGENTS.md, tool definitions \u2014 not compressible)
 - "tool" = tool call outputs (largest category \u2014 compress first when consumed)
 - "summaries" = existing compression block summaries (already compressed; do not re-compress standalone)
 - "code" = messages containing code blocks
 - "text" = plain text messages
-- "reasoning" = model thinking blocks (counted to match real API usage; freed when their message is compressed)
 
 Below the breakdown, the system lists compressible ranges grouped by conversation turn. All listed ranges should be compressed to summary format \u2014 the only exceptions are protected content, content the current step is actively using, or critical content you cannot reconstruct. Compress the largest ranges first when the current step no longer needs them.
 
@@ -11864,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.374.107" : "dev",
+    version: true ? "1.14.27-pr.376.109" : "dev",
     workspace: ctx.directory,
     logLevel: logger.level,
     debug: config.debug,