lody 0.94.0 → 0.95.0

package/dist/chunks/{index-rdPvrzqi.js → index-qnlCmQGA.js}

@@ -4240,9 +4240,9 @@ function $constructor(name, initializer3, params) {
     inst._zod.traits.add(name);
     initializer3(inst, def);
     const proto = _.prototype;
-    const keys = Object.keys(proto);
-    for (let i = 0; i < keys.length; i++) {
-      const k = keys[i];
+    const keys2 = Object.keys(proto);
+    for (let i = 0; i < keys2.length; i++) {
+      const k = keys2[i];
       if (!(k in inst)) {
         inst[k] = proto[k].bind(inst);
       }
@@ -4467,12 +4467,12 @@ function getElementAtPath(obj, path10) {
   return path10.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
-  const keys = Object.keys(promisesObj);
-  const promises = keys.map((key) => promisesObj[key]);
+  const keys2 = Object.keys(promisesObj);
+  const promises = keys2.map((key) => promisesObj[key]);
   return Promise.all(promises).then((results) => {
     const resolvedObj = {};
-    for (let i = 0; i < keys.length; i++) {
-      resolvedObj[keys[i]] = results[i];
+    for (let i = 0; i < keys2.length; i++) {
+      resolvedObj[keys2[i]] = results[i];
     }
     return resolvedObj;
   });
@@ -6583,8 +6583,8 @@ function handlePropertyResult(result, final, key, input, isOptionalOut) {
   }
 }
 function normalizeDef(def) {
-  const keys = Object.keys(def.shape);
-  for (const k of keys) {
+  const keys2 = Object.keys(def.shape);
+  for (const k of keys2) {
     if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
       throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
     }
@@ -6592,9 +6592,9 @@ function normalizeDef(def) {
   const okeys = optionalKeys(def.shape);
   return {
     ...def,
-    keys,
-    keySet: new Set(keys),
-    numKeys: keys.length,
+    keys: keys2,
+    keySet: new Set(keys2),
+    numKeys: keys2.length,
     optionalKeys: new Set(okeys)
   };
 }
@@ -16411,11 +16411,11 @@ var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   inst._zod.processJSONSchema = (ctx, json2, params) => enumProcessor(inst, ctx, json2);
   inst.enum = def.entries;
   inst.options = Object.values(def.entries);
-  const keys = new Set(Object.keys(def.entries));
+  const keys2 = new Set(Object.keys(def.entries));
   inst.extract = (values, params) => {
     const newEntries = {};
     for (const value of values) {
-      if (keys.has(value)) {
+      if (keys2.has(value)) {
         newEntries[value] = def.entries[value];
       } else
         throw new Error(`Key ${value} not found in enum`);
@@ -16430,7 +16430,7 @@ var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   inst.exclude = (values, params) => {
     const newEntries = { ...def.entries };
     for (const value of values) {
-      if (keys.has(value)) {
+      if (keys2.has(value)) {
         delete newEntries[value];
       } else
         throw new Error(`Key ${value} not found in enum`);
@@ -21253,8 +21253,7 @@ function toPromptUsage(tokenCount) {
     thoughtTokens: tokenCount.reasoningOutputTokens
   };
 }
-var CODEX_UNATTRIBUTED_MODEL = "codex:unattributed";
-var counters = [
+var keys = [
   "inputTokens",
   "outputTokens",
   "cacheReadInputTokens",
@@ -21268,39 +21267,51 @@ var empty = () => ({
   cacheCreationInputTokens: 0,
   reasoningOutputTokens: 0
 });
-function normalizeCodexUsage(raw) {
+function normalize(total) {
   return {
-    inputTokens: Math.max(0, raw.inputTokens - raw.cachedInputTokens - raw.cacheWriteInputTokens),
-    outputTokens: Math.max(0, raw.outputTokens - raw.reasoningOutputTokens),
-    cacheReadInputTokens: raw.cachedInputTokens,
-    cacheCreationInputTokens: raw.cacheWriteInputTokens,
-    reasoningOutputTokens: raw.reasoningOutputTokens
-  };
-}
-var CodexUsageAccounting = class {
-  offset = empty();
-  total = empty();
-  atReset = false;
-  update(sessionId, params) {
-    const { total: raw, modelContextWindow } = params.tokenUsage;
-    const reset = modelContextWindow !== null && modelContextWindow > 0 && raw.totalTokens === modelContextWindow && raw.inputTokens === 0 && raw.outputTokens === 0 && raw.cachedInputTokens === 0 && raw.cacheWriteInputTokens === 0 && raw.reasoningOutputTokens === 0;
-    if (reset && !this.atReset) this.offset = { ...this.total };
-    this.atReset = reset;
-    const normalized = normalizeCodexUsage(raw);
-    const next = empty();
-    const difference = empty();
-    for (const key of counters) {
-      next[key] = Math.max(this.total[key] ?? 0, (this.offset[key] ?? 0) + (normalized[key] ?? 0));
-      difference[key] = (next[key] ?? 0) - (this.total[key] ?? 0);
-    }
-    this.total = next;
-    const usage = { ...next };
-    if (modelContextWindow !== null) usage.contextWindow = modelContextWindow;
+    inputTokens: Math.max(0, total.inputTokens - total.cachedInputTokens - total.cacheWriteInputTokens),
+    outputTokens: Math.max(0, total.outputTokens - total.reasoningOutputTokens),
+    cacheReadInputTokens: total.cachedInputTokens,
+    cacheCreationInputTokens: total.cacheWriteInputTokens,
+    reasoningOutputTokens: total.reasoningOutputTokens
+  };
+}
+var CodexTurnUsage = class {
+  previous;
+  turn;
+  requestedModel;
+  constructor(fresh = false, snapshot) {
+    this.previous = snapshot ? normalize(snapshot) : fresh ? empty() : void 0;
+  }
+  prepare(model) {
+    this.requestedModel = model;
+  }
+  start(turnId, model) {
+    if (this.turn?.id === turnId) return;
+    this.turn = { id: turnId, model: this.requestedModel ?? model, usage: empty() };
+  }
+  update(params) {
+    const next = normalize(params.tokenUsage.total);
+    const turn = this.turn;
+    if (!turn) {
+      this.previous = next;
+      return void 0;
+    }
+    if (params.turnId !== turn.id) return void 0;
+    if (!this.previous) {
+      this.previous = next;
+      return void 0;
+    }
+    const delta = empty();
+    for (const key of keys) delta[key] = Math.max(0, (next[key] ?? 0) - (this.previous[key] ?? 0));
+    this.previous = next;
+    if (!keys.some((key) => (delta[key] ?? 0) > 0)) return void 0;
+    for (const key of keys) turn.usage[key] = (turn.usage[key] ?? 0) + (delta[key] ?? 0);
     return {
-      sessionId,
-      usage,
-      modelUsage: { [CODEX_UNATTRIBUTED_MODEL]: { ...next } },
-      delta: { usage: { ...difference }, modelUsage: { [CODEX_UNATTRIBUTED_MODEL]: { ...difference } } }
+      sessionId: params.threadId,
+      usage: { ...turn.usage, ...params.tokenUsage.modelContextWindow !== null && { contextWindow: params.tokenUsage.modelContextWindow } },
+      modelUsage: { [turn.model]: { ...turn.usage } },
+      _meta: { codex: { usageTurnId: turn.id } }
     };
   }
 };
@@ -23646,6 +23657,13 @@ var CodexEventHandler = class _CodexEventHandler {
       case "error":
         return await this.createErrorEvent(notification.params);
       case "turn/started":
+        if (notification.params.threadId === this.sessionState.sessionId) {
+          this.sessionState.turnUsage ??= new CodexTurnUsage();
+          this.sessionState.turnUsage.start(
+            notification.params.turn.id,
+            this.sessionState.currentModelId.replace(/\[.*?]$/, "")
+          );
+        }
         this.sessionState.currentTurnId = notification.params.turn.id;
         await this.flushPendingErrors();
         return null;
@@ -23784,25 +23802,16 @@ var CodexEventHandler = class _CodexEventHandler {
     }
   }
   async emitExtNotification(notification) {
-    switch (notification.method) {
-      case "thread/tokenUsage/updated":
-        await this.notifyExt(
-          ACP_EXT_SESSION_USAGE_UPDATE_METHOD,
-          this.createSessionUsageExtNotification(notification.params)
-        );
-        return;
-      default:
-        return;
+    if (notification.method === "thread/tokenUsage/updated" && notification.params.threadId === this.sessionState.sessionId) {
+      this.sessionState.turnUsage ??= new CodexTurnUsage();
+      const update = this.sessionState.turnUsage.update(notification.params);
+      if (update) await this.notifyExt(ACP_EXT_SESSION_USAGE_UPDATE_METHOD, update);
     }
   }
   async notifyExt(method, params) {
     const extMethod = method.startsWith("_") ? method : `_${method}`;
     await this.connection.notify(extMethod, params);
   }
-  createSessionUsageExtNotification(params) {
-    this.sessionState.usageAccounting ??= new CodexUsageAccounting();
-    return this.sessionState.usageAccounting.update(this.sessionState.sessionId, params);
-  }
   createSessionRateLimitsExtNotification(rateLimits) {
     return {
       rateLimits: [toLodyRateLimit(rateLimits)],
@@ -28468,17 +28477,22 @@ var CodexAppServerClient = class {
   threadGoalUpdateCaptures = /* @__PURE__ */ new Map();
   threadGoalClearedCaptures = /* @__PURE__ */ new Map();
   threadSettings = /* @__PURE__ */ new Map();
+  tokenUsage = /* @__PURE__ */ new Map();
   staleTurnIds = /* @__PURE__ */ new Map();
   turnCompletionTerminalError = null;
   constructor(connection) {
     this.connection = connection;
-    const failPendingTurns = () => this.rejectAllPendingTurnCompletions(
-      new Error("Codex process exited before completing the turn")
-    );
+    const failPendingTurns = () => {
+      const error48 = new Error("Codex process exited before completing the turn");
+      this.rejectAllPendingTurnCompletions(error48);
+    };
     this.connection.onClose(failPendingTurns);
     this.connection.onDispose(failPendingTurns);
     this.connection.onUnhandledNotification((data) => {
       const serverNotification = data;
+      if (serverNotification.method === "thread/tokenUsage/updated") {
+        this.tokenUsage.set(serverNotification.params.threadId, serverNotification.params);
+      }
       if (isMcpServerStatusUpdatedNotification(serverNotification)) {
         this.mcpServerStartupVersion += 1;
         this.mcpServerStartupStates.set(serverNotification.params.name, {
@@ -28586,6 +28600,7 @@ var CodexAppServerClient = class {
     this.elicitationHandlers.set(threadId, handler);
   }
   clearThreadHandlers(threadId) {
+    this.tokenUsage.delete(threadId);
     this.notificationHandlers.delete(threadId);
     this.approvalHandlers.delete(threadId);
     this.elicitationHandlers.delete(threadId);
@@ -28846,6 +28861,9 @@ var CodexAppServerClient = class {
   async threadProjectUpdate(params) {
     await this.sendRequest({ method: "thread/metadata/update", params });
   }
+  getThreadTokenUsage(threadId) {
+    return this.tokenUsage.get(threadId);
+  }
   async threadStart(params) {
     return await this.sendRequest({ method: "thread/start", params });
   }
@@ -31902,6 +31920,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       sessionState.cwd,
       () => sessionState.sessionTitleSource
     );
+    if (operation.kind === "new") sessionState.turnUsage = new CodexTurnUsage(true);
     this.installSessionState(sessionState);
     this.publishRateLimitsAsync(sessionState);
     subscribed = false;
@@ -32649,7 +32668,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         throw error48;
       }
       logger.error(`Steering request for session ${params.sessionId} failed`, error48);
-      return { outcome: "failed" };
+      throw error48;
     } finally {
       if (queue.isIdle && this.steeringQueues.get(params.sessionId) === queue) {
         this.steeringQueues.delete(params.sessionId);
@@ -32686,7 +32705,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     this.assertSteerInputSupported(params, sessionState);
     const turnId = await this.getSteerableTurnId(sessionState);
     if (turnId) {
-      const injected = await this.injectSteerIntoActiveTurn(params, turnId, sessionState);
+      const injected = await this.injectSteerIntoActiveTurn(params, turnId);
       if (injected) {
         logger.log("Steering session injected", { sessionId: params.sessionId, turnId });
         return { outcome: "injected" };
@@ -32707,15 +32726,10 @@ Check ${configPath} and project .codex directories, especially their config.toml
   /**
    * Attempts to inject the prompt into the given running turn.
    *
-   * A failed injection is fatal only when the turn is still the session's
-   * current turn and Codex reported something other than "no active turn to
-   * steer". Otherwise the turn has already ended underneath us and steering
-   * reports a failed delivery.
-   *
-   * @returns true when the prompt was injected; false when the target turn
-   *     already ended.
+   * After submission, only an explicit refusal proves non-delivery. A turn
+   * ending (including Stop) does not prove whether it consumed the input.
    */
-  async injectSteerIntoActiveTurn(params, turnId, sessionState) {
+  async injectSteerIntoActiveTurn(params, turnId) {
     const activePrompt = this.activePrompts.get(params.sessionId);
     const activeTurn = activePrompt?.currentTurn;
     const firstText = params.prompt[0]?.type === "text" ? params.prompt[0].text : "";
@@ -32729,8 +32743,23 @@ Check ${configPath} and project .codex directories, especially their config.toml
     if (pending.has(params.steerId)) {
       throw RequestError.invalidRequest(`Duplicate Codex steer id: ${params.steerId}`);
     }
-    pending.set(params.steerId, { activePrompt, turnId });
+    let resolveApplied = () => {
+    };
+    const applied = new Promise((resolve) => {
+      resolveApplied = resolve;
+    });
+    const steer = {
+      activePrompt,
+      threadId: activeTurn.threadId,
+      turnId,
+      requestPending: true,
+      acknowledgement: null,
+      applied,
+      resolveApplied
+    };
+    pending.set(params.steerId, steer);
     this.pendingSteers.set(params.sessionId, pending);
+    let requestAccepted = false;
     try {
       const response = await this.runWithProcessCheck(() => this.codexAcpClient.steerTurn({
         threadId: activeTurn.threadId,
@@ -32744,18 +32773,48 @@ Check ${configPath} and project .codex directories, especially their config.toml
           `Codex steered unexpected turn ${response.turnId}; expected ${turnId}`
         );
       }
+      requestAccepted = true;
       return true;
     } catch (err) {
-      if (pending.get(params.steerId)?.activePrompt === activePrompt) {
-        pending.delete(params.steerId);
-        if (pending.size === 0) this.pendingSteers.delete(params.sessionId);
+      const refused = this.isNoActiveTurnToSteerError(err);
+      if (await this.reconcileSteer(params, steer, !refused)) {
+        await this.acknowledgeSteer(params.sessionId, params.steerId, steer);
+        return true;
       }
-      await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
-      const turnStillActive = sessionState.currentTurnId === turnId;
-      if (turnStillActive && !this.isNoActiveTurnToSteerError(err)) {
-        throw err;
+      if (refused) return false;
+      throw err;
+    } finally {
+      steer.requestPending = false;
+      if (!requestAccepted || this.activePrompts.get(params.sessionId) !== activePrompt) {
+        this.removePendingSteer(params.sessionId, params.steerId, steer);
       }
-      return false;
+    }
+  }
+  async reconcileSteer(params, steer, readHistory) {
+    let finished = false;
+    let timeout;
+    try {
+      const historyApplied = (async () => {
+        await this.codexAcpClient.waitForSessionNotifications(params.sessionId);
+        if (steer.acknowledgement !== null) return true;
+        if (finished || !readHistory) return false;
+        const thread = await this.codexAcpClient.readSessionHistory(steer.threadId);
+        return thread.id === steer.threadId && thread.turns.some((turn) => turn.id === steer.turnId && turn.items.some((item) => item.type === "userMessage" && item.clientId === params.steerId));
+      })().catch((error48) => {
+        logger.error("Could not reconcile Codex steer history", error48);
+        return false;
+      });
+      return await Promise.race([
+        historyApplied,
+        steer.applied.then(() => true),
+        new Promise((resolve) => {
+          timeout = setTimeout(() => resolve(false), 5e3);
+          timeout.unref?.();
+        })
+      ]) || steer.acknowledgement !== null;
+    } finally {
+      finished = true;
+      clearTimeout(timeout);
     }
   }
   async startGoalContinuationIfCurrent(sessionState, sessionGeneration, goalControlGeneration, expectedGoal) {
@@ -33600,7 +33659,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
     const pending = this.pendingSteers.get(sessionId);
     if (!pending) return;
     for (const [steerId, steer] of pending) {
-      if (steer.activePrompt === activePrompt) pending.delete(steerId);
+      if (steer.activePrompt === activePrompt && !steer.requestPending) pending.delete(steerId);
     }
     if (pending.size === 0) this.pendingSteers.delete(sessionId);
   }
@@ -33611,10 +33670,22 @@ Check ${configPath} and project .codex directories, especially their config.toml
     const pending = this.pendingSteers.get(sessionId);
     if (!pending) return;
     const steer = pending.get(steerId);
-    if (!steer || steer.activePrompt !== activePrompt || steer.turnId !== event.params.turnId) return;
+    if (!steer || steer.activePrompt !== activePrompt || steer.threadId !== event.params.threadId || steer.turnId !== event.params.turnId) return;
+    await this.acknowledgeSteer(sessionId, steerId, steer);
+  }
+  removePendingSteer(sessionId, steerId, steer) {
+    const pending = this.pendingSteers.get(sessionId);
+    if (pending?.get(steerId) !== steer) return;
     pending.delete(steerId);
     if (pending.size === 0) this.pendingSteers.delete(sessionId);
-    await this.connection.notify(CODEX_STEER_APPLIED_METHOD, { sessionId, steerId });
+  }
+  async acknowledgeSteer(sessionId, steerId, steer) {
+    if (steer.acknowledgement === null) {
+      steer.acknowledgement = Promise.resolve().then(() => this.connection.notify(CODEX_STEER_APPLIED_METHOD, { sessionId, steerId }));
+      this.removePendingSteer(sessionId, steerId, steer);
+      steer.resolveApplied();
+    }
+    await steer.acknowledgement;
   }
   cancelBeforeTurnStarted(activePrompt) {
     return activePrompt.cancelSignal.then(() => {
@@ -33803,6 +33874,11 @@ Check ${configPath} and project .codex directories, especially their config.toml
       return this.cancelledPromptResponse(sessionState);
     };
     try {
+      sessionState.turnUsage ??= new CodexTurnUsage(
+        false,
+        this.codexAcpClient.appServerClient.getThreadTokenUsage(params.sessionId)?.tokenUsage.total
+      );
+      sessionState.turnUsage.prepare(ModelId.fromString(sessionState.currentModelId).model);
       const promptEventHandler = new CodexEventHandler(
         this.connection,
         sessionState,
@@ -33991,6 +34067,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       sessionState.lastTokenUsage = null;
       ensurePendingTurnStart();
       goalLifecycle.prepareTurn();
+      sessionState.turnUsage.prepare(modelId.model);
       const sendPromptPromise = this.runWithProcessCheck(
         () => this.codexAcpClient.sendPrompt(
           effectiveParams,
@@ -34093,6 +34170,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
           activePrompt.currentTurn = null;
           sessionState.currentTurnId = null;
           goalLifecycle.prepareTurn();
+          sessionState.turnUsage.prepare(modelId.model);
           const implementationPromise = this.runWithProcessCheck(
             () => this.codexAcpClient.sendPrompt(
               implementationRequest,

package/dist/chunks/{profile-6mKAZyTP.js → profile-DQaC7SJZ.js}

@@ -421,9 +421,10 @@ export {
   ACP_EXTENSION_DSH_SESSION_ROOT_ENV as f,
   createDeepSeekHarnessNpxSpecifiers as g,
   DEEPSEEK_HARNESS_DEFAULT_SESSION_COMPRESSION as h,
-  DEEPSEEK_HARNESS_BASE_URL_ENV as i,
-  DEEPSEEK_HARNESS_API_KEY_ENV as j,
-  ACP_EXTENSION_DSH_VERSION as k,
-  DEEPSEEK_HARNESS_DEFAULT_MODEL as l,
-  DEEPSEEK_HARNESS_PROVIDER as m
+  DEEPSEEK_HARNESS_VERSION as i,
+  DEEPSEEK_HARNESS_BASE_URL_ENV as j,
+  DEEPSEEK_HARNESS_API_KEY_ENV as k,
+  ACP_EXTENSION_DSH_VERSION as l,
+  DEEPSEEK_HARNESS_DEFAULT_MODEL as m,
+  DEEPSEEK_HARNESS_PROVIDER as n
 };

package/dist/chunks/{review-viewer-DGlltQj7.js → review-viewer-BXpPp9r0.js}

@@ -28,7 +28,7 @@ import "node:util";
 import "node:zlib";
 import "child_process";
 import "./plan-mode-BLOER-fv.js";
-import "./profile-6mKAZyTP.js";
+import "./profile-DQaC7SJZ.js";
 import "node:url";
 import { __tla as __tla_1 } from "./loro_wasm_bg-Br-Fa9wV.js";
 import "perf_hooks";
@@ -53,18 +53,19 @@ import "node:console";
 import "node:dns";
 import "./directory-handle-35P9qcGk.js";
 import "./diff-line-counts-bmGB_T-n.js";
-import "./acp-DCoAUZc7.js";
-import "node:string_decoder";
-import "./methods-CvEDMahD.js";
 import "node:stream/promises";
+import "node:string_decoder";
 import "./package-DlotPnLa.js";
 import "./runtime-manifest-FeOT7MvW.js";
+import "./acp-DCoAUZc7.js";
+import "./methods-CvEDMahD.js";
 import "async_hooks";
 import "module";
 import "./diff-worker-task-8tVIjLTu.js";
 import "./workspace-watch-protocol-CSO-IQeE.js";
 import "node:module";
 import "node:v8";
+import "node:timers/promises";
 import "http2";
 let resolveReviewViewerTemplate;
 let __tla = Promise.all([
@@ -81,7 +82,7 @@ let __tla = Promise.all([
     }
   })()
 ]).then(async () => {
-  const reviewViewerVersion = "0.94.0";
+  const reviewViewerVersion = "0.95.0";
   const reviewViewerSha256 = "dc9c7fc1dde49bb39c5fe86392d69219b469c0cab4fd492d8b562045e7f676e4";
   const reviewViewerFileName = "standalone.html";
   const DEFAULT_CDN_BASES = [

package/dist/codex-acp.js

@@ -3,5 +3,5 @@
     console.error("CODEX_PATH is required for the bundled Codex ACP adapter.");
     process.exit(1);
   }
-  await import("./chunks/index-rdPvrzqi.js");
+  await import("./chunks/index-qnlCmQGA.js");
 })();

package/dist/deepseek-acp.js

@@ -3,7 +3,7 @@ import { randomUUID, createHash } from "node:crypto";
 import { isAbsolute } from "node:path";
 import { Readable, Writable } from "node:stream";
 import { n as ndJsonStream, A as AgentSideConnection, R as RequestError, P as PROTOCOL_VERSION } from "./chunks/acp-DCoAUZc7.js";
-import { i as DEEPSEEK_HARNESS_BASE_URL_ENV, j as DEEPSEEK_HARNESS_API_KEY_ENV, a as DEEPSEEK_HARNESS_AGENT_PRESETS, k as ACP_EXTENSION_DSH_VERSION, l as DEEPSEEK_HARNESS_DEFAULT_MODEL, m as DEEPSEEK_HARNESS_PROVIDER } from "./chunks/profile-6mKAZyTP.js";
+import { j as DEEPSEEK_HARNESS_BASE_URL_ENV, k as DEEPSEEK_HARNESS_API_KEY_ENV, a as DEEPSEEK_HARNESS_AGENT_PRESETS, l as ACP_EXTENSION_DSH_VERSION, m as DEEPSEEK_HARNESS_DEFAULT_MODEL, n as DEEPSEEK_HARNESS_PROVIDER } from "./chunks/profile-DQaC7SJZ.js";
 import { L as LODY_EXTENSION_METHODS } from "./chunks/methods-CvEDMahD.js";
 import { c as createPlanModeConfigOption, L as LODY_PLAN_MODE_CONFIG_ID } from "./chunks/plan-mode-BLOER-fv.js";
 import "node:url";
@@ -1026,9 +1026,13 @@ function apply(ctx, rawConfig) {
           }
         };
         const agentPresetOptions = (await ctx.agentPresets.list()).filter((preset) => preset.broken === void 0);
-        const requestedPreset = ctx.agentPresets.defaultId;
+        let requestedPreset = ctx.agentPresets.defaultId;
         if (!agentPresetOptions.some((preset) => preset.id === requestedPreset)) {
-          throw internalError(`default agent preset ${JSON.stringify(requestedPreset)} is unavailable`);
+          if (!agentPresetOptions.some((preset) => preset.id === "standard")) {
+            throw internalError(`default agent preset ${JSON.stringify(requestedPreset)} and recovery preset "standard" are unavailable; restore the bundled standard preset or choose an available agent-presets.default in $DSH_HOME/settings.yaml`);
+          }
+          ctx.logger.warn(`acp-extension-dsh: default agent preset ${JSON.stringify(requestedPreset)} is unavailable; using "standard" for this session without changing settings`);
+          requestedPreset = "standard";
         }
         const mcpServerNames = reserveMcpServerNames(params.mcpServers, sessionId, activeMcpServerNames);
         let mountedPreset = requestedPreset;