@posthog/agent 2.3.67 → 2.3.73

package/dist/server/bin.cjs

@@ -904,7 +904,7 @@ var import_hono = require("hono");
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.67",
+  version: "2.3.73",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -991,8 +991,8 @@ var package_default = {
     vitest: "^2.1.8"
   },
   dependencies: {
-    "@agentclientprotocol/sdk": "0.15.0",
-    "@anthropic-ai/claude-agent-sdk": "0.2.71",
+    "@agentclientprotocol/sdk": "0.16.1",
+    "@anthropic-ai/claude-agent-sdk": "0.2.76",
     "@anthropic-ai/sdk": "^0.78.0",
     "@hono/node-server": "^1.19.9",
     "@opentelemetry/api-logs": "^0.208.0",
@@ -1372,12 +1372,14 @@ function formatGatewayModelName(model) {
 }
 
 // src/adapters/base-acp-agent.ts
+var DEFAULT_CONTEXT_WINDOW = 2e5;
 var BaseAcpAgent = class {
   session;
   sessionId;
   client;
   logger;
   fileContentCache = {};
+  gatewayModels = [];
   constructor(client) {
     this.client = client;
     this.logger = new Logger({ debug: true, prefix: "[BaseAcpAgent]" });
@@ -1430,8 +1432,8 @@ var BaseAcpAgent = class {
     throw new Error("Method not implemented.");
   }
   async getModelConfigOptions(currentModelOverride) {
-    const gatewayModels = await fetchGatewayModels();
-    const options = gatewayModels.filter((model) => isAnthropicModel(model)).map((model) => ({
+    this.gatewayModels = await fetchGatewayModels();
+    const options = this.gatewayModels.filter((model) => isAnthropicModel(model)).map((model) => ({
       value: model.id,
       name: formatGatewayModelName(model),
       description: `Context: ${model.context_window.toLocaleString()} tokens`
@@ -1452,6 +1454,10 @@ var BaseAcpAgent = class {
     }
     return { currentModelId, options };
   }
+  getContextWindowForModel(modelId) {
+    const match = this.gatewayModels.find((m) => m.id === modelId);
+    return match?.context_window ?? DEFAULT_CONTEXT_WINDOW;
+  }
 };
 
 // src/adapters/claude/conversion/acp-to-sdk.ts
@@ -2627,7 +2633,7 @@ function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileCon
   }
 }
 async function handleSystemMessage(message, context) {
-  const { sessionId, client, logger } = context;
+  const { session, sessionId, client, logger } = context;
   switch (message.subtype) {
     case "init":
       break;
@@ -2635,7 +2641,8 @@ async function handleSystemMessage(message, context) {
       await client.extNotification("_posthog/compact_boundary", {
         sessionId,
         trigger: message.compact_metadata.trigger,
-        preTokens: message.compact_metadata.pre_tokens
+        preTokens: message.compact_metadata.pre_tokens,
+        contextSize: session.contextSize
       });
       break;
     case "hook_response":
@@ -2807,21 +2814,6 @@ function filterMessageContent(content) {
 async function handleUserAssistantMessage(message, context) {
   const { session, sessionId, client, toolUseCache, fileContentCache, logger } = context;
   if (shouldSkipUserAssistantMessage(message)) {
-    const content2 = message.message.content;
-    if (typeof content2 === "string" && hasLocalCommandStdout(content2) && content2.includes("Context Usage")) {
-      const stripped = content2.replace("<local-command-stdout>", "").replace("</local-command-stdout>", "");
-      for (const notification of toAcpNotifications(
-        stripped,
-        "assistant",
-        sessionId,
-        toolUseCache,
-        fileContentCache,
-        client,
-        logger
-      )) {
-        await client.sessionUpdate(notification);
-      }
-    }
     logSpecialMessages(message, logger);
     if (isLoginRequiredMessage(message)) {
       return { shouldStop: true, error: import_sdk.RequestError.authRequired() };
@@ -3081,8 +3073,17 @@ function buildPermissionOptions(toolName, toolInput, cwd, suggestions) {
   }
   return permissionOptions("Yes, always allow");
 }
+var ALLOW_BYPASS2 = !IS_ROOT || !!process.env.IS_SANDBOX;
 function buildExitPlanModePermissionOptions() {
-  return [
+  const options = [];
+  if (ALLOW_BYPASS2) {
+    options.push({
+      kind: "allow_always",
+      name: "Yes, bypass all permissions",
+      optionId: "bypassPermissions"
+    });
+  }
+  options.push(
     {
       kind: "allow_always",
       name: "Yes, and auto-accept edits",
@@ -3099,7 +3100,8 @@ function buildExitPlanModePermissionOptions() {
       optionId: "reject_with_feedback",
       _meta: { customInput: true }
     }
-  ];
+  );
+  return options;
 }
 
 // src/adapters/claude/permissions/permission-handlers.ts
@@ -3173,7 +3175,7 @@ async function requestPlanApproval(context, updatedInput) {
 }
 async function applyPlanApproval(response, context, updatedInput) {
   const { session } = context;
-  if (response.outcome?.outcome === "selected" && (response.outcome.optionId === "default" || response.outcome.optionId === "acceptEdits")) {
+  if (response.outcome?.outcome === "selected" && (response.outcome.optionId === "default" || response.outcome.optionId === "acceptEdits" || response.outcome.optionId === "bypassPermissions")) {
     session.permissionMode = response.outcome.optionId;
     await session.query.setPermissionMode(response.outcome.optionId);
     await context.client.sessionUpdate({
@@ -3246,8 +3248,7 @@ async function handleAskUserQuestionTool(context) {
     context.logger.warn("[AskUserQuestion] No questions found in input");
     return {
       behavior: "deny",
-      message: "No questions provided",
-      interrupt: true
+      message: "No questions provided"
     };
   }
   const { client, sessionId, toolUseID, toolInput } = context;
@@ -3278,16 +3279,14 @@ async function handleAskUserQuestionTool(context) {
     const customMessage = response._meta?.message;
     return {
       behavior: "deny",
-      message: typeof customMessage === "string" ? customMessage : "User cancelled the questions",
-      interrupt: true
+      message: typeof customMessage === "string" ? customMessage : "User cancelled the questions"
     };
   }
   const answers = response._meta?.answers;
   if (!answers || Object.keys(answers).length === 0) {
     return {
       behavior: "deny",
-      message: "User did not provide answers",
-      interrupt: true
+      message: "User did not provide answers"
     };
   }
   return {
@@ -3354,8 +3353,7 @@ async function handleDefaultPermissionFlow(context) {
     await emitToolDenial(context, message);
     return {
       behavior: "deny",
-      message,
-      interrupt: true
+      message
     };
   }
 }
@@ -3469,16 +3467,6 @@ var GATEWAY_TO_SDK_MODEL = {
 function toSdkModelId(modelId) {
   return GATEWAY_TO_SDK_MODEL[modelId] ?? modelId;
 }
-var MODELS_WITH_1M_CONTEXT = /* @__PURE__ */ new Set([
-  "claude-opus-4-6",
-  "claude-sonnet-4-6"
-]);
-function supports1MContext(modelId) {
-  return MODELS_WITH_1M_CONTEXT.has(modelId);
-}
-function getDefaultContextWindow(modelId) {
-  return supports1MContext(modelId) ? 1e6 : 2e5;
-}
 var MODELS_WITH_EFFORT = /* @__PURE__ */ new Set([
   "claude-opus-4-5",
   "claude-opus-4-6",
@@ -3503,6 +3491,56 @@ function getEffortOptions(modelId) {
   }
   return options;
 }
+var MODEL_CONTEXT_HINT_PATTERN = /\[(\d+m)\]$/i;
+function tokenizeModelPreference(model) {
+  const lower = model.trim().toLowerCase();
+  const contextHint = lower.match(MODEL_CONTEXT_HINT_PATTERN)?.[1]?.toLowerCase();
+  const normalized = lower.replace(MODEL_CONTEXT_HINT_PATTERN, " $1 ");
+  const rawTokens = normalized.split(/[^a-z0-9]+/).filter(Boolean);
+  const tokens = rawTokens.map((token) => {
+    if (token === "opusplan") return "opus";
+    if (token === "best" || token === "default") return "";
+    return token;
+  }).filter((token) => token && token !== "claude").filter((token) => /[a-z]/.test(token) || token.endsWith("m"));
+  return { tokens, contextHint };
+}
+function scoreModelMatch(model, tokens, contextHint) {
+  const haystack = `${model.value} ${model.name ?? ""}`.toLowerCase();
+  let score = 0;
+  for (const token of tokens) {
+    if (haystack.includes(token)) {
+      score += token === contextHint ? 3 : 1;
+    }
+  }
+  return score;
+}
+function resolveModelPreference(preference, options) {
+  const trimmed2 = preference.trim();
+  if (!trimmed2) return null;
+  const lower = trimmed2.toLowerCase();
+  const directMatch = options.find(
+    (o) => o.value === trimmed2 || o.value.toLowerCase() === lower || o.name && o.name.toLowerCase() === lower
+  );
+  if (directMatch) return directMatch.value;
+  const includesMatch = options.find((o) => {
+    const value = o.value.toLowerCase();
+    const display = (o.name ?? "").toLowerCase();
+    return value.includes(lower) || display.includes(lower) || lower.includes(value);
+  });
+  if (includesMatch) return includesMatch.value;
+  const { tokens, contextHint } = tokenizeModelPreference(trimmed2);
+  if (tokens.length === 0) return null;
+  let bestMatch = null;
+  let bestScore = 0;
+  for (const model of options) {
+    const score = scoreModelMatch(model, tokens, contextHint);
+    if (0 < score && (!bestMatch || bestScore < score)) {
+      bestMatch = model;
+      bestScore = score;
+    }
+  }
+  return bestMatch?.value ?? null;
+}
 
 // src/adapters/claude/session/options.ts
 var import_node_child_process = require("child_process");
@@ -3983,6 +4021,7 @@ var SettingsManager = class {
 // src/adapters/claude/claude-agent.ts
 var SESSION_VALIDATION_TIMEOUT_MS = 1e4;
 var MAX_TITLE_LENGTH = 256;
+var LOCAL_ONLY_COMMANDS = /* @__PURE__ */ new Set(["/context", "/heapdump", "/extra-usage"]);
 function sanitizeTitle(text2) {
   const sanitized = text2.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
   if (sanitized.length <= MAX_TITLE_LENGTH) {
@@ -4019,7 +4058,8 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
         sessionCapabilities: {
           list: {},
           fork: {},
-          resume: {}
+          resume: {},
+          close: {}
         },
         _meta: {
           posthog: {
@@ -4059,6 +4099,8 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     );
   }
   async unstable_resumeSession(params) {
+    const existing = this.getExistingSessionState(params.sessionId);
+    if (existing) return existing;
     const response = await this.createSession(
       {
         cwd: params.cwd,
@@ -4072,6 +4114,8 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     return response;
   }
   async loadSession(params) {
+    const existing = this.getExistingSessionState(params.sessionId);
+    if (existing) return existing;
     const response = await this.createSession(
       {
         cwd: params.cwd,
@@ -4088,7 +4132,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       configOptions: response.configOptions
     };
   }
-  async unstable_listSessions(params) {
+  async listSessions(params) {
     const sdkSessions = await (0, import_claude_agent_sdk.listSessions)({ dir: params.cwd ?? void 0 });
     const sessions = [];
     for (const session of sdkSessions) {
@@ -4104,6 +4148,9 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       sessions
     };
   }
+  async unstable_listSessions(params) {
+    return this.listSessions(params);
+  }
   async prompt(params) {
     this.session.cancelled = false;
     this.session.interruptReason = void 0;
@@ -4114,17 +4161,37 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       cachedWriteTokens: 0
     };
     const userMessage = promptToClaude(params);
+    const promptUuid = (0, import_node_crypto.randomUUID)();
+    userMessage.uuid = promptUuid;
+    let promptReplayed = false;
+    let isLocalOnlyCommand = false;
+    const msgContent = userMessage.message.content;
+    let firstTextPart = "";
+    if (typeof msgContent === "string") {
+      firstTextPart = msgContent;
+    } else if (Array.isArray(msgContent)) {
+      for (const block of msgContent) {
+        if ("type" in block && block.type === "text" && "text" in block) {
+          firstTextPart = block.text;
+          break;
+        }
+      }
+    }
+    const commandMatch = firstTextPart.match(/^(\/\S+)/);
+    if (commandMatch && LOCAL_ONLY_COMMANDS.has(commandMatch[1])) {
+      isLocalOnlyCommand = true;
+      promptReplayed = true;
+    }
     if (this.session.promptRunning) {
-      const uuid = (0, import_node_crypto.randomUUID)();
-      userMessage.uuid = uuid;
       this.session.input.push(userMessage);
       const order = this.session.nextPendingOrder++;
       const cancelled = await new Promise((resolve4) => {
-        this.session.pendingMessages.set(uuid, { resolve: resolve4, order });
+        this.session.pendingMessages.set(promptUuid, { resolve: resolve4, order });
       });
       if (cancelled) {
         return { stopReason: "cancelled" };
       }
+      promptReplayed = true;
     } else {
       this.session.input.push(userMessage);
     }
@@ -4132,6 +4199,16 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     this.session.promptRunning = true;
     let handedOff = false;
     let lastAssistantTotalUsage = null;
+    if (this.session.lastContextWindowSize == null) {
+      this.session.lastContextWindowSize = this.getContextWindowForModel(
+        this.session.modelId ?? ""
+      );
+      this.logger.debug("Initial context window size from gateway", {
+        modelId: this.session.modelId,
+        contextWindowSize: this.session.lastContextWindowSize
+      });
+    }
+    let lastContextWindowSize = this.session.lastContextWindowSize;
     const supportsTerminalOutput = this.clientCapabilities?._meta?.terminal_output === true;
     const context = {
       session: this.session,
@@ -4158,10 +4235,21 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
           case "system":
             if (message.subtype === "compact_boundary") {
               lastAssistantTotalUsage = 0;
+              promptReplayed = true;
+            }
+            if (message.subtype === "local_command_output") {
+              promptReplayed = true;
             }
             await handleSystemMessage(message, context);
             break;
           case "result": {
+            if (!promptReplayed) {
+              this.logger.debug(
+                "Skipping background task result before prompt replay",
+                { sessionId: params.sessionId }
+              );
+              break;
+            }
             if (this.session.cancelled) {
               return { stopReason: "cancelled" };
             }
@@ -4172,8 +4260,19 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
             const contextWindows = Object.values(message.modelUsage).map(
               (m) => m.contextWindow
             );
-            const contextWindowSize = contextWindows.length > 0 ? Math.min(...contextWindows) : getDefaultContextWindow(this.session.modelId ?? "");
-            this.session.contextSize = contextWindowSize;
+            if (contextWindows.length > 0) {
+              const sdkContextWindow = Math.min(...contextWindows);
+              if (sdkContextWindow > lastContextWindowSize) {
+                lastContextWindowSize = sdkContextWindow;
+              }
+            }
+            this.session.lastContextWindowSize = lastContextWindowSize;
+            this.logger.debug("Context window size from result", {
+              sdkReported: contextWindows,
+              resolved: lastContextWindowSize,
+              modelId: this.session.modelId
+            });
+            this.session.contextSize = lastContextWindowSize;
             if (lastAssistantTotalUsage !== null) {
               this.session.contextUsed = lastAssistantTotalUsage;
             }
@@ -4183,7 +4282,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
                 update: {
                   sessionUpdate: "usage_update",
                   used: lastAssistantTotalUsage,
-                  size: contextWindowSize,
+                  size: lastContextWindowSize,
                   cost: {
                     amount: message.total_cost_usd,
                     currency: "USD"
@@ -4210,6 +4309,15 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
             };
             const result = handleResultMessage(message);
             if (result.error) throw result.error;
+            if (isLocalOnlyCommand && message.subtype === "success" && message.result) {
+              await this.client.sessionUpdate({
+                sessionId: params.sessionId,
+                update: {
+                  sessionUpdate: "agent_message_chunk",
+                  content: { type: "text", text: message.result }
+                }
+              });
+            }
             return { stopReason: result.stopReason ?? "end_turn", usage };
           }
           case "stream_event":
@@ -4221,6 +4329,10 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
               break;
             }
             if (message.type === "user" && "uuid" in message && message.uuid) {
+              if (message.uuid === promptUuid) {
+                promptReplayed = true;
+                break;
+              }
               const pending = this.session.pendingMessages.get(
                 message.uuid
               );
@@ -4236,7 +4348,16 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
             }
             if ("usage" in message.message && message.parent_tool_use_id === null) {
               const usage = message.message.usage;
-              lastAssistantTotalUsage = usage.input_tokens + usage.output_tokens + usage.cache_read_input_tokens + usage.cache_creation_input_tokens;
+              lastAssistantTotalUsage = usage.input_tokens + usage.cache_read_input_tokens + usage.cache_creation_input_tokens;
+              await this.client.sessionUpdate({
+                sessionId: params.sessionId,
+                update: {
+                  sessionUpdate: "usage_update",
+                  used: lastAssistantTotalUsage,
+                  size: lastContextWindowSize,
+                  cost: null
+                }
+              });
             }
             const result = await handleUserAssistantMessage(message, context);
             if (result.error) throw result.error;
@@ -4266,6 +4387,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
         this.logger.error(`Process died: ${msg}`, {
           sessionId: this.sessionId
         });
+        this.session.settingsManager.dispose();
         this.session.input.end();
         throw import_sdk2.RequestError.internalError(
           void 0,
@@ -4293,9 +4415,11 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     await this.session.query.interrupt();
   }
   async unstable_setSessionModel(params) {
-    const sdkModelId = toSdkModelId(params.modelId);
-    await this.session.query.setModel(sdkModelId);
+    await this.session.query.setModel(toSdkModelId(params.modelId));
     this.session.modelId = params.modelId;
+    this.session.lastContextWindowSize = this.getContextWindowForModel(
+      params.modelId
+    );
     this.rebuildEffortConfigOption(params.modelId);
     await this.updateConfigOption("model", params.modelId);
     return {};
@@ -4312,42 +4436,55 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     if (!option) {
       throw new Error(`Unknown config option: ${params.configId}`);
     }
+    if (typeof params.value !== "string") {
+      throw new Error(
+        `Invalid value type for config option ${params.configId}`
+      );
+    }
     const allValues = "options" in option && Array.isArray(option.options) ? option.options.flatMap(
       (o) => "options" in o && Array.isArray(o.options) ? o.options : [o]
     ) : [];
-    const validValue = allValues.find((o) => o.value === params.value);
+    let validValue = allValues.find((o) => o.value === params.value);
+    if (!validValue && params.configId === "model") {
+      const resolved = resolveModelPreference(params.value, allValues);
+      if (resolved) {
+        validValue = allValues.find((o) => o.value === resolved);
+      }
+    }
     if (!validValue) {
       throw new Error(
         `Invalid value for config option ${params.configId}: ${params.value}`
       );
     }
+    const resolvedValue = validValue.value;
     if (params.configId === "mode") {
-      await this.applySessionMode(params.value);
+      await this.applySessionMode(resolvedValue);
       await this.client.sessionUpdate({
         sessionId: this.sessionId,
         update: {
           sessionUpdate: "current_mode_update",
-          currentModeId: params.value
+          currentModeId: resolvedValue
         }
       });
     } else if (params.configId === "model") {
-      const sdkModelId = toSdkModelId(params.value);
+      const sdkModelId = toSdkModelId(resolvedValue);
       await this.session.query.setModel(sdkModelId);
-      this.session.modelId = params.value;
-      this.rebuildEffortConfigOption(params.value);
+      this.session.modelId = resolvedValue;
+      this.session.lastContextWindowSize = this.getContextWindowForModel(resolvedValue);
+      this.rebuildEffortConfigOption(resolvedValue);
     } else if (params.configId === "effort") {
-      const newEffort = params.value;
+      const newEffort = resolvedValue;
       this.session.effort = newEffort;
       this.session.queryOptions.effort = newEffort;
     }
     this.session.configOptions = this.session.configOptions.map(
-      (o) => o.id === params.configId ? { ...o, currentValue: params.value } : o
+      (o) => o.id === params.configId && typeof o.currentValue === "string" ? { ...o, currentValue: resolvedValue } : o
     );
     return { configOptions: this.session.configOptions };
   }
   async updateConfigOption(configId, value) {
     this.session.configOptions = this.session.configOptions.map(
-      (o) => o.id === configId ? { ...o, currentValue: value } : o
+      (o) => o.id === configId && typeof o.currentValue === "string" ? { ...o, currentValue: value } : o
     );
     await this.client.sessionUpdate({
       sessionId: this.sessionId,
@@ -4414,7 +4551,10 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       sessionId,
       isResume,
       forkSession,
-      additionalDirectories: meta?.claudeCode?.options?.additionalDirectories,
+      additionalDirectories: [
+        ...meta?.claudeCode?.options?.additionalDirectories ?? [],
+        ...meta?.additionalRoots ?? []
+      ],
       disableBuiltInTools: meta?.disableBuiltInTools,
       settingsManager,
       onModeChange: this.createOnModeChange(),
@@ -4491,11 +4631,10 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     const modelOptions = await this.getModelConfigOptions();
     const resolvedModelId = settingsModel || modelOptions.currentModelId;
     session.modelId = resolvedModelId;
-    if (!isResume) {
-      const resolvedSdkModel = toSdkModelId(resolvedModelId);
-      if (resolvedSdkModel !== DEFAULT_MODEL) {
-        await this.session.query.setModel(resolvedSdkModel);
-      }
+    session.lastContextWindowSize = this.getContextWindowForModel(resolvedModelId);
+    const resolvedSdkModel = toSdkModelId(resolvedModelId);
+    if (!isResume && resolvedSdkModel !== DEFAULT_MODEL) {
+      await this.session.query.setModel(resolvedSdkModel);
     }
     const availableModes2 = getAvailableModes();
     const modes = {
@@ -4558,6 +4697,35 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       await this.updateConfigOption("mode", newMode);
     };
   }
+  getExistingSessionState(sessionId) {
+    if (this.sessionId !== sessionId || !this.session) return null;
+    const availableModes2 = getAvailableModes();
+    const modes = {
+      currentModeId: this.session.permissionMode,
+      availableModes: availableModes2.map((mode) => ({
+        id: mode.id,
+        name: mode.name,
+        description: mode.description ?? void 0
+      }))
+    };
+    const modelOptions = this.session.configOptions.find(
+      (o) => o.id === "model"
+    );
+    const models = {
+      currentModelId: this.session.modelId ?? DEFAULT_MODEL,
+      availableModels: modelOptions && "options" in modelOptions ? modelOptions.options.map((opt) => ({
+        modelId: opt.value,
+        name: opt.name,
+        description: opt.description
+      })) : []
+    };
+    return {
+      sessionId,
+      modes,
+      models,
+      configOptions: this.session.configOptions
+    };
+  }
   buildConfigOptions(currentModeId, modelOptions, currentEffort = "high") {
     const modeOptions = getAvailableModes().map((mode) => ({
       value: mode.id,
@@ -4613,7 +4781,8 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       }
       return;
     }
-    const currentValue = existingEffort?.currentValue ?? "high";
+    const rawCurrentValue = existingEffort?.currentValue;
+    const currentValue = typeof rawCurrentValue === "string" ? rawCurrentValue : "high";
     const isValidValue = effortOptions.some((o) => o.value === currentValue);
     const resolvedValue = isValidValue ? currentValue : "high";
     if (resolvedValue !== currentValue && this.session.effort) {