@autohq/cli 0.1.583 → 0.1.584

package/dist/index.js

@@ -16681,13 +16681,13 @@ function parseClaudeCodeStreamRecord(parsed) {
   }
   const isError = record2.is_error === true || record2.subtype === "error";
   const sdkErrorMessage = record2.errors?.map((error51) => error51.trim()).filter(Boolean).join("\n");
-  const errorMessage6 = isError ? record2.error ?? record2.result ?? (sdkErrorMessage || void 0) ?? "claude-code reported an error" : void 0;
+  const errorMessage7 = isError ? record2.error ?? record2.result ?? (sdkErrorMessage || void 0) ?? "claude-code reported an error" : void 0;
   const usage = claudeCodeUsageFromRecord(record2);
   return {
     projections: [],
     result: {
       isError,
-      errorMessage: errorMessage6,
+      errorMessage: errorMessage7,
       ...usage ? { usage } : {}
     }
   };
@@ -16705,11 +16705,11 @@ function isClaudeCodeInterruptMarker(record2) {
     (block) => block !== null && block.type === "text" && block.text.startsWith(CLAUDE_CODE_INTERRUPT_MARKER_PREFIX)
   );
 }
-function isClaudeCodeEdeDiagnosticOnlyError(errorMessage6) {
-  if (!errorMessage6) {
+function isClaudeCodeEdeDiagnosticOnlyError(errorMessage7) {
+  if (!errorMessage7) {
     return false;
   }
-  const lines = errorMessage6.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  const lines = errorMessage7.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
   return lines.length > 0 && lines.every((line) => line.startsWith(CLAUDE_CODE_EDE_DIAGNOSTIC_PREFIX));
 }
 function isClaudeCodePermissionDenialText(text) {
@@ -88606,7 +88606,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@autohq/cli",
-      version: "0.1.583",
+      version: "0.1.584",
       license: "SEE LICENSE IN README.md",
       publishConfig: {
         access: "public"
@@ -92337,9 +92337,9 @@ var init_actions = __esm({
 });
 
 // src/commands/auth/pkce.ts
-import { createHash as createHash6, randomBytes as randomBytes3 } from "crypto";
+import { createHash as createHash6, randomBytes as randomBytes4 } from "crypto";
 function pkceVerifier() {
-  return randomBytes3(32).toString("base64url");
+  return randomBytes4(32).toString("base64url");
 }
 function pkceChallenge(verifier) {
   return createHash6("sha256").update(verifier).digest("base64url");
@@ -95904,7 +95904,7 @@ function SessionsView({
     visibleSessions.map((session, vi) => {
       const i = scrollOffset + vi;
       const title = sessionDisplayTitle(session);
-      const err = session.status === "failed" ? errorMessage4(session) : null;
+      const err = session.status === "failed" ? errorMessage5(session) : null;
       const isSelected = i === safeIndex;
       const isMarked = selectedSessionIds.has(session.id);
       return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", children: [
@@ -96042,7 +96042,7 @@ function truncateToWidth(value, width) {
 function agentNameForRun(session) {
   return session.snapshot.metadata.name;
 }
-function errorMessage4(session) {
+function errorMessage5(session) {
   if (session.error == null) return null;
   if (typeof session.error === "string") return session.error;
   const msg = readField(session.error, "message");
@@ -97477,7 +97477,7 @@ function HomeView({
   if (inspectedResource) {
     sectionTitle = `Inspect ${inspectedResource.kind}/${inspectedResource.name}`;
   }
-  const runError = errorMessage5(triggerSession.error) ?? errorMessage5(archiveSessions.error) ?? errorMessage5(unarchiveSessions.error) ?? errorMessage5(stopSessions.error);
+  const runError = errorMessage6(triggerSession.error) ?? errorMessage6(archiveSessions.error) ?? errorMessage6(unarchiveSessions.error) ?? errorMessage6(stopSessions.error);
   const isRunMutationPending = triggerSession.isPending || archiveSessions.isPending || unarchiveSessions.isPending || stopSessions.isPending;
   const isConnectionMutationPending = startConnection.isPending || allowConnection.isPending || removeConnection.isPending || createGithubSyncBinding.isPending;
   const serviceAccountStatus = createServiceAccount2.error instanceof Error ? createServiceAccount2.error.message : rotateServiceAccount2.error instanceof Error ? rotateServiceAccount2.error.message : removeServiceAccount2.error instanceof Error ? removeServiceAccount2.error.message : serviceAccountNotice;
@@ -97890,7 +97890,7 @@ function runActionTargetLabel(sessionIds, markedRunCount) {
 function pluralizeRunCount(count) {
   return `${count} ${count === 1 ? "session" : "sessions"}`;
 }
-function errorMessage5(error51) {
+function errorMessage6(error51) {
   if (error51 instanceof Error) return error51.message;
   return error51 ? String(error51) : null;
 }
@@ -100733,7 +100733,7 @@ function jsonRecordString(value, key) {
 init_src();
 
 // src/commands/agent-bridge/harness/agent-facing-auto-mcp.ts
-import { randomBytes as randomBytes2, timingSafeEqual } from "crypto";
+import { randomBytes as randomBytes2 } from "crypto";
 import { lstatSync, readFileSync as readFileSync3, realpathSync, statSync } from "fs";
 import {
   createServer as createServer3
@@ -100751,7 +100751,17 @@ import {
 import { parseAllDocuments as parseAllDocuments2 } from "yaml";
 
 // src/commands/agent-bridge/harness/turn-bound-mcp.ts
+import { timingSafeEqual } from "crypto";
 var AGENT_BRIDGE_MCP_CAPABILITY_HEADER = "x-auto-agent-bridge-mcp-capability";
+function requestHasMcpCapability(headers, expected) {
+  const received = headers[AGENT_BRIDGE_MCP_CAPABILITY_HEADER];
+  if (typeof received !== "string") {
+    return false;
+  }
+  const expectedBytes = Buffer.from(expected);
+  const receivedBytes = Buffer.from(received);
+  return expectedBytes.length === receivedBytes.length && timingSafeEqual(expectedBytes, receivedBytes);
+}
 
 // src/commands/agent-bridge/harness/agent-facing-auto-mcp.ts
 var MAX_DRY_RUN_PATH_FILES = 100;
@@ -101221,7 +101231,7 @@ async function startAutoMcpProxy(input) {
   let pathsCompatible = false;
   const server = createServer3(async (request, response) => {
     try {
-      if (!requestHasCapability(request.headers, input.capability)) {
+      if (!requestHasMcpCapability(request.headers, input.capability)) {
         writeResponse(
           response,
           401,
@@ -101427,15 +101437,6 @@ function exactActiveCommandId(activeTurnCommandIds) {
   const commandIds = activeTurnCommandIds();
   return commandIds.length === 1 ? commandIds[0] ?? null : null;
 }
-function requestHasCapability(headers, expected) {
-  const received = headers[AGENT_BRIDGE_MCP_CAPABILITY_HEADER];
-  if (typeof received !== "string") {
-    return false;
-  }
-  const expectedBytes = Buffer.from(expected);
-  const receivedBytes = Buffer.from(received);
-  return expectedBytes.length === receivedBytes.length && timingSafeEqual(expectedBytes, receivedBytes);
-}
 function readRequestBody(request) {
   return new Promise((resolveBody, reject) => {
     const chunks = [];
@@ -101468,6 +101469,384 @@ function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/commands/agent-bridge/harness/ask-user-projection.ts
+init_src();
+var ASK_USER_MCP_SERVER_NAME = "user";
+var ASK_USER_MCP_TOOL_NAME = "ask_question";
+var ASK_USER_TOOL_NAME = `${ASK_USER_MCP_SERVER_NAME}.${ASK_USER_MCP_TOOL_NAME}`;
+var CLAUDE_ASK_USER_TOOL_NAME = `mcp__${ASK_USER_MCP_SERVER_NAME}__${ASK_USER_MCP_TOOL_NAME}`;
+function isAskUserMcpTool(server, tool) {
+  return server === ASK_USER_MCP_SERVER_NAME && tool === ASK_USER_MCP_TOOL_NAME;
+}
+function projectAskUserQuestion(input) {
+  return [
+    {
+      type: "entry",
+      entry: {
+        role: "assistant",
+        kind: "question",
+        turnStatus: "waiting_for_input",
+        content: {
+          parts: [
+            {
+              type: "question",
+              toolCallId: input.id,
+              questions: input.questions
+            }
+          ]
+        }
+      }
+    },
+    {
+      type: "ui_message_chunk",
+      chunk: {
+        type: "tool-input-available",
+        toolCallId: input.id,
+        toolName: ASK_USER_TOOL_NAME,
+        input: { questions: input.questions }
+      },
+      turnStatus: "waiting_for_input"
+    }
+  ];
+}
+function projectAskUserAnswer(answer) {
+  return {
+    type: "ui_message_chunk",
+    chunk: {
+      type: "tool-output-available",
+      toolCallId: answer.toolCallId || UNKNOWN_MESSAGE_ID,
+      output: toJsonValue({
+        answers: answer.answers,
+        ...answer.response ? { response: answer.response } : {}
+      })
+    }
+  };
+}
+
+// src/commands/agent-bridge/harness/ask-user-server.ts
+init_src();
+init_zod();
+import { randomBytes as randomBytes3, randomUUID } from "crypto";
+import {
+  createServer as createServer4
+} from "http";
+import { Server as McpProtocolServer } from "@modelcontextprotocol/sdk/server/index.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import {
+  CallToolRequestSchema as CallToolRequestSchema2,
+  ListToolsRequestSchema as ListToolsRequestSchema2
+} from "@modelcontextprotocol/sdk/types.js";
+var ASK_USER_PROGRESS_INTERVAL_MS = 3e4;
+var ASK_USER_CALL_DEADLINE_MS = 84e4;
+var ASK_USER_FALLBACK_MESSAGE = "The question remains pending for the user. Continue this turn; the answer will arrive as a user message.";
+var AuthoredQuestionSchema = ConversationQuestionSchema.extend({
+  question: external_exports.string().trim().min(1).max(1024),
+  header: external_exports.string().trim().min(1).max(64),
+  options: external_exports.array(
+    external_exports.object({
+      label: external_exports.string().trim().min(1).max(128),
+      description: external_exports.string().trim().max(512)
+    }).strict()
+  ).min(2).max(6)
+}).strict();
+var AskUserQuestionInputSchema2 = external_exports.object({
+  questions: external_exports.array(AuthoredQuestionSchema).min(1).max(4)
+}).strict();
+var AskUserQuestionRegistry = class {
+  pending = /* @__PURE__ */ new Map();
+  deadlineMs;
+  progressIntervalMs;
+  constructor(options = {}) {
+    this.deadlineMs = positiveDuration(
+      options.deadlineMs ?? ASK_USER_CALL_DEADLINE_MS,
+      "ask-user deadline"
+    );
+    this.progressIntervalMs = positiveDuration(
+      options.progressIntervalMs ?? ASK_USER_PROGRESS_INTERVAL_MS,
+      "ask-user progress interval"
+    );
+  }
+  get size() {
+    return this.pending.size;
+  }
+  has(id) {
+    return this.pending.has(id);
+  }
+  park(input) {
+    const { questions } = AskUserQuestionInputSchema2.parse({
+      questions: input.questions
+    });
+    const id = `q_${randomUUID()}`;
+    let resolveWait = () => {
+    };
+    const wait = new Promise((resolve6) => {
+      resolveWait = resolve6;
+    });
+    const progress = setInterval(() => {
+      try {
+        void Promise.resolve(input.onProgress?.()).catch(() => {
+        });
+      } catch {
+      }
+    }, this.progressIntervalMs);
+    const deadline = setTimeout(() => {
+      this.settle(id, {
+        kind: "fallback",
+        message: ASK_USER_FALLBACK_MESSAGE,
+        reason: "deadline"
+      });
+    }, this.deadlineMs);
+    this.pending.set(id, {
+      id,
+      questions,
+      deadline,
+      progress,
+      resolve: resolveWait,
+      onSettled: input.onSettled
+    });
+    return { id, wait };
+  }
+  answer(id, answer) {
+    if (answer.toolCallId !== id) {
+      return false;
+    }
+    return this.settle(id, { kind: "answered", answer });
+  }
+  quarantine(id, reason) {
+    return this.settle(id, {
+      kind: "fallback",
+      message: ASK_USER_FALLBACK_MESSAGE,
+      reason
+    });
+  }
+  quarantineAll(reason) {
+    let settled = 0;
+    for (const id of [...this.pending.keys()]) {
+      if (this.quarantine(id, reason)) {
+        settled += 1;
+      }
+    }
+    return settled;
+  }
+  settle(id, settlement) {
+    const pending = this.pending.get(id);
+    if (!pending || !this.pending.delete(id)) {
+      return false;
+    }
+    clearTimeout(pending.deadline);
+    clearInterval(pending.progress);
+    pending.resolve(settlement);
+    try {
+      pending.onSettled?.(settlement);
+    } catch {
+    }
+    return true;
+  }
+};
+var AskUserServer = class {
+  constructor(options) {
+    this.options = options;
+    this.registry = new AskUserQuestionRegistry(options);
+  }
+  options;
+  registry;
+  path = `/mcp/${randomBytes3(24).toString("base64url")}`;
+  capability = randomBytes3(32).toString("base64url");
+  server = null;
+  prepared = null;
+  prepare() {
+    this.prepared ??= this.prepareOnce();
+    return this.prepared;
+  }
+  answer(answer) {
+    return this.registry.answer(answer.toolCallId, answer);
+  }
+  quarantineAll(reason) {
+    return this.registry.quarantineAll(reason);
+  }
+  close() {
+    this.quarantineAll("harness shutdown");
+    this.server?.close();
+    this.server = null;
+  }
+  async prepareOnce() {
+    const server = createServer4((request, response) => {
+      void this.handleRequest(request, response);
+    });
+    this.server = server;
+    await new Promise((resolve6, reject) => {
+      server.once("error", reject);
+      server.listen(0, "127.0.0.1", () => {
+        server.off("error", reject);
+        resolve6();
+      });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+      server.close();
+      throw new Error("ask-user MCP server did not receive a TCP address");
+    }
+    server.unref();
+    return {
+      url: `http://127.0.0.1:${address.port}${this.path}`,
+      headers: {
+        [AGENT_BRIDGE_MCP_CAPABILITY_HEADER]: this.capability
+      }
+    };
+  }
+  async handleRequest(request, response) {
+    if (request.url !== this.path || request.method !== "POST") {
+      response.writeHead(request.url === this.path ? 405 : 404).end();
+      return;
+    }
+    if (!requestHasMcpCapability(request.headers, this.capability)) {
+      response.writeHead(401, { "content-type": "application/json" }).end(JSON.stringify({ error: "Invalid ask-user MCP capability" }));
+      return;
+    }
+    try {
+      await this.handleMcpRequest(request, response);
+    } catch (error51) {
+      this.options.writeOutput?.(
+        `agent_bridge_ask_user_http_error error=${errorMessage2(error51)}`
+      );
+      if (!response.headersSent) {
+        response.writeHead(500, { "content-type": "application/json" });
+        response.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: null,
+            error: { code: -32603, message: "Ask-user server failed" }
+          })
+        );
+      }
+    }
+  }
+  async handleMcpRequest(request, response) {
+    const body = await readJsonRequest(request);
+    this.options.writeOutput?.(
+      `agent_bridge_ask_user_mcp_request method=${typeof body.method === "string" ? body.method : "unknown"}`
+    );
+    const server = this.createMcpServer();
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: void 0,
+      // Codex 0.145.0 requires ordinary initialize/list responses as JSON. A
+      // parked tool call keeps SSE enabled so progress notifications can flow
+      // over the held response without extending the hard client deadline.
+      enableJsonResponse: body.method !== "tools/call"
+    });
+    response.once("close", () => {
+      void transport.close();
+      void server.close();
+    });
+    await server.connect(transport);
+    await transport.handleRequest(request, response, body);
+  }
+  createMcpServer() {
+    const server = new McpProtocolServer(
+      { name: "auto-ask-user", version: "1.0.0" },
+      { capabilities: { tools: {} } }
+    );
+    server.setRequestHandler(ListToolsRequestSchema2, () => ({
+      tools: [
+        {
+          name: ASK_USER_MCP_TOOL_NAME,
+          title: ASK_USER_TOOL_NAME,
+          description: "Ask the user one to four blocking questions and wait for their answer.",
+          inputSchema: external_exports.toJSONSchema(AskUserQuestionInputSchema2)
+        }
+      ]
+    }));
+    server.setRequestHandler(
+      CallToolRequestSchema2,
+      async (request, extra) => {
+        if (request.params.name !== ASK_USER_MCP_TOOL_NAME) {
+          throw new Error(`Unknown ask-user tool: ${request.params.name}`);
+        }
+        const { questions } = AskUserQuestionInputSchema2.parse(
+          request.params.arguments
+        );
+        let questionId = "";
+        const parked = this.registry.park({
+          questions,
+          onProgress: async () => {
+            const progressToken = extra._meta?.progressToken;
+            if (progressToken === void 0) {
+              return;
+            }
+            await extra.sendNotification({
+              method: "notifications/progress",
+              params: {
+                progressToken,
+                progress: Date.now(),
+                message: "Waiting for the user to answer"
+              }
+            });
+          },
+          onSettled: (settlement2) => {
+            this.options.onQuestionSettled?.({ id: questionId, settlement: settlement2 });
+          }
+        });
+        questionId = parked.id;
+        try {
+          await this.options.onQuestionPending({
+            id: parked.id,
+            questions
+          });
+        } catch (error51) {
+          this.registry.quarantine(parked.id, "question projection failed");
+          throw error51;
+        }
+        const settlement = await parked.wait;
+        return settlementResult(settlement);
+      }
+    );
+    return server;
+  }
+};
+function settlementResult(settlement) {
+  if (settlement.kind === "fallback") {
+    return {
+      content: [{ type: "text", text: settlement.message }]
+    };
+  }
+  const answer = settlement.answer;
+  const lines = Object.entries(answer.answers).map(
+    ([question, value]) => `- ${question}: ${value}`
+  );
+  return {
+    content: [
+      {
+        type: "text",
+        text: [
+          "The user answered your questions:",
+          ...lines,
+          ...answer.response ? [`The user also responded: ${answer.response}`] : []
+        ].join("\n")
+      }
+    ]
+  };
+}
+function positiveDuration(value, label) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new Error(`${label} must be a positive safe integer`);
+  }
+  return value;
+}
+function errorMessage2(error51) {
+  return error51 instanceof Error ? error51.message : String(error51);
+}
+async function readJsonRequest(request) {
+  const chunks = [];
+  for await (const chunk of request) {
+    chunks.push(Buffer.from(chunk));
+  }
+  const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("ask-user MCP request body must be a JSON object");
+  }
+  return parsed;
+}
+
 // src/commands/agent-bridge/harness/liveness-ticker.ts
 var RUNTIME_LIVENESS_INTERVAL_MS = 2e4;
 function startRuntimeLivenessTicker(input) {
@@ -102597,7 +102976,7 @@ function isTerminalUiMessageChunk(chunk) {
 function legacyToolEntries(chunk) {
   switch (chunk.type) {
     case "tool-input-available":
-      if (chunk.toolName === ASK_USER_QUESTION_TOOL_NAME) {
+      if (chunk.toolName === ASK_USER_QUESTION_TOOL_NAME || chunk.toolName === ASK_USER_TOOL_NAME) {
         return [];
       }
       return [
@@ -102921,6 +103300,111 @@ function jsonRecordString2(value, key) {
   return typeof field === "string" ? field : void 0;
 }
 
+// src/commands/agent-bridge/harness/mcp-timeout.ts
+var HARNESS_MCP_TOOL_TIMEOUT_SECONDS = 900;
+var MAX_HARNESS_MCP_TOOL_TIMEOUT_SECONDS = 3600;
+function validatedMcpToolTimeoutSeconds(value) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > MAX_HARNESS_MCP_TOOL_TIMEOUT_SECONDS) {
+    throw new Error(
+      `MCP tool timeout must be a safe integer from 1 to ${MAX_HARNESS_MCP_TOOL_TIMEOUT_SECONDS} seconds`
+    );
+  }
+  return value;
+}
+function validatedMcpToolTimeoutMilliseconds(value) {
+  return validatedMcpToolTimeoutSeconds(value) * 1e3;
+}
+
+// src/commands/agent-bridge/harness/claude-code/options.ts
+var CLAUDE_AGENT_SDK_CLIENT_APP = "auto-agent-bridge";
+var CLAUDE_RUNTIME_PROCESS_ENV_KEYS = ["PATH", "HOME"];
+var CLAUDE_CODE_EXECUTABLE_PATH = "/usr/local/bin/claude";
+var CLAUDE_CODE_SHELL_PATH = "/bin/bash";
+var CLAUDE_CODE_DEFAULT_MODEL = "claude-opus-4-8";
+function claudeAgentOptions(config2, input = {}) {
+  return {
+    ...config2.cwd ? { cwd: config2.cwd } : {},
+    ...input.resume ? { resume: input.resume } : {},
+    env: claudeProcessEnv(
+      config2.env,
+      input.clientApp ?? CLAUDE_AGENT_SDK_CLIENT_APP
+    ),
+    includePartialMessages: true,
+    thinking: { type: "adaptive", display: "summarized" },
+    settings: { showThinkingSummaries: true },
+    model: config2.model?.id ?? CLAUDE_CODE_DEFAULT_MODEL,
+    ...config2.reasoningEffort ? { effort: config2.reasoningEffort } : {},
+    permissionMode: "bypassPermissions",
+    allowDangerouslySkipPermissions: true,
+    pathToClaudeCodeExecutable: claudeCodeExecutablePath(),
+    ...input.mcpServers ?? config2.mcpServers ? {
+      mcpServers: input.mcpServers ?? config2.mcpServers,
+      strictMcpConfig: true
+    } : {},
+    systemPrompt: {
+      type: "preset",
+      preset: "claude_code",
+      ...config2.systemPromptAppend ? { append: config2.systemPromptAppend } : {}
+    },
+    settingSources: [],
+    tools: {
+      type: "preset",
+      preset: "claude_code"
+    },
+    stderr: input.onStderrChunk ?? (() => {
+    })
+  };
+}
+function withClaudeAskUserMcpServer(mcpServers, url2, headers) {
+  if (mcpServers?.[ASK_USER_MCP_SERVER_NAME]) {
+    throw new Error(
+      `MCP server name ${ASK_USER_MCP_SERVER_NAME} is reserved by the harness`
+    );
+  }
+  return {
+    ...mcpServers,
+    [ASK_USER_MCP_SERVER_NAME]: {
+      type: "http",
+      url: url2,
+      headers,
+      timeout: validatedMcpToolTimeoutMilliseconds(
+        HARNESS_MCP_TOOL_TIMEOUT_SECONDS
+      )
+    }
+  };
+}
+function claudeProcessEnv(env, clientApp) {
+  const runtimeEnv = runtimeProcessEnv();
+  return {
+    // Claude Code only needs ambient shell basics from the bridge process.
+    // Dynamic Claude/MCP/session secrets arrive through encrypted bootstrap env.
+    ...runtimeEnv,
+    ...env,
+    // Claude Code auto-detects a shell when this is absent. Hosted sandboxes run
+    // Bash tool commands, so pin the shell snapshot source to bash instead of
+    // letting zsh profile functions leak into bash snapshots and inherit user
+    // strict-mode options such as `set -u`.
+    CLAUDE_CODE_SHELL: CLAUDE_CODE_SHELL_PATH,
+    CLAUDE_AGENT_SDK_CLIENT_APP: clientApp
+  };
+}
+function runtimeProcessEnv() {
+  const selected = {};
+  for (const key of CLAUDE_RUNTIME_PROCESS_ENV_KEYS) {
+    const value = process.env[key];
+    if (value !== void 0) {
+      selected[key] = value;
+    }
+  }
+  return selected;
+}
+function claudeCodeExecutablePath() {
+  if (process.env.AUTO_AGENT_BRIDGE_TEST_CLAUDE_COMMAND === "1" && process.env.AUTO_CLAUDE_CODE_COMMAND?.trim()) {
+    return process.env.AUTO_CLAUDE_CODE_COMMAND.trim();
+  }
+  return CLAUDE_CODE_EXECUTABLE_PATH;
+}
+
 // src/commands/agent-bridge/harness/claude-code/projector.ts
 init_src();
 var ClaudeCodeProjector = class {
@@ -102939,6 +103423,7 @@ var ClaudeCodeProjector = class {
   activeResponseMessageId = null;
   activeParts = /* @__PURE__ */ new Map();
   activeToolInputs = /* @__PURE__ */ new Map();
+  suppressedAskUserToolCallIds = /* @__PURE__ */ new Set();
   streamedMessageIds = /* @__PURE__ */ new Set();
   // The SDK's "[Request interrupted by user]" transcript marker was seen since
   // the last terminal result: the very next diagnostic-only
@@ -102958,6 +103443,7 @@ var ClaudeCodeProjector = class {
       bridge: context.bridgeInterruptSettling === true
     };
     const parsed = parseClaudeCodeStreamRecord(message);
+    parsed.projections = this.suppressAskUserProjections(parsed.projections);
     const snapshotMessageId = assistantSnapshotMessageId(message);
     const suppressStreamed = snapshotMessageId !== null && this.streamedMessageIds.has(snapshotMessageId);
     if (message.type === "assistant" && !suppressStreamed) {
@@ -102990,6 +103476,7 @@ var ClaudeCodeProjector = class {
         );
       }
       outputs.push(projectClaudeCodeResult(parsed.result, { interrupted }));
+      this.suppressedAskUserToolCallIds.clear();
       this.interruptMarkerSeen = false;
     }
     return outputs;
@@ -103074,6 +103561,11 @@ var ClaudeCodeProjector = class {
     return [uiChunk({ type: `${type}-end`, id })];
   }
   startToolInput(message) {
+    const askUserToolCallId = askUserMcpToolCallId(message);
+    if (askUserToolCallId) {
+      this.suppressedAskUserToolCallIds.add(askUserToolCallId);
+      return [];
+    }
     const started = toolInputStartFromEvent(message);
     if (!started) {
       return [];
@@ -103092,6 +103584,32 @@ var ClaudeCodeProjector = class {
       })
     ];
   }
+  suppressAskUserProjections(projections) {
+    return projections.flatMap((projection) => {
+      if (projection.kind === "tool_call") {
+        const askUserParts = projection.content.parts.filter(
+          (part) => part.type === "tool_call" && (part.name === ASK_USER_TOOL_NAME || part.name === CLAUDE_ASK_USER_TOOL_NAME)
+        );
+        for (const part of askUserParts) {
+          if (part.type === "tool_call" && part.toolCallId) {
+            this.suppressedAskUserToolCallIds.add(part.toolCallId);
+          }
+        }
+        if (askUserParts.length > 0) {
+          return [];
+        }
+      }
+      if (projection.kind === "tool_result") {
+        const suppressed = projection.content.parts.some(
+          (part) => part.type === "tool_result" && part.toolUseId !== null && this.suppressedAskUserToolCallIds.has(part.toolUseId)
+        );
+        if (suppressed) {
+          return [];
+        }
+      }
+      return [projection];
+    });
+  }
   finishActiveToolInput(index) {
     const active = this.activeToolInputs.get(index);
     if (!active) {
@@ -103288,6 +103806,17 @@ function toolInputStartFromEvent(message) {
     input: contentBlock.input
   };
 }
+function askUserMcpToolCallId(message) {
+  const event = message.event;
+  if (event.type !== "content_block_start") {
+    return null;
+  }
+  const block = event.content_block;
+  if (block.type !== "mcp_tool_use" || typeof block.id !== "string" || typeof block.server_name !== "string" || typeof block.name !== "string" || !isAskUserMcpTool(block.server_name, block.name)) {
+    return null;
+  }
+  return block.id;
+}
 function toolInputDeltaFromDelta(delta) {
   if (delta.type !== "input_json_delta") {
     return null;
@@ -103808,78 +104337,6 @@ function serverStatusList(servers, context) {
   return reported.map((server) => `${server.name}:${server.status}`).join(",");
 }
 
-// src/commands/agent-bridge/harness/claude-code/options.ts
-var CLAUDE_AGENT_SDK_CLIENT_APP = "auto-agent-bridge";
-var CLAUDE_RUNTIME_PROCESS_ENV_KEYS = ["PATH", "HOME"];
-var CLAUDE_CODE_EXECUTABLE_PATH = "/usr/local/bin/claude";
-var CLAUDE_CODE_SHELL_PATH = "/bin/bash";
-var CLAUDE_CODE_DEFAULT_MODEL = "claude-opus-4-8";
-function claudeAgentOptions(config2, input = {}) {
-  return {
-    ...config2.cwd ? { cwd: config2.cwd } : {},
-    ...input.resume ? { resume: input.resume } : {},
-    env: claudeProcessEnv(
-      config2.env,
-      input.clientApp ?? CLAUDE_AGENT_SDK_CLIENT_APP
-    ),
-    includePartialMessages: true,
-    thinking: { type: "adaptive", display: "summarized" },
-    settings: { showThinkingSummaries: true },
-    model: config2.model?.id ?? CLAUDE_CODE_DEFAULT_MODEL,
-    ...config2.reasoningEffort ? { effort: config2.reasoningEffort } : {},
-    permissionMode: "bypassPermissions",
-    allowDangerouslySkipPermissions: true,
-    pathToClaudeCodeExecutable: claudeCodeExecutablePath(),
-    ...input.mcpServers ?? config2.mcpServers ? {
-      mcpServers: input.mcpServers ?? config2.mcpServers,
-      strictMcpConfig: true
-    } : {},
-    systemPrompt: {
-      type: "preset",
-      preset: "claude_code",
-      ...config2.systemPromptAppend ? { append: config2.systemPromptAppend } : {}
-    },
-    settingSources: [],
-    tools: {
-      type: "preset",
-      preset: "claude_code"
-    },
-    stderr: input.onStderrChunk ?? (() => {
-    })
-  };
-}
-function claudeProcessEnv(env, clientApp) {
-  const runtimeEnv = runtimeProcessEnv();
-  return {
-    // Claude Code only needs ambient shell basics from the bridge process.
-    // Dynamic Claude/MCP/session secrets arrive through encrypted bootstrap env.
-    ...runtimeEnv,
-    ...env,
-    // Claude Code auto-detects a shell when this is absent. Hosted sandboxes run
-    // Bash tool commands, so pin the shell snapshot source to bash instead of
-    // letting zsh profile functions leak into bash snapshots and inherit user
-    // strict-mode options such as `set -u`.
-    CLAUDE_CODE_SHELL: CLAUDE_CODE_SHELL_PATH,
-    CLAUDE_AGENT_SDK_CLIENT_APP: clientApp
-  };
-}
-function runtimeProcessEnv() {
-  const selected = {};
-  for (const key of CLAUDE_RUNTIME_PROCESS_ENV_KEYS) {
-    const value = process.env[key];
-    if (value !== void 0) {
-      selected[key] = value;
-    }
-  }
-  return selected;
-}
-function claudeCodeExecutablePath() {
-  if (process.env.AUTO_AGENT_BRIDGE_TEST_CLAUDE_COMMAND === "1" && process.env.AUTO_CLAUDE_CODE_COMMAND?.trim()) {
-    return process.env.AUTO_CLAUDE_CODE_COMMAND.trim();
-  }
-  return CLAUDE_CODE_EXECUTABLE_PATH;
-}
-
 // src/commands/agent-bridge/harness/claude-code/stderr.ts
 var STDERR_LINE_MAX_CHARS = 400;
 var STDERR_FORWARD_MAX_LINES = 200;
@@ -105055,6 +105512,10 @@ var ClaudeCodeCommandHandler = class {
       mcpServers: input.claude.mcpServers,
       writeOutput: input.writeOutput
     });
+    this.askUserServer = new AskUserServer({
+      onQuestionPending: (question) => this.handleAskUserQuestion(question),
+      writeOutput: input.writeOutput
+    });
     this.outputBuffer = new AgentBridgeOutputBuffer(input);
     this.projector = new ClaudeCodeProjector({
       writeOutput: input.writeOutput
@@ -105067,6 +105528,7 @@ var ClaudeCodeCommandHandler = class {
   claudeConfig;
   claudeMcpServers;
   autoMcpShim;
+  askUserServer;
   // Selection-change restarts happen in-process, so prefer the live SDK id even
   // when the file resume store is stale or temporarily unreadable.
   lastObservedAgentId = null;
@@ -105102,7 +105564,13 @@ var ClaudeCodeCommandHandler = class {
     return this.outputBuffer.pendingOutputStats();
   }
   async prepare() {
-    this.claudeMcpServers = await this.autoMcpShim.prepareClaude();
+    const mcpServers = await this.autoMcpShim.prepareClaude();
+    const askUserEndpoint = await this.askUserServer.prepare();
+    this.claudeMcpServers = withClaudeAskUserMcpServer(
+      mcpServers,
+      askUserEndpoint.url,
+      askUserEndpoint.headers
+    );
     await this.ensureAgentSession().prepare();
   }
   shutdown() {
@@ -105111,6 +105579,7 @@ var ClaudeCodeCommandHandler = class {
     this.agentSession?.close();
     this.agentSession = null;
     this.autoMcpShim.close();
+    this.askUserServer.close();
     this.settlePendingQuestions("Runtime is shutting down");
   }
   async handleCommand(rawDelivery) {
@@ -105170,6 +105639,7 @@ var ClaudeCodeCommandHandler = class {
     }
     if (delivery.kind === "interrupt") {
       this.injectedCommands.add(delivery.commandId);
+      this.askUserServer.quarantineAll("turn interrupted");
       await this.agentSession?.interruptActiveTurn();
       this.input.runtimeLogger?.info(
         "agent_bridge_claude_command_interrupt_ready",
@@ -105378,6 +105848,17 @@ var ClaudeCodeCommandHandler = class {
       );
       return;
     }
+    if (this.askUserServer.answer(answer)) {
+      this.agentSession?.noteActiveTurnCommand(delivery.commandId);
+      await this.emitRequiredBridgeOutput(
+        activeContext,
+        projectAskUserAnswer(answer)
+      );
+      this.input.writeOutput?.(
+        `agent_bridge_question_answered tool_use_id=${answer.toolCallId}`
+      );
+      return;
+    }
     const message = answerFallbackMessage(answer);
     await this.emitRequiredBridgeOutput(activeContext, {
       type: "entry",
@@ -105408,11 +105889,28 @@ var ClaudeCodeCommandHandler = class {
     }
     this.pendingQuestions.clear();
   }
+  async handleAskUserQuestion(input) {
+    const activeContext = this.context;
+    if (!activeContext) {
+      throw new Error(
+        "Cannot publish an ask-user question without bridge context"
+      );
+    }
+    this.input.writeOutput?.(
+      `agent_bridge_question_pending tool_use_id=${input.id}`
+    );
+    for (const projection of projectAskUserQuestion(input)) {
+      await this.emitRequiredBridgeOutput(activeContext, projection);
+    }
+  }
   // Permission callback for the Claude Agent SDK session. The sessions with
   // bypassPermissions, so regular tools are auto-approved and only the
   // AskUserQuestion tool reaches this callback for a real decision: it parks
   // the SDK on a promise that an `answer` bridge command later resolves.
   canUseTool = (toolName, toolInput, options) => {
+    if (toolName === CLAUDE_ASK_USER_TOOL_NAME) {
+      return Promise.resolve({ behavior: "allow", updatedInput: toolInput });
+    }
     if (toolName !== ASK_USER_QUESTION_TOOL_NAME) {
       return Promise.resolve({ behavior: "allow", updatedInput: toolInput });
     }
@@ -105491,6 +105989,9 @@ var ClaudeCodeCommandHandler = class {
     }
     this.persistAgentId(activeContext, message);
     this.trackReadState(activeContext, message);
+    if (message.type === "result") {
+      this.askUserServer.quarantineAll("turn ended");
+    }
     let projections;
     try {
       projections = this.projector.project(message, {
@@ -105510,6 +106011,7 @@ var ClaudeCodeCommandHandler = class {
     }
   }
   async handleAgentError(error51) {
+    this.askUserServer.quarantineAll("harness session failed");
     this.input.writeOutput?.(
       `agent_bridge_claude_sdk_failed error=${error51 instanceof Error ? error51.message : String(error51)}`
     );
@@ -105629,6 +106131,7 @@ var ClaudeCodeCommandHandler = class {
       onMessage: (message, meta3) => this.handleAgentMessage(message, meta3),
       onError: (error51) => this.handleAgentError(error51),
       onExit: () => {
+        this.askUserServer.quarantineAll("harness child exited");
         if (this.agentSession === session) {
           this.agentSession = null;
         }
@@ -105657,6 +106160,7 @@ var ClaudeCodeCommandHandler = class {
     this.requireResumeForNextAgentSession = this.lastObservedAgentId !== null;
     this.agentSession?.close();
     this.agentSession = null;
+    this.askUserServer.quarantineAll("harness session restarted");
     this.settlePendingQuestions("The runtime restarted to change model");
     this.input.writeOutput?.(
       `agent_bridge_claude_model_selection_changed provider=${next.model?.provider ?? ""} model=${next.model?.id ?? ""} reasoning_effort=${next.reasoningEffort ?? ""}`
@@ -105850,6 +106354,9 @@ var CodexProjector = class {
           toolMetadata: statusMetadata(item.status)
         });
       case "mcpToolCall":
+        if (isAskUserMcpTool(item.server, item.tool)) {
+          return [];
+        }
         return this.projectToolItem({
           phase,
           itemId: item.id,
@@ -106193,6 +106700,9 @@ function renderCodexConfigToml(config2) {
     lines.push("");
     lines.push(`[mcp_servers.${tomlKey(name)}]`);
     lines.push(`url = ${tomlString(server.url)}`);
+    lines.push(
+      `tool_timeout_sec = ${validatedMcpToolTimeoutSeconds(HARNESS_MCP_TOOL_TIMEOUT_SECONDS)}`
+    );
     const persistedHeaders = Object.fromEntries(
       Object.entries(server.headers ?? {}).filter(
         ([name2]) => name2 !== AGENT_BRIDGE_MCP_CAPABILITY_HEADER
@@ -106206,20 +106716,30 @@ function renderCodexConfigToml(config2) {
 `;
 }
 function turnOnlyMcpConfig(mcpServers) {
+  const hasTurnOnlyCapability = Object.values(mcpServers ?? {}).some(
+    (server) => server.headers?.[AGENT_BRIDGE_MCP_CAPABILITY_HEADER] !== void 0
+  );
+  if (!hasTurnOnlyCapability) {
+    return void 0;
+  }
   const servers = Object.fromEntries(
-    Object.entries(mcpServers ?? {}).flatMap(([name, server]) => {
+    Object.entries(mcpServers ?? {}).map(([name, server]) => {
       const capability = server.headers?.[AGENT_BRIDGE_MCP_CAPABILITY_HEADER];
-      return capability ? [
-        [
-          name,
-          {
-            url: server.url,
+      return [
+        name,
+        {
+          url: server.url,
+          tool_timeout_sec: validatedMcpToolTimeoutSeconds(
+            HARNESS_MCP_TOOL_TIMEOUT_SECONDS
+          ),
+          ...server.headers ? {
             http_headers: {
-              [AGENT_BRIDGE_MCP_CAPABILITY_HEADER]: capability
+              ...server.headers,
+              ...capability ? { [AGENT_BRIDGE_MCP_CAPABILITY_HEADER]: capability } : {}
             }
-          }
-        ]
-      ] : [];
+          } : {}
+        }
+      ];
     })
   );
   return Object.keys(servers).length > 0 ? { mcp_servers: servers } : void 0;
@@ -106813,7 +107333,7 @@ var CodexAgentBridgeSessionImpl = class {
         return;
       } catch (error51) {
         this.input.writeOutput?.(
-          `agent_bridge_codex_resume_fallback thread_id=${this.input.resumeThreadId} error=${errorMessage2(error51)}`
+          `agent_bridge_codex_resume_fallback thread_id=${this.input.resumeThreadId} error=${errorMessage3(error51)}`
         );
       }
     }
@@ -106891,7 +107411,7 @@ var CodexAgentBridgeSessionImpl = class {
       this.activeCommandIds = previousCommandIds;
       this.publishActiveTurnCommandIds();
       this.input.writeOutput?.(
-        `agent_bridge_codex_steer_failed error=${errorMessage2(error51)}`
+        `agent_bridge_codex_steer_failed error=${errorMessage3(error51)}`
       );
     }
     if (this.activeTurnId) {
@@ -106905,7 +107425,7 @@ var CodexAgentBridgeSessionImpl = class {
       this.input.writeOutput?.("agent_bridge_codex_interrupted");
     } catch (error51) {
       this.input.writeOutput?.(
-        `agent_bridge_codex_interrupt_failed error=${errorMessage2(error51)}`
+        `agent_bridge_codex_interrupt_failed error=${errorMessage3(error51)}`
       );
     }
   }
@@ -106980,7 +107500,7 @@ var CodexAgentBridgeSessionImpl = class {
       message = parseCodexServerFrame(JSON.parse(line));
     } catch (error51) {
       this.input.writeOutput?.(
-        `agent_bridge_codex_parse_failed error=${errorMessage2(error51)}`
+        `agent_bridge_codex_parse_failed error=${errorMessage3(error51)}`
       );
       return;
     }
@@ -107175,7 +107695,7 @@ var CodexAgentBridgeSessionImpl = class {
       );
     } catch (error51) {
       this.input.writeOutput?.(
-        `agent_bridge_codex_turn_retry_failed attempt=${input.attempt} error=${errorMessage2(error51)}`
+        `agent_bridge_codex_turn_retry_failed attempt=${input.attempt} error=${errorMessage3(error51)}`
       );
       this.turnRetry = null;
       this.clearPendingRetryableError();
@@ -107390,7 +107910,7 @@ function threadIdFromResult(result) {
   const id = thread.id;
   return typeof id === "string" && id.length > 0 ? id : null;
 }
-function errorMessage2(error51) {
+function errorMessage3(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
 }
 function toErrnoException(error51) {
@@ -107416,6 +107936,11 @@ var CodexCommandHandler = class {
       mcpServers: input.codex.mcpServers,
       writeOutput: input.writeOutput
     });
+    this.askUserServer = new AskUserServer({
+      onQuestionPending: (question) => this.handleAskUserQuestion(question),
+      onQuestionSettled: ({ id }) => this.pendingQuestions.delete(id),
+      writeOutput: input.writeOutput
+    });
     this.outputBuffer = new AgentBridgeOutputBuffer(input);
   }
   input;
@@ -107423,10 +107948,12 @@ var CodexCommandHandler = class {
   session = null;
   codexConfig;
   autoMcpShim;
+  askUserServer;
   injectedCommands = /* @__PURE__ */ new Set();
   // itemId -> JSON-RPC request id of the parked approval request, so an `answer`
   // command keyed by toolCallId (= itemId) can resolve the right server request.
   pendingApprovals = /* @__PURE__ */ new Map();
+  pendingQuestions = /* @__PURE__ */ new Set();
   outputBuffer;
   projector = new CodexProjector();
   livenessTicker = null;
@@ -107448,9 +107975,23 @@ var CodexCommandHandler = class {
     return this.outputBuffer.pendingOutputStats();
   }
   async prepare() {
+    const mcpServers = await this.autoMcpShim.prepare();
+    if (mcpServers?.[ASK_USER_MCP_SERVER_NAME]) {
+      throw new Error(
+        `MCP server name ${ASK_USER_MCP_SERVER_NAME} is reserved by the harness`
+      );
+    }
+    const askUserEndpoint = await this.askUserServer.prepare();
     this.codexConfig = {
       ...this.codexConfig,
-      mcpServers: await this.autoMcpShim.prepare()
+      mcpServers: {
+        ...mcpServers,
+        [ASK_USER_MCP_SERVER_NAME]: {
+          type: "http",
+          url: askUserEndpoint.url,
+          headers: askUserEndpoint.headers
+        }
+      }
     };
     await this.ensureSession().prepare();
   }
@@ -107460,7 +108001,9 @@ var CodexCommandHandler = class {
     this.session?.close();
     this.session = null;
     this.autoMcpShim.close();
+    this.askUserServer.close();
     this.pendingApprovals.clear();
+    this.pendingQuestions.clear();
   }
   async handleCommand(rawDelivery) {
     const delivery = RuntimeBridgeCommandDeliverySchema.parse(rawDelivery);
@@ -107477,6 +108020,7 @@ var CodexCommandHandler = class {
     }
     if (delivery.kind === "interrupt") {
       this.injectedCommands.add(delivery.commandId);
+      this.askUserServer.quarantineAll("turn interrupted");
       await this.session?.interruptActiveTurn();
       return commandAck({ delivery, socketId, status: "injected" });
     }
@@ -107520,7 +108064,7 @@ var CodexCommandHandler = class {
         delivery,
         socketId,
         status: "failed",
-        error: errorMessage3(error51)
+        error: errorMessage4(error51)
       });
     }
     return commandAck({ delivery, socketId, status: "injected" });
@@ -107553,6 +108097,11 @@ var CodexCommandHandler = class {
         this.input.writeOutput?.(
           `agent_bridge_codex_question_answered tool_use_id=${payload.data.toolCallId} decision=${decision}`
         );
+      } else if (this.pendingQuestions.has(payload.data.toolCallId) && this.askUserServer.answer(payload.data)) {
+        await this.emit(activeContext, projectAskUserAnswer(payload.data));
+        this.input.writeOutput?.(
+          `agent_bridge_codex_question_answered tool_use_id=${payload.data.toolCallId} decision=answered`
+        );
       } else {
         const message = answerFallbackMessage2(payload.data);
         await this.emitUserMessageEntry(
@@ -107570,7 +108119,7 @@ var CodexCommandHandler = class {
         delivery,
         socketId,
         status: "failed",
-        error: errorMessage3(error51)
+        error: errorMessage4(error51)
       });
     }
     return commandAck({ delivery, socketId, status: "injected" });
@@ -107598,6 +108147,9 @@ var CodexCommandHandler = class {
     if (notification.type === "tokenUsage") {
       return;
     }
+    if (notification.type === "turnCompleted") {
+      this.askUserServer.quarantineAll("turn ended");
+    }
     for (const projection of this.projector.project(notification)) {
       await this.emit(activeContext, projection);
     }
@@ -107615,9 +108167,25 @@ var CodexCommandHandler = class {
       await this.emit(activeContext, projection);
     }
   }
+  async handleAskUserQuestion(input) {
+    const activeContext = this.context;
+    if (!activeContext) {
+      throw new Error(
+        "Cannot publish an ask-user question without bridge context"
+      );
+    }
+    this.pendingQuestions.add(input.id);
+    this.input.writeOutput?.(
+      `agent_bridge_codex_question_pending tool_use_id=${input.id}`
+    );
+    for (const projection of projectAskUserQuestion(input)) {
+      await this.emitRequired(activeContext, projection);
+    }
+  }
   async handleSessionError(error51) {
+    this.askUserServer.quarantineAll("harness session failed");
     this.input.writeOutput?.(
-      `agent_bridge_codex_session_failed error=${errorMessage3(error51)}`
+      `agent_bridge_codex_session_failed error=${errorMessage4(error51)}`
     );
     const activeContext = this.context;
     if (!activeContext) {
@@ -107625,7 +108193,7 @@ var CodexCommandHandler = class {
     }
     await this.emit(
       activeContext,
-      this.projector.projectSessionFailure(errorMessage3(error51))
+      this.projector.projectSessionFailure(errorMessage4(error51))
     );
   }
   async emitLivenessBeat() {
@@ -107650,10 +108218,16 @@ var CodexCommandHandler = class {
       await this.outputBuffer.emitProjection(activeContext, projection);
     } catch (error51) {
       this.input.writeOutput?.(
-        `agent_bridge_output_emit_failed error=${errorMessage3(error51)}`
+        `agent_bridge_output_emit_failed error=${errorMessage4(error51)}`
       );
     }
   }
+  async emitRequired(activeContext, projection) {
+    await this.outputBuffer.emitProjection(activeContext, projection, {
+      discardOnFailure: true,
+      requireDrain: true
+    });
+  }
   ensureSession() {
     if (this.session) {
       return this.session;
@@ -107670,6 +108244,7 @@ var CodexCommandHandler = class {
       onUsageTurnChanged: (turnId) => this.emitUsageTurn(turnId),
       onError: (error51) => this.handleSessionError(error51),
       onExit: () => {
+        this.askUserServer.quarantineAll("harness child exited");
         if (this.session === session) {
           this.session = null;
         }
@@ -107697,7 +108272,9 @@ var CodexCommandHandler = class {
     this.skipResumeForNextSession = true;
     this.session?.close();
     this.session = null;
+    this.askUserServer.quarantineAll("harness session restarted");
     this.pendingApprovals.clear();
+    this.pendingQuestions.clear();
     this.input.writeOutput?.(
       `agent_bridge_codex_model_selection_changed provider=${next.model?.provider ?? ""} model=${next.model?.id ?? ""} reasoning_effort=${next.reasoningEffort ?? ""}`
     );
@@ -107712,7 +108289,7 @@ var CodexCommandHandler = class {
       return store.read(activeContext.sessionId) ?? void 0;
     } catch (error51) {
       this.input.writeOutput?.(
-        `agent_bridge_codex_thread_read_failed error=${errorMessage3(error51)}`
+        `agent_bridge_codex_thread_read_failed error=${errorMessage4(error51)}`
       );
       return void 0;
     }
@@ -107727,7 +108304,7 @@ var CodexCommandHandler = class {
       store.write({ sessionId: activeContext.sessionId, threadId });
     } catch (error51) {
       this.input.writeOutput?.(
-        `agent_bridge_codex_thread_persist_failed error=${errorMessage3(error51)}`
+        `agent_bridge_codex_thread_persist_failed error=${errorMessage4(error51)}`
       );
     }
   }
@@ -107769,7 +108346,7 @@ function deliveryMode2(delivery) {
   }
   return "interrupt";
 }
-function errorMessage3(error51) {
+function errorMessage4(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
 }