opencode-acp 1.16.0-pr.376.121 → 1.16.0-pr.382.117

package/dist/index.js

@@ -2390,12 +2390,12 @@ function serializePruneMessagesState(messagesState) {
     markedForCleanup: Array.from(messagesState.markedForCleanup)
   };
 }
-async function getForkParentId(client, sessionID) {
+async function isSubAgentSession(client, sessionID) {
   try {
     const result = await client.session.get({ path: { id: sessionID } });
-    return result.data?.parentID ?? null;
+    return !!result.data?.parentID;
   } catch (error) {
-    return null;
+    return false;
   }
 }
 function findLastCompactionTimestamp(messages) {
@@ -4456,205 +4456,6 @@ 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);
@@ -4849,8 +4650,8 @@ async function ensureSessionInitialized(client, state, sessionId, logger, messag
   resetSessionState(state);
   state.sessionId = sessionId;
   state.storageDir = config?.storagePath ? resolveStorageDir(config.storagePath, projectDir ?? cwd()) : void 0;
-  const parentId = await getForkParentId(client, sessionId);
-  state.isSubAgent = parentId !== null;
+  const isSubAgent = await isSubAgentSession(client, sessionId);
+  state.isSubAgent = isSubAgent;
   state.lastCompaction = findLastCompactionTimestamp(messages);
   state.currentTurn = countTurns(state, messages);
   state.nudges.turnNudgeAnchors = collectTurnNudgeAnchors(messages);
@@ -4864,14 +4665,8 @@ async function ensureSessionInitialized(client, state, sessionId, logger, messag
       );
     }
     if (config) {
-      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) {
+      const rebuilt = rebuildCompressionState(state, messages, config, logger);
+      if (rebuilt > 0) {
         await saveSessionState(state, logger);
       }
     }
@@ -9735,7 +9530,7 @@ import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { join as join4 } from "path";
 import { existsSync as existsSync4 } from "fs";
 import { homedir as homedir3 } from "os";
-var LOG_VERSION = true ? "1.16.0-pr.376.121" : "dev";
+var LOG_VERSION = true ? "1.16.0-pr.382.117" : "dev";
 var LEVEL_RANK = {
   debug: 10,
   info: 20,
@@ -12226,7 +12021,7 @@ var server = (async (ctx) => {
   }
   const logger = new Logger(config.debug, config.debug ? "debug" : config.logLevel);
   logger.info("ACP plugin initialized", {
-    version: true ? "1.16.0-pr.376.121" : "dev",
+    version: true ? "1.16.0-pr.382.117" : "dev",
     workspace: ctx.directory,
     logLevel: logger.level,
     debug: config.debug,