@aiden-ade/sandbox-agent 0.1.43 → 0.1.45

package/dist/index.cjs

@@ -14479,13 +14479,7 @@ function alanMcpConfigFilesForBackend(backendKind, mcpServers, home) {
 var SESSION_RESUME_FAILED_MESSAGE = "Session resume failed. The previous session may have expired or is no longer available. Please start a new session.";
 
 // ../shared/dist/agent/system-prompt.js
-var ALAN_IDENTITY_PROMPT = `You are Alan, the software factory agent built by Supatest in Bangalore. Alan ships software end to end \u2014 plan, write, review, test, deploy.
-
-Do not present yourself as a runtime model, CLI, or backend vendor as your primary identity \u2014 those are runtime details. Mention them only if the user explicitly asks about the underlying model or backend. If the user asks who you are, answer in Alan terms first, and identify by your current agent role (described after this block).
-
-## Voice
-
-Direct. Structured. Concise. No hype, no "Great question!", no tool-brand roleplay. Speak like a teammate, not a data dump. Precise and decisive when working a task; listen, think, then act.
+var ALAN_IDENTITY_PROMPT = `You are Alan, the software factory agent. Alan ships software end to end \u2014 plan, write, review, test, deploy.
 
 ## How Alan is structured
 
@@ -14503,10 +14497,6 @@ Team
 - **Document vs Artifact**: Document = standalone page in a team. Artifact = output from work on a task + conversation, tied to that context. Belongs to a task \u2192 artifact. Doesn't \u2192 document.
 - **IDs are not interchangeable**: teamId, taskId, conversationId identify different things. Substituting one for another orphans records. Use the IDs the system provides; never invent or guess.
 
-## Structure over chat
-
-Deliverables persist as Alan artifacts and documents \u2014 not as chat. Plans, PRDs, specs, test reports, and reviews live as structured outputs tied to team, task, and conversation. If a skill exists for the workflow you're in, use it instead of improvising in chat.
-
 ## Universal teammate principles
 
 - Listen first. Don't jump to solutions. One question at a time, not a list.
@@ -14545,7 +14535,6 @@ Examples: "where is X configured", "which file handles Y", "how does Z work", "f
 - Do NOT start with \`grep\`, \`rg\`, \`find\`, or broad Bash filesystem search for codebase discovery or implementation-answer questions when \`search_code_context\` is available.
 - Do NOT repeat or rephrase index searches after the first result identifies useful paths. Continue locally instead.
 - Do NOT claim current behavior from an index excerpt without reading the cited local file.
-- Do NOT use graphify or local graph tools for the initial semantic "where is this implemented" pass.
 
 ### Local follow-ups
 - Import/caller structure: use local \`code_graph_query\` or narrow symbol search after reading the cited files.
@@ -15296,6 +15285,8 @@ var import_path5 = require("path");
 var import_fs6 = require("fs");
 var import_os6 = require("os");
 var import_path6 = require("path");
+var import_readline2 = require("readline");
+var import_url2 = require("url");
 var import_fs7 = require("fs");
 var import_os7 = require("os");
 var import_path7 = require("path");
@@ -15333,7 +15324,7 @@ function writeFileSafe(path, content) {
     (0, import_fs2.rmSync)(pendingPath, { force: true });
   }
 }
-function acquireConfigLock(path) {
+async function acquireConfigLock(path) {
   (0, import_fs2.mkdirSync)((0, import_path2.dirname)(path), { recursive: true });
   const lockPath = `${path}.alan-lock`;
   const startedAt = Date.now();
@@ -15355,7 +15346,7 @@ function acquireConfigLock(path) {
       if (Date.now() - startedAt >= 2e3) {
         throw new Error(`Alan could not safely update ${path}`);
       }
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+      await new Promise((resolve22) => setTimeout(resolve22, 20));
     }
   }
 }
@@ -15619,13 +15610,13 @@ function buildJsonTargets(home) {
     }
   ];
 }
-function syncAlanMcpSessionHeaders(input) {
+async function syncAlanMcpSessionHeaders(input) {
   const home = input.homeDir ?? (0, import_os2.homedir)();
   const sessionHeaders = buildSessionHeaders(input);
   const written = [];
   for (const target of buildCodexTomlTargets(home)) {
     if (!(0, import_fs2.existsSync)(target.guardDir)) continue;
-    const releaseLock = acquireConfigLock(target.configPath);
+    const releaseLock = await acquireConfigLock(target.configPath);
     try {
       if (patchCodexTomlMcpTarget(target, sessionHeaders)) {
         written.push(target.cli);
@@ -15637,7 +15628,7 @@ function syncAlanMcpSessionHeaders(input) {
   }
   for (const target of buildJsonTargets(home)) {
     if (!(0, import_fs2.existsSync)(target.guardDir)) continue;
-    const releaseLock = acquireConfigLock(target.configPath);
+    const releaseLock = await acquireConfigLock(target.configPath);
     try {
       if (patchJsonMcpTarget(target, sessionHeaders)) {
         written.push(target.cli);
@@ -19157,7 +19148,7 @@ function createGrokAcpDriver(imageFiles) {
     }
     newSession(context);
   }
-  function sendPrompt(context, state) {
+  function sendPrompt2(context, state) {
     const text = buildPromptWithImagePathReferences(context, imageFiles);
     isPromptActive = true;
     promptId = request("session/prompt", {
@@ -19200,7 +19191,7 @@ function createGrokAcpDriver(imageFiles) {
       const sessionId = asString(result?.sessionId);
       if (sessionId) state.runtimeSessionId = sessionId;
       state.iterations = Math.max(state.iterations, 1);
-      sendPrompt(context, state);
+      sendPrompt2(context, state);
       return;
     }
     if (message.id === promptId) {
@@ -19546,23 +19537,59 @@ function createKimiCliBackend(command = "kimi-cli", defaultArgs = []) {
     }
   };
 }
+var AUTONOMOUS_OPENCODE_CONFIG_CONTENT = JSON.stringify({
+  $schema: "https://opencode.ai/config.json",
+  permission: "allow"
+});
+function buildAutonomousOpenCodeConfigContent(existing) {
+  if (!existing?.trim()) return AUTONOMOUS_OPENCODE_CONFIG_CONTENT;
+  try {
+    const parsed = JSON.parse(existing);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return JSON.stringify({
+        ...parsed,
+        permission: "allow"
+      });
+    }
+  } catch {
+  }
+  return AUTONOMOUS_OPENCODE_CONFIG_CONTENT;
+}
+function withAutonomousOpenCodePermissions(context) {
+  if (shouldUseReadOnlyRuntimePermissions(context.config)) return context;
+  return {
+    ...context,
+    env: {
+      ...context.env,
+      OPENCODE_CONFIG_CONTENT: buildAutonomousOpenCodeConfigContent(
+        context.env.OPENCODE_CONFIG_CONTENT
+      )
+    }
+  };
+}
 function getRecord(value2) {
   return typeof value2 === "object" && value2 !== null ? value2 : null;
 }
 function getString(value2) {
   return typeof value2 === "string" ? value2.trim() : "";
 }
-function getOpenCodeToolError(parsed, part) {
-  const state = getRecord(part?.state) ?? getRecord(parsed.state);
-  const error = getRecord(part?.error) ?? getRecord(parsed.error) ?? getRecord(state?.error);
-  return getString(part?.error) || getString(state?.error) || getString(error?.message) || getString(parsed.error);
+function getOpenCodeToolError(part) {
+  const state = getRecord(part.state);
+  const error = getRecord(part.error) ?? getRecord(state?.error);
+  return getString(part.error) || getString(state?.error) || getString(error?.message);
 }
-function isOpenCodeToolError(parsed, part) {
-  const state = getRecord(part?.state) ?? getRecord(parsed.state);
-  return part?.is_error === true || part?.isError === true || state?.status === "error" || Boolean(getOpenCodeToolError(parsed, part));
+function isOpenCodeToolError(part) {
+  const state = getRecord(part.state);
+  return part.is_error === true || part.isError === true || state?.status === "error" || Boolean(getOpenCodeToolError(part));
 }
-function getOpenCodePartId(parsed, part) {
-  return getString(part?.id) || getString(parsed.id) || getString(parsed.partID);
+function getOpenCodePartId(part) {
+  return getString(part.id) || getString(part.partID);
+}
+function getOpenCodeToolId(part) {
+  return getString(part.callID) || getString(part.id) || `opencode-tool-${Date.now()}`;
+}
+function getOpenCodeToolName(part) {
+  return getString(part.tool) || (typeof part.name === "string" ? part.name.trim() : "") || "Tool";
 }
 function resolveOpenCodePartSnapshotDelta(text, partId, snapshots) {
   if (!partId) return text;
@@ -19579,93 +19606,92 @@ function resolveOpenCodeReasoningDelta(text, partId, state) {
   state.opencodeReasoningByPartId ??= /* @__PURE__ */ new Map();
   return resolveOpenCodePartSnapshotDelta(text, partId, state.opencodeReasoningByPartId);
 }
-function handleOpencodeStructuredEvent(parsed, context, state) {
+var TASK_TOOL_NAME = "task";
+var TASK_RESULT_TAG_PATTERN = /<task_result>\n?([\s\S]*?)\n?<\/task_result>/;
+var TASK_ERROR_TAG_PATTERN = /<task_error>\n?([\s\S]*?)\n?<\/task_error>/;
+function unwrapOpenCodeTaskOutput(output) {
+  const result = output.match(TASK_RESULT_TAG_PATTERN);
+  if (result?.[1] !== void 0) return result[1].trim();
+  const error = output.match(TASK_ERROR_TAG_PATTERN);
+  if (error?.[1] !== void 0) return error[1].trim();
+  return output;
+}
+function emitOpenCodeToolPart(presenter, state, part, opts) {
+  const stateRecord = getRecord(part.state);
+  const status = getString(stateRecord?.status);
+  if (status === "pending") return;
+  const toolName = getOpenCodeToolName(part);
+  const toolId = getOpenCodeToolId(part);
+  const isTask = toolName.toLowerCase() === TASK_TOOL_NAME;
+  const parentToolUseId = opts.parentToolUseId ?? void 0;
+  state.opencodeToolUseIds ??= /* @__PURE__ */ new Set();
+  if (!state.opencodeToolUseIds.has(toolId)) {
+    state.opencodeToolUseIds.add(toolId);
+    void presenter.onToolUse(toolName, stateRecord?.input ?? part, toolId, parentToolUseId);
+    if (isTask) registerBackgroundLauncher(state, toolId);
+  }
+  if (status !== "completed" && status !== "error") return;
+  const toolError = isOpenCodeToolError(part);
+  const rawOutput = getString(stateRecord?.output) || getString(stateRecord?.error) || JSON.stringify(stateRecord ?? part);
+  const output = isTask ? unwrapOpenCodeTaskOutput(rawOutput) : rawOutput;
+  void presenter.onToolResult?.(toolId, output, toolError, parentToolUseId);
+  if (isTask) clearBackgroundTaskIds(state, [toolId]);
+  if (toolError && !state.error) {
+    const message = getOpenCodeToolError(part) || "OpenCode tool call failed.";
+    state.error = message;
+    void presenter.onError(message);
+  }
+}
+function mapOpencodePart(part, context, state, opts = {}) {
   const presenter = context.presenter;
-  const type = typeof parsed.type === "string" ? parsed.type : "";
-  if (!type) return false;
-  const sessionID = typeof parsed.sessionID === "string" ? parsed.sessionID : void 0;
-  if (sessionID) state.runtimeSessionId = sessionID;
-  const part = typeof parsed.part === "object" && parsed.part !== null ? parsed.part : null;
+  const type = getString(part.type);
   switch (type) {
-    case "step_start": {
+    case "step-start": {
       state.iterations += 1;
       void presenter.onLog(`[opencode] Step ${state.iterations} started`);
       return true;
     }
     case "text": {
-      const text = part && typeof part.text === "string" ? part.text : "";
+      const text = typeof part.text === "string" ? part.text : "";
       if (text) {
-        const delta = resolveOpenCodeTextDelta(text, getOpenCodePartId(parsed, part), state);
-        if (!delta) return true;
-        state.summary += delta;
-        void presenter.onAssistantText(delta);
+        const delta = resolveOpenCodeTextDelta(text, getOpenCodePartId(part), state);
+        if (delta) {
+          state.summary += delta;
+          void presenter.onAssistantText(delta);
+        }
       }
       return true;
     }
+    // Real Part schema only ever uses "reasoning"; "thinking" is a defensive alias in
+    // case a CLI dialect ever names the part itself that way.
     case "reasoning":
     case "thinking": {
-      const text = part && typeof part.text === "string" ? part.text : "";
+      const text = typeof part.text === "string" ? part.text : "";
       if (!text) return true;
-      const delta = resolveOpenCodeReasoningDelta(text, getOpenCodePartId(parsed, part), state);
+      const delta = resolveOpenCodeReasoningDelta(text, getOpenCodePartId(part), state);
       if (!delta) return true;
       state.iterations = Math.max(state.iterations, 1);
       void presenter.onThinking(delta);
       return true;
     }
-    case "tool_use":
-    case "tool.execute": {
-      const toolName = getString(parsed.tool) || (part && typeof part.name === "string" ? part.name : "") || getString(parsed.name) || (part && typeof part.tool === "string" ? part.tool : "") || "Tool";
-      const toolId = part && typeof part.id === "string" ? part.id : `opencode-tool-${Date.now()}`;
-      void presenter.onToolUse(toolName, part ?? {}, toolId);
-      return true;
-    }
     case "tool": {
-      const stateRecord = getRecord(parsed.state);
-      const toolName = getString(parsed.tool) || (part && typeof part.name === "string" ? part.name : "") || getString(parsed.name) || (part && typeof part.tool === "string" ? part.tool : "") || "Tool";
-      const toolId = getString(parsed.id) || getString(parsed.callID) || `opencode-tool-${Date.now()}`;
-      state.opencodeToolUseIds ??= /* @__PURE__ */ new Set();
-      if (!state.opencodeToolUseIds.has(toolId)) {
-        state.opencodeToolUseIds.add(toolId);
-        void presenter.onToolUse(toolName, stateRecord?.input ?? part ?? parsed, toolId);
-      }
-      const status = getString(stateRecord?.status);
-      if (status === "completed" || status === "error") {
-        const toolError = isOpenCodeToolError(parsed, part);
-        const output = getString(stateRecord?.output) || getString(stateRecord?.error) || JSON.stringify(stateRecord ?? part ?? parsed);
-        void presenter.onToolResult?.(toolId, output, toolError);
-        if (toolError && !state.error) {
-          const message = getOpenCodeToolError(parsed, part) || "OpenCode tool call failed.";
-          state.error = message;
-          void presenter.onError(message);
-        }
-      }
+      emitOpenCodeToolPart(presenter, state, part, opts);
       return true;
     }
-    case "tool_result":
-    case "tool.result": {
-      const toolId = part && typeof part.id === "string" ? part.id : `opencode-tool-${Date.now()}`;
-      const output = part && typeof part.output === "string" ? part.output : JSON.stringify(part);
-      const toolError = isOpenCodeToolError(parsed, part);
-      void presenter.onToolResult?.(toolId, output, toolError);
-      if (toolError && !state.error) {
-        const message = getOpenCodeToolError(parsed, part) || "OpenCode tool call failed.";
-        state.error = message;
-        void presenter.onError(message);
-      }
-      return true;
-    }
-    case "step_finish": {
-      if (part && typeof part.tokens === "object" && part.tokens !== null) {
-        const tokens = part.tokens;
+    case "step-finish": {
+      const tokens = getRecord(part.tokens);
+      if (tokens) {
+        const cache2 = getRecord(tokens.cache);
+        const cost = typeof part.cost === "number" ? part.cost : 0;
         state.usage = {
           model: typeof context.config.selectedModel === "string" && context.config.selectedModel.trim() || "opencode",
           numTurns: Math.max(state.iterations, 1),
           durationMs: 0,
-          inputTokens: tokens.input ?? 0,
-          outputTokens: tokens.output ?? 0,
-          cacheReadTokens: tokens.cache_read ?? 0,
-          cacheCreationTokens: tokens.cache_creation ?? 0,
-          costUsd: 0
+          inputTokens: Number(tokens.input) || 0,
+          outputTokens: Number(tokens.output) || 0,
+          cacheReadTokens: Number(cache2?.read) || 0,
+          cacheCreationTokens: Number(cache2?.write) || 0,
+          costUsd: cost
         };
         void presenter.onUsageUpdate?.({
           model: state.usage.model,
@@ -19677,6 +19703,57 @@ function handleOpencodeStructuredEvent(parsed, context, state) {
       }
       return true;
     }
+    default:
+      return false;
+  }
+}
+function normalizeOpenCodePart(parsed, part, partType) {
+  return { ...parsed, ...part ?? {}, type: partType };
+}
+function handleOpencodeStructuredEvent(parsed, context, state) {
+  const presenter = context.presenter;
+  const type = typeof parsed.type === "string" ? parsed.type : "";
+  if (!type) return false;
+  const sessionID = typeof parsed.sessionID === "string" ? parsed.sessionID : void 0;
+  if (sessionID) state.runtimeSessionId = sessionID;
+  const part = typeof parsed.part === "object" && parsed.part !== null ? parsed.part : null;
+  switch (type) {
+    case "step_start":
+      return mapOpencodePart(normalizeOpenCodePart(parsed, part, "step-start"), context, state);
+    case "text":
+      return mapOpencodePart(normalizeOpenCodePart(parsed, part, "text"), context, state);
+    case "reasoning":
+    case "thinking":
+      return mapOpencodePart(normalizeOpenCodePart(parsed, part, "reasoning"), context, state);
+    // Real event: `opencode run --format json` emits exactly this shape — a single
+    // terminal event per tool call, carrying part.state.{input,output|error}. See
+    // notes/opencode-cli-reverse-engineering.md for the live-captured schema.
+    case "tool_use":
+    case "tool.execute":
+    case "tool":
+      return mapOpencodePart(normalizeOpenCodePart(parsed, part, "tool"), context, state);
+    case "step_finish":
+      return mapOpencodePart(normalizeOpenCodePart(parsed, part, "step-finish"), context, state);
+    // Defensive fallback only: no observed OpenCode version emits a separate
+    // tool_result/tool.result event in `--format json` mode (tool state always
+    // arrives via `tool_use` above). Kept in case a future/older CLI build splits
+    // the terminal tool event into a distinct result message. Deliberately NOT routed
+    // through mapOpencodePart — this shape has no part.state wrapper at all (output
+    // sits directly on the part), so it isn't a real Part-schema shape.
+    case "tool_result":
+    case "tool.result": {
+      const toolId = getString(part?.callID) || getString(parsed.callID) || getString(part?.id) || getString(parsed.id) || `opencode-tool-${Date.now()}`;
+      const output = part && typeof part.output === "string" ? part.output : JSON.stringify(part);
+      const stateRecord = getRecord(part?.state) ?? getRecord(parsed.state);
+      const toolError = part?.is_error === true || part?.isError === true || stateRecord?.status === "error" || Boolean(getString(part?.error) || getString(stateRecord?.error));
+      void presenter.onToolResult?.(toolId, output, toolError);
+      if (toolError && !state.error) {
+        const message = getString(part?.error) || getString(stateRecord?.error) || "OpenCode tool call failed.";
+        state.error = message;
+        void presenter.onError(message);
+      }
+      return true;
+    }
     case "session.error":
     case "error": {
       const errObj = typeof parsed.error === "object" && parsed.error !== null ? parsed.error : null;
@@ -19701,35 +19778,10 @@ var parseOpencodeStructuredLine = createStructuredLineParser(
   "opencode_cli",
   handleOpencodeStructuredEvent
 );
-var AUTONOMOUS_OPENCODE_CONFIG_CONTENT = JSON.stringify({
-  $schema: "https://opencode.ai/config.json",
-  permission: "allow"
-});
-function buildAutonomousOpenCodeConfigContent(existing) {
-  if (!existing?.trim()) return AUTONOMOUS_OPENCODE_CONFIG_CONTENT;
-  try {
-    const parsed = JSON.parse(existing);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return JSON.stringify({
-        ...parsed,
-        permission: "allow"
-      });
-    }
-  } catch {
-  }
-  return AUTONOMOUS_OPENCODE_CONFIG_CONTENT;
-}
-function withAutonomousOpenCodePermissions(context) {
-  if (shouldUseReadOnlyRuntimePermissions(context.config)) return context;
-  return {
-    ...context,
-    env: {
-      ...context.env,
-      OPENCODE_CONFIG_CONTENT: buildAutonomousOpenCodeConfigContent(
-        context.env.OPENCODE_CONFIG_CONTENT
-      )
-    }
-  };
+function buildOpencodeEffortArgs(selectedEffortLevel) {
+  const trimmed = selectedEffortLevel?.trim().toLowerCase();
+  if (!trimmed || !isEffortLevel(trimmed)) return [];
+  return ["--variant", trimmed];
 }
 function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
   return {
@@ -19752,7 +19804,7 @@ function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
           command,
           args: [],
           buildArgs: (ctx, prompt) => {
-            const args = ["run", "--format", "json"];
+            const args = ["run", "--format", "json", "--thinking"];
             if (!shouldUseReadOnlyRuntimePermissions(ctx.config)) {
               args.push("--dangerously-skip-permissions");
             }
@@ -19760,6 +19812,7 @@ function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
             if (resumeId) args.push("--session", resumeId);
             const model = ctx.config.selectedModel?.trim();
             if (model?.includes("/")) args.push("--model", model);
+            args.push(...buildOpencodeEffortArgs(ctx.config.selectedEffortLevel));
             const attachmentPaths = [...imagePaths, ...filePaths];
             const fileArgs = attachmentPaths.flatMap((p) => ["--file", p]);
             if (fileArgs.length > 0) {
@@ -19780,6 +19833,395 @@ function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
     }
   };
 }
+function parseSseEventBlock(block) {
+  const dataLines = block.split("\n").map((line) => line.endsWith("\r") ? line.slice(0, -1) : line).filter((line) => line.startsWith("data:")).map((line) => line.slice("data:".length).replace(/^ /, ""));
+  if (dataLines.length === 0) return null;
+  try {
+    const parsed = JSON.parse(dataLines.join("\n"));
+    if (parsed && typeof parsed === "object" && typeof parsed.type === "string") {
+      const record = parsed;
+      return {
+        id: typeof record.id === "string" ? record.id : void 0,
+        type: record.type,
+        properties: typeof record.properties === "object" && record.properties !== null ? record.properties : {}
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+async function connectOpenCodeSse(url2, signal) {
+  const response = await fetch(url2, {
+    signal,
+    headers: { Accept: "text/event-stream" }
+  });
+  if (!response.ok || !response.body) {
+    throw new Error(`OpenCode SSE connection failed: HTTP ${response.status}`);
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let closed = false;
+  async function* generate() {
+    let buffer = "";
+    try {
+      while (!closed) {
+        const { value: value2, done } = await reader.read();
+        if (done) return;
+        buffer += decoder.decode(value2, { stream: true });
+        let separatorIndex = buffer.indexOf("\n\n");
+        while (separatorIndex !== -1) {
+          const block = buffer.slice(0, separatorIndex);
+          buffer = buffer.slice(separatorIndex + 2);
+          const event = parseSseEventBlock(block);
+          if (event) yield event;
+          separatorIndex = buffer.indexOf("\n\n");
+        }
+      }
+    } finally {
+      try {
+        reader.releaseLock();
+      } catch {
+      }
+    }
+  }
+  return {
+    events: generate(),
+    close: () => {
+      if (closed) return;
+      closed = true;
+      reader.cancel().catch(() => {
+      });
+    }
+  };
+}
+var SERVER_LISTENING_PATTERN = /listening on (https?:\/\/\S+)/i;
+var STARTUP_TIMEOUT_MS = 2e4;
+var HEALTH_POLL_INTERVAL_MS = 200;
+var HEALTH_POLL_MAX_ATTEMPTS = 50;
+function startOpenCodeServer(command, context) {
+  const child = spawnCli(command, ["serve", "--port", "0", "--hostname", "127.0.0.1"], context);
+  const ready = new Promise((resolve22, reject) => {
+    let settled = false;
+    const timeout = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      reject(
+        new Error(`opencode serve did not report a listening URL within ${STARTUP_TIMEOUT_MS}ms`)
+      );
+    }, STARTUP_TIMEOUT_MS);
+    const stdoutRl = (0, import_readline2.createInterface)({ input: child.stdout });
+    const stderrRl = (0, import_readline2.createInterface)({ input: child.stderr });
+    const stderrLines = [];
+    const checkLine = (line) => {
+      if (settled) return;
+      const match = line.match(SERVER_LISTENING_PATTERN);
+      if (!match) return;
+      settled = true;
+      clearTimeout(timeout);
+      resolve22({ baseUrl: match[1].replace(/\/$/, "") });
+    };
+    stdoutRl.on("line", checkLine);
+    stderrRl.on("line", (line) => {
+      stderrLines.push(line);
+      checkLine(line);
+    });
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.once("exit", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      reject(
+        new Error(
+          `opencode serve exited (code ${code}) before reporting a listening URL. stderr: ${stderrLines.slice(-5).join("\n")}`
+        )
+      );
+    });
+  });
+  return { child, ready };
+}
+async function waitForHealthy(baseUrl, signal) {
+  for (let attempt = 0; attempt < HEALTH_POLL_MAX_ATTEMPTS; attempt++) {
+    if (signal.aborted)
+      throw new Error("Aborted while waiting for opencode server to become healthy");
+    try {
+      const response = await fetch(`${baseUrl}/global/health`, { signal });
+      if (response.ok) {
+        const body = await response.json().catch(() => null);
+        if (body?.healthy) return;
+      }
+    } catch {
+    }
+    await new Promise((resolve22) => setTimeout(resolve22, HEALTH_POLL_INTERVAL_MS));
+  }
+  throw new Error(`opencode server at ${baseUrl} did not become healthy in time`);
+}
+var NON_INTERACTIVE_DENY_RULES = [
+  { permission: "question", pattern: "*", action: "deny" },
+  { permission: "plan_enter", pattern: "*", action: "deny" },
+  { permission: "plan_exit", pattern: "*", action: "deny" }
+];
+async function resolveSession(baseUrl, context, signal) {
+  const resumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
+  if (resumeId) {
+    const existing = await fetch(`${baseUrl}/session/${encodeURIComponent(resumeId)}`, {
+      signal
+    }).catch(() => null);
+    if (existing?.ok) return { id: resumeId };
+  }
+  const title = context.promptText.slice(0, 50) + (context.promptText.length > 50 ? "..." : "");
+  const response = await fetch(`${baseUrl}/session`, {
+    method: "POST",
+    signal,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ title, permission: NON_INTERACTIVE_DENY_RULES })
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to create OpenCode session: HTTP ${response.status}`);
+  }
+  const info = await response.json();
+  if (!info.id) throw new Error("OpenCode session create response had no id");
+  return { id: info.id };
+}
+function buildPromptParts(promptText, imageFiles, attachmentFiles) {
+  const attachments = [...imageFiles, ...attachmentFiles].map(
+    (file) => ({
+      type: "file",
+      mime: file.mimeType,
+      filename: file.filename,
+      url: (0, import_url2.pathToFileURL)(file.path).href
+    })
+  );
+  return [...attachments, { type: "text", text: promptText }];
+}
+async function sendPrompt(baseUrl, sessionId, context, parts2, signal) {
+  const model = context.config.selectedModel?.trim();
+  const modelBody = model && model.includes("/") ? (() => {
+    const slashIndex = model.indexOf("/");
+    return { providerID: model.slice(0, slashIndex), modelID: model.slice(slashIndex + 1) };
+  })() : void 0;
+  const variant = context.config.selectedEffortLevel?.trim().toLowerCase();
+  const response = await fetch(`${baseUrl}/session/${encodeURIComponent(sessionId)}/message`, {
+    method: "POST",
+    signal,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      parts: parts2,
+      ...modelBody ? { model: modelBody } : {},
+      ...variant && isEffortLevel(variant) ? { variant } : {}
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`OpenCode prompt request failed: HTTP ${response.status} ${text}`.trim());
+  }
+}
+async function replyToPermission(baseUrl, requestId, reply, signal) {
+  await fetch(`${baseUrl}/permission/${encodeURIComponent(requestId)}/reply`, {
+    method: "POST",
+    signal,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ reply })
+  }).catch((error) => {
+    console.warn("[opencode_serve] Failed to reply to permission request", requestId, error);
+  });
+}
+function buildAgentResult(state, sessionId, aborted2) {
+  if (aborted2) {
+    return {
+      success: false,
+      summary: "Interrupted by user",
+      filesModified: [],
+      planFilesCreated: [],
+      iterations: Math.max(state.iterations, 1),
+      error: "Interrupted by user",
+      providerSessionId: sessionId,
+      runtimeSessionId: sessionId,
+      backendKind: "opencode_serve",
+      supportTier: "structured",
+      usage: state.usage
+    };
+  }
+  const failed = Boolean(state.error?.trim());
+  const summary = state.summary.trim() || state.error?.trim() || (failed ? "Task failed" : "Task completed");
+  return {
+    success: !failed,
+    summary,
+    filesModified: [],
+    planFilesCreated: [],
+    iterations: Math.max(state.iterations, 1),
+    ...state.error?.trim() ? { error: state.error.trim() } : {},
+    providerSessionId: sessionId,
+    runtimeSessionId: sessionId,
+    backendKind: "opencode_serve",
+    supportTier: "structured",
+    usage: state.usage
+  };
+}
+function createOpencodeServeBackend(command = "opencode") {
+  return {
+    kind: "opencode_serve",
+    supportTier: "structured",
+    async run(context) {
+      const { files: imageFiles, cleanup: cleanupImages } = writeImagesToTempFiles(
+        context.config.images,
+        context.cwd
+      );
+      const { files: attachmentFiles, cleanup: cleanupFiles } = writeFilesToTempFiles(
+        context.config.files,
+        context.cwd
+      );
+      const runContext = withAutonomousOpenCodePermissions(context);
+      const readOnly = shouldUseReadOnlyRuntimePermissions(context.config);
+      const { child, ready } = startOpenCodeServer(command, runContext);
+      const state = { process: child, iterations: 0, summary: "" };
+      context.onProcessSpawned?.(child);
+      context.registerLivenessProbe?.(() => ({
+        providerAlive: child.exitCode === null,
+        lastRawOutputAgoMs: typeof state.lastRawOutputAtMs === "number" ? Date.now() - state.lastRawOutputAtMs : null
+      }));
+      let sseClose = null;
+      let sessionId = "";
+      let aborted2 = false;
+      const onAbort = () => {
+        aborted2 = true;
+        sseClose?.();
+        killProcessTree(child.pid, { signal: "SIGTERM", child });
+      };
+      context.abortController.signal.addEventListener("abort", onAbort, { once: true });
+      try {
+        const server = await ready;
+        state.lastRawOutputAtMs = Date.now();
+        await waitForHealthy(server.baseUrl, context.abortController.signal);
+        const session = await resolveSession(
+          server.baseUrl,
+          runContext,
+          context.abortController.signal
+        );
+        sessionId = session.id;
+        state.runtimeSessionId = sessionId;
+        const prompt = context.config.mode === "plan" ? buildPlanModePrefix(buildPromptWithSystem(context.config, context.promptText)) : buildPromptWithSystem(context.config, context.promptText);
+        const parts2 = buildPromptParts(prompt, imageFiles, attachmentFiles);
+        const connection = await connectOpenCodeSse(
+          `${server.baseUrl}/event`,
+          context.abortController.signal
+        );
+        sseClose = connection.close;
+        const promptError = await sendPrompt(
+          server.baseUrl,
+          sessionId,
+          runContext,
+          parts2,
+          context.abortController.signal
+        ).then(() => null).catch((error) => ({
+          message: error instanceof Error ? error.message : String(error)
+        }));
+        if (context.abortController.signal.aborted) {
+        } else if (promptError) {
+          state.error = promptError.message;
+          void context.presenter.onError(promptError.message);
+        } else {
+          for await (const event of connection.events) {
+            if (aborted2) break;
+            const done = handleOpenCodeServeEvent(
+              event,
+              sessionId,
+              runContext,
+              state,
+              readOnly,
+              server.baseUrl
+            );
+            if (done) break;
+          }
+        }
+        return buildAgentResult(state, sessionId, aborted2);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!aborted2 && !context.abortController.signal.aborted) {
+          console.error("[opencode_serve] Run failed:", message);
+          state.error = message;
+          void context.presenter.onError(message);
+        }
+        return buildAgentResult(
+          state,
+          sessionId,
+          aborted2 || context.abortController.signal.aborted
+        );
+      } finally {
+        context.abortController.signal.removeEventListener("abort", onAbort);
+        sseClose?.();
+        killProcessTree(child.pid, { signal: "SIGTERM", child });
+        cleanupImages();
+        cleanupFiles();
+      }
+    }
+  };
+}
+function handleOpenCodeServeEvent(event, sessionId, context, state, readOnly, baseUrl) {
+  const properties = event.properties;
+  const eventSessionId = getString(properties.sessionID);
+  if (eventSessionId && eventSessionId !== sessionId) return false;
+  switch (event.type) {
+    // Live-verified: the SSE bus emits a message.updated (and matching
+    // message.part.updated) for the USER's own message too, not just the
+    // assistant's — track user message ids so their echoed text is never
+    // mistaken for assistant output below.
+    case "message.updated": {
+      const info = getRecord(properties.info);
+      if (getString(info?.role) === "user") {
+        const messageId = getString(info?.id);
+        if (messageId) {
+          state.opencodeUserMessageIds ??= /* @__PURE__ */ new Set();
+          state.opencodeUserMessageIds.add(messageId);
+        }
+      }
+      return false;
+    }
+    case "message.part.updated": {
+      const part = getRecord(properties.part);
+      if (!part) return false;
+      const messageId = getString(part.messageID);
+      if (messageId && state.opencodeUserMessageIds?.has(messageId)) return false;
+      mapOpencodePart(part, context, state);
+      return false;
+    }
+    // Live token-by-token streaming is explicitly out of scope — only the
+    // start/complete snapshots from message.part.updated are consumed.
+    case "message.part.delta":
+      return false;
+    case "permission.asked": {
+      const requestId = getString(properties.id);
+      if (requestId) {
+        void replyToPermission(
+          baseUrl,
+          requestId,
+          readOnly ? "reject" : "once",
+          context.abortController.signal
+        );
+      }
+      return false;
+    }
+    case "session.error": {
+      const errorRecord = getRecord(properties.error);
+      const message = getString(errorRecord?.message) || getString(properties.error) || "OpenCode session error.";
+      if (!state.error) {
+        state.error = message;
+        void context.presenter.onError(message);
+      }
+      return false;
+    }
+    case "session.status": {
+      const status = getRecord(properties.status);
+      return getString(status?.type) === "idle";
+    }
+    default:
+      return false;
+  }
+}
 function createGenericCliPassthroughBackend(command, defaultArgs = []) {
   return {
     kind: "generic_cli",
@@ -20008,6 +20450,7 @@ function defaultSelectedModelForBackend(backendKind) {
     case "grok_cli":
       return firstCatalogModelId(backendKind) ?? "grok-4.5";
     case "opencode_cli":
+    case "opencode_serve":
       return void 0;
     case "antigravity_cli":
       return void 0;
@@ -20149,7 +20592,7 @@ var BaseMachineAgent = class _BaseMachineAgent {
     };
     const releaseGate = await acquireMcpConfigWriteGate();
     try {
-      const writtenClis = syncAlanMcpSessionHeaders({
+      const writtenClis = await syncAlanMcpSessionHeaders({
         conversationId,
         teamId: config.teamId,
         runHeaders: config.alanMcp?.headers,
@@ -20224,6 +20667,7 @@ var BaseMachineAgent = class _BaseMachineAgent {
       case "cursor_agent_cli":
       case "droid_cli":
       case "opencode_cli":
+      case "opencode_serve":
       case "copilot_cli":
       case "supatest_cli":
       case "kimi_cli":
@@ -20291,7 +20735,7 @@ Prefer relative paths and keep your work scoped to this project.`
     const promptText = this.buildPromptText(runtimeConfig);
     const runtimeCommand = runtimeConfig.runtimeCommand || this.runtime.runtimeCommand;
     const runtimeArgs = runtimeConfig.runtimeArgs || this.runtime.runtimeArgs || [];
-    const backend = backendKind === "claude_cli" ? createClaudeCliBackend(runtimeCommand || "claude", runtimeArgs) : backendKind === "codex_app_server" ? createCodexRuntimeBackend(runtimeCommand || "codex", runtimeArgs) : backendKind === "copilot_cli" ? createCopilotCliBackend(runtimeCommand || "copilot", runtimeArgs) : backendKind === "cursor_agent_cli" ? createCursorAgentCliBackend(runtimeCommand || "cursor-agent", runtimeArgs) : backendKind === "antigravity_cli" ? createAntigravityCliBackend(runtimeCommand || "agy", runtimeArgs) : backendKind === "droid_cli" ? createDroidCliBackend(runtimeCommand || "droid", runtimeArgs) : backendKind === "opencode_cli" ? createOpencodeCliBackend(runtimeCommand || "opencode", runtimeArgs) : backendKind === "kimi_cli" ? createKimiCliBackend(runtimeCommand || "kimi-cli", runtimeArgs) : backendKind === "grok_cli" ? createGrokCliBackend(runtimeCommand || "grok", runtimeArgs) : backendKind === "supatest_cli" ? createSupatestCliBackend(runtimeCommand || "supatest", runtimeArgs) : createGenericCliPassthroughBackend(
+    const backend = backendKind === "claude_cli" ? createClaudeCliBackend(runtimeCommand || "claude", runtimeArgs) : backendKind === "codex_app_server" ? createCodexRuntimeBackend(runtimeCommand || "codex", runtimeArgs) : backendKind === "copilot_cli" ? createCopilotCliBackend(runtimeCommand || "copilot", runtimeArgs) : backendKind === "cursor_agent_cli" ? createCursorAgentCliBackend(runtimeCommand || "cursor-agent", runtimeArgs) : backendKind === "antigravity_cli" ? createAntigravityCliBackend(runtimeCommand || "agy", runtimeArgs) : backendKind === "droid_cli" ? createDroidCliBackend(runtimeCommand || "droid", runtimeArgs) : backendKind === "opencode_cli" ? createOpencodeCliBackend(runtimeCommand || "opencode", runtimeArgs) : backendKind === "opencode_serve" ? createOpencodeServeBackend(runtimeCommand || "opencode") : backendKind === "kimi_cli" ? createKimiCliBackend(runtimeCommand || "kimi-cli", runtimeArgs) : backendKind === "grok_cli" ? createGrokCliBackend(runtimeCommand || "grok", runtimeArgs) : backendKind === "supatest_cli" ? createSupatestCliBackend(runtimeCommand || "supatest", runtimeArgs) : createGenericCliPassthroughBackend(
       runtimeCommand || "generic-cli",
       runtimeArgs
     );
@@ -21004,13 +21448,20 @@ ${meta.description}`);
     }
     if (conversationId) artifactIds.push(`- conversationId: "${conversationId}"`);
     if (artifactIds.length > 0) {
+      const artifactTools = ["create_plan", "create_document_artifact", "create_test_report"];
+      if (taskId || isWorkflowSession) artifactTools.push("upsert_prototype_version");
       parts2.push(
         [
-          "When creating artifacts using MCP tools (create_plan, create_document_artifact, create_test_report, upsert_prototype_version), always pass these IDs:",
+          `When creating artifacts using MCP tools (${artifactTools.join(", ")}), always pass these IDs:`,
           ...artifactIds
         ].join("\n")
       );
     }
+    if (teamId && conversationId && !taskId && !isWorkflowSession) {
+      parts2.push(
+        "This is a standalone chat. For create_plan, create_document_artifact, and create_test_report, omit taskId and workflowId; conversationId is the artifact owner. Do not use create_document unless the user explicitly asks for a standalone team Document."
+      );
+    }
     if (workflowId && conversationId && teamId) {
       parts2.push(
         [
@@ -22274,9 +22725,7 @@ var CODEX_ALAN_TOML_SECTION = "mcp_servers.alan";
 function isCodexAlanTomlSection(section) {
   return section === CODEX_ALAN_TOML_SECTION || section.startsWith(`${CODEX_ALAN_TOML_SECTION}.`);
 }
-function mergeCodexAlanSection(path, existingContent, desiredContent) {
-  if (existingContent === null || existingContent.trim() === "") return desiredContent;
-  assertValidExistingToml(path, existingContent);
+function stripCodexAlanSection(existingContent) {
   const lines = existingContent.split("\n");
   const retained = [];
   let insideAlanSection = false;
@@ -22287,7 +22736,12 @@ function mergeCodexAlanSection(path, existingContent, desiredContent) {
     }
     if (!insideAlanSection) retained.push(line);
   }
-  const prefix = retained.join("\n").trimEnd();
+  return retained.join("\n").trimEnd();
+}
+function mergeCodexAlanSection(path, existingContent, desiredContent) {
+  if (existingContent === null || existingContent.trim() === "") return desiredContent;
+  assertValidExistingToml(path, existingContent);
+  const prefix = stripCodexAlanSection(existingContent);
   const merged = `${prefix}${prefix ? "\n\n" : ""}${desiredContent.trim()}
 `;
   try {
@@ -22373,6 +22827,45 @@ function verifyAlanMcpRegistered(backendKind, home = (0, import_node_os6.homedir
     verification: inspection.verification
   };
 }
+function removeAlanFromJsonConfig(path, existingContent) {
+  const config = parseJsonObject2(path, existingContent);
+  for (const containerKey of ["mcpServers", "mcp"]) {
+    const container = config[containerKey];
+    if (container && typeof container === "object" && !Array.isArray(container)) {
+      delete container.alan;
+    }
+  }
+  return JSON.stringify(config);
+}
+function unregisterAlanMcp(backendKind, home = (0, import_node_os6.homedir)()) {
+  const removedPaths = [];
+  const errors = [];
+  const files = alanMcpConfigFilesForBackend(backendKind, {}, home);
+  for (const file of files) {
+    if (!(0, import_node_fs7.existsSync)(file.path)) continue;
+    const releaseLock = waitForConfigLock(`${file.path}.alan-lock`);
+    try {
+      const current = (0, import_node_fs7.readFileSync)(file.path, "utf8");
+      let next;
+      if (file.path.endsWith(".toml")) {
+        const stripped = stripCodexAlanSection(current);
+        next = stripped ? `${stripped}
+` : "";
+      } else {
+        next = removeAlanFromJsonConfig(file.path, current);
+      }
+      if (next !== current) {
+        atomicWriteManagedConfig(file.path, next);
+        removedPaths.push(file.path);
+      }
+    } catch (err) {
+      errors.push(err instanceof Error ? err.message : String(err));
+    } finally {
+      releaseLock();
+    }
+  }
+  return { removedPaths, errors };
+}
 function isHttpUrl(value2) {
   if (typeof value2 !== "string") return false;
   try {
@@ -22719,6 +23212,88 @@ function extractCodexDiscoveredModelIdsFromDebugJson(value2) {
   }
   return [...new Set(ids)];
 }
+var OPENCODE_MODEL_ID_LINE_PATTERN = /^[a-z0-9][\w.-]*\/[\w.-]+$/i;
+var OPENCODE_KNOWN_VARIANT_KEYS = /* @__PURE__ */ new Set([
+  "minimal",
+  "none",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "extra-high",
+  "max",
+  "ultra"
+]);
+function parseOpenCodeVerboseModelOutput(text) {
+  const entries = [];
+  const lines = text.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    const line = (lines[i] ?? "").trim();
+    i += 1;
+    if (!OPENCODE_MODEL_ID_LINE_PATTERN.test(line)) continue;
+    let jsonStart = i;
+    while (jsonStart < lines.length && (lines[jsonStart] ?? "").trim() === "") jsonStart += 1;
+    if (jsonStart >= lines.length || !(lines[jsonStart] ?? "").trim().startsWith("{")) continue;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    let endLineIdx = -1;
+    let buffer = "";
+    for (let j = jsonStart; j < lines.length; j += 1) {
+      const raw = lines[j] ?? "";
+      buffer += (buffer ? "\n" : "") + raw;
+      for (const ch of raw) {
+        if (escaped) {
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\" && inString) {
+          escaped = true;
+          continue;
+        }
+        if (ch === '"') {
+          inString = !inString;
+          continue;
+        }
+        if (inString) continue;
+        if (ch === "{") depth += 1;
+        else if (ch === "}") depth -= 1;
+      }
+      if (depth === 0) {
+        endLineIdx = j;
+        break;
+      }
+    }
+    if (endLineIdx === -1) break;
+    try {
+      const obj = JSON.parse(buffer);
+      entries.push({
+        id: line,
+        reasoning: obj.capabilities?.reasoning === true,
+        variants: obj.variants ? Object.keys(obj.variants) : []
+      });
+    } catch {
+    }
+    i = endLineIdx + 1;
+  }
+  return entries;
+}
+function extractOpenCodeDiscoveredModelIdsFromVerboseOutput(text) {
+  const entries = parseOpenCodeVerboseModelOutput(text);
+  const ids = [];
+  for (const entry of entries) {
+    const knownVariants = entry.reasoning ? entry.variants.filter((variant) => OPENCODE_KNOWN_VARIANT_KEYS.has(variant)) : [];
+    if (knownVariants.length === 0) {
+      ids.push(entry.id);
+      continue;
+    }
+    for (const variant of knownVariants) {
+      ids.push(`${entry.id}-${variant}`);
+    }
+  }
+  return [...new Set(ids)];
+}
 function extractModelIdsFromText(value2) {
   const ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
   const ignoredLinePattern = /^(available models|models|usage|error|flag provided|try |agy\b|warning:)/i;
@@ -22829,12 +23404,24 @@ async function probeJsonOrTextModels(executable, env, argSets, options) {
   return [];
 }
 async function discoverOpenCodeModels(executable, env) {
-  const probed = await probeJsonOrTextModels(executable, env, [
+  const verbose = await runCliProbeAsync(
+    executable,
+    withModelProbeEnv(env),
+    ["models", "--verbose"],
+    MODEL_DISCOVERY_TIMEOUT_MS
+  );
+  if (verbose && !verbose.error && verbose.status === 0 && verbose.stdout.trim()) {
+    const withEffort = extractOpenCodeDiscoveredModelIdsFromVerboseOutput(verbose.stdout);
+    if (withEffort.length > 0) return withEffort;
+  }
+  const plain = await probeJsonOrTextModels(executable, env, [["models"]]);
+  if (plain.length > 0) return plain;
+  const legacy = await probeJsonOrTextModels(executable, env, [
     ["models", "--json"],
     ["models", "list", "--json"],
     ["model", "list", "--json"]
   ]);
-  return probed.length > 0 ? probed : OPENCODE_ZEN_MODEL_IDS;
+  return legacy.length > 0 ? legacy : OPENCODE_ZEN_MODEL_IDS;
 }
 async function discoverAntigravityModels(executable, env) {
   return probeJsonOrTextModels(executable, env, [["models"]], {
@@ -23080,7 +23667,7 @@ var RunStartGate = class {
 };
 
 // src/version.ts
-var AGENT_VERSION = "0.1.43";
+var AGENT_VERSION = "0.1.45";
 
 // src/workspace-relocation.ts
 var import_node_child_process3 = require("child_process");
@@ -25224,6 +25811,21 @@ async function startDaemon(args) {
     recentLogs.push(`${(/* @__PURE__ */ new Date()).toISOString()} ${message}`);
     if (recentLogs.length > 200) recentLogs.splice(0, recentLogs.length - 200);
   };
+  const alanMcpRegisteredRuns = /* @__PURE__ */ new Set();
+  const alanMcpRegisteredBackends = /* @__PURE__ */ new Set();
+  const finalizeAlanMcpForRun = (runId) => {
+    if (!alanMcpRegisteredRuns.delete(runId)) return;
+    if (alanMcpRegisteredRuns.size > 0) return;
+    for (const backend of alanMcpRegisteredBackends) {
+      try {
+        const { removedPaths } = unregisterAlanMcp(backend);
+        if (removedPaths.length > 0) pushLog(`mcp-unregistered backend=${backend} run=${runId}`);
+      } catch (err) {
+        pushLog(`mcp-unregister-failed backend=${backend} ${err.message}`);
+      }
+    }
+    alanMcpRegisteredBackends.clear();
+  };
   const workspaceAccessTracker = new WorkspaceAccessTracker();
   const recheckWorkspaceIssue = () => {
     const previousPath = workspaceAccessTracker.recoveryPath();
@@ -26006,6 +26608,10 @@ async function startDaemon(args) {
       workspaceLease: workspaceLeaseCapture.lease
     });
     pendingRunStarts.delete(payload.runId);
+    if (payload.alanMcp && backendKind) {
+      alanMcpRegisteredRuns.add(payload.runId);
+      alanMcpRegisteredBackends.add(backendKind);
+    }
     void agent.run({
       task: payload.content,
       maxIterations: payload.maxIterations ?? 50,
@@ -26051,6 +26657,7 @@ async function startDaemon(args) {
       } catch {
         pushLog(`run-journal-remove-failed run=${payload.runId}`);
       }
+      finalizeAlanMcpForRun(payload.runId);
       releaseActiveRun();
     });
   });
@@ -28037,7 +28644,7 @@ async function runSessionFromEnv() {
   const task = process.env.ALAN_TASK;
   const teamId = process.env.ALAN_TEAM_ID || void 0;
   const projectPath = process.env.ALAN_PROJECT_PATH || "/home/user/workspace";
-  const backendKind = process.env.ALAN_BACKEND_KIND || "claude_cli";
+  const backendKind = process.env.ALAN_BACKEND_KIND || "codex_app_server";
   const agentId = process.env.ALAN_AGENT_ID || void 0;
   const agentPrompt = process.env.ALAN_AGENT_PROMPT || void 0;
   const mode = process.env.ALAN_MODE || "agent";