opencode-acp 1.15.0 → 1.16.0-pr.376.121

package/dist/index.js

@@ -869,6 +869,7 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "autoUpdate",
   "debug",
   "logLevel",
+  "storagePath",
   "showUpdateToasts",
   "allowSubAgents",
   "pruneNotification",
@@ -959,6 +960,9 @@ function validateConfigTypes(config) {
   if (config.debug !== void 0 && typeof config.debug !== "boolean") {
     errors.push({ key: "debug", expected: "boolean", actual: typeof config.debug });
   }
+  if (config.storagePath !== void 0 && typeof config.storagePath !== "string") {
+    errors.push({ key: "storagePath", expected: "string", actual: typeof config.storagePath });
+  }
   if (config.allowSubAgents !== void 0 && typeof config.allowSubAgents !== "boolean") {
     errors.push({ key: "allowSubAgents", expected: "boolean", actual: typeof config.allowSubAgents });
   }
@@ -1995,6 +1999,7 @@ function mergeLayer(config, data) {
     autoUpdate: data.autoUpdate ?? config.autoUpdate,
     debug: data.debug ?? config.debug,
     logLevel: data.logLevel ?? config.logLevel,
+    storagePath: data.storagePath ?? config.storagePath,
     allowSubAgents: data.allowSubAgents ?? data.experimental?.allowSubAgents ?? config.allowSubAgents,
     pruneNotification: data.pruneNotification ?? config.pruneNotification,
     pruneNotificationType: data.pruneNotificationType ?? config.pruneNotificationType,
@@ -2349,7 +2354,7 @@ Each entry needs a topic \u2014 either its own or the top-level fallback.`;
 import * as fs from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { isAbsolute, join as join2 } from "path";
 
 // lib/state/utils.ts
 var isMessageCompacted = (state, msg) => {
@@ -2385,12 +2390,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) {
@@ -2632,7 +2637,7 @@ function resetOnCompaction(state) {
 }
 
 // lib/state/persistence.ts
-function getStorageDir() {
+function getDefaultStorageDir() {
   return join2(
     process.env.XDG_DATA_HOME || join2(homedir2(), ".local", "share"),
     "opencode",
@@ -2641,14 +2646,33 @@ function getStorageDir() {
     "acp"
   );
 }
-function getSessionFilePath(sessionId) {
-  return join2(getStorageDir(), `${sessionId}.json`);
+function resolveStorageDir(configured, projectDir) {
+  const trimmed = configured?.trim();
+  if (!trimmed) {
+    return getDefaultStorageDir();
+  }
+  if (trimmed === "~") {
+    return homedir2();
+  }
+  if (trimmed.startsWith("~/")) {
+    return join2(homedir2(), trimmed.slice(2));
+  }
+  if (isAbsolute(trimmed)) {
+    return trimmed;
+  }
+  return join2(projectDir, trimmed);
+}
+function getStorageDir(override) {
+  return override || getDefaultStorageDir();
+}
+function getSessionFilePath(sessionId, storageDir) {
+  return join2(getStorageDir(storageDir), `${sessionId}.json`);
 }
-async function writePersistedSessionState(sessionId, state, logger) {
-  const filePath = getSessionFilePath(sessionId);
-  const storageDir = getStorageDir();
-  if (!existsSync2(storageDir)) {
-    await fs.mkdir(storageDir, { recursive: true });
+async function writePersistedSessionState(sessionId, state, logger, storageDir) {
+  const filePath = getSessionFilePath(sessionId, storageDir);
+  const dir = getStorageDir(storageDir);
+  if (!existsSync2(dir)) {
+    await fs.mkdir(dir, { recursive: true });
   }
   const content = JSON.stringify(state, null, 2);
   await fs.writeFile(filePath, content, "utf-8");
@@ -2690,11 +2714,11 @@ async function saveSessionState(sessionState, logger, sessionName) {
     modelProviderID: sessionState.modelProviderID,
     modelID: sessionState.modelID
   };
-  await writePersistedSessionState(sessionState.sessionId, state, logger);
+  await writePersistedSessionState(sessionState.sessionId, state, logger, sessionState.storageDir);
 }
-async function loadSessionState(sessionId, logger) {
+async function loadSessionState(sessionId, logger, storageDir) {
   try {
-    const filePath = getSessionFilePath(sessionId);
+    const filePath = getSessionFilePath(sessionId, storageDir);
     if (!existsSync2(filePath)) {
       return null;
     }
@@ -2770,6 +2794,11 @@ async function loadSessionState(sessionId, logger) {
   }
 }
 
+// lib/state/state.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { cwd } from "process";
+
 // lib/message-ids.ts
 var MESSAGE_REF_REGEX = /^m(\d{4,5})$/;
 var BLOCK_REF_REGEX = /^b([1-9]\d*)$/;
@@ -4427,6 +4456,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);
@@ -4446,10 +4674,12 @@ async function updatePerTurnState(state, logger, messages) {
 }
 var REGISTRY_SOFT_CAP = 32;
 var SessionStateRegistry = class {
-  constructor(logger) {
+  constructor(logger, projectDir) {
     this.logger = logger;
+    this.projectDir = projectDir;
   }
   logger;
+  projectDir;
   states = /* @__PURE__ */ new Map();
   compressionTiming = {
     startsByCallId: /* @__PURE__ */ new Map(),
@@ -4502,7 +4732,8 @@ var SessionStateRegistry = class {
         sessionId,
         this.logger,
         messages,
-        config
+        config,
+        this.projectDir
       );
     } catch (err) {
       this.logger.error("Failed to initialize session state", {
@@ -4566,6 +4797,7 @@ function createSessionState() {
     modelProviderID: void 0,
     modelID: void 0,
     systemPromptTokens: void 0,
+    storageDir: void 0,
     qualityGateRetryPending: false
   };
 }
@@ -4607,24 +4839,39 @@ function resetSessionState(state) {
   state.modelProviderID = void 0;
   state.modelID = void 0;
   state.systemPromptTokens = void 0;
+  state.storageDir = void 0;
   state.qualityGateRetryPending = false;
 }
-async function ensureSessionInitialized(client, state, sessionId, logger, messages, config) {
+async function ensureSessionInitialized(client, state, sessionId, logger, messages, config, projectDir) {
   if (state.sessionId === sessionId) {
     return;
   }
   resetSessionState(state);
   state.sessionId = sessionId;
-  const isSubAgent = await isSubAgentSession(client, sessionId);
-  state.isSubAgent = isSubAgent;
+  state.storageDir = config?.storagePath ? resolveStorageDir(config.storagePath, projectDir ?? cwd()) : void 0;
+  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);
+  const persisted = await loadSessionState(sessionId, logger, state.storageDir);
   if (persisted === null) {
+    const defaultPath = join3(getDefaultStorageDir(), `${sessionId}.json`);
+    if (state.storageDir && existsSync3(defaultPath)) {
+      logger.warn(
+        "storagePath is set but no valid state was found there; a state file exists at the default location \u2014 move it manually to keep history",
+        { sessionId, storageDir: state.storageDir, defaultPath }
+      );
+    }
     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);
       }
     }
@@ -9485,10 +9732,10 @@ function hideFailedCompressCalls(messages) {
 
 // lib/logger.ts
 import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join3 } from "path";
-import { existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
+import { existsSync as existsSync4 } from "fs";
 import { homedir as homedir3 } from "os";
-var LOG_VERSION = true ? "1.15.0" : "dev";
+var LOG_VERSION = true ? "1.16.0-pr.376.121" : "dev";
 var LEVEL_RANK = {
   debug: 10,
   info: 20,
@@ -9508,8 +9755,8 @@ var Logger = class {
   constructor(enabled, level) {
     const resolved = level !== void 0 && LEVEL_RANK[level] !== void 0 ? level : void 0;
     this.level = resolved ?? (enabled ? "debug" : "warn");
-    const configHome = process.env.XDG_CONFIG_HOME || join3(homedir3(), ".config");
-    this.logDir = join3(configHome, "opencode", "logs", "acp");
+    const configHome = process.env.XDG_CONFIG_HOME || join4(homedir3(), ".config");
+    this.logDir = join4(configHome, "opencode", "logs", "acp");
   }
   /** Back-compat view of the old flag: true only at full debug verbosity. */
   get enabled() {
@@ -9519,7 +9766,7 @@ var Logger = class {
     return LEVEL_RANK[level] >= LEVEL_RANK[this.level];
   }
   async ensureLogDir() {
-    if (!existsSync3(this.logDir)) {
+    if (!existsSync4(this.logDir)) {
       await mkdir2(this.logDir, { recursive: true });
     }
   }
@@ -9571,11 +9818,11 @@ var Logger = class {
       const dataStr = this.formatData(data);
       const logLine = `${timestamp} ${level.padEnd(5)} ${component}: ${message}${dataStr ? " | " + dataStr : ""} | v=${LOG_VERSION}
 `;
-      const dailyLogDir = join3(this.logDir, "daily");
-      if (!existsSync3(dailyLogDir)) {
+      const dailyLogDir = join4(this.logDir, "daily");
+      if (!existsSync4(dailyLogDir)) {
         await mkdir2(dailyLogDir, { recursive: true });
       }
-      const logFile = join3(dailyLogDir, `${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.log`);
+      const logFile = join4(dailyLogDir, `${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.log`);
       await writeFile2(logFile, logLine, { flag: "a" });
     } catch (error) {
     }
@@ -9686,18 +9933,18 @@ var Logger = class {
   async saveContext(sessionId, messages) {
     if (this.level !== "debug") return;
     try {
-      const contextDir = join3(this.logDir, "context", sessionId);
-      if (!existsSync3(contextDir)) {
+      const contextDir = join4(this.logDir, "context", sessionId);
+      if (!existsSync4(contextDir)) {
         await mkdir2(contextDir, { recursive: true });
       }
       const minimized = this.minimizeForDebug(messages).filter(
         (msg) => msg.parts && msg.parts.length > 0
       );
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      const contextFile = join3(contextDir, `${timestamp}.json`);
+      const contextFile = join4(contextDir, `${timestamp}.json`);
       await writeFile2(contextFile, JSON.stringify(minimized, null, 2));
-      const versionFile = join3(contextDir, "_version");
-      if (!existsSync3(versionFile)) {
+      const versionFile = join4(contextDir, "_version");
+      if (!existsSync4(versionFile)) {
         await writeFile2(versionFile, LOG_VERSION);
       }
     } catch (error) {
@@ -9706,8 +9953,8 @@ var Logger = class {
 };
 
 // lib/prompts/store.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, statSync as statSync2 } from "fs";
-import { join as join4, dirname as dirname2 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, statSync as statSync2 } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
 import { homedir as homedir4 } from "os";
 
 // lib/prompts/system.ts
@@ -10037,8 +10284,8 @@ function createBundledRuntimePrompts() {
 function findOpencodeDir2(startDir) {
   let current = startDir;
   while (current !== "/") {
-    const candidate = join4(current, ".opencode");
-    if (existsSync4(candidate)) {
+    const candidate = join5(current, ".opencode");
+    if (existsSync5(candidate)) {
       try {
         if (statSync2(candidate).isDirectory()) {
           return candidate;
@@ -10055,13 +10302,13 @@ function findOpencodeDir2(startDir) {
   return null;
 }
 function resolvePromptPaths(workingDirectory) {
-  const configHome = process.env.XDG_CONFIG_HOME || join4(homedir4(), ".config");
-  const globalRoot = join4(configHome, "opencode", "acp-prompts");
-  const defaultsDir = join4(globalRoot, "defaults");
-  const globalOverridesDir = join4(globalRoot, "overrides");
-  const configDirOverridesDir = process.env.OPENCODE_CONFIG_DIR ? join4(process.env.OPENCODE_CONFIG_DIR, "acp-prompts", "overrides") : null;
+  const configHome = process.env.XDG_CONFIG_HOME || join5(homedir4(), ".config");
+  const globalRoot = join5(configHome, "opencode", "acp-prompts");
+  const defaultsDir = join5(globalRoot, "defaults");
+  const globalOverridesDir = join5(globalRoot, "overrides");
+  const configDirOverridesDir = process.env.OPENCODE_CONFIG_DIR ? join5(process.env.OPENCODE_CONFIG_DIR, "acp-prompts", "overrides") : null;
   const opencodeDir = findOpencodeDir2(workingDirectory);
-  const projectOverridesDir = opencodeDir ? join4(opencodeDir, "acp-prompts", "overrides") : null;
+  const projectOverridesDir = opencodeDir ? join5(opencodeDir, "acp-prompts", "overrides") : null;
   return {
     defaultsDir,
     globalOverridesDir,
@@ -10161,7 +10408,7 @@ function buildDefaultsReadmeContent() {
 `;
 }
 function readFileIfExists(filePath) {
-  if (!existsSync4(filePath)) {
+  if (!existsSync5(filePath)) {
     return null;
   }
   try {
@@ -10232,16 +10479,16 @@ var PromptStore = class {
     const candidates = [];
     if (this.paths.projectOverridesDir) {
       candidates.push({
-        path: join4(this.paths.projectOverridesDir, fileName)
+        path: join5(this.paths.projectOverridesDir, fileName)
       });
     }
     if (this.paths.configDirOverridesDir) {
       candidates.push({
-        path: join4(this.paths.configDirOverridesDir, fileName)
+        path: join5(this.paths.configDirOverridesDir, fileName)
       });
     }
     candidates.push({
-      path: join4(this.paths.globalOverridesDir, fileName)
+      path: join5(this.paths.globalOverridesDir, fileName)
     });
     return candidates;
   }
@@ -10264,7 +10511,7 @@ var PromptStore = class {
       const managedContent = buildDefaultPromptFileContent(
         bundledEditable || BUNDLED_EDITABLE_PROMPTS[definition.runtimeField]
       );
-      const filePath = join4(this.paths.defaultsDir, definition.fileName);
+      const filePath = join5(this.paths.defaultsDir, definition.fileName);
       try {
         const existing = readFileIfExists(filePath);
         if (existing === managedContent) {
@@ -10278,7 +10525,7 @@ var PromptStore = class {
         });
       }
     }
-    const readmePath = join4(this.paths.defaultsDir, DEFAULTS_README_FILE);
+    const readmePath = join5(this.paths.defaultsDir, DEFAULTS_README_FILE);
     const readmeContent = buildDefaultsReadmeContent();
     try {
       const existing = readFileIfExists(readmePath);
@@ -10575,8 +10822,8 @@ ${report}`;
 
 // lib/commands/export.ts
 import * as fs2 from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-import { dirname as dirname3, isAbsolute, join as join5, resolve } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join6, resolve } from "path";
 var ALL_TIERS = [1, 2, 3];
 var TIER_NAMES = {
   1: "Tier 1 \u2014 Capture",
@@ -10687,9 +10934,9 @@ function parseTiers(raw) {
   }
   return result;
 }
-function resolveDefaultOutputPath(sessionId, cwd) {
+function resolveDefaultOutputPath(sessionId, cwd2) {
   const short = (sessionId || "session").slice(0, 8);
-  return join5(cwd, ".opencode", `acp-export-${short}.md`);
+  return join6(cwd2, ".opencode", `acp-export-${short}.md`);
 }
 function formatTokens2(n) {
   if (!Number.isFinite(n) || n <= 0) return "0";
@@ -10816,15 +11063,15 @@ async function handleExportCommand(ctx, args) {
     await sendExportNotice(client, sessionId, ctx, markdown);
     return;
   }
-  const cwd = ctx.workingDirectory || process.cwd();
-  const targetPath = options.outputPath !== "" ? isAbsolute(options.outputPath) ? options.outputPath : resolve(cwd, options.outputPath) : resolveDefaultOutputPath(sessionId, cwd);
+  const cwd2 = ctx.workingDirectory || process.cwd();
+  const targetPath = options.outputPath !== "" ? isAbsolute2(options.outputPath) ? options.outputPath : resolve(cwd2, options.outputPath) : resolveDefaultOutputPath(sessionId, cwd2);
   try {
     const dir = dirname3(targetPath);
-    if (!existsSync5(dir)) {
+    if (!existsSync6(dir)) {
       await fs2.mkdir(dir, { recursive: true });
     }
     const flag = options.append ? "a" : "w";
-    if (options.append && existsSync5(targetPath)) {
+    if (options.append && existsSync6(targetPath)) {
       await fs2.appendFile(targetPath, `
 
 ---
@@ -11767,7 +12014,7 @@ function findBiliProxyProviders(provider) {
 
 // lib/update.ts
 import { readFile as readFile2, rm } from "fs/promises";
-import { basename, dirname as dirname4, join as join6 } from "path";
+import { basename, dirname as dirname4, join as join7 } from "path";
 import { fileURLToPath } from "url";
 var PACKAGE_NAME = "opencode-acp";
 function startAutoUpdate(ctx, enabled, logger) {
@@ -11814,7 +12061,7 @@ async function checkAutoUpdate(signal, logger) {
     logger?.info("Auto-update skipped: package dir not found");
     return { updated: false };
   }
-  const pkg = await readPackageJson(join6(packageDir, "package.json"));
+  const pkg = await readPackageJson(join7(packageDir, "package.json"));
   if (!pkg?.name || !pkg.version) {
     logger?.info("Auto-update skipped: package.json unreadable", { packageDir });
     return { updated: false };
@@ -11855,7 +12102,7 @@ async function checkAutoUpdate(signal, logger) {
 async function findPackageDir(name) {
   let dir = dirname4(fileURLToPath(import.meta.url));
   for (; ; ) {
-    const pkg = await readPackageJson(join6(dir, "package.json"));
+    const pkg = await readPackageJson(join7(dir, "package.json"));
     if (pkg?.name === name) return dir;
     const parent = dirname4(dir);
     if (parent === dir) return void 0;
@@ -11867,7 +12114,7 @@ async function updateTarget(packageDir, name) {
   const nodeModulesDir = basename(packageParent).startsWith("@") ? dirname4(packageParent) : packageParent;
   if (basename(nodeModulesDir) !== "node_modules") return void 0;
   const wrapperDir = dirname4(nodeModulesDir);
-  const wrapperPkg = await readPackageJson(join6(wrapperDir, "package.json"));
+  const wrapperPkg = await readPackageJson(join7(wrapperDir, "package.json"));
   const spec = wrapperSpec(wrapperDir, name) ?? wrapperPkg?.dependencies?.[name];
   if (!spec || !isAutoUpdatableSpec(spec)) return void 0;
   return { removeDir: wrapperDir, spec };
@@ -11979,14 +12226,14 @@ var server = (async (ctx) => {
   }
   const logger = new Logger(config.debug, config.debug ? "debug" : config.logLevel);
   logger.info("ACP plugin initialized", {
-    version: true ? "1.15.0" : "dev",
+    version: true ? "1.16.0-pr.376.121" : "dev",
     workspace: ctx.directory,
     logLevel: logger.level,
     debug: config.debug,
     autoUpdate: config.autoUpdate,
     secureMode: isSecureMode()
   });
-  const registry4 = new SessionStateRegistry(logger);
+  const registry4 = new SessionStateRegistry(logger, ctx.directory);
   const prompts = new PromptStore(logger, ctx.directory, config.experimental.customPrompts);
   const hostPermissions = {
     global: void 0,