@super-one/cli 0.77.0-alpha.1 → 0.77.0-alpha.2

package/lib/cli.mjs

@@ -142,8 +142,8 @@ import { fileURLToPath } from "node:url";
 function resolveCliReleaseVersion() {
   const fromEnv = process.env.SUPERONE_CLI_VERSION?.trim();
   if (fromEnv) return fromEnv;
-  if ("0.77.0-alpha.1".trim()) {
-    return "0.77.0-alpha.1".trim();
+  if ("0.77.0-alpha.2".trim()) {
+    return "0.77.0-alpha.2".trim();
   }
   const fromDist = readDistManifestVersion();
   if (fromDist) return fromDist;
@@ -10753,8 +10753,8 @@ var init_mcp_app_resource = __esm({
         return cached5 ? Promise.resolve(cached5) : this.refresh(key3, read5);
       }
       refresh(key3, read5) {
-        const pending3 = this.pending.get(key3);
-        if (pending3) return pending3;
+        const pending4 = this.pending.get(key3);
+        if (pending4) return pending4;
         if (this.pending.size >= this.limits.pending) return Promise.reject(new McpAppsError("denied", "Too many pending MCP App resource reads"));
         const next = Promise.resolve().then(read5).then((value) => {
           this.put(key3, value);
@@ -11170,6 +11170,10 @@ function isToolResultBlock(block) {
 function isToolUseBlock(block) {
   return "toolName" in block;
 }
+function hasEditReplacementFields(input) {
+  const obj = parseInputObject(input);
+  return typeof obj.old_string === "string" || typeof obj.new_string === "string" || typeof obj.TargetContent === "string" || typeof obj.ReplacementContent === "string" || Array.isArray(obj.ReplacementChunks) || Array.isArray(obj.edits);
+}
 function parseInputObject(input) {
   if (input == null || input === "") return {};
   if (typeof input === "object" && !Array.isArray(input)) {
@@ -11301,12 +11305,14 @@ function applyContentDelta(content, delta, now = Date.now, options = {}) {
         delta.toolSummary,
         mergedInput
       );
+      const preservedToolName = existing.toolName === "Write" && delta.toolName === "Edit" && !hasEditReplacementFields(delta.input) ? existing.toolName : delta.toolName;
       const liveOutput = delta.outputDelta === void 0 ? existing.liveOutput : options.replace ? delta.outputDelta : (existing.liveOutput ?? "") + delta.outputDelta;
       return content.map((b5, i2) => i2 === idx ? {
         ...existing,
         ...withoutOutputDelta(delta),
         ...liveOutput !== void 0 ? { liveOutput } : {},
         ...existing.app || delta.app ? { app: mergeMcpAppAttachment(existing.app, delta.app) } : {},
+        toolName: preservedToolName,
         startedAt: existing.startedAt,
         elapsedSeconds: delta.elapsedSeconds ?? existing.elapsedSeconds,
         status: delta.status ?? existing.status,
@@ -11452,7 +11458,14 @@ var init_content_delta = __esm({
       "skill",
       "tool_name",
       "subject",
-      "task_id"
+      "task_id",
+      "content",
+      "CodeContent",
+      "old_string",
+      "new_string",
+      "TargetContent",
+      "ReplacementContent",
+      "TargetFile"
     ];
     CODEX_DETACHED_ITEM_TYPES = /* @__PURE__ */ new Set(["image_generation", "video_generation"]);
   }
@@ -11822,21 +11835,21 @@ function codexAsyncQuestionItems(message) {
 function pendingCodexAsyncQuestions(messages) {
   const answered = new Set(messages.filter(isCodexAsyncAnswer).map((message) => message.id));
   const seen = /* @__PURE__ */ new Set();
-  const pending3 = [];
+  const pending4 = [];
   for (const message of messages) {
     if (message.role !== "assistant") continue;
     for (const item of codexAsyncQuestionItems(message)) {
       if (seen.has(item.id)) continue;
       seen.add(item.id);
-      if (!answered.has(codexAsyncAnswerId(item.id))) pending3.push({ messageId: message.id, item, request: codexAsyncQuestionRequest(item) });
+      if (!answered.has(codexAsyncAnswerId(item.id))) pending4.push({ messageId: message.id, item, request: codexAsyncQuestionRequest(item) });
     }
   }
-  return pending3;
+  return pending4;
 }
 function codexAsyncQuestionQueue(session) {
-  const pending3 = session.pendingAsyncQuestions ?? pendingCodexAsyncQuestions(session.messages);
+  const pending4 = session.pendingAsyncQuestions ?? pendingCodexAsyncQuestions(session.messages);
   const answered = new Set(session.messages.filter(isCodexAsyncAnswer).map((message) => message.id));
-  return pending3.some((q3) => answered.has(q3.request.requestId)) ? pending3.filter((q3) => !answered.has(q3.request.requestId)) : pending3;
+  return pending4.some((q3) => answered.has(q3.request.requestId)) ? pending4.filter((q3) => !answered.has(q3.request.requestId)) : pending4;
 }
 function codexAsyncAnswerQuestions(message, messages) {
   if (!isCodexAsyncAnswer(message)) return void 0;
@@ -12004,10 +12017,10 @@ function coverBeforeCut(content, at2) {
   const keys = contentKeys(content);
   const counts = /* @__PURE__ */ new Map();
   const map2 = {};
-  let pending3 = [];
+  let pending4 = [];
   const flush = () => {
-    for (const item of pending3) map2[item.key] = item.length;
-    pending3 = [];
+    for (const item of pending4) map2[item.key] = item.length;
+    pending4 = [];
   };
   const placed = () => (counts.get(kind) ?? 0) === target2 && Object.keys(map2).length ? map2 : null;
   for (let index = 0; index < content.length; index++) {
@@ -12023,7 +12036,7 @@ function coverBeforeCut(content, at2) {
         counts.set(name, (counts.get(name) ?? 0) + value);
       }
       if (count === 0) {
-        if (key3) pending3.push({ key: key3, length: -1 });
+        if (key3) pending4.push({ key: key3, length: -1 });
         continue;
       }
       if (target2 < start || target2 < start + count) return target2 < start ? placed() : null;
@@ -12048,7 +12061,7 @@ function coverBeforeCut(content, at2) {
       }
     }
     const text4 = blockText(block);
-    if (key3) pending3.push({ key: key3, length: text4 === void 0 ? -1 : text4.length });
+    if (key3) pending4.push({ key: key3, length: text4 === void 0 ? -1 : text4.length });
   }
   return placed();
 }
@@ -13990,6 +14003,53 @@ var init_input_admission = __esm({
   }
 });
 
+// ../../packages/runtime/src/session/codex-async-question.ts
+async function answerNodeAsyncQuestion(session, messages, command, deliver) {
+  if (session.harnessId !== "codex") throw Object.assign(new Error("Async questions require a Codex session"), { code: "unsupported" });
+  const savedId = typeof command.itemId === "string" ? codexAsyncAnswerId(command.itemId) : null;
+  const saved = codexAsyncReplyText(messages.find((message2) => message2.id === savedId && message2.role === "user"));
+  if (saved !== null) return { reply: saved };
+  const message = messages.find((message2) => message2.id === command.messageId && message2.role === "assistant");
+  const item = message ? codexAsyncQuestionItems(message).find((item2) => item2.id === command.itemId) : void 0;
+  if (!item?.questions?.length) throw Object.assign(new Error("Async question not found"), { code: "not_found" });
+  if (!Array.isArray(command.answers) || command.answers.length !== item.questions.length || command.answers.some((answer2) => typeof answer2 !== "string" || !answer2.trim())) {
+    throw Object.assign(new Error("Every question requires an answer"), { code: "invalid_argument" });
+  }
+  const replyId = codexAsyncAnswerId(item.id);
+  let requests2 = pending.get(session);
+  if (!requests2) {
+    requests2 = /* @__PURE__ */ new Map();
+    pending.set(session, requests2);
+  }
+  const existing = requests2.get(replyId);
+  if (existing) return existing;
+  const reply = formatCodexAsyncQuestionReply(item.questions, command.answers);
+  const answer = anchorAsyncAnswer({
+    id: replyId,
+    role: "user",
+    status: "complete",
+    content: [{ type: "text", text: reply, codexAsyncQuestions: item.questions }],
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    providerId: "codex"
+  }, messages);
+  const request = deliver(answer, reply).then(() => ({ reply }));
+  requests2.set(replyId, request);
+  try {
+    return await request;
+  } finally {
+    requests2.delete(replyId);
+  }
+}
+var pending;
+var init_codex_async_question2 = __esm({
+  "../../packages/runtime/src/session/codex-async-question.ts"() {
+    "use strict";
+    init_codex_async_question();
+    init_transcript_boundary();
+    pending = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // ../../packages/shared/src/codex-accounts.ts
 function isCodexAccountProvider(id) {
   return !!id?.startsWith(CODEX_ACCOUNT_PREFIX);
@@ -17610,6 +17670,7 @@ var init_session_runtime = __esm({
     init_attachment_state();
     init_artifact_wakes();
     init_input_admission();
+    init_codex_async_question2();
     init_codex_accounts();
     init_session_send();
     init_agent_types();
@@ -18587,6 +18648,45 @@ var init_session_runtime = __esm({
       }) {
         const session = this.live.get(sessionId);
         if (!session || session.closed) throw Object.assign(new Error("session not found"), { code: "not_found" });
+        if (method === "session.answerAsyncQuestion") {
+          assertControl2();
+          if (this.disposing || session.status === "ended") throw Object.assign(new Error("session is closed"), { code: "failed_precondition" });
+          return answerNodeAsyncQuestion(session, this.messages(sessionId), input, async (message, text4) => {
+            const admission = new InputAdmission({
+              beforeInput: assertControl2,
+              onInputAccepted: () => {
+                session.transcript.push({
+                  id: message.id,
+                  role: "user",
+                  text: text4,
+                  createdAt: Date.parse(message.createdAt),
+                  userMessageContent: message.content,
+                  ...message.metadata ? { metadata: message.metadata } : {}
+                });
+                session.updatedAt = Date.now();
+                this.persist(session);
+                this.events.appendSession({
+                  sessionId,
+                  eventType: SESSION_DURABLE_EVENT.userMessage,
+                  payload: { blockId: message.id, text: text4, message, echoUserMessage: true }
+                });
+              }
+            });
+            this.beginTurn(session, {
+              text: text4,
+              userBlockId: message.id,
+              inputAdmission: admission,
+              // The Codex runner steers a live turn and starts normally when it has ended.
+              turnKind: "run",
+              model: session.model,
+              effort: session.effort,
+              apiProviderId: session.apiProviderId,
+              permissionMode: session.permissionMode,
+              sandboxMode: session.sandboxMode
+            });
+            await admission.promise;
+          });
+        }
         if (method === "session.steer" || method === "session.dequeue") return operateNodeQueue(method, input, {
           session,
           queue: this.turnQueues.get(sessionId) ?? [],
@@ -18615,7 +18715,7 @@ var init_session_runtime = __esm({
         });
       }
       get servedOperations() {
-        return this.turnRunner.servedOperations ?? /* @__PURE__ */ new Set();
+        return /* @__PURE__ */ new Set(["session.answerAsyncQuestion", ...this.turnRunner.servedOperations ?? []]);
       }
       /** Live Codex app-server for a voice call on this node. */
       codexVoice() {
@@ -19199,11 +19299,11 @@ var init_session_runtime = __esm({
           generation: input.generation,
           holderClientId: input.client.clientSessionId
         });
-        const pending3 = session.pendingInteraction;
-        if (!pending3 || pending3.interactionId !== input.interactionId) {
+        const pending4 = session.pendingInteraction;
+        if (!pending4 || pending4.interactionId !== input.interactionId) {
           throw Object.assign(new Error("no matching pending permission"), { code: "failed_precondition" });
         }
-        if (pending3.kind === "session_agents_confirm" || pending3.kind === "session_cleanup_confirm") {
+        if (pending4.kind === "session_agents_confirm" || pending4.kind === "session_cleanup_confirm") {
           const waiter2 = this.agentsConfirmWaiters.get(input.interactionId);
           if (!waiter2 || waiter2.sessionId !== input.sessionId) {
             throw Object.assign(new Error("no matching pending agents confirm"), {
@@ -19221,7 +19321,7 @@ var init_session_runtime = __esm({
           });
           return;
         }
-        if (pending3.kind && pending3.kind !== "permission") {
+        if (pending4.kind && pending4.kind !== "permission") {
           throw Object.assign(new Error("no matching pending permission"), { code: "failed_precondition" });
         }
         const waiter = this.permissionWaiters.get(input.interactionId);
@@ -19229,14 +19329,14 @@ var init_session_runtime = __esm({
           throw Object.assign(new Error("no matching pending permission"), { code: "failed_precondition" });
         }
         const decision = input.decision === "deny" || input.cancel ? "deny" : "allow";
-        if (input.decision === "allow_always" && pending3.permissionDetails && pending3.allowAlwaysAllow === false && !input.cancel) {
+        if (input.decision === "allow_always" && pending4.permissionDetails && pending4.allowAlwaysAllow === false && !input.cancel) {
           throw Object.assign(new Error("This native permission request supports allow once or deny"), { code: "failed_precondition" });
         }
-        if (pending3.requestKind === "mcp_elicitation" && decision === "allow") {
-          const accepted = acceptedElicitationContent(pending3.schemaForm, input.formAnswers);
+        if (pending4.requestKind === "mcp_elicitation" && decision === "allow") {
+          const accepted = acceptedElicitationContent(pending4.schemaForm, input.formAnswers);
           if (!accepted.ok) throw Object.assign(new Error(accepted.reason), { code: "failed_precondition" });
         }
-        if (input.decision === "allow_always" && pending3.requestKind !== "mcp_elicitation" && !input.cancel) {
+        if (input.decision === "allow_always" && pending4.requestKind !== "mcp_elicitation" && !input.cancel) {
           const tool2 = session.pendingInteraction?.toolName?.trim();
           if (tool2) {
             const list = session.alwaysAllowedTools ?? [];
@@ -19559,27 +19659,27 @@ var init_session_runtime = __esm({
       }
       /** Deny and clear any active permission waiter for this session. */
       rejectPendingPermission(session) {
-        const pending3 = session.pendingInteraction;
-        if (!pending3) return;
-        if (pending3.kind === "question") {
-          const qw = this.questionWaiters.get(pending3.interactionId);
+        const pending4 = session.pendingInteraction;
+        if (!pending4) return;
+        if (pending4.kind === "question") {
+          const qw = this.questionWaiters.get(pending4.interactionId);
           if (qw) qw.settle({ answers: {}, reason: "aborted" });
           else session.pendingInteraction = null;
           return;
         }
-        if (pending3.kind === "plan") {
-          const pw = this.planWaiters.get(pending3.interactionId);
+        if (pending4.kind === "plan") {
+          const pw = this.planWaiters.get(pending4.interactionId);
           if (pw) pw.settle({ decision: "reject", reason: "aborted" });
           else session.pendingInteraction = null;
           return;
         }
-        if (pending3.kind === "session_agents_confirm" || pending3.kind === "session_cleanup_confirm") {
-          const aw = this.agentsConfirmWaiters.get(pending3.interactionId);
+        if (pending4.kind === "session_agents_confirm" || pending4.kind === "session_cleanup_confirm") {
+          const aw = this.agentsConfirmWaiters.get(pending4.interactionId);
           if (aw) aw.settle({ action: "cancel", reason: "aborted" });
           else session.pendingInteraction = null;
           return;
         }
-        const waiter = this.permissionWaiters.get(pending3.interactionId);
+        const waiter = this.permissionWaiters.get(pending4.interactionId);
         if (waiter) {
           waiter.settle({ decision: "deny", reason: "aborted" });
         } else {
@@ -19590,23 +19690,23 @@ var init_session_runtime = __esm({
         if (session.pendingInteraction) {
           this.rejectPendingPermission(session);
         }
-        const pending3 = { ...interaction, kind: "question" };
+        const pending4 = { ...interaction, kind: "question" };
         return new Promise((resolve24) => {
           let settled = false;
-          session.pendingInteraction = pending3;
+          session.pendingInteraction = pending4;
           session.updatedAt = Date.now();
           this.persist(session);
           this.events.appendSession({
             sessionId: session.sessionId,
             eventType: SESSION_DURABLE_EVENT.questionRequested,
-            payload: pending3,
+            payload: pending4,
             causationRequestId: requestId
           });
           const settle2 = (result3) => {
             if (settled) return;
             settled = true;
-            this.questionWaiters.delete(pending3.interactionId);
-            if (session.pendingInteraction?.interactionId === pending3.interactionId) {
+            this.questionWaiters.delete(pending4.interactionId);
+            if (session.pendingInteraction?.interactionId === pending4.interactionId) {
               session.pendingInteraction = null;
               session.updatedAt = Date.now();
               this.persist(session);
@@ -19615,18 +19715,18 @@ var init_session_runtime = __esm({
               this.events.appendSession({
                 sessionId: session.sessionId,
                 eventType: SESSION_DURABLE_EVENT.questionResponded,
-                payload: { interactionId: pending3.interactionId, answers: result3.answers }
+                payload: { interactionId: pending4.interactionId, answers: result3.answers }
               });
             } else {
               this.events.appendSession({
                 sessionId: session.sessionId,
                 eventType: SESSION_DURABLE_EVENT.questionAborted,
-                payload: { interactionId: pending3.interactionId }
+                payload: { interactionId: pending4.interactionId }
               });
             }
             resolve24(result3.answers);
           };
-          this.questionWaiters.set(pending3.interactionId, {
+          this.questionWaiters.set(pending4.interactionId, {
             sessionId: session.sessionId,
             settle: settle2
           });
@@ -19647,23 +19747,23 @@ var init_session_runtime = __esm({
         if (session.pendingInteraction) {
           this.rejectPendingPermission(session);
         }
-        const pending3 = { ...interaction, kind: "plan" };
+        const pending4 = { ...interaction, kind: "plan" };
         return new Promise((resolve24) => {
           let settled = false;
-          session.pendingInteraction = pending3;
+          session.pendingInteraction = pending4;
           session.updatedAt = Date.now();
           this.persist(session);
           this.events.appendSession({
             sessionId: session.sessionId,
             eventType: SESSION_DURABLE_EVENT.planRequested,
-            payload: pending3,
+            payload: pending4,
             causationRequestId: requestId
           });
           const settle2 = (result3) => {
             if (settled) return;
             settled = true;
-            this.planWaiters.delete(pending3.interactionId);
-            if (session.pendingInteraction?.interactionId === pending3.interactionId) {
+            this.planWaiters.delete(pending4.interactionId);
+            if (session.pendingInteraction?.interactionId === pending4.interactionId) {
               session.pendingInteraction = null;
               session.updatedAt = Date.now();
               this.persist(session);
@@ -19673,7 +19773,7 @@ var init_session_runtime = __esm({
                 sessionId: session.sessionId,
                 eventType: SESSION_DURABLE_EVENT.planResponded,
                 payload: {
-                  interactionId: pending3.interactionId,
+                  interactionId: pending4.interactionId,
                   decision: result3.decision,
                   options: result3.options
                 }
@@ -19682,12 +19782,12 @@ var init_session_runtime = __esm({
               this.events.appendSession({
                 sessionId: session.sessionId,
                 eventType: SESSION_DURABLE_EVENT.planAborted,
-                payload: { interactionId: pending3.interactionId, decision: "reject" }
+                payload: { interactionId: pending4.interactionId, decision: "reject" }
               });
             }
             resolve24({ decision: result3.decision, options: result3.options });
           };
-          this.planWaiters.set(pending3.interactionId, {
+          this.planWaiters.set(pending4.interactionId, {
             sessionId: session.sessionId,
             settle: settle2
           });
@@ -22850,85 +22950,85 @@ var init_ask_user_question = __esm({
 });
 
 // ../../packages/shared/src/node-session-messages.ts
-function nodePendingToPermissionRequest(pending3) {
-  if (!pending3?.interactionId) return null;
-  if (pending3.kind === "session_agents_confirm") {
-    const confirm = pending3.sessionAgentsConfirm;
+function nodePendingToPermissionRequest(pending4) {
+  if (!pending4?.interactionId) return null;
+  if (pending4.kind === "session_agents_confirm") {
+    const confirm = pending4.sessionAgentsConfirm;
     const payload = {
       launches: Array.isArray(confirm?.launches) ? confirm.launches : [],
       profiles: Array.isArray(confirm?.profiles) ? confirm.profiles : []
     };
     return {
-      requestId: pending3.interactionId,
-      toolName: pending3.toolName || "session_collab_request",
-      toolUseId: pending3.toolUseId ?? pending3.interactionId,
-      input: pending3.input && typeof pending3.input === "object" ? pending3.input : {},
+      requestId: pending4.interactionId,
+      toolName: pending4.toolName || "session_collab_request",
+      toolUseId: pending4.toolUseId ?? pending4.interactionId,
+      input: pending4.input && typeof pending4.input === "object" ? pending4.input : {},
       allowAlwaysAllow: false,
       requestKind: "session_agents_confirm",
-      serverName: pending3.serverName || "superone",
-      message: pending3.message || "Allow this agent to start the following sessions?",
+      serverName: pending4.serverName || "superone",
+      message: pending4.message || "Allow this agent to start the following sessions?",
       sessionAgentsConfirm: payload
     };
   }
-  if (pending3.kind === "session_cleanup_confirm") {
-    const sessions = Array.isArray(pending3.sessionCleanupConfirm?.sessions) ? pending3.sessionCleanupConfirm.sessions : [];
+  if (pending4.kind === "session_cleanup_confirm") {
+    const sessions = Array.isArray(pending4.sessionCleanupConfirm?.sessions) ? pending4.sessionCleanupConfirm.sessions : [];
     return {
-      requestId: pending3.interactionId,
-      toolName: pending3.toolName || "mcp__superone__session_cleanup",
-      toolUseId: pending3.toolUseId ?? pending3.interactionId,
-      input: pending3.input && typeof pending3.input === "object" ? pending3.input : {},
+      requestId: pending4.interactionId,
+      toolName: pending4.toolName || "mcp__superone__session_cleanup",
+      toolUseId: pending4.toolUseId ?? pending4.interactionId,
+      input: pending4.input && typeof pending4.input === "object" ? pending4.input : {},
       allowAlwaysAllow: false,
       requestKind: "session_cleanup_confirm",
-      serverName: pending3.serverName || "superone",
-      message: pending3.message || "Delete these sessions permanently?",
+      serverName: pending4.serverName || "superone",
+      message: pending4.message || "Delete these sessions permanently?",
       sessionCleanupConfirm: { sessions }
     };
   }
-  if (pending3.kind && pending3.kind !== "permission") return null;
-  if (pending3.requestKind === "input_request") {
-    if (!pending3.inputRequest || !pending3.schemaForm) return null;
+  if (pending4.kind && pending4.kind !== "permission") return null;
+  if (pending4.requestKind === "input_request") {
+    if (!pending4.inputRequest || !pending4.schemaForm) return null;
     return {
-      requestId: pending3.interactionId,
-      toolName: pending3.toolName || "composer_request",
-      toolUseId: pending3.toolUseId ?? pending3.interactionId,
+      requestId: pending4.interactionId,
+      toolName: pending4.toolName || "composer_request",
+      toolUseId: pending4.toolUseId ?? pending4.interactionId,
       input: {},
       allowAlwaysAllow: false,
       requestKind: "input_request",
-      serverName: pending3.serverName || "superone",
-      message: pending3.message || pending3.inputRequest.title,
-      schemaForm: pending3.schemaForm,
-      inputRequest: pending3.inputRequest
+      serverName: pending4.serverName || "superone",
+      message: pending4.message || pending4.inputRequest.title,
+      schemaForm: pending4.schemaForm,
+      inputRequest: pending4.inputRequest
     };
   }
-  const input = pending3.input && typeof pending3.input === "object" ? pending3.input : {};
-  const elicitationUrl = pending3.elicitationUrl ?? (typeof input.elicitationUrl === "string" ? input.elicitationUrl : void 0);
-  const elicitationId = pending3.elicitationId ?? (typeof input.elicitationId === "string" ? input.elicitationId : void 0);
-  const schemaForm = pending3.schemaForm ?? (input.schemaForm && typeof input.schemaForm === "object" ? input.schemaForm : void 0);
-  const requestKind = pending3.requestKind === "mcp_elicitation" ? "mcp_elicitation" : void 0;
+  const input = pending4.input && typeof pending4.input === "object" ? pending4.input : {};
+  const elicitationUrl = pending4.elicitationUrl ?? (typeof input.elicitationUrl === "string" ? input.elicitationUrl : void 0);
+  const elicitationId = pending4.elicitationId ?? (typeof input.elicitationId === "string" ? input.elicitationId : void 0);
+  const schemaForm = pending4.schemaForm ?? (input.schemaForm && typeof input.schemaForm === "object" ? input.schemaForm : void 0);
+  const requestKind = pending4.requestKind === "mcp_elicitation" ? "mcp_elicitation" : void 0;
   return {
-    requestId: pending3.interactionId,
-    toolName: pending3.toolName || "tool",
-    toolUseId: pending3.toolUseId,
+    requestId: pending4.interactionId,
+    toolName: pending4.toolName || "tool",
+    toolUseId: pending4.toolUseId,
     input,
-    allowAlwaysAllow: requestKind === "mcp_elicitation" ? !schemaForm && pending3.allowAlwaysAllow === true : pending3.allowAlwaysAllow !== false,
+    allowAlwaysAllow: requestKind === "mcp_elicitation" ? !schemaForm && pending4.allowAlwaysAllow === true : pending4.allowAlwaysAllow !== false,
     ...requestKind ? { requestKind } : {},
-    ...pending3.message ? { message: pending3.message } : {},
-    ...pending3.permissionDetails ? { permissionDetails: pending3.permissionDetails } : {},
-    ...pending3.serverName ? { serverName: pending3.serverName } : {},
-    ...pending3.serverLabel ? { serverLabel: pending3.serverLabel } : {},
+    ...pending4.message ? { message: pending4.message } : {},
+    ...pending4.permissionDetails ? { permissionDetails: pending4.permissionDetails } : {},
+    ...pending4.serverName ? { serverName: pending4.serverName } : {},
+    ...pending4.serverLabel ? { serverLabel: pending4.serverLabel } : {},
     ...elicitationUrl ? { elicitationUrl, subtitle: elicitationUrl } : {},
     ...elicitationId ? { elicitationId } : {},
-    ...elicitationUrl && pending3.elicitationAcceptOnOpen ? { elicitationAcceptOnOpen: true } : {},
+    ...elicitationUrl && pending4.elicitationAcceptOnOpen ? { elicitationAcceptOnOpen: true } : {},
     ...schemaForm ? { schemaForm } : {},
-    ...pending3.elicitationForm ? { elicitationForm: pending3.elicitationForm } : {},
-    ...pending3.subtitle ? { subtitle: pending3.subtitle } : {},
-    ...pending3.riskLevel ? { riskLevel: pending3.riskLevel } : {},
-    ...pending3.supportsAlwaysPersist !== void 0 ? { supportsAlwaysPersist: pending3.supportsAlwaysPersist } : {}
+    ...pending4.elicitationForm ? { elicitationForm: pending4.elicitationForm } : {},
+    ...pending4.subtitle ? { subtitle: pending4.subtitle } : {},
+    ...pending4.riskLevel ? { riskLevel: pending4.riskLevel } : {},
+    ...pending4.supportsAlwaysPersist !== void 0 ? { supportsAlwaysPersist: pending4.supportsAlwaysPersist } : {}
   };
 }
-function nodePendingToQuestionRequest(pending3) {
-  if (!pending3?.interactionId || pending3.kind !== "question") return null;
-  const input = pending3.input && typeof pending3.input === "object" ? pending3.input : {};
+function nodePendingToQuestionRequest(pending4) {
+  if (!pending4?.interactionId || pending4.kind !== "question") return null;
+  const input = pending4.input && typeof pending4.input === "object" ? pending4.input : {};
   const raw2 = Array.isArray(input.questions) ? input.questions : [];
   const questions = [];
   for (const q3 of raw2) {
@@ -22970,26 +23070,26 @@ function nodePendingToQuestionRequest(pending3) {
     typeof input.previewFormat === "string" ? input.previewFormat : void 0
   );
   return {
-    requestId: pending3.interactionId,
+    requestId: pending4.interactionId,
     questions,
     ...previewFormat ? { previewFormat } : {}
   };
 }
-function nodePendingToPlanApprovalRequest(pending3) {
-  if (!pending3?.interactionId || pending3.kind !== "plan") return null;
-  const input = pending3.input && typeof pending3.input === "object" ? pending3.input : {};
+function nodePendingToPlanApprovalRequest(pending4) {
+  if (!pending4?.interactionId || pending4.kind !== "plan") return null;
+  const input = pending4.input && typeof pending4.input === "object" ? pending4.input : {};
   const plan = typeof input.plan === "string" ? input.plan : typeof input.planContent === "string" ? input.planContent : input.plan && typeof input.plan === "object" ? JSON.stringify(input.plan) : "Plan approval required";
   return {
-    requestId: pending3.interactionId,
+    requestId: pending4.interactionId,
     planContent: plan,
     planFilePath: typeof input.planFilePath === "string" ? input.planFilePath : "",
     allowedPrompts: Array.isArray(input.allowedPrompts) ? input.allowedPrompts : []
   };
 }
-function nodePendingInteractionFields(pending3, inputRequests = []) {
-  const perm = nodePendingToPermissionRequest(pending3);
-  const question = nodePendingToQuestionRequest(pending3);
-  const plan = nodePendingToPlanApprovalRequest(pending3);
+function nodePendingInteractionFields(pending4, inputRequests = []) {
+  const perm = nodePendingToPermissionRequest(pending4);
+  const question = nodePendingToQuestionRequest(pending4);
+  const plan = nodePendingToPlanApprovalRequest(pending4);
   const forms = inputRequests.flatMap((request) => nodePendingToPermissionRequest(request) ?? []);
   return {
     pendingPermissions: [...perm ? [perm] : [], ...forms],
@@ -23198,7 +23298,7 @@ var init_read_model = __esm({
           return session;
         }
         const events = this.log.listForSession(sessionId, Number.MAX_SAFE_INTEGER);
-        const pending3 = nodePendingInteractionFields(record13?.pendingInteraction);
+        const pending4 = nodePendingInteractionFields(record13?.pendingInteraction);
         const core2 = {
           ...createDefaultChatCoreSession(),
           sessionProvider: providerId,
@@ -23206,7 +23306,7 @@ var init_read_model = __esm({
           claudeFastMode: record13?.claudeFastMode ?? void 0,
           messages: record13 ? sessionMessageBlocksToChatMessages(buildSessionMessageCatalog(record13, events), providerId) : [],
           status: record13?.status === "streaming" ? "streaming" : "idle",
-          ...pending3
+          ...pending4
         };
         session = {
           mapper,
@@ -40975,7 +41075,7 @@ var init_scanner_DX8LRFGE = __esm({
       }
       findNextMatchSync(string8, startPosition, _options) {
         const str5 = typeof string8 === "string" ? string8 : string8.content;
-        const pending3 = [];
+        const pending4 = [];
         function toResult(index, match, offset = 0) {
           return {
             index,
@@ -41001,7 +41101,7 @@ var init_scanner_DX8LRFGE = __esm({
             const match = regexp.exec(str5);
             if (!match) continue;
             if (match.index === startPosition) return toResult(i2, match, 0);
-            pending3.push([
+            pending4.push([
               i2,
               match,
               0
@@ -41011,9 +41111,9 @@ var init_scanner_DX8LRFGE = __esm({
             throw e;
           }
         }
-        if (pending3.length) {
-          const minIndex = Math.min(...pending3.map((m5) => m5[1].index));
-          for (const [i2, match, offset] of pending3) if (match.index === minIndex) return toResult(i2, match, offset);
+        if (pending4.length) {
+          const minIndex = Math.min(...pending4.map((m5) => m5[1].index));
+          for (const [i2, match, offset] of pending4) if (match.index === minIndex) return toResult(i2, match, offset);
         }
         return null;
       }
@@ -48035,7 +48135,7 @@ async function openCodexAppServer(opts) {
     stderrBuf = (stderrBuf + chunk).slice(-MAX_STDERR_CHARS);
   });
   const rl = createInterface({ input: child.stdout });
-  const pending3 = /* @__PURE__ */ new Map();
+  const pending4 = /* @__PURE__ */ new Map();
   const notificationWaiters = [];
   const notificationQueue = [];
   let nextId = 1;
@@ -48059,11 +48159,11 @@ async function openCodexAppServer(opts) {
   };
   const failAll = (err) => {
     inboundAbort.abort();
-    for (const [, p4] of pending3) {
+    for (const [, p4] of pending4) {
       p4.cancelDeadline();
       p4.reject(err);
     }
-    pending3.clear();
+    pending4.clear();
     while (notificationWaiters.length) {
       const w5 = notificationWaiters.shift();
       clearTimeout(w5.timer);
@@ -48191,9 +48291,9 @@ async function openCodexAppServer(opts) {
         }
         if (rec.id != null && (typeof rec.id === "number" || typeof rec.id === "string")) {
           const id = typeof rec.id === "number" ? rec.id : Number(rec.id);
-          const waiter = pending3.get(id);
+          const waiter = pending4.get(id);
           if (!waiter) continue;
-          pending3.delete(id);
+          pending4.delete(id);
           waiter.cancelDeadline();
           if (rec.error) {
             const errObj = rec.error;
@@ -48211,6 +48311,10 @@ async function openCodexAppServer(opts) {
           pushNotification({ method: rec.method, params });
         }
       }
+      if (!closed && !readLoopError) {
+        readLoopError = new Error("Codex app-server connection closed");
+        failAll(readLoopError);
+      }
     } catch (err) {
       readLoopError = err instanceof Error ? err : new Error(String(err));
       failAll(safePublicError("Codex app-server read failed", readLoopError));
@@ -48232,15 +48336,15 @@ async function openCodexAppServer(opts) {
     }
     const id = nextId++;
     const cancelDeadline = inputBudget.deadline(timeoutMs, () => {
-      pending3.delete(id);
+      pending4.delete(id);
       reject(new Error(`Codex app-server ${method} timed out after ${timeoutMs}ms`));
     });
     const waiter = { resolve: resolve24, reject, cancelDeadline };
-    pending3.set(id, waiter);
+    pending4.set(id, waiter);
     try {
       writeLine({ jsonrpc: "2.0", id, method, params: params ?? {} });
     } catch (err) {
-      pending3.delete(id);
+      pending4.delete(id);
       waiter.cancelDeadline();
       reject(safePublicError("Codex app-server write failed", err));
     }
@@ -48258,7 +48362,7 @@ async function openCodexAppServer(opts) {
       return;
     }
     if (closed) {
-      resolve24(null);
+      reject(new Error("Codex app-server closed"));
       return;
     }
     const timer = setTimeout(() => {
@@ -48457,9 +48561,6 @@ async function runCodexAppServerTurn(opts) {
     turnId = readString4(turn?.id);
   }
   let finalText = "";
-  const deadline = Date.now() + TURN_WAIT_TIMEOUT_MS;
-  const inputWaitAtStart = opts.client.getUserInputWaitMs?.() ?? 0;
-  const remaining = () => deadline - Date.now() + (opts.client.getUserInputWaitMs?.() ?? 0) - inputWaitAtStart;
   const agentEventMapper = opts.onAgentEvent ? createCodexAgentEventMapper({
     messageId: opts.messageId ?? `codex_${turnId ?? Date.now()}`,
     emit: opts.onAgentEvent,
@@ -48470,10 +48571,10 @@ async function runCodexAppServerTurn(opts) {
     turnKind
   }) : null;
   agentEventMapper?.start(threadId);
-  while (!opts.signal.aborted && remaining() > 0) {
+  while (!opts.signal.aborted) {
     let note;
     try {
-      note = await opts.client.nextNotification(Math.min(5e3, Math.max(0, remaining())));
+      note = await opts.client.nextNotification(5e3);
     } catch (err) {
       const error51 = err instanceof Error ? err : new Error(String(err));
       agentEventMapper?.fail(error51.message, /interrupt|abort/i.test(error51.message));
@@ -48523,12 +48624,8 @@ async function runCodexAppServerTurn(opts) {
       return { finalText, threadId, turnId };
     }
   }
-  if (opts.signal.aborted) {
-    agentEventMapper?.fail("Codex turn interrupted", true);
-    throw new Error("Codex turn interrupted");
-  }
-  agentEventMapper?.fail("Codex turn timed out waiting for turn/completed");
-  throw new Error("Codex turn timed out waiting for turn/completed");
+  agentEventMapper?.fail("Codex turn interrupted", true);
+  throw new Error("Codex turn interrupted");
 }
 function normalizeCollaborationMode(value, model, reasoningEffort) {
   if (!value) return void 0;
@@ -48590,7 +48687,7 @@ function asRecord9(value) {
 function readString4(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
-var DEFAULT_REQUEST_TIMEOUT_MS, THREAD_TIMEOUT_MS, TURN_WAIT_TIMEOUT_MS, MAX_STDERR_CHARS;
+var DEFAULT_REQUEST_TIMEOUT_MS, THREAD_TIMEOUT_MS, MAX_STDERR_CHARS;
 var init_app_server_client = __esm({
   "../../packages/codex/src/app-server-client.ts"() {
     "use strict";
@@ -48608,7 +48705,6 @@ var init_app_server_client = __esm({
     init_agent_event_mapper();
     DEFAULT_REQUEST_TIMEOUT_MS = 12e4;
     THREAD_TIMEOUT_MS = 6e4;
-    TURN_WAIT_TIMEOUT_MS = 3e5;
     MAX_STDERR_CHARS = 8e3;
   }
 });
@@ -49239,8 +49335,8 @@ var init_account_manager = __esm({
         if (browser) this.browserStarting = true;
         try {
           this.store.home(id);
-          for (const [loginId, pending3] of this.pending) {
-            if (pending3.accountId === id) await this.cancel(loginId).catch(() => {
+          for (const [loginId, pending4] of this.pending) {
+            if (pending4.accountId === id) await this.cancel(loginId).catch(() => {
             });
           }
           this.failed.delete(id);
@@ -49251,9 +49347,9 @@ var init_account_manager = __esm({
               type,
               ...browser ? { useHostedLoginSuccessPage: true, appBrand: "chatgpt" } : {}
             }));
-            const pending3 = { accountId: id, connection, browser };
-            this.pending.set(result3.loginId, pending3);
-            void this.wait(result3.loginId, pending3);
+            const pending4 = { accountId: id, connection, browser };
+            this.pending.set(result3.loginId, pending4);
+            void this.wait(result3.loginId, pending4);
             return { ...result3, accountId: id };
           } catch (error51) {
             this.failed.add(id);
@@ -49265,53 +49361,53 @@ var init_account_manager = __esm({
           if (browser) this.browserStarting = false;
         }
       }
-      async wait(loginId, pending3) {
+      async wait(loginId, pending4) {
         const deadline = Date.now() + 15 * 6e4;
         const timeout = setTimeout(() => {
           void this.cancel(loginId).catch(() => {
           });
-          this.failed.add(pending3.accountId);
+          this.failed.add(pending4.accountId);
         }, 15 * 6e4);
         timeout.unref?.();
         try {
-          while (this.pending.get(loginId) === pending3 && Date.now() < deadline) {
-            const notification = await pending3.connection.nextNotification();
+          while (this.pending.get(loginId) === pending4 && Date.now() < deadline) {
+            const notification = await pending4.connection.nextNotification();
             if (!notification) throw new Error("Login connection closed");
             if (notification?.method !== "account/login/completed" || notification.params.loginId !== loginId) continue;
             if (notification.params.success !== true) throw new Error("Sign-in failed");
-            const status2 = parseAccountStatus(await pending3.connection.request("account/read", { refreshToken: false }));
+            const status2 = parseAccountStatus(await pending4.connection.request("account/read", { refreshToken: false }));
             if (!status2.signedIn) throw new Error("Sign-in did not complete");
-            if (this.pending.get(loginId) !== pending3) return;
-            this.store.update(pending3.accountId, status2);
-            this.store.invalidateCredentials(pending3.accountId);
-            this.changed(codexAccountProviderId(pending3.accountId));
+            if (this.pending.get(loginId) !== pending4) return;
+            this.store.update(pending4.accountId, status2);
+            this.store.invalidateCredentials(pending4.accountId);
+            this.changed(codexAccountProviderId(pending4.accountId));
             return;
           }
-          if (this.pending.get(loginId) === pending3) this.failed.add(pending3.accountId);
+          if (this.pending.get(loginId) === pending4) this.failed.add(pending4.accountId);
         } catch {
-          this.failed.add(pending3.accountId);
+          this.failed.add(pending4.accountId);
         } finally {
           clearTimeout(timeout);
-          if (this.pending.get(loginId) === pending3) this.pending.delete(loginId);
-          await pending3.connection.close().catch(() => {
+          if (this.pending.get(loginId) === pending4) this.pending.delete(loginId);
+          await pending4.connection.close().catch(() => {
           });
         }
       }
       async cancel(loginId) {
-        const pending3 = this.pending.get(loginId);
-        if (!pending3) return;
+        const pending4 = this.pending.get(loginId);
+        if (!pending4) return;
         this.pending.delete(loginId);
         try {
-          await pending3.connection.request("account/login/cancel", { loginId });
+          await pending4.connection.request("account/login/cancel", { loginId });
         } finally {
-          await pending3.connection.close();
+          await pending4.connection.close();
         }
       }
       async logout(providerId) {
         const id = codexAccountId(providerId) ?? codexAccountId(this.store.defaultProviderId()) ?? CODEX_CLI_ACCOUNT_ID;
         this.revisions.set(id, (this.revisions.get(id) ?? 0) + 1);
-        for (const [loginId, pending3] of this.pending) {
-          if (pending3.accountId === id) await this.cancel(loginId);
+        for (const [loginId, pending4] of this.pending) {
+          if (pending4.accountId === id) await this.cancel(loginId);
         }
         const selected = codexAccountProviderId(id);
         const connection = await this.open(selected);
@@ -49338,8 +49434,8 @@ var init_account_manager = __esm({
         const unreachable = signedIn() && await this.status(providerId).then(() => false, () => true);
         if (!unreachable && signedIn()) throw new Error("Sign out before removing this Codex account.");
         this.revisions.set(id, (this.revisions.get(id) ?? 0) + 1);
-        for (const [loginId, pending3] of this.pending) {
-          if (pending3.accountId === id) await this.cancel(loginId);
+        for (const [loginId, pending4] of this.pending) {
+          if (pending4.accountId === id) await this.cancel(loginId);
         }
         this.store.remove(id, unreachable);
         this.failed.delete(id);
@@ -51869,7 +51965,7 @@ var init_claude_live_session = __esm({
             this.failAmbient("Claude SDK stream ended before the background turn completed");
             this.active?.reject(new Error("Claude SDK stream ended before the user turn completed"));
             this.active = null;
-            for (const pending3 of this.pending.splice(0)) pending3.reject(new Error("Claude SDK stream ended before the queued turn started"));
+            for (const pending4 of this.pending.splice(0)) pending4.reject(new Error("Claude SDK stream ended before the queued turn started"));
           }
           this.closed = true;
           this.bridge.close();
@@ -52322,7 +52418,7 @@ var init_mod_surface = __esm({
         this.disposed = true;
         if (this.available) this.opts.emit({ type: "mod_ui_state", available: false });
         this.available = false;
-        for (const pending3 of this.pendingHost.values()) pending3.resolve(null);
+        for (const pending4 of this.pendingHost.values()) pending4.resolve(null);
         this.pendingHost.clear();
       }
       /**
@@ -52357,10 +52453,10 @@ var init_mod_surface = __esm({
         return this.pendingHost.has(requestId);
       }
       acceptHostReply({ requestId, clientId: clientId2, reply }) {
-        const pending3 = this.pendingHost.get(requestId);
-        if (!pending3 || pending3.kind !== reply.kind || pending3.clientId !== clientId2) return { accepted: false };
+        const pending4 = this.pendingHost.get(requestId);
+        if (!pending4 || pending4.kind !== reply.kind || pending4.clientId !== clientId2) return { accepted: false };
         this.pendingHost.delete(requestId);
-        pending3.resolve(reply);
+        pending4.resolve(reply);
         return { accepted: true };
       }
     };
@@ -102834,7 +102930,7 @@ function make7(connect) {
     subscribe(options) {
       return {
         [Symbol.asyncIterator]() {
-          const pending3 = [];
+          const pending4 = [];
           const queued = [];
           let started = false;
           let completion;
@@ -102846,7 +102942,7 @@ function make7(connect) {
             options?.signal?.removeEventListener("abort", abort);
             if (connection?.subscribers.delete(subscriber) && !connection.subscribers.size)
               stop3(connection);
-            pending3.splice(0).forEach((request) => {
+            pending4.splice(0).forEach((request) => {
               if ("error" in result3)
                 request.reject(result3.error);
               else
@@ -102864,7 +102960,7 @@ function make7(connect) {
             push(value) {
               if (completion)
                 return;
-              const request = pending3.shift();
+              const request = pending4.shift();
               if (request) {
                 request.resolve({ done: false, value });
                 return;
@@ -102906,7 +103002,7 @@ function make7(connect) {
                 return Promise.resolve({ done: true, value: void 0 });
               }
               const request = Promise.withResolvers();
-              pending3.push(request);
+              pending4.push(request);
               if (!started) {
                 started = true;
                 options?.signal?.addEventListener("abort", abort, { once: true });
@@ -106245,15 +106341,15 @@ var init_opencode_oauth = __esm({
         return task;
       }
       reply(id, answers) {
-        const pending3 = this.forms.get(id);
-        if (!pending3) return false;
-        pending3.reply(openCodeV2FormAnswer(pending3.form, answers));
+        const pending4 = this.forms.get(id);
+        if (!pending4) return false;
+        pending4.reply(openCodeV2FormAnswer(pending4.form, answers));
         return true;
       }
       reject(id) {
-        const pending3 = this.forms.get(id);
-        if (!pending3) return false;
-        pending3.cancel();
+        const pending4 = this.forms.get(id);
+        if (!pending4) return false;
+        pending4.cancel();
         return true;
       }
       async close() {
@@ -106403,8 +106499,8 @@ var init_opencode_oauth = __esm({
         } finally {
           clearTimeout(expiry);
           if (!complete && !signal2.aborted) controller.abort(new Error("OpenCode sign-in did not complete"));
-          for (const pending3 of [...this.forms.values()]) {
-            if (pending3.owner === controller) pending3.reply({});
+          for (const pending4 of [...this.forms.values()]) {
+            if (pending4.owner === controller) pending4.reply({});
           }
           if (!complete) await this.deps.client.cancelOAuth(id, attempt.attemptID).catch(() => void 0);
         }
@@ -108469,13 +108565,13 @@ function createManagedOpenCodeTurnRunner(resolveProjectPath2, options = {}) {
       if (existing.active || existing.host) throw new Error("Wait for OpenCode to become idle before changing its provider or launch configuration");
       await runner.disposeSession(id);
     }
-    let pending3 = sessions.get(id);
-    if (!pending3) {
+    let pending4 = sessions.get(id);
+    if (!pending4) {
       if (!isOpenCodeBinaryRunnable(opts.binaryPath) && !opts.serverUrl?.trim())
         throw new Error(
           "OpenCode runtime client not available on node: enable the harness with a real binary or endpoint"
         );
-      pending3 = startOpenCodeSessionServer({
+      pending4 = startOpenCodeSessionServer({
         ...opts,
         sessionId: id,
         nativeSessionId: input.session.providerResume?.startsWith("opencode:") ? input.session.providerResume.slice(9) : void 0,
@@ -108498,9 +108594,9 @@ function createManagedOpenCodeTurnRunner(resolveProjectPath2, options = {}) {
           return live2;
         }
       );
-      sessions.set(id, pending3);
+      sessions.set(id, pending4);
     }
-    const live = await pending3.catch((error51) => {
+    const live = await pending4.catch((error51) => {
       sessions.delete(id);
       throw error51;
     });
@@ -108583,7 +108679,7 @@ function createManagedOpenCodeTurnRunner(resolveProjectPath2, options = {}) {
       const opts = { ...options, ...options.resolveLaunch?.(connection) };
       const cwd = session.cwd?.trim() || resolveProjectPath2(session.projectId) || process.cwd();
       if (!isOpenCodeBinaryRunnable(opts.binaryPath) && !opts.serverUrl?.trim()) throw new Error("OpenCode runtime is unavailable");
-      const pending3 = sessions.get(session.sessionId) ?? startOpenCodeSessionServer({
+      const pending4 = sessions.get(session.sessionId) ?? startOpenCodeSessionServer({
         ...opts,
         sessionId: session.sessionId,
         nativeSessionId: session.providerResume.slice(9),
@@ -108597,8 +108693,8 @@ function createManagedOpenCodeTurnRunner(resolveProjectPath2, options = {}) {
         }
         return open2(connection, opts, server, cwd);
       });
-      sessions.set(session.sessionId, pending3);
-      const handle2 = await pending3;
+      sessions.set(session.sessionId, pending4);
+      const handle2 = await pending4;
       if (!("legacy" in handle2)) live = handle2;
     }
     if (!live) {
@@ -108797,9 +108893,9 @@ function createManagedOpenCodeTurnRunner(resolveProjectPath2, options = {}) {
     events?.finish(void 0, true);
   };
   runner.disposeSession = async (id) => {
-    const pending3 = sessions.get(id);
+    const pending4 = sessions.get(id);
     sessions.delete(id);
-    const live = await pending3?.catch(() => null);
+    const live = await pending4?.catch(() => null);
     if (live && !("legacy" in live)) {
       live.abort.abort();
       await live.runtime.close();
@@ -110674,17 +110770,17 @@ var init_cursor_store = __esm({
 
 // ../../packages/cursor/src/cursor-sdk.ts
 function loadCursorSdk() {
-  pending ??= import("@cursor/sdk").then((sdk) => loaded = sdk);
-  return pending;
+  pending2 ??= import("@cursor/sdk").then((sdk) => loaded = sdk);
+  return pending2;
 }
 function isCursorSdkError(error51, name) {
   return loaded !== null && error51 instanceof loaded[name];
 }
-var pending, loaded;
+var pending2, loaded;
 var init_cursor_sdk = __esm({
   "../../packages/cursor/src/cursor-sdk.ts"() {
     "use strict";
-    pending = null;
+    pending2 = null;
     loaded = null;
   }
 });
@@ -111707,9 +111803,6 @@ async function openTurnAndStream(opts) {
   const turnId = readString6(turn?.id);
   opts.onTurnStarted?.(turnId);
   let finalText = "";
-  const deadline = Date.now() + TURN_WAIT_TIMEOUT_MS2;
-  const inputWaitAtStart = opts.client.getUserInputWaitMs?.() ?? 0;
-  const remaining = () => deadline - Date.now() + (opts.client.getUserInputWaitMs?.() ?? 0) - inputWaitAtStart;
   const agentEventMapper = opts.onAgentEvent ? createCodexAgentEventMapper({
     messageId: opts.messageId ?? `codex_${turnId ?? Date.now()}`,
     emit: opts.onAgentEvent,
@@ -111720,12 +111813,10 @@ async function openTurnAndStream(opts) {
     ...opts.parentTurnId || opts.rootTurnId ? { requestedProvenance: { ...opts.parentTurnId ? { parentTurnId: opts.parentTurnId } : {}, ...opts.rootTurnId ? { rootTurnId: opts.rootTurnId } : {} } } : {}
   }) : null;
   agentEventMapper?.start(opts.threadId);
-  while (!opts.signal.aborted && remaining() > 0) {
+  while (!opts.signal.aborted) {
     let note;
     try {
-      note = await opts.client.nextNotification(
-        Math.min(5e3, Math.max(0, remaining()))
-      );
+      note = await opts.client.nextNotification(5e3);
     } catch (err) {
       const error51 = err instanceof Error ? err : new Error(String(err));
       agentEventMapper?.fail(error51.message, /interrupt|abort/i.test(error51.message));
@@ -111768,20 +111859,14 @@ async function openTurnAndStream(opts) {
       return { finalText, threadId: opts.threadId, turnId };
     }
   }
-  if (opts.signal.aborted) {
-    agentEventMapper?.fail("Codex turn interrupted", true);
-    throw new Error("Codex turn interrupted");
-  }
-  agentEventMapper?.fail("Codex turn timed out waiting for turn/completed");
-  throw new Error("Codex turn timed out waiting for turn/completed");
+  agentEventMapper?.fail("Codex turn interrupted", true);
+  throw new Error("Codex turn interrupted");
 }
-var TURN_WAIT_TIMEOUT_MS2;
 var init_codex_live_turn = __esm({
   "src/session/codex-live-turn.ts"() {
     "use strict";
     init_protocol_v162();
     init_src4();
-    TURN_WAIT_TIMEOUT_MS2 = 3e5;
   }
 });
 
@@ -127623,6 +127708,7 @@ init_environment();
 
 // ../../packages/shared/src/environment/session-operations.ts
 var SESSION_OPERATION_METHODS = /* @__PURE__ */ new Set([
+  "session.answerAsyncQuestion",
   "session.dequeue",
   "session.steer",
   "session.reportWorktreeRemoved",
@@ -127684,6 +127770,13 @@ async function callOperation(payload, ctx, method) {
   const p4 = asRecord(payload);
   try {
     const sessionId = requiredText(p4, "sessionId");
+    if (method === "session.answerAsyncQuestion") {
+      requiredText(p4, "messageId");
+      requiredText(p4, "itemId");
+      if (!Array.isArray(p4.answers) || p4.answers.some((answer) => typeof answer !== "string")) {
+        throw Object.assign(new Error("answers must be a string array"), { code: "invalid_argument" });
+      }
+    }
     if (method === "session.dequeue" || method === "session.steer") requiredText(p4, "clientMessageId");
     if (method === "session.rewind" || method === "session.previewRewind" || method === "session.truncateAtCheckpoint") requiredText(p4, "checkpointId");
     if (method === "session.mcpAuthenticate") requiredText(p4, "serverName");
@@ -128518,14 +128611,14 @@ async function cloneRepository(input, onProgress) {
       }
     });
     let stderrTail = "";
-    let pending3 = "";
+    let pending4 = "";
     let lastPercent = -1;
     child.stderr.setEncoding("utf8");
     child.stderr.on("data", (chunk) => {
       stderrTail = (stderrTail + chunk).slice(-STDERR_TAIL_CHARS);
       if (!onProgress) return;
-      const lines2 = (pending3 + chunk).split(/\r|\n/);
-      pending3 = lines2.pop() ?? "";
+      const lines2 = (pending4 + chunk).split(/\r|\n/);
+      pending4 = lines2.pop() ?? "";
       for (const line of lines2) {
         const percent = parseCloneProgress(line);
         if (percent !== null && percent > lastPercent) {
@@ -130571,10 +130664,10 @@ init_environment();
 // ../../packages/shared/src/environment/draft-content.ts
 function hasPersistableDraftContent(draft) {
   if (draft.text.trim() || draft.attachments?.length) return true;
-  const pending3 = [draft.docJson];
+  const pending4 = [draft.docJson];
   const seen = /* @__PURE__ */ new Set();
-  while (pending3.length) {
-    const node = pending3.pop();
+  while (pending4.length) {
+    const node = pending4.pop();
     if (!node || typeof node !== "object") continue;
     if (seen.has(node)) continue;
     seen.add(node);
@@ -130582,7 +130675,7 @@ function hasPersistableDraftContent(draft) {
     if (type === "text" && typeof text4 === "string" && text4.trim()) return true;
     const value = type === "pasteChip" ? attrs?.text : type === "mention" ? attrs?.value : null;
     if (typeof value === "string" && value.trim()) return true;
-    if (Array.isArray(content)) pending3.push(...content);
+    if (Array.isArray(content)) pending4.push(...content);
   }
   return false;
 }
@@ -130615,15 +130708,15 @@ function openTerminalStream(opts) {
 }
 function openDraftStream(opts) {
   let following = false;
-  const pending3 = /* @__PURE__ */ new Map();
+  const pending4 = /* @__PURE__ */ new Map();
   const cancel = (draftId) => {
-    clearTimeout(pending3.get(draftId)?.timer);
-    pending3.delete(draftId);
+    clearTimeout(pending4.get(draftId)?.timer);
+    pending4.delete(draftId);
   };
   const send = (event) => opts.push(event.draft ? { ...event, draft: withoutDraftAttachmentBytes(event.draft) } : event);
   const setTopics = (topics) => {
     following = topics.some((topic2) => topic2.kind === "drafts" && topic2.environmentId === opts.environmentId);
-    if (!following) for (const draftId of [...pending3.keys()]) cancel(draftId);
+    if (!following) for (const draftId of [...pending4.keys()]) cancel(draftId);
   };
   setTopics(opts.topics);
   const off = opts.source.watch((event) => {
@@ -130633,23 +130726,23 @@ function openDraftStream(opts) {
       send(event);
       return;
     }
-    const queued = pending3.get(event.draftId);
+    const queued = pending4.get(event.draftId);
     if (queued) {
       queued.event = event;
       return;
     }
     const timer = setTimeout(() => {
-      const latest = pending3.get(event.draftId);
-      pending3.delete(event.draftId);
+      const latest = pending4.get(event.draftId);
+      pending4.delete(event.draftId);
       if (latest) send(latest.event);
     }, DRAFT_SAVE_INTERVAL_MS);
-    pending3.set(event.draftId, { event, timer });
+    pending4.set(event.draftId, { event, timer });
   });
   return {
     setTopics,
     close: () => {
       off();
-      for (const draftId of [...pending3.keys()]) cancel(draftId);
+      for (const draftId of [...pending4.keys()]) cancel(draftId);
     }
   };
 }
@@ -144534,32 +144627,32 @@ function sidebarStatus(status2) {
   if (status2 === "streaming" || status2 === "background" || status2 === "error") return status2;
   return "idle";
 }
-function pendingAgentEvents(pending3) {
-  if (!pending3) return [];
-  if (pending3.kind === "question") return [questionEvent(pending3)];
-  if (pending3.kind === "plan") return [planEvent(pending3)];
-  return [permissionEvent(pending3)];
+function pendingAgentEvents(pending4) {
+  if (!pending4) return [];
+  if (pending4.kind === "question") return [questionEvent(pending4)];
+  if (pending4.kind === "plan") return [planEvent(pending4)];
+  return [permissionEvent(pending4)];
 }
-function permissionEvent(pending3) {
-  const confirm = pending3.requestKind === "session_agents_confirm" || pending3.kind === "session_agents_confirm";
+function permissionEvent(pending4) {
+  const confirm = pending4.requestKind === "session_agents_confirm" || pending4.kind === "session_agents_confirm";
   return {
     type: "permission_request",
     request: {
-      requestId: pending3.interactionId,
-      toolName: pending3.toolName ?? "",
-      ...pending3.toolUseId ? { toolUseId: pending3.toolUseId } : {},
-      input: pending3.input ?? {},
-      allowAlwaysAllow: pending3.allowAlwaysAllow === true,
-      ...pending3.message ? { message: pending3.message } : {},
+      requestId: pending4.interactionId,
+      toolName: pending4.toolName ?? "",
+      ...pending4.toolUseId ? { toolUseId: pending4.toolUseId } : {},
+      input: pending4.input ?? {},
+      allowAlwaysAllow: pending4.allowAlwaysAllow === true,
+      ...pending4.message ? { message: pending4.message } : {},
       ...confirm ? {
         requestKind: "session_agents_confirm",
-        ...pending3.sessionAgentsConfirm ? { sessionAgentsConfirm: pending3.sessionAgentsConfirm } : {}
+        ...pending4.sessionAgentsConfirm ? { sessionAgentsConfirm: pending4.sessionAgentsConfirm } : {}
       } : {}
     }
   };
 }
-function questionEvent(pending3) {
-  const raw2 = pending3.input?.questions;
+function questionEvent(pending4) {
+  const raw2 = pending4.input?.questions;
   const questions = Array.isArray(raw2) ? raw2.flatMap((item) => {
     if (!item || typeof item !== "object") return [];
     const row2 = item;
@@ -144577,11 +144670,11 @@ function questionEvent(pending3) {
       multiSelect: row2.multiSelect === true
     }];
   }) : [];
-  return { type: "ask_user_question", request: { requestId: pending3.interactionId, questions } };
+  return { type: "ask_user_question", request: { requestId: pending4.interactionId, questions } };
 }
-function planEvent(pending3) {
-  const input = pending3.input ?? {};
-  const planContent2 = typeof input.plan === "string" ? input.plan : typeof input.planContent === "string" ? input.planContent : pending3.message ?? "";
+function planEvent(pending4) {
+  const input = pending4.input ?? {};
+  const planContent2 = typeof input.plan === "string" ? input.plan : typeof input.planContent === "string" ? input.planContent : pending4.message ?? "";
   const planFilePath = typeof input.planFilePath === "string" ? input.planFilePath : "";
   const allowedPrompts = Array.isArray(input.allowedPrompts) ? input.allowedPrompts.flatMap((item) => {
     if (!item || typeof item !== "object") return [];
@@ -144589,7 +144682,7 @@ function planEvent(pending3) {
     if (typeof row2.tool !== "string" || typeof row2.prompt !== "string") return [];
     return [{ tool: row2.tool, prompt: row2.prompt }];
   }) : [];
-  return { type: "plan_approval", request: { requestId: pending3.interactionId, planContent: planContent2, planFilePath, allowedPrompts } };
+  return { type: "plan_approval", request: { requestId: pending4.interactionId, planContent: planContent2, planFilePath, allowedPrompts } };
 }
 
 // src/runtime.ts
@@ -145967,7 +146060,7 @@ async function dispatchSuggestedTaskRpc(method, payload, ctx) {
   }
 }
 
-// ../../node_modules/@toon-format/toon/dist/index.mjs
+// node_modules/@toon-format/toon/dist/index.mjs
 var NULL_LITERAL = "null";
 var DELIMITERS = {
   comma: ",",
@@ -145993,13 +146086,29 @@ function setOwnProperty(target2, key3, value) {
   }
   target2[key3] = value;
 }
+var COMMENT_LINE_PATTERN = new RegExp(`(?:^\uFEFF?|\\n) *#`);
+var RawString = class {
+  constructor(value) {
+    if (COMMENT_LINE_PATTERN.test(value)) throw new TypeError(`Raw string must not contain a line starting with "#": ${JSON.stringify(value)}`);
+    this.value = value;
+  }
+};
+function isRawString(value) {
+  return value instanceof RawString;
+}
+var SURROGATE_PATTERN = /[\uD800-\uDFFF]/;
 function normalizeValue(value) {
   if (value === null) return null;
+  if (isRawString(value)) return value;
   if (typeof value === "object" && value !== null && "toJSON" in value && typeof value.toJSON === "function") {
     const next = value.toJSON();
     if (next !== value) return normalizeValue(next);
   }
-  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    assertNoLoneSurrogate(value, "string value");
+    return value;
+  }
+  if (typeof value === "boolean") return value;
   if (typeof value === "number") {
     if (Object.is(value, -0)) return 0;
     if (!Number.isFinite(value)) return null;
@@ -146015,19 +146124,39 @@ function normalizeValue(value) {
   if (value instanceof Map) return Object.fromEntries(Array.from(value, ([k5, v4]) => [String(k5), normalizeValue(v4)]));
   if (isPlainObject2(value)) {
     const encodedValues = {};
-    for (const key3 in value) if (Object.hasOwn(value, key3)) setOwnProperty(encodedValues, key3, normalizeValue(value[key3]));
+    for (const key3 in value) if (Object.hasOwn(value, key3)) {
+      assertNoLoneSurrogate(key3, "object key");
+      setOwnProperty(encodedValues, key3, normalizeValue(value[key3]));
+    }
     return encodedValues;
   }
   return null;
 }
+function assertNoLoneSurrogate(value, context) {
+  if (!SURROGATE_PATTERN.test(value)) return;
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code < 55296 || code > 57343) continue;
+    const isHighSurrogate = code <= 56319;
+    const next = value.charCodeAt(index + 1);
+    if (isHighSurrogate && next >= 56320 && next <= 57343) {
+      index++;
+      continue;
+    }
+    throw new TypeError(`Cannot encode ${context} containing an unpaired surrogate U+${code.toString(16).toUpperCase()} at index ${index}`);
+  }
+}
 function isJsonPrimitive(value) {
   return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
 }
+function isEncodablePrimitive(value) {
+  return isJsonPrimitive(value) || isRawString(value);
+}
 function isJsonArray(value) {
   return Array.isArray(value);
 }
 function isJsonObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+  return value !== null && typeof value === "object" && !Array.isArray(value) && !isRawString(value);
 }
 function isEmptyObject(value) {
   return Object.keys(value).length === 0;
@@ -146038,7 +146167,7 @@ function isPlainObject2(value) {
   return prototype === null || prototype === Object.prototype;
 }
 function isArrayOfPrimitives(value) {
-  return value.length === 0 || value.every((item) => isJsonPrimitive(item));
+  return value.length === 0 || value.every((item) => isEncodablePrimitive(item));
 }
 function isArrayOfArrays(value) {
   return value.length === 0 || value.every((item) => isJsonArray(item));
@@ -146046,17 +146175,16 @@ function isArrayOfArrays(value) {
 function isArrayOfObjects(value) {
   return value.length === 0 || value.every((item) => isJsonObject(item));
 }
-var NUMERIC_LIKE_PATTERN = /^-?\d+(?:\.\d+)?(?:e[+-]?\d+)?$/i;
-var LEADING_ZERO_PATTERN = /^0\d+$/;
+var NUMERIC_LIKE_PATTERN = /^[+-]?\d+(?:\.\d+)?(?:e[+-]?\d+)?$/i;
+function assertValidDelimiter(delimiter3) {
+  if (!Object.values(DELIMITERS).includes(delimiter3)) throw new TypeError(`Invalid delimiter ${JSON.stringify(delimiter3)}. Valid delimiters are: comma (,), tab (\\t), pipe (|)`);
+}
 function isValidUnquotedKey(key3) {
   return /^[A-Z_][\w.]*$/i.test(key3);
 }
-function isIdentifierSegment(key3) {
-  return /^[A-Z_]\w*$/i.test(key3);
-}
 function isSafeUnquoted(value, delimiter3 = DEFAULT_DELIMITER) {
   if (!value) return false;
-  if (value !== value.trim()) return false;
+  if (/^[ \t]|[ \t]$/.test(value)) return false;
   if (isBooleanOrNullLiteral(value) || isNumericLike(value)) return false;
   if (value.includes(":")) return false;
   if (value.includes('"') || value.includes("\\")) return false;
@@ -146064,55 +146192,14 @@ function isSafeUnquoted(value, delimiter3 = DEFAULT_DELIMITER) {
   if (/[\u0000-\u001F]/.test(value)) return false;
   if (value.includes(delimiter3)) return false;
   if (value.startsWith("-")) return false;
+  if (value.startsWith("#")) return false;
   return true;
 }
 function isNumericLike(value) {
-  return NUMERIC_LIKE_PATTERN.test(value) || LEADING_ZERO_PATTERN.test(value);
-}
-function tryFoldKeyChain(key3, value, siblings2, options, rootLiteralKeys, pathPrefix, flattenDepth) {
-  if (options.keyFolding !== "safe") return;
-  if (!isJsonObject(value)) return;
-  const { segments, tail, leafValue } = collectSingleKeyChain(key3, value, flattenDepth ?? options.flattenDepth);
-  if (segments.length < 2) return;
-  if (!segments.every((seg) => isIdentifierSegment(seg))) return;
-  const foldedKey = buildFoldedKey(segments);
-  const absolutePath2 = pathPrefix ? `${pathPrefix}.${foldedKey}` : foldedKey;
-  if (siblings2.includes(foldedKey)) return;
-  if (rootLiteralKeys && rootLiteralKeys.has(absolutePath2)) return;
-  return {
-    foldedKey,
-    remainder: tail,
-    leafValue,
-    segmentCount: segments.length
-  };
-}
-function collectSingleKeyChain(startKey, startValue, maxDepth) {
-  const segments = [startKey];
-  let currentValue = startValue;
-  while (segments.length < maxDepth) {
-    if (!isJsonObject(currentValue)) break;
-    const keys = Object.keys(currentValue);
-    if (keys.length !== 1) break;
-    const nextKey = keys[0];
-    const nextValue = currentValue[nextKey];
-    segments.push(nextKey);
-    currentValue = nextValue;
-  }
-  if (!isJsonObject(currentValue) || isEmptyObject(currentValue)) return {
-    segments,
-    tail: void 0,
-    leafValue: currentValue
-  };
-  return {
-    segments,
-    tail: currentValue,
-    leafValue: currentValue
-  };
-}
-function buildFoldedKey(segments) {
-  return segments.join(".");
+  return NUMERIC_LIKE_PATTERN.test(value);
 }
 function encodePrimitive(value, delimiter3) {
+  if (isRawString(value)) return value.value;
   if (value === null) return NULL_LITERAL;
   if (typeof value === "boolean") return String(value);
   if (typeof value === "number") return String(value);
@@ -146135,73 +146222,114 @@ function formatHeader(length, options) {
   const delimiter3 = options?.delimiter ?? ",";
   let header = "";
   if (key3 != null) header += encodeKey(key3);
-  header += `[${length}${delimiter3 !== DEFAULT_DELIMITER ? delimiter3 : ""}]`;
-  if (fields) {
-    const quotedFields = fields.map((f4) => encodeKey(f4));
-    header += `{${quotedFields.join(delimiter3)}}`;
-  }
+  header += `[${length}${options?.keyed ? ":" : ""}${delimiter3 !== DEFAULT_DELIMITER ? delimiter3 : ""}]`;
+  if (fields) header += `{${formatFieldSegment(fields, delimiter3)}}`;
   header += ":";
   return header;
 }
+function formatFieldSegment(fields, delimiter3) {
+  return fields.map((field) => encodeKey(field.name) + (field.children ? `{${formatFieldSegment(field.children, delimiter3)}}` : "")).join(delimiter3);
+}
+function extractTabularFields(rows) {
+  if (rows.length === 0) return;
+  const firstKeys = Object.keys(rows[0]);
+  if (firstKeys.length === 0) return;
+  for (const row2 of rows) {
+    if (Object.keys(row2).length !== firstKeys.length) return;
+    for (const key3 of firstKeys) if (!Object.hasOwn(row2, key3)) return;
+  }
+  const fieldNodes = [];
+  for (const key3 of firstKeys) {
+    const fieldNode = classifyColumn(key3, rows.map((row2) => row2[key3]));
+    if (!fieldNode) return;
+    fieldNodes.push(fieldNode);
+  }
+  return fieldNodes;
+}
+function extractKeyedTabularFields(value) {
+  const entryValues = Object.values(value);
+  if (entryValues.length < 2) return;
+  if (!entryValues.every((entryValue) => isJsonObject(entryValue) && !isEmptyObject(entryValue))) return;
+  return extractTabularFields(entryValues);
+}
+function collectRowLeaves(row2, fields) {
+  const leaves = [];
+  collectLeafValues(row2, fields, leaves);
+  return leaves;
+}
+function classifyColumn(name, values) {
+  if (values.every((value) => isEncodablePrimitive(value))) return { name };
+  if (!values.every((value) => isJsonObject(value) && !isEmptyObject(value))) return;
+  const children = extractTabularFields(values);
+  if (!children) return;
+  return {
+    name,
+    children
+  };
+}
+function collectLeafValues(row2, fields, leaves) {
+  for (const field of fields) {
+    const value = row2[field.name];
+    if (field.children) collectLeafValues(value, field.children, leaves);
+    else leaves.push(value);
+  }
+}
 function* encodeJsonValue(value, options, depth) {
-  if (isJsonPrimitive(value)) {
+  if (isEncodablePrimitive(value)) {
     const encodedPrimitive = encodePrimitive(value, options.delimiter);
     if (encodedPrimitive !== "") yield encodedPrimitive;
     return;
   }
   if (isJsonArray(value)) yield* encodeArrayLines(void 0, value, depth, options);
-  else if (isJsonObject(value)) yield* encodeObjectLines(value, depth, options);
-}
-function* encodeObjectLines(value, depth, options, rootLiteralKeys, pathPrefix, remainingDepth) {
-  const keys = Object.keys(value);
-  if (depth === 0 && !rootLiteralKeys) rootLiteralKeys = new Set(keys.filter((k5) => k5.includes(".")));
-  const effectiveFlattenDepth = remainingDepth ?? options.flattenDepth;
-  for (const [key3, val] of Object.entries(value)) yield* encodeKeyValuePairLines(key3, val, depth, options, keys, rootLiteralKeys, pathPrefix, effectiveFlattenDepth);
-}
-function* encodeKeyValuePairLines(key3, value, depth, options, siblings2, rootLiteralKeys, pathPrefix, flattenDepth) {
-  const currentPath = pathPrefix ? `${pathPrefix}.${key3}` : key3;
-  const effectiveFlattenDepth = flattenDepth ?? options.flattenDepth;
-  if (options.keyFolding === "safe" && siblings2) {
-    const foldResult = tryFoldKeyChain(key3, value, siblings2, options, rootLiteralKeys, pathPrefix, effectiveFlattenDepth);
-    if (foldResult) {
-      const { foldedKey, remainder, leafValue, segmentCount } = foldResult;
-      const encodedFoldedKey = encodeKey(foldedKey);
-      if (remainder === void 0) {
-        if (isJsonPrimitive(leafValue)) {
-          yield indentedLine(depth, `${encodedFoldedKey}: ${encodePrimitive(leafValue, options.delimiter)}`, options.indent);
-          return;
-        } else if (isJsonArray(leafValue)) {
-          yield* encodeArrayLines(foldedKey, leafValue, depth, options);
-          return;
-        } else if (isJsonObject(leafValue) && isEmptyObject(leafValue)) {
-          yield indentedLine(depth, `${encodedFoldedKey}:`, options.indent);
-          return;
-        }
-      }
-      if (isJsonObject(remainder)) {
-        yield indentedLine(depth, `${encodedFoldedKey}:`, options.indent);
-        const remainingDepth = effectiveFlattenDepth - segmentCount;
-        const foldedPath = pathPrefix ? `${pathPrefix}.${foldedKey}` : foldedKey;
-        yield* encodeObjectLines(remainder, depth + 1, options, rootLiteralKeys, foldedPath, remainingDepth);
-        return;
-      }
+  else if (isJsonObject(value)) {
+    const keyedFields = extractKeyedTabularFields(value);
+    if (keyedFields) {
+      yield* encodeKeyedObjectLines(void 0, value, keyedFields, depth, options);
+      return;
     }
+    yield* encodeObjectLines(value, depth, options);
   }
+}
+function* encodeObjectLines(value, depth, options) {
+  for (const [key3, val] of Object.entries(value)) yield* encodeKeyValuePairLines(key3, val, depth, options);
+}
+function* encodeKeyValuePairLines(key3, value, depth, options) {
   const encodedKey = encodeKey(key3);
-  if (isJsonPrimitive(value)) yield indentedLine(depth, `${encodedKey}: ${encodePrimitive(value, options.delimiter)}`, options.indent);
+  if (isEncodablePrimitive(value)) yield indentedLine(depth, `${encodedKey}: ${encodePrimitive(value, options.delimiter)}`, options.indentSize);
   else if (isJsonArray(value)) yield* encodeArrayLines(key3, value, depth, options);
   else if (isJsonObject(value)) {
-    yield indentedLine(depth, `${encodedKey}:`, options.indent);
-    if (!isEmptyObject(value)) yield* encodeObjectLines(value, depth + 1, options, rootLiteralKeys, currentPath, effectiveFlattenDepth);
+    const keyedFields = extractKeyedTabularFields(value);
+    if (keyedFields) {
+      yield* encodeKeyedObjectLines(key3, value, keyedFields, depth, options);
+      return;
+    }
+    yield indentedLine(depth, `${encodedKey}:`, options.indentSize);
+    if (!isEmptyObject(value)) yield* encodeObjectLines(value, depth + 1, options);
+  }
+}
+function* encodeKeyedObjectLines(key3, value, fields, depth, options) {
+  const entries = Object.entries(value);
+  yield indentedLine(depth, formatHeader(entries.length, {
+    key: key3,
+    fields,
+    delimiter: options.delimiter,
+    keyed: true
+  }), options.indentSize);
+  yield* encodeKeyedEntryRowsLines(entries, fields, depth + 1, options);
+}
+function* encodeKeyedEntryRowsLines(entries, fields, depth, options) {
+  for (const [entryKey, entryValue] of entries) {
+    const leaves = collectRowLeaves(entryValue, fields);
+    yield indentedLine(depth, `${encodeKey(entryKey)}: ${encodeAndJoinPrimitives(leaves, options.delimiter)}`, options.indentSize);
   }
 }
 function* encodeArrayLines(key3, value, depth, options) {
   if (value.length === 0) {
-    yield indentedLine(depth, key3 != null ? `${encodeKey(key3)}: []` : "[]", options.indent);
+    yield indentedLine(depth, key3 != null ? `${encodeKey(key3)}: []` : "[]", options.indentSize);
     return;
   }
   if (isArrayOfPrimitives(value)) {
-    yield indentedLine(depth, encodeInlineArrayLine(value, options.delimiter, key3), options.indent);
+    yield indentedLine(depth, encodeInlineArrayLine(value, options.delimiter, key3), options.indentSize);
     return;
   }
   if (isArrayOfArrays(value)) {
@@ -146211,8 +146339,8 @@ function* encodeArrayLines(key3, value, depth, options) {
     }
   }
   if (isArrayOfObjects(value)) {
-    const header = extractTabularHeader(value);
-    if (header) yield* encodeArrayOfObjectsAsTabularLines(key3, value, header, depth, options);
+    const fields = extractTabularFields(value);
+    if (fields) yield* encodeArrayOfObjectsAsTabularLines(key3, value, fields, depth, options);
     else yield* encodeMixedArrayAsListItemsLines(key3, value, depth, options);
     return;
   }
@@ -146222,10 +146350,10 @@ function* encodeArrayOfArraysAsListItemsLines(prefix, values, depth, options) {
   yield indentedLine(depth, formatHeader(values.length, {
     key: prefix,
     delimiter: options.delimiter
-  }), options.indent);
+  }), options.indentSize);
   for (const arr of values) if (isArrayOfPrimitives(arr)) {
     const arrayLine = encodeInlineArrayLine(arr, options.delimiter);
-    yield indentedListItem(depth + 1, arrayLine, options.indent);
+    yield indentedListItem(depth + 1, arrayLine, options.indentSize);
   }
 }
 function encodeInlineArrayLine(values, delimiter3, prefix) {
@@ -146237,81 +146365,79 @@ function encodeInlineArrayLine(values, delimiter3, prefix) {
   if (values.length === 0) return header;
   return `${header} ${joinedValue}`;
 }
-function* encodeArrayOfObjectsAsTabularLines(prefix, rows, header, depth, options) {
+function* encodeArrayOfObjectsAsTabularLines(prefix, rows, fields, depth, options) {
   yield indentedLine(depth, formatHeader(rows.length, {
     key: prefix,
-    fields: header,
+    fields,
     delimiter: options.delimiter
-  }), options.indent);
-  yield* writeTabularRowsLines(rows, header, depth + 1, options);
+  }), options.indentSize);
+  yield* writeTabularRowsLines(rows, fields, depth + 1, options);
 }
-function extractTabularHeader(rows) {
-  if (rows.length === 0) return;
-  const firstRow = rows[0];
-  const firstKeys = Object.keys(firstRow);
-  if (firstKeys.length === 0) return;
-  if (isTabularArray(rows, firstKeys)) return firstKeys;
-}
-function isTabularArray(rows, header) {
-  for (const row2 of rows) {
-    if (Object.keys(row2).length !== header.length) return false;
-    for (const key3 of header) {
-      if (!Object.hasOwn(row2, key3)) return false;
-      if (!isJsonPrimitive(row2[key3])) return false;
-    }
-  }
-  return true;
-}
-function* writeTabularRowsLines(rows, header, depth, options) {
-  for (const row2 of rows) yield indentedLine(depth, encodeAndJoinPrimitives(header.map((key3) => row2[key3]), options.delimiter), options.indent);
+function* writeTabularRowsLines(rows, fields, depth, options) {
+  for (const row2 of rows) yield indentedLine(depth, encodeAndJoinPrimitives(collectRowLeaves(row2, fields), options.delimiter), options.indentSize);
 }
 function* encodeMixedArrayAsListItemsLines(prefix, items, depth, options) {
   yield indentedLine(depth, formatHeader(items.length, {
     key: prefix,
     delimiter: options.delimiter
-  }), options.indent);
+  }), options.indentSize);
   for (const item of items) yield* encodeListItemValueLines(item, depth + 1, options);
 }
 function* encodeObjectAsListItemLines(obj, depth, options) {
   if (isEmptyObject(obj)) {
-    yield indentedLine(depth, "-", options.indent);
+    yield indentedLine(depth, "-", options.indentSize);
     return;
   }
   const entries = Object.entries(obj);
   const [firstKey, firstValue] = entries[0];
   const restEntries = entries.slice(1);
   if (isJsonArray(firstValue) && isArrayOfObjects(firstValue)) {
-    const header = extractTabularHeader(firstValue);
-    if (header) {
+    const fields = extractTabularFields(firstValue);
+    if (fields) {
       yield indentedListItem(depth, formatHeader(firstValue.length, {
         key: firstKey,
-        fields: header,
+        fields,
         delimiter: options.delimiter
-      }), options.indent);
-      yield* writeTabularRowsLines(firstValue, header, depth + 2, options);
+      }), options.indentSize);
+      yield* writeTabularRowsLines(firstValue, fields, depth + 2, options);
+      if (restEntries.length > 0) yield* encodeObjectLines(Object.fromEntries(restEntries), depth + 1, options);
+      return;
+    }
+  }
+  if (isJsonObject(firstValue)) {
+    const keyedFields = extractKeyedTabularFields(firstValue);
+    if (keyedFields) {
+      const keyedEntries = Object.entries(firstValue);
+      yield indentedListItem(depth, formatHeader(keyedEntries.length, {
+        key: firstKey,
+        fields: keyedFields,
+        delimiter: options.delimiter,
+        keyed: true
+      }), options.indentSize);
+      yield* encodeKeyedEntryRowsLines(keyedEntries, keyedFields, depth + 2, options);
       if (restEntries.length > 0) yield* encodeObjectLines(Object.fromEntries(restEntries), depth + 1, options);
       return;
     }
   }
   const encodedKey = encodeKey(firstKey);
-  if (isJsonPrimitive(firstValue)) yield indentedListItem(depth, `${encodedKey}: ${encodePrimitive(firstValue, options.delimiter)}`, options.indent);
-  else if (isJsonArray(firstValue)) if (firstValue.length === 0) yield indentedListItem(depth, `${encodedKey}: []`, options.indent);
-  else if (isArrayOfPrimitives(firstValue)) yield indentedListItem(depth, `${encodedKey}${encodeInlineArrayLine(firstValue, options.delimiter)}`, options.indent);
+  if (isEncodablePrimitive(firstValue)) yield indentedListItem(depth, `${encodedKey}: ${encodePrimitive(firstValue, options.delimiter)}`, options.indentSize);
+  else if (isJsonArray(firstValue)) if (firstValue.length === 0) yield indentedListItem(depth, `${encodedKey}: []`, options.indentSize);
+  else if (isArrayOfPrimitives(firstValue)) yield indentedListItem(depth, `${encodedKey}${encodeInlineArrayLine(firstValue, options.delimiter)}`, options.indentSize);
   else {
-    yield indentedListItem(depth, `${encodedKey}${formatHeader(firstValue.length, { delimiter: options.delimiter })}`, options.indent);
+    yield indentedListItem(depth, `${encodedKey}${formatHeader(firstValue.length, { delimiter: options.delimiter })}`, options.indentSize);
     for (const item of firstValue) yield* encodeListItemValueLines(item, depth + 2, options);
   }
   else if (isJsonObject(firstValue)) {
-    yield indentedListItem(depth, `${encodedKey}:`, options.indent);
+    yield indentedListItem(depth, `${encodedKey}:`, options.indentSize);
     if (!isEmptyObject(firstValue)) yield* encodeObjectLines(firstValue, depth + 2, options);
   }
   if (restEntries.length > 0) yield* encodeObjectLines(Object.fromEntries(restEntries), depth + 1, options);
 }
 function* encodeListItemValueLines(value, depth, options) {
-  if (isJsonPrimitive(value)) yield indentedListItem(depth, encodePrimitive(value, options.delimiter), options.indent);
-  else if (isJsonArray(value)) if (isArrayOfPrimitives(value)) yield indentedListItem(depth, encodeInlineArrayLine(value, options.delimiter), options.indent);
+  if (isEncodablePrimitive(value)) yield indentedListItem(depth, encodePrimitive(value, options.delimiter), options.indentSize);
+  else if (isJsonArray(value)) if (isArrayOfPrimitives(value)) yield indentedListItem(depth, encodeInlineArrayLine(value, options.delimiter), options.indentSize);
   else {
-    yield indentedListItem(depth, formatHeader(value.length, { delimiter: options.delimiter }), options.indent);
+    yield indentedListItem(depth, formatHeader(value.length, { delimiter: options.delimiter }), options.indentSize);
     for (const item of value) yield* encodeListItemValueLines(item, depth + 1, options);
   }
   else if (isJsonObject(value)) yield* encodeObjectAsListItemLines(value, depth, options);
@@ -146325,7 +146451,11 @@ function indentedListItem(depth, content, indentSize) {
 function applyReplacer(root2, replacer) {
   const replacedRoot = replacer("", root2, []);
   if (replacedRoot === void 0) return transformChildren(root2, replacer, []);
-  return transformChildren(normalizeValue(replacedRoot), replacer, []);
+  return transformReplaced(root2, replacedRoot, replacer, []);
+}
+function transformReplaced(original, replaced, replacer, path) {
+  if (isRawString(replaced) && !isEncodablePrimitive(original)) return transformChildren(original, replacer, path);
+  return transformChildren(normalizeValue(replaced), replacer, path);
 }
 function transformChildren(value, replacer, path) {
   if (isJsonObject(value)) return transformObject(value, replacer, path);
@@ -146338,7 +146468,7 @@ function transformObject(obj, replacer, path) {
     const childPath = [...path, key3];
     const replacedValue = replacer(key3, value, childPath);
     if (replacedValue === void 0) continue;
-    setOwnProperty(result3, key3, transformChildren(normalizeValue(replacedValue), replacer, childPath));
+    setOwnProperty(result3, key3, transformReplaced(value, replacedValue, replacer, childPath));
   }
   return result3;
 }
@@ -146349,8 +146479,7 @@ function transformArray(arr, replacer, path) {
     const childPath = [...path, i2];
     const replacedValue = replacer(String(i2), value, childPath);
     if (replacedValue === void 0) continue;
-    const normalizedValue = normalizeValue(replacedValue);
-    result3.push(transformChildren(normalizedValue, replacer, childPath));
+    result3.push(transformReplaced(value, replacedValue, replacer, childPath));
   }
   return result3;
 }
@@ -146363,11 +146492,11 @@ function encodeLines(input, options) {
   return encodeJsonValue(resolvedOptions.replacer ? applyReplacer(normalizedValue, resolvedOptions.replacer) : normalizedValue, resolvedOptions, 0);
 }
 function resolveOptions(options) {
+  const delimiter3 = options?.delimiter ?? DEFAULT_DELIMITER;
+  assertValidDelimiter(delimiter3);
   return {
-    indent: options?.indent ?? 2,
-    delimiter: options?.delimiter ?? DEFAULT_DELIMITER,
-    keyFolding: options?.keyFolding ?? "off",
-    flattenDepth: options?.flattenDepth ?? Number.POSITIVE_INFINITY,
+    indentSize: options?.indentSize ?? options?.indent ?? 2,
+    delimiter: delimiter3,
     replacer: options?.replacer
   };
 }
@@ -147478,14 +147607,14 @@ async function startMcpOauth(client3, login) {
   return { loginId, authorizationUrl: first };
 }
 async function completeMcpOauth(client3, loginId, callbackUrl) {
-  const pending3 = pendingMcpOauth.get(loginId);
-  if (!pending3 || pending3.clientSessionId !== client3.clientSessionId) {
+  const pending4 = pendingMcpOauth.get(loginId);
+  if (!pending4 || pending4.clientSessionId !== client3.clientSessionId) {
     throw Object.assign(new Error("MCP sign-in not found"), { code: "not_found" });
   }
   if (callbackUrl) {
     let callback;
     try {
-      callback = validateLoopbackOAuthCallback(pending3.authorizationUrl, callbackUrl);
+      callback = validateLoopbackOAuthCallback(pending4.authorizationUrl, callbackUrl);
     } catch (err) {
       invalid10(err.message);
     }
@@ -147493,7 +147622,7 @@ async function completeMcpOauth(client3, loginId, callbackUrl) {
     await response.body?.cancel();
   }
   try {
-    return await pending3.result;
+    return await pending4.result;
   } finally {
     pendingMcpOauth.delete(loginId);
   }
@@ -147990,8 +148119,8 @@ function claudeCatalogFor(ctx, apiProviderId, cwd) {
   if (ctx.probeModels) return null;
   if (ctx.probeClaudeCatalog) {
     const probe = ctx.probeClaudeCatalog;
-    let pending4 = null;
-    return () => pending4 ??= probe(cwd);
+    let pending5 = null;
+    return () => pending5 ??= probe(cwd);
   }
   const binaryPath = resolveClaudeBinaryPath({ harnesses: ctx.harnesses });
   if (!binaryPath) {
@@ -148000,8 +148129,8 @@ function claudeCatalogFor(ctx, apiProviderId, cwd) {
     );
     return async () => EMPTY_CLAUDE_CATALOG;
   }
-  let pending3 = null;
-  return () => pending3 ??= getNodeClaudeCatalog({
+  let pending4 = null;
+  return () => pending4 ??= getNodeClaudeCatalog({
     cwd,
     binaryPath,
     env: claudeAccountProbeEnv(apiProviderId),
@@ -152480,7 +152609,7 @@ function suggestedTaskToolResult(raw2) {
 
 // src/session/suggested-task.ts
 var exec = promisify2(execFile6);
-function pending2(ctx, sessionId, taskId) {
+function pending3(ctx, sessionId, taskId) {
   const parent = ctx.deps.sessions.get(sessionId);
   if (!parent || parent.closed) throw new CollaborationError("This session is no longer available.", "not_found");
   const found = findSuggestedTask(ctx.deps.sessions.messages(sessionId), taskId);
@@ -152495,7 +152624,7 @@ function suggestTask(ctx, sessionId, args) {
   return suggestedTaskToolResult(args);
 }
 async function suggestedTaskOptions(ctx, sessionId, taskId) {
-  const { parent } = pending2(ctx, sessionId, taskId);
+  const { parent } = pending3(ctx, sessionId, taskId);
   const profiles = ctx.listProfiles();
   if (profiles.some((profile2) => profile2.harnessId === "claude")) {
     const { getNodeClaudeModelCatalog: getNodeClaudeModelCatalog2 } = await Promise.resolve().then(() => (init_claude_model_catalog(), claude_model_catalog_exports));
@@ -152530,7 +152659,7 @@ async function taskLocation(ctx, projectId, cwd, input, taskId, assertControl2)
 }
 async function launchNodeSuggestedTask(ctx, sessionId, taskId, choice, assertControl2, controllerClientSessionId) {
   assertControl2();
-  const { parent, input } = pending2(ctx, sessionId, taskId);
+  const { parent, input } = pending3(ctx, sessionId, taskId);
   const launchId = `suggested-task-${taskId}`;
   if (!ctx.store.grantForLaunch(sessionId, launchId)?.started_at) {
     const { profiles, initial } = await suggestedTaskOptions(ctx, sessionId, taskId);
@@ -166886,6 +167015,7 @@ function withSessionZone(runner, syncRoot) {
   wrapped.disposeSession = runner.disposeSession;
   wrapped.disposeAll = runner.disposeAll;
   wrapped.listActiveRuntimes = runner.listActiveRuntimes;
+  wrapped.codexVoice = runner.codexVoice;
   return wrapped;
 }