@zixt/host 0.0.38 → 0.0.39

package/dist/index.js

@@ -31,7 +31,7 @@ import { homedir } from "node:os";
 // package.json
 var package_default = {
   name: "@zixt/host",
-  version: "0.0.38",
+  version: "0.0.39",
   type: "module",
   exports: {
     ".": "./src/client.ts",
@@ -15299,6 +15299,8 @@ var HostTelemetry = external_exports.object({
      * legacy Hosts must receive the original strict refusal frame.
      */
     providerOperationGrantRetry: external_exports.literal(true).optional(),
+    /** Accepts durable human follow-ups for an active runner turn. */
+    liveRunnerInput: external_exports.literal(true).optional(),
     linearToolPack: external_exports.boolean().default(false),
     providerToolPacks: external_exports.array(ProviderToolPackCapability).max(20).superRefine((capabilities, ctx) => {
       const providers = capabilities.map(({ provider }) => provider);
@@ -15866,6 +15868,8 @@ var Task = external_exports.object({
   /** Follow-ups accepted but not yet folded into a run; the thread renders
    * exactly this many trailing prompts as queued rather than answered. */
   pendingMessageCount: external_exports.number().int().min(0).default(0),
+  /** Delivery state for each trailing pending prompt, in transcript order. */
+  pendingMessageStates: external_exports.array(external_exports.enum(["queued", "sending", "sent"])).default([]),
   /** Present after cancellation; absent on legacy/non-cancelled tasks. */
   cancellation: TaskCancellation.nullable().default(null),
   /**
@@ -17292,9 +17296,17 @@ var BrowserCommandFrame = external_exports.object({
   browserSessionId: external_exports.string().min(1).max(200),
   command: BrowserCommand
 });
+var TaskInput = external_exports.object({
+  type: external_exports.literal("task.input"),
+  taskId: TaskId,
+  epoch: external_exports.number().int().min(1),
+  inputId: external_exports.uuid(),
+  text: external_exports.string().min(1).max(1e5)
+});
 var DurableDownMessage = external_exports.discriminatedUnion("type", [
   TaskAssign,
   TaskCancel,
+  TaskInput,
   SecretsGrant,
   ApprovalDecision,
   ConnectionsGrant
@@ -17338,6 +17350,13 @@ var TaskTitle = external_exports.object({
   epoch: external_exports.number().int().min(1),
   title: external_exports.string().min(1).max(300)
 });
+var TaskInputResult = external_exports.object({
+  type: external_exports.literal("task.input.result"),
+  taskId: TaskId,
+  epoch: external_exports.number().int().min(1),
+  inputId: external_exports.uuid(),
+  accepted: external_exports.boolean()
+});
 var TaskResult = external_exports.object({
   type: external_exports.literal("task.result"),
   taskId: TaskId,
@@ -17365,7 +17384,9 @@ var TaskResult = external_exports.object({
       detail: external_exports.string().max(1e4).optional(),
       evidenceClass: external_exports.enum(["agent_claimed", "host_observed"])
     })
-  ).max(200).optional()
+  ).max(200).optional(),
+  /** Inputs the provider accepted into this exact run before it completed. */
+  acceptedInputIds: external_exports.array(external_exports.uuid()).max(1e3).optional()
 });
 var DurableTaskResult = TaskResult.extend({ resultId: external_exports.uuid() });
 var HostReport = external_exports.object({
@@ -17427,6 +17448,7 @@ var UpMessage = external_exports.discriminatedUnion("type", [
   TaskWorkingContextReport,
   TaskRunnerRuntimeReport,
   TaskTitle,
+  TaskInputResult,
   TaskResult,
   HostReport,
   HostConsoleReport,
@@ -19796,6 +19818,10 @@ var HostClient = class _HostClient {
   onUnwindStalled;
   /** Exact identity for each active run; unlike model output this is safe to acknowledge. */
   activeAssignments = /* @__PURE__ */ new Map();
+  liveInputHandlers = /* @__PURE__ */ new Map();
+  liveInputBacklog = /* @__PURE__ */ new Map();
+  liveInputInFlight = /* @__PURE__ */ new Map();
+  acceptedLiveInputIds = /* @__PURE__ */ new Map();
   /**
    * Connection-loss runs confirmed stopped locally but not yet acknowledged
    * by a new cloud socket generation. Replayed only inside hello.
@@ -20311,6 +20337,11 @@ var HostClient = class _HostClient {
           label: safe(fact.label, 2e3),
           ...fact.detail !== void 0 ? { detail: safe(fact.detail, 1e4) } : {}
         }))
+      } : {},
+      ...this.acceptedLiveInputIds.get(`${assign.taskId}:${assign.epoch}`)?.size ? {
+        acceptedInputIds: [
+          ...this.acceptedLiveInputIds.get(`${assign.taskId}:${assign.epoch}`)
+        ]
       } : {}
     };
   }
@@ -20561,6 +20592,7 @@ var HostClient = class _HostClient {
           ...measuredCapabilities,
           linearToolPack: measured.capabilities?.linearToolPack ?? false,
           providerOperationGrantRetry: true,
+          liveRunnerInput: true,
           hostConsole: true,
           ...workerWatchdogIsActive() ? { taskAuthorityLifecycle: true } : {}
         },
@@ -20604,6 +20636,9 @@ var HostClient = class _HostClient {
           message.purpose === "credential_rollover" ? "credential_rollover" : "cloud_cancel"
         );
         return;
+      case "task.input":
+        this.queueLiveInput(message);
+        return;
       case "secrets.grant": {
         const key = `${message.taskId}:${message.epoch}`;
         if (!this.cancels.has(key)) return;
@@ -20667,6 +20702,51 @@ var HostClient = class _HostClient {
       }
     }
   }
+  sendLiveInputResult(input, accepted) {
+    this.sendUp({
+      type: "task.input.result",
+      taskId: input.taskId,
+      epoch: input.epoch,
+      inputId: input.inputId,
+      accepted
+    });
+  }
+  deliverLiveInput(key, input) {
+    const accepted = this.acceptedLiveInputIds.get(key);
+    if (accepted?.has(input.inputId)) {
+      this.sendLiveInputResult(input, true);
+      return;
+    }
+    const inFlight = this.liveInputInFlight.get(key) ?? /* @__PURE__ */ new Set();
+    if (inFlight.has(input.inputId)) return;
+    const handler5 = this.liveInputHandlers.get(key);
+    if (!handler5) {
+      const backlog = this.liveInputBacklog.get(key) ?? [];
+      if (!backlog.some((candidate) => candidate.inputId === input.inputId)) backlog.push(input);
+      this.liveInputBacklog.set(key, backlog);
+      return;
+    }
+    inFlight.add(input.inputId);
+    this.liveInputInFlight.set(key, inFlight);
+    void handler5({ inputId: input.inputId, text: input.text }).then((wasAccepted) => {
+      if (wasAccepted) {
+        const acceptedIds = this.acceptedLiveInputIds.get(key) ?? /* @__PURE__ */ new Set();
+        acceptedIds.add(input.inputId);
+        this.acceptedLiveInputIds.set(key, acceptedIds);
+      }
+      this.sendLiveInputResult(input, wasAccepted);
+    }).catch(() => this.sendLiveInputResult(input, false)).finally(() => {
+      this.liveInputInFlight.get(key)?.delete(input.inputId);
+    });
+  }
+  queueLiveInput(input) {
+    const key = `${input.taskId}:${input.epoch}`;
+    if (!this.cancels.has(key)) {
+      this.sendLiveInputResult(input, false);
+      return;
+    }
+    this.deliverLiveInput(key, input);
+  }
   startTask(assign) {
     const key = `${assign.taskId}:${assign.epoch}`;
     if (this.activeRuns.has(key)) return;
@@ -21217,6 +21297,19 @@ var HostClient = class _HostClient {
         runnerRuntime: emitRunnerRuntime,
         siblingTasks: () => [...this.liveTasks.values()].filter((live) => live.agentId === assign.agentId && live.taskId !== assign.taskId).map(({ taskId, title }) => ({ taskId, title })),
         fetchAttachment: (attachmentId) => this.fetchAttachment(attachmentId, authorityController.signal),
+        followUps: (handler5) => {
+          if (cancelled) return () => {
+          };
+          this.liveInputHandlers.set(cancelKey, handler5);
+          const backlog = this.liveInputBacklog.get(cancelKey) ?? [];
+          this.liveInputBacklog.delete(cancelKey);
+          for (const input of backlog) this.deliverLiveInput(cancelKey, input);
+          return () => {
+            if (this.liveInputHandlers.get(cancelKey) === handler5) {
+              this.liveInputHandlers.delete(cancelKey);
+            }
+          };
+        },
         secrets,
         connections,
         providers,
@@ -21294,6 +21387,13 @@ var HostClient = class _HostClient {
       this.agentOpWaiters.delete(cancelKey);
       this.rejectOperationGrantWaiters(cancelKey);
       this.rejectBrowserCredentialWaiters(cancelKey);
+      this.liveInputHandlers.delete(cancelKey);
+      for (const input of this.liveInputBacklog.get(cancelKey) ?? []) {
+        this.sendLiveInputResult(input, false);
+      }
+      this.liveInputBacklog.delete(cancelKey);
+      this.liveInputInFlight.delete(cancelKey);
+      this.acceptedLiveInputIds.delete(cancelKey);
       sensitiveValues?.clear();
       sensitiveValues = null;
       if (stopReason === "cloud_cancel") {
@@ -33108,6 +33208,7 @@ let expectedBytes = null;
 let config = null;
 let launchPending = false;
 let stderrTail = '';
+let postReleaseInput = Buffer.alloc(0);
 let reported = false;
 const report = (result) => {
   if (reported) return;
@@ -33125,7 +33226,6 @@ prelaunchTimeout.unref();
 
 const launchTarget = (release) => {
   try {
-    config = release;
     const command = config.comspec || config.command;
     const args = config.comspec
       ? ['/d', '/s', '/c', '"' + [config.command, ...config.args].map(quote).join(' ') + '"']
@@ -33172,11 +33272,16 @@ const launchTarget = (release) => {
     maybeReport();
   });
   if (config.prompt) target.stdin.write(config.prompt);
+  if (postReleaseInput.length) {
+    target.stdin.write(postReleaseInput);
+    postReleaseInput = Buffer.alloc(0);
+  }
   if (stdinEnded) target.stdin.end();
 };
 
 const launch = (release) => {
   clearTimeout(prelaunchTimeout);
+  config = release;
   launchPending = true;
   if (process.platform === 'win32') {
     launchTarget(release);
@@ -33211,6 +33316,11 @@ process.stdin.on('data', (chunk) => {
     target.stdin.write(chunk);
     return;
   }
+  if (config) {
+    postReleaseInput = Buffer.concat([postReleaseInput, chunk]);
+    if (postReleaseInput.length > maxReleaseBytes) process.exit(1);
+    return;
+  }
   pending = Buffer.concat([pending, chunk]);
   if (pending.length > maxReleaseBytes + 256) process.exit(1);
   if (!containmentReady) {
@@ -33232,9 +33342,9 @@ process.stdin.on('data', (chunk) => {
     pending = pending.subarray(newline + 1);
   }
   if (pending.length < expectedBytes) return;
-  if (pending.length !== expectedBytes) process.exit(1);
   try {
-    const release = JSON.parse(pending.toString('utf8'));
+    const release = JSON.parse(pending.subarray(0, expectedBytes).toString('utf8'));
+    postReleaseInput = pending.subarray(expectedBytes);
     pending = Buffer.alloc(0);
     launch(release);
   } catch {
@@ -34038,7 +34148,8 @@ function createCliRunner(adapter, opts = {}) {
         cwd,
         command: resolvedCommand,
         commandPrefixArgs: prefixArgs,
-        env
+        env,
+        liveInput: opts.liveInput ?? opts.command === void 0
       });
       const runEnv = prepared.env ? { ...env, ...prepared.env } : env;
       let attachmentSection = "";
@@ -34227,7 +34338,8 @@ ${attachmentSection}` : prompt;
               ...detail.ephemeral === void 0 ? {} : { ephemeral: detail.ephemeral }
             });
           },
-          createParser: prepared.createParser,
+          createParser: (onStream) => prepared.createParser(onStream, mode2),
+          ...task.followUps ? { registerFollowUps: task.followUps } : {},
           notFoundMessage: adapter.notFoundMessage,
           cliLabel: adapter.type,
           // Durable evidence for the next Host process: which assignment this
@@ -34564,6 +34676,8 @@ function runCliProcess(options) {
       detached: platform !== "win32"
     });
     const parser = options.createParser(options.onStream);
+    let unregisterFollowUps;
+    const liveInputSettlements = /* @__PURE__ */ new Set();
     let stderrBuf = "";
     let settled = false;
     let terminalResult;
@@ -34592,12 +34706,15 @@ function runCliProcess(options) {
       if (settled) return;
       settled = true;
       clearInterval(timer);
+      unregisterFollowUps?.();
+      parser.stop?.();
       resolve14(result);
     };
     const terminate = (result) => {
       if (settled || forcedResult) return;
       forcedResult = result;
       clearInterval(timer);
+      child.stdin?.end();
       void containmentReady.then(async () => {
         if (windowsContainment) {
           await windowsContainment.terminate();
@@ -34613,7 +34730,12 @@ function runCliProcess(options) {
           } : {}
         });
       }).then(
-        () => settle4(result),
+        async () => {
+          unregisterFollowUps?.();
+          parser.stop?.();
+          await Promise.allSettled([...liveInputSettlements]);
+          settle4(result);
+        },
         () => settle4({
           outcome: "failed",
           summary: PROCESS_CLEANUP_FAILURE,
@@ -34768,7 +34890,7 @@ function runCliProcess(options) {
             cwd: options.cwd,
             env: options.env,
             ...options.guardian.comspec ? { comspec: options.guardian.comspec } : {},
-            prompt: options.prompt
+            prompt: parser.start ? "" : options.prompt
           }),
           "utf8"
         );
@@ -34776,9 +34898,39 @@ function runCliProcess(options) {
 `);
         child.stdin?.write(release);
       } else {
-        child.stdin?.write(options.prompt);
       }
-      child.stdin?.end();
+      if (parser.start) {
+        const write = (data) => new Promise((resolveWrite, rejectWrite) => {
+          if (!child.stdin || child.stdin.destroyed || settled || forcedResult) {
+            rejectWrite(new Error("runner input is unavailable"));
+            return;
+          }
+          child.stdin.write(data, (error52) => {
+            if (error52) rejectWrite(error52);
+            else resolveWrite();
+          });
+        });
+        try {
+          await parser.start(write, options.prompt);
+          if (parser.steer && options.registerFollowUps) {
+            unregisterFollowUps = options.registerFollowUps((input) => {
+              const settlement = parser.steer(input);
+              liveInputSettlements.add(settlement);
+              void settlement.finally(() => liveInputSettlements.delete(settlement));
+              return settlement;
+            });
+          }
+        } catch {
+          terminate({
+            outcome: "failed",
+            summary: `${options.cliLabel} input protocol could not be started`,
+            usage: parser.usage()
+          });
+        }
+      } else {
+        if (!options.guardian) child.stdin?.write(options.prompt);
+        child.stdin?.end();
+      }
     })();
   });
 }
@@ -34964,6 +35116,7 @@ var claudeCodeAdapter = {
   notFoundMessage: CLAUDE_NOT_FOUND_MESSAGE,
   missingApiKeyMessage: 'Runner auth is set to "API key" but no ANTHROPIC_API_KEY credential is granted to this task. Add it in Resources \u2192 Credentials (org-wide or scoped to this agent).',
   async prepareRun(input) {
+    const liveInput = input.liveInput && input.task.followUps !== void 0;
     const baseArgs = await buildArgs(
       input.task,
       input.runner,
@@ -34972,7 +35125,8 @@ var claudeCodeAdapter = {
       input.preparedWorkspace,
       input.taskRoot,
       input.cwd,
-      input.gitDetected
+      input.gitDetected,
+      liveInput
     );
     const sessionId = input.task.spec.sessionKey ?? randomUUID11();
     const observeRuntime = createRuntimeReporter(input, sessionId);
@@ -34983,7 +35137,7 @@ var claudeCodeAdapter = {
       ],
       prompt: buildRunnerPrompt(input.task),
       recoveryPrompt: buildRunnerPrompt(input.task, true),
-      createParser: (onStream) => createStreamParser(onStream, { onSessionModel: observeRuntime }),
+      createParser: (onStream) => liveInput ? createClaudeLiveParser(onStream, observeRuntime) : createStreamParser(onStream, { onSessionModel: observeRuntime }),
       // Self-heal both directions: a crashed first run leaves a transcript
       // (new → conflict), a lost workspace breaks resume (resume → not
       // found). One flip covers both.
@@ -35024,7 +35178,7 @@ function delay2(ms) {
     timer.unref?.();
   });
 }
-async function buildArgs(task, runner, artifacts, mcp, preparedWorkspace, taskRoot, workspacePath = taskRoot ?? "", gitDetected = false) {
+async function buildArgs(task, runner, artifacts, mcp, preparedWorkspace, taskRoot, workspacePath = taskRoot ?? "", gitDetected = false, liveInput = false) {
   const args = [
     // Hermetic, non-interactive run — no local slash commands or global state.
     "--disable-slash-commands",
@@ -35038,6 +35192,7 @@ async function buildArgs(task, runner, artifacts, mcp, preparedWorkspace, taskRo
     // guardrails via runner permission hooks are the follow-up (PRD GR-5).
     "--dangerously-skip-permissions"
   ];
+  if (liveInput) args.push("--input-format", "stream-json", "--replay-user-messages");
   if (runner.effort) args.push("--effort", runner.effort);
   if (runner.model) args.push("--model", runner.model);
   const systemPrompt = workspaceSystemPrompt(
@@ -35069,6 +35224,47 @@ async function buildArgs(task, runner, artifacts, mcp, preparedWorkspace, taskRo
   );
   return args;
 }
+function createClaudeLiveParser(onStream, onSessionModel) {
+  let write = null;
+  const acknowledgements = /* @__PURE__ */ new Map();
+  const input = (uuid3, text) => `${JSON.stringify({
+    type: "user",
+    uuid: uuid3,
+    message: { role: "user", content: text },
+    parent_tool_use_id: null
+  })}
+`;
+  const parser = createStreamParser(onStream, {
+    onSessionModel,
+    onUserReplay: (uuid3) => {
+      const acknowledge = acknowledgements.get(uuid3);
+      if (!acknowledge) return;
+      acknowledgements.delete(uuid3);
+      acknowledge(true);
+    }
+  });
+  return {
+    ...parser,
+    async start(writer, prompt) {
+      write = writer;
+      await writer(input(randomUUID11(), prompt));
+    },
+    async steer(followUp) {
+      if (!write) return false;
+      return await new Promise((resolve14) => {
+        acknowledgements.set(followUp.inputId, resolve14);
+        void write(input(followUp.inputId, followUp.text)).catch(() => {
+          if (acknowledgements.delete(followUp.inputId)) resolve14(false);
+        });
+      });
+    },
+    stop() {
+      write = null;
+      for (const acknowledge of acknowledgements.values()) acknowledge(false);
+      acknowledgements.clear();
+    }
+  };
+}
 function createStreamParser(onStream, hooks = {}) {
   let buffer = "";
   let responseText = "";
@@ -35096,6 +35292,10 @@ function createStreamParser(onStream, hooks = {}) {
     const type = json2["type"];
     if (type === "system" && json2["subtype"] === "init") {
       if (typeof json2["model"] === "string" && json2["model"]) hooks.onSessionModel?.(json2["model"]);
+    } else if (type === "user") {
+      if (json2["isReplay"] === true && typeof json2["uuid"] === "string") {
+        hooks.onUserReplay?.(json2["uuid"]);
+      }
     } else if (type === "assistant") {
       const message = json2["message"];
       applyUsage(message?.["usage"]);
@@ -35129,12 +35329,13 @@ function createStreamParser(onStream, hooks = {}) {
         const errors = Array.isArray(json2["errors"]) ? json2["errors"].filter((e) => typeof e === "string") : [];
         const base = typeof json2["result"] === "string" && json2["result"].trim() ? json2["result"] : "";
         const message = [base, ...errors].filter(Boolean).join("; ") || "Unknown error";
-        return {
+        const result2 = {
           outcome: "failed",
           summary: improveErrorMessage(message),
           usage: usage(),
           sessionConflict: isSessionConflict(errors.join(" "))
         };
+        return hooks.shouldCompleteResult?.() === false ? void 0 : result2;
       }
       const finalText = typeof json2["result"] === "string" && json2["result"].trim() ? json2["result"] : responseText;
       if (!finalText.trim() && outputTokens === 0) {
@@ -35145,7 +35346,8 @@ function createStreamParser(onStream, hooks = {}) {
           emptyResult: true
         };
       }
-      return { outcome: "done", summary: finalText, usage: usage() };
+      const result = { outcome: "done", summary: finalText, usage: usage() };
+      return hooks.shouldCompleteResult?.() === false ? void 0 : result;
     } else if (type === "error") {
       const message = typeof json2["error"] === "string" ? json2["error"] : JSON.stringify(json2);
       return {
@@ -35213,6 +35415,7 @@ function improveErrorMessage(error52) {
 
 // src/runners/codex.ts
 import { mkdir as mkdir11, readFile as readFile7, writeFile as writeFile6 } from "node:fs/promises";
+import { randomUUID as randomUUID12 } from "node:crypto";
 import { homedir as homedir6 } from "node:os";
 import { join as join16 } from "node:path";
 var CODEX_NOT_FOUND_MESSAGE = "The `codex` CLI was not found on this Machine. Install it (npm install -g @openai/codex) and sign in with `codex login`, or switch the agent to API-key auth.";
@@ -35251,20 +35454,23 @@ function createCodexAdapter(threadIndexRoot) {
     missingApiKeyMessage: 'Runner auth is set to "API key" but no OPENAI_API_KEY credential is granted to this task. Add it in Resources \u2192 Credentials (org-wide or scoped to this agent).',
     async prepareRun(input) {
       const { task, runner, mcp } = input;
-      const flags = [
+      const liveInput = input.liveInput && task.followUps !== void 0;
+      const flags = liveInput ? [
+        "app-server",
+        "--stdio",
+        // Replace machine-configured MCP servers while retaining auth.json.
+        "-c",
+        "mcp_servers={}"
+      ] : [
         "--json",
-        // The machine's config.toml (its MCP servers, plugins, hooks) stays
-        // out of Zixt-managed sessions; auth.json machine login still applies.
         "--ignore-user-config",
-        // A teammate workspace is not necessarily a git repository.
         "--skip-git-repo-check",
-        // Headless runs can't answer approval prompts, and guardrails are
-        // instructions-first (PRD GR); the OS sandbox remains the documented
-        // out-of-scope boundary, same as Claude's --dangerously-skip-permissions.
         "--dangerously-bypass-approvals-and-sandbox"
       ];
-      if (runner.model) flags.push("--model", runner.model);
-      if (runner.effort) flags.push("-c", `model_reasoning_effort=${tomlString(runner.effort)}`);
+      if (!liveInput && runner.model) flags.push("--model", runner.model);
+      if (!liveInput && runner.effort) {
+        flags.push("-c", `model_reasoning_effort=${tomlString(runner.effort)}`);
+      }
       const env = { ZIXT_RUN_TOKEN: mcp.runToken };
       flags.push("-c", `mcp_servers.zixt.url=${tomlString(mcp.mcpUrl)}`);
       flags.push(
@@ -35302,13 +35508,13 @@ function createCodexAdapter(threadIndexRoot) {
         task.siblingTasks(),
         input.gitDetected
       );
-      const withPlatformInstructions = (prompt2) => platformInstructions ? `<zixt_platform_instructions>
+      const withPlatformInstructions = (value) => platformInstructions ? `<zixt_platform_instructions>
 ${platformInstructions}
 </zixt_platform_instructions>
 
-${prompt2}` : prompt2;
-      const prompt = withPlatformInstructions(buildRunnerPrompt(task));
-      const recoveryPrompt = withPlatformInstructions(buildRunnerPrompt(task, true));
+${value}` : value;
+      const prompt = liveInput ? buildRunnerPrompt(task) : withPlatformInstructions(buildRunnerPrompt(task));
+      const recoveryPrompt = liveInput ? buildRunnerPrompt(task, true) : withPlatformInstructions(buildRunnerPrompt(task, true));
       const sessionKey = task.spec.sessionKey;
       const indexPath = sessionKey ? threadIndexPath(threadIndexRoot, task.agentId, sessionKey) : null;
       const recordedThreadId = indexPath ? await readThreadId(indexPath) : null;
@@ -35322,20 +35528,28 @@ ${prompt2}` : prompt2;
       };
       return {
         argsFor: (mode) => {
-          if (mode === "resume") {
-            return recordedThreadId ? ["exec", "resume", recordedThreadId, ...flags, "-"] : null;
-          }
-          return ["exec", ...flags, "-"];
+          if (mode === "resume" && !recordedThreadId) return null;
+          if (liveInput) return flags;
+          return mode === "resume" ? ["exec", "resume", recordedThreadId, ...flags, "-"] : ["exec", ...flags, "-"];
         },
         prompt,
         recoveryPrompt,
         env,
-        createParser: (onStream) => createCodexStreamParser(onStream, {
-          onThreadStarted: (threadId) => {
+        createParser: (onStream, mode = "new") => {
+          const onThreadStarted = (threadId) => {
             rememberThread(threadId);
             observeRuntime(threadId);
-          }
-        }),
+          };
+          return liveInput ? createCodexAppServerParser(onStream, {
+            mode,
+            recordedThreadId,
+            cwd: input.cwd,
+            ...runner.model ? { model: runner.model } : {},
+            ...runner.effort ? { effort: runner.effort } : {},
+            developerInstructions: platformInstructions ?? "",
+            onThreadStarted
+          }) : createCodexStreamParser(onStream, { onThreadStarted });
+        },
         // Only one flip is meaningful: a resume whose rollout vanished starts
         // over. Codex assigns new-session ids itself, so a new session can
         // never collide the way a pre-specified id can.
@@ -35372,6 +35586,258 @@ function createCodexRunner(opts = {}) {
   const adapter = createCodexAdapter(opts.threadIndexRoot ?? defaultCodexThreadIndexRoot());
   return createCliRunner(adapter, opts);
 }
+function createCodexAppServerParser(onStream, options) {
+  let write = null;
+  let prompt = "";
+  let buffer = "";
+  let threadId = null;
+  let activeTurnId = null;
+  let responseText = "";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let terminal;
+  let stopped = false;
+  const steerWaiters = /* @__PURE__ */ new Map();
+  const turnReadyWaiters = /* @__PURE__ */ new Set();
+  const usage = () => ({ inputTokens, outputTokens });
+  const settleTurnReadiness = (ready) => {
+    for (const resolve14 of turnReadyWaiters) resolve14(ready);
+    turnReadyWaiters.clear();
+  };
+  const send = async (message) => {
+    if (!write || stopped) throw new Error("Codex app-server input is unavailable");
+    await write(`${JSON.stringify({ jsonrpc: "2.0", ...message })}
+`);
+  };
+  const threadParams = () => ({
+    cwd: options.cwd,
+    approvalPolicy: "never",
+    sandbox: "danger-full-access",
+    ...options.model ? { model: options.model } : {},
+    ...options.developerInstructions ? { developerInstructions: options.developerInstructions } : {}
+  });
+  const startTurn = async () => {
+    if (!threadId) throw new Error("Codex app-server did not provide a thread id");
+    await send({
+      id: "turn:start",
+      method: "turn/start",
+      params: {
+        threadId,
+        input: [{ type: "text", text: prompt }],
+        clientUserMessageId: randomUUID12(),
+        ...options.model ? { model: options.model } : {},
+        ...options.effort ? { effort: options.effort } : {}
+      }
+    });
+  };
+  const itemCompleted = (item) => {
+    const type = item["type"];
+    if (type === "agentMessage" && typeof item["text"] === "string") {
+      responseText = item["text"];
+      onStream("thought", truncateThought(item["text"]));
+      return;
+    }
+    if (type === "reasoning") {
+      const summary = Array.isArray(item["summary"]) ? item["summary"].filter((part) => typeof part === "string") : [];
+      if (summary.length) onStream("thought", truncateThought(summary.join("\n")));
+      return;
+    }
+    if (type === "commandExecution") {
+      const parameter = String(item["command"] ?? "").slice(0, 2e3);
+      onStream("action", `shell${parameter ? `: ${parameter.slice(0, 100)}` : ""}`, {
+        tool: "shell",
+        ...parameter ? { parameter } : {},
+        ephemeral: true
+      });
+      return;
+    }
+    if (type === "mcpToolCall") {
+      const tool = `${String(item["server"] ?? "mcp")}.${String(item["tool"] ?? "tool")}`.slice(
+        0,
+        200
+      );
+      const args = item["arguments"];
+      const parameter = (typeof args === "string" ? args : args ? JSON.stringify(args) : "").slice(
+        0,
+        2e3
+      );
+      onStream("action", `${tool}${parameter ? `: ${parameter.slice(0, 100)}` : ""}`, {
+        tool,
+        ...parameter ? { parameter } : {},
+        ephemeral: true
+      });
+      return;
+    }
+    if (type === "fileChange") {
+      const changes = Array.isArray(item["changes"]) ? item["changes"].map((change) => String(change["path"] ?? "")).filter(Boolean) : [];
+      const parameter = changes.join(", ").slice(0, 2e3);
+      onStream("action", `file_change${parameter ? `: ${parameter.slice(0, 100)}` : ""}`, {
+        tool: "file_change",
+        ...parameter ? { parameter } : {},
+        ephemeral: true,
+        ...changes.length ? { localPaths: changes } : {}
+      });
+    }
+  };
+  const processLine = (line) => {
+    if (!line.trim()) return void 0;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return void 0;
+    }
+    const id = typeof message["id"] === "string" ? message["id"] : null;
+    const error52 = message["error"];
+    if (id && error52) {
+      const detail = typeof error52["message"] === "string" ? error52["message"] : JSON.stringify(error52);
+      if (id.startsWith("steer:")) {
+        const inputId = id.slice("steer:".length);
+        steerWaiters.get(inputId)?.(false);
+        steerWaiters.delete(inputId);
+        return void 0;
+      }
+      terminal = {
+        outcome: "failed",
+        summary: improveCodexErrorMessage(detail),
+        usage: usage(),
+        sessionConflict: isCodexSessionConflict(detail)
+      };
+      return terminal;
+    }
+    const result = message["result"];
+    if (id === "initialize" && result) {
+      void send({ method: "initialized" }).then(
+        () => send({
+          id: "thread:open",
+          method: options.mode === "resume" ? "thread/resume" : "thread/start",
+          params: options.mode === "resume" ? { ...threadParams(), threadId: options.recordedThreadId } : threadParams()
+        })
+      ).catch(() => {
+      });
+    } else if (id === "thread:open" && result) {
+      const thread = result["thread"];
+      if (typeof thread?.["id"] === "string") {
+        threadId = thread["id"];
+        options.onThreadStarted(threadId);
+        void startTurn().catch(() => {
+        });
+      }
+    } else if (id === "turn:start" && result) {
+      const turn = result["turn"];
+      if (typeof turn?.["id"] === "string") {
+        activeTurnId = turn["id"];
+      }
+    } else if (id?.startsWith("steer:") && result) {
+      const inputId = id.slice("steer:".length);
+      const accepted = typeof result["turnId"] === "string";
+      steerWaiters.get(inputId)?.(accepted);
+      steerWaiters.delete(inputId);
+    }
+    const method = message["method"];
+    const params = message["params"];
+    if (method === "thread/started") {
+      const thread = params?.["thread"];
+      if (!threadId && typeof thread?.["id"] === "string") {
+        threadId = thread["id"];
+        options.onThreadStarted(threadId);
+      }
+    } else if (method === "turn/started") {
+      const turn = params?.["turn"];
+      if (typeof turn?.["id"] === "string") {
+        activeTurnId = turn["id"];
+        settleTurnReadiness(true);
+      }
+    } else if (method === "item/completed") {
+      const item = params?.["item"];
+      if (item && typeof item === "object") itemCompleted(item);
+    } else if (method === "thread/tokenUsage/updated") {
+      const tokenUsage = params?.["tokenUsage"];
+      const total = tokenUsage?.["total"];
+      if (typeof total?.["inputTokens"] === "number") inputTokens = total["inputTokens"];
+      if (typeof total?.["outputTokens"] === "number") outputTokens = total["outputTokens"];
+    } else if (method === "turn/completed") {
+      const turn = params?.["turn"];
+      activeTurnId = null;
+      settleTurnReadiness(false);
+      const status = turn?.["status"];
+      const turnError = turn?.["error"];
+      const detail = typeof turnError?.["message"] === "string" ? turnError["message"] : "Codex turn failed";
+      terminal = status === "completed" ? { outcome: "done", summary: responseText, usage: usage() } : { outcome: "failed", summary: improveCodexErrorMessage(detail), usage: usage() };
+      return terminal;
+    }
+    return void 0;
+  };
+  return {
+    usage,
+    async start(writer, initialPrompt) {
+      write = writer;
+      prompt = initialPrompt;
+      await send({
+        id: "initialize",
+        method: "initialize",
+        params: { clientInfo: { name: "zixt", version: "1" } }
+      });
+    },
+    async steer(input) {
+      if (stopped) return false;
+      if (!activeTurnId) {
+        const ready = await new Promise((resolve14) => turnReadyWaiters.add(resolve14));
+        if (!ready || stopped) return false;
+      }
+      if (!threadId || !activeTurnId) return false;
+      return await new Promise((resolve14) => {
+        steerWaiters.set(input.inputId, resolve14);
+        void send({
+          id: `steer:${input.inputId}`,
+          method: "turn/steer",
+          params: {
+            threadId,
+            expectedTurnId: activeTurnId,
+            input: [{ type: "text", text: input.text }],
+            clientUserMessageId: input.inputId
+          }
+        }).catch(() => {
+          if (steerWaiters.delete(input.inputId)) resolve14(false);
+        });
+      });
+    },
+    stop() {
+      stopped = true;
+      write = null;
+      settleTurnReadiness(false);
+      for (const resolve14 of steerWaiters.values()) resolve14(false);
+      steerWaiters.clear();
+    },
+    push(chunk) {
+      buffer += chunk;
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const parsed = processLine(line);
+        if (parsed) return parsed;
+      }
+      return void 0;
+    },
+    finish(stderr, exitCode = 0) {
+      if (buffer.trim()) {
+        const parsed = processLine(buffer);
+        buffer = "";
+        if (parsed) return parsed;
+      }
+      if (terminal) return terminal;
+      const detail = stderr.trim() || "Codex app-server exited before the turn completed";
+      return {
+        outcome: "failed",
+        summary: improveCodexErrorMessage(
+          exitCode ? `codex exited with code ${exitCode}: ${detail}` : detail
+        ),
+        usage: usage(),
+        sessionConflict: isCodexSessionConflict(detail)
+      };
+    }
+  };
+}
 function createCodexStreamParser(onStream, hooks = {}) {
   let buffer = "";
   let responseText = "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zixt/host",
-  "version": "0.0.38",
+  "version": "0.0.39",
   "type": "module",
   "exports": {
     ".": "./src/client.ts",