opencode-acp 1.15.0 → 1.16.0-pr.349.122

package/dist/index.js

@@ -869,6 +869,7 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "autoUpdate",
   "debug",
   "logLevel",
+  "storagePath",
   "showUpdateToasts",
   "allowSubAgents",
   "pruneNotification",
@@ -889,6 +890,7 @@ var VALID_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "compress.modelMaxLimits",
   "compress.modelMinLimits",
   "compress.providers",
+  "compress.contextLimitFallback",
   "compress.nudgeFrequency",
   "compress.minNudgeContextPercent",
   "compress.nudgeGrowthTokens",
@@ -959,6 +961,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 });
   }
@@ -1517,6 +1522,20 @@ function validateConfigTypes(config) {
         }
       };
       validateProviderOverrides(compress.providers);
+      if (compress.contextLimitFallback !== void 0 && typeof compress.contextLimitFallback !== "number") {
+        errors.push({
+          key: "compress.contextLimitFallback",
+          expected: "number",
+          actual: typeof compress.contextLimitFallback
+        });
+      }
+      if (typeof compress.contextLimitFallback === "number" && compress.contextLimitFallback < 0) {
+        errors.push({
+          key: "compress.contextLimitFallback",
+          expected: "non-negative number (0 disables the fallback)",
+          actual: `${compress.contextLimitFallback}`
+        });
+      }
       const validValues = ["ask", "allow", "deny"];
       if (compress.permission !== void 0 && !validValues.includes(compress.permission)) {
         errors.push({
@@ -1698,6 +1717,7 @@ var defaultConfig = {
     summaryBuffer: true,
     maxContextLimit: "80%",
     minContextLimit: "80%",
+    contextLimitFallback: 128e3,
     nudgeFrequency: 5,
     minNudgeContextPercent: 5,
     iterationNudgeThreshold: 15,
@@ -1868,6 +1888,7 @@ function mergeCompress(base, override) {
     modelMaxLimits: override.modelMaxLimits ?? base.modelMaxLimits,
     modelMinLimits: override.modelMinLimits ?? base.modelMinLimits,
     providers: mergeProviderOverrides(base.providers, override.providers),
+    contextLimitFallback: override.contextLimitFallback ?? base.contextLimitFallback,
     nudgeFrequency: override.nudgeFrequency ?? base.nudgeFrequency,
     minNudgeContextPercent: override.minNudgeContextPercent ?? base.minNudgeContextPercent,
     nudgeGrowthTokens: override.nudgeGrowthTokens,
@@ -1995,6 +2016,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 +2371,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) => {
@@ -2630,9 +2652,19 @@ function resetOnCompaction(state) {
     nextRef: 1
   };
 }
+function resolveEffectiveContextLimit(state, config) {
+  if (typeof state.modelContextLimit === "number" && state.modelContextLimit > 0) {
+    return { limit: state.modelContextLimit, source: "model" };
+  }
+  const fallback = config.compress.contextLimitFallback;
+  if (typeof fallback === "number" && fallback > 0) {
+    return { limit: fallback, source: "fallback" };
+  }
+  return void 0;
+}
 
 // lib/state/persistence.ts
-function getStorageDir() {
+function getDefaultStorageDir() {
   return join2(
     process.env.XDG_DATA_HOME || join2(homedir2(), ".local", "share"),
     "opencode",
@@ -2641,14 +2673,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 +2741,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 +2821,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*)$/;
@@ -4446,10 +4502,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(),
@@ -4475,6 +4533,24 @@ var SessionStateRegistry = class {
   hydrateModelLimitsFromClient(client) {
     return this.catalog.hydrateFromClient(client);
   }
+  // [FIX #346] The init-time seed (above) is fire-and-forget and races
+  // server readiness: in headless spawn+resume mode the provider-config
+  // call can fail before the server is up, leaving the catalog empty for
+  // the process's lifetime. During a request the server is guaranteed up
+  // (we are inside its pipeline), so on a catalog miss we retry hydration
+  // once per process before giving up (the fallback limit then applies).
+  // The in-flight promise (not a boolean) lets concurrent callers await the
+  // same hydration instead of skipping it.
+  lazyHydration;
+  async hydrateAndResolve(client, providerId, modelId) {
+    const existing = this.catalog.resolve(providerId, modelId);
+    if (existing !== void 0) {
+      return existing;
+    }
+    this.lazyHydration ??= this.catalog.hydrateFromClient(client);
+    await this.lazyHydration;
+    return this.catalog.resolve(providerId, modelId);
+  }
   get(sessionId) {
     return this.states.get(sessionId);
   }
@@ -4502,7 +4578,8 @@ var SessionStateRegistry = class {
         sessionId,
         this.logger,
         messages,
-        config
+        config,
+        this.projectDir
       );
     } catch (err) {
       this.logger.error("Failed to initialize session state", {
@@ -4566,6 +4643,7 @@ function createSessionState() {
     modelProviderID: void 0,
     modelID: void 0,
     systemPromptTokens: void 0,
+    storageDir: void 0,
     qualityGateRetryPending: false
   };
 }
@@ -4607,21 +4685,30 @@ 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;
+  state.storageDir = config?.storagePath ? resolveStorageDir(config.storagePath, projectDir ?? cwd()) : void 0;
   const isSubAgent = await isSubAgentSession(client, sessionId);
   state.isSubAgent = isSubAgent;
   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) {
@@ -6615,6 +6702,7 @@ function getModelInfo(messages) {
   };
 }
 function resolveContextTokenLimit(config, state, providerId, modelId, threshold) {
+  const effectiveLimit = resolveEffectiveContextLimit(state, config);
   const parseLimitValue = (limit) => {
     if (limit === void 0) {
       return void 0;
@@ -6622,7 +6710,7 @@ function resolveContextTokenLimit(config, state, providerId, modelId, threshold)
     if (typeof limit === "number") {
       return limit;
     }
-    if (!limit.endsWith("%") || state.modelContextLimit === void 0) {
+    if (!limit.endsWith("%") || effectiveLimit === void 0) {
       return void 0;
     }
     const parsedPercent = parseFloat(limit.slice(0, -1));
@@ -6631,7 +6719,7 @@ function resolveContextTokenLimit(config, state, providerId, modelId, threshold)
     }
     const roundedPercent = Math.round(parsedPercent);
     const clampedPercent = Math.max(0, Math.min(100, roundedPercent));
-    return Math.round(clampedPercent / 100 * state.modelContextLimit);
+    return Math.round(clampedPercent / 100 * effectiveLimit.limit);
   };
   if (threshold === "max") {
     const nestedLimit = resolveCompressOverrides(config, providerId, modelId).maxContextLimit;
@@ -6682,11 +6770,12 @@ function isContextOverLimits(config, state, providerId, modelId, messages) {
       if (!overMaxLimit) break;
     }
   }
+  const effectiveLimit = resolveEffectiveContextLimit(state, config);
   return {
     overMaxLimit,
     overMinLimit,
     currentTokens,
-    modelContextLimit: state.modelContextLimit
+    modelContextLimit: effectiveLimit?.limit
   };
 }
 ensureBuiltinTriggerPolicyRegistered();
@@ -8765,8 +8854,9 @@ function createDecompressTool(factoryCtx) {
     async execute(args, toolCtx) {
       const ctx = resolveToolContext(factoryCtx, toolCtx.sessionID);
       const { rawMessages } = await prepareDecompressSession(ctx, toolCtx);
-      const contextUsageBefore = ctx.state.modelContextLimit ? Math.round(
-        getCurrentTokenUsage(ctx.state, rawMessages) / ctx.state.modelContextLimit * 100
+      const effectiveLimitBefore = resolveEffectiveContextLimit(ctx.state, ctx.config);
+      const contextUsageBefore = effectiveLimitBefore ? Math.round(
+        getCurrentTokenUsage(ctx.state, rawMessages) / effectiveLimitBefore.limit * 100
       ) : void 0;
       const resolved = resolveTargets(args, ctx.state, rawMessages, ctx.logger);
       if (!resolved.ok) {
@@ -8830,8 +8920,9 @@ function createDecompressTool(factoryCtx) {
         0,
         ctx.state.stats.totalPruneTokens - restoredTokens
       );
-      const contextUsageAfter = ctx.state.modelContextLimit ? Math.round(
-        getCurrentTokenUsage(ctx.state, rawMessages) / ctx.state.modelContextLimit * 100
+      const effectiveLimitAfter = resolveEffectiveContextLimit(ctx.state, ctx.config);
+      const contextUsageAfter = effectiveLimitAfter ? Math.round(
+        getCurrentTokenUsage(ctx.state, rawMessages) / effectiveLimitAfter.limit * 100
       ) : void 0;
       await finalizeDecompressSession(ctx);
       const restoredContentPreview = buildRestoredContentPreview(
@@ -9485,10 +9576,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.349.122" : "dev";
 var LEVEL_RANK = {
   debug: 10,
   info: 20,
@@ -9508,8 +9599,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 +9610,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 +9662,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 +9777,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 +9797,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 +10128,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 +10146,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 +10252,7 @@ function buildDefaultsReadmeContent() {
 `;
 }
 function readFileIfExists(filePath) {
-  if (!existsSync4(filePath)) {
+  if (!existsSync5(filePath)) {
     return null;
   }
   try {
@@ -10232,16 +10323,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 +10355,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 +10369,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);
@@ -10312,6 +10403,8 @@ var MIN_OUTPUT_TOKENS = 1e3;
 var KEEP_PREFIX_CHARS = 2e3;
 var KEEP_SUFFIX_CHARS = 2e3;
 var PROTECT_RECENT_MESSAGES = 3;
+var OUTPUT_RESERVE_TOKENS = 16384;
+var overheadErrorLogged = /* @__PURE__ */ new Set();
 function parseGcThreshold(threshold, modelContextLimit) {
   if (typeof threshold === "number") return threshold;
   const str = threshold ?? "100%";
@@ -10320,10 +10413,26 @@ function parseGcThreshold(threshold, modelContextLimit) {
   return modelContextLimit;
 }
 function truncateLargeToolOutputs(state, config, logger, messages) {
-  if (!state.modelContextLimit) return;
+  const effective = resolveEffectiveContextLimit(state, config);
+  if (!effective) return;
   const currentTokens = getCurrentTokenUsage(state, messages);
   if (currentTokens === 0) return;
-  const threshold = parseGcThreshold(config.gc?.majorGcThresholdPercent, state.modelContextLimit);
+  const configuredThreshold = parseGcThreshold(config.gc?.majorGcThresholdPercent, effective.limit);
+  const overhead = (state.systemPromptTokens ?? 0) + OUTPUT_RESERVE_TOKENS;
+  const threshold = Math.min(configuredThreshold, effective.limit - overhead);
+  if (threshold <= 0) {
+    const sessionKey = state.sessionId ?? "unknown";
+    if (!overheadErrorLogged.has(sessionKey)) {
+      overheadErrorLogged.add(sessionKey);
+      logger.error("ACP: model context window too small to fit overhead", {
+        session: state.sessionId,
+        limit: effective.limit,
+        contextLimitSource: effective.source,
+        overhead
+      });
+    }
+    return;
+  }
   if (currentTokens < threshold) return;
   const protectedIndex = messages.length - PROTECT_RECENT_MESSAGES;
   const candidates = [];
@@ -10368,7 +10477,9 @@ function truncateLargeToolOutputs(state, config, logger, messages) {
       truncatedCount,
       estimatedSavedTokens: Math.round(savedTokens),
       currentTokens,
-      threshold
+      threshold,
+      contextLimit: effective.limit,
+      contextLimitSource: effective.source
     });
   }
 }
@@ -10575,8 +10686,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 +10798,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 +10927,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, `
 
 ---
@@ -11329,11 +11440,12 @@ function runBatchCleanup(state, config, logger, messages) {
     mergedCount: 0,
     savedTokens: 0
   };
-  if (!state.modelContextLimit || state.modelContextLimit <= 0) {
+  const effective = resolveEffectiveContextLimit(state, config);
+  if (!effective) {
     return noop;
   }
   const currentTokens = getCurrentTokenUsage(state, messages);
-  if (currentTokens < state.modelContextLimit) {
+  if (currentTokens < effective.limit) {
     return noop;
   }
   const maxMergedLength = config.gc.maxOldGenSummaryLength;
@@ -11350,7 +11462,8 @@ function runBatchCleanup(state, config, logger, messages) {
     mergedCount: result.mergedCount,
     savedTokens: result.savedTokens,
     currentTokens,
-    contextLimit: state.modelContextLimit
+    contextLimit: effective.limit,
+    contextLimitSource: effective.source
   });
   return {
     tier: 3,
@@ -11384,11 +11497,6 @@ function createSystemPromptHandler(registry4, logger, config, prompts) {
       input.model?.limit?.context
     );
     const state = input.sessionID ? registry4.get(input.sessionID) : void 0;
-    if (state && input.model?.limit?.context) {
-      state.modelContextLimit = input.model.limit.context;
-      state.modelProviderID = input.model?.providerID;
-      state.modelID = input.model?.id;
-    }
     if (!state || state.isSubAgent && !config.allowSubAgents) {
       return;
     }
@@ -11397,6 +11505,23 @@ function createSystemPromptHandler(registry4, logger, config, prompts) {
       logger.info("Skipping DCP system prompt injection for internal agent");
       return;
     }
+    if (input.model?.limit?.context) {
+      const limit = input.model.limit.context;
+      const providerID = input.model?.providerID;
+      const modelID = input.model?.id;
+      const changed = state.modelContextLimit !== limit || providerID !== void 0 && state.modelProviderID !== providerID || modelID !== void 0 && state.modelID !== modelID;
+      state.modelContextLimit = limit;
+      if (providerID !== void 0) {
+        state.modelProviderID = providerID;
+      }
+      if (modelID !== void 0) {
+        state.modelID = modelID;
+      }
+      if (changed) {
+        saveSessionState(state, logger).catch(() => {
+        });
+      }
+    }
     const effectivePermission = compressPermission(state, config);
     if (effectivePermission === "deny") {
       return;
@@ -11441,10 +11566,17 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
         config
       );
       const requestModel = lastUserMessage.info.model;
-      const requestModelLimit = registry4.resolveModelLimit(
+      let requestModelLimit = registry4.resolveModelLimit(
         requestModel?.providerID,
         requestModel?.modelID
       );
+      if (requestModelLimit === void 0 && requestModel?.providerID && requestModel?.modelID) {
+        requestModelLimit = await registry4.hydrateAndResolve(
+          client,
+          requestModel.providerID,
+          requestModel.modelID
+        );
+      }
       const prevModelID = state.modelID;
       if (requestModelLimit !== void 0) {
         state.modelContextLimit = requestModelLimit;
@@ -11499,10 +11631,11 @@ function createChatMessageTransformHandler(client, registry4, logger, config, pr
       }
     }
     ensureBuiltinFiltersRegistered();
+    const effectiveLimit = resolveEffectiveContextLimit(state, config);
     applyMessageFilters(output.messages, config.messageFilters, logger, {
       sessionId: state.sessionId ?? "",
       isSubAgent: state.isSubAgent,
-      modelContextLimit: state.modelContextLimit
+      modelContextLimit: effectiveLimit?.limit
     });
     cacheSystemPromptTokens(state, output.messages);
     assignMessageRefs(state, output.messages);
@@ -11553,14 +11686,31 @@ ${text}`);
     stripStaleMetadata(output.messages);
     dropEmptyMessages(output.messages);
     const postTokens = getCurrentTokenUsage(state, output.messages);
+    if (postTokens !== void 0 && effectiveLimit) {
+      const budget = effectiveLimit.limit - (state.systemPromptTokens ?? 0) - OUTPUT_RESERVE_TOKENS;
+      if (postTokens > budget) {
+        logger.error(
+          "ACP hard guard: context exceeds model budget after in-flight reduction",
+          {
+            session: state.sessionId,
+            postTokens,
+            budget,
+            contextLimit: effectiveLimit.limit,
+            contextLimitSource: effectiveLimit.source,
+            hint: "request will likely be rejected; run /compact or start a new session"
+          }
+        );
+      }
+    }
     logger.info("Chat transform complete", {
       session: state.sessionId,
       model: state.modelID,
       messages: output.messages.length,
       prePruneTokens,
       postTokens,
-      contextLimit: state.modelContextLimit,
-      usagePct: postTokens !== void 0 && state.modelContextLimit ? `${(postTokens / state.modelContextLimit * 100).toFixed(1)}%` : void 0,
+      contextLimit: effectiveLimit?.limit,
+      contextLimitSource: effectiveLimit?.source,
+      usagePct: postTokens !== void 0 && effectiveLimit ? `${(postTokens / effectiveLimit.limit * 100).toFixed(1)}%` : void 0,
       nudged: state.nudges.shouldInjectThisTurn
     });
     if (state.sessionId) {
@@ -11767,7 +11917,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 +11964,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 +12005,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 +12017,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 +12129,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.349.122" : "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,