@the-open-engine/zeroshot 6.33.1 → 6.34.1

package/src/hosted-target/adapter-request.ts

@@ -1,12 +1,50 @@
 import type { RouteTemplate, TargetDiscoveryDescriptor } from '../target/discovery.js';
-import { TargetProtocolError } from './errors.js';
+import {
+  TargetAdapterError,
+  TargetAuthError,
+  TargetProtocolError,
+  TargetTransportError,
+} from './errors.js';
 import type { TargetOperation } from './retry-executor.js';
+import type { HttpTransport, TargetAccessTokenProvider } from './types.js';
+
+const DEFAULT_TRANSPORT: HttpTransport = {
+  fetch(url, init) {
+    return globalThis.fetch(url, init);
+  },
+};
+
+function throwIfAborted(signal?: AbortSignal): void {
+  if (signal?.aborted)
+    throw signal.reason ?? new globalThis.DOMException('The operation was aborted', 'AbortError');
+}
+
+async function resolveAccessToken(
+  tokenProvider: TargetAccessTokenProvider,
+  accessToken: string | undefined,
+  signal: AbortSignal | undefined
+): Promise<string> {
+  if (accessToken !== undefined) return accessToken;
+  try {
+    return await tokenProvider.getAccessToken(signal);
+  } catch {
+    throw new TargetAuthError('Target access authorization failed');
+  }
+}
 
 export type AdapterRequest = {
   readonly body?: string;
   readonly headers?: Readonly<Record<string, string>>;
 };
 
+export type AdapterRequester = (input: {
+  readonly method: string;
+  readonly path: string;
+  readonly signal: AbortSignal | undefined;
+  readonly request: AdapterRequest;
+  readonly accessToken: string | undefined;
+}) => Promise<Response>;
+
 export type ExecuteArguments<T> = [
   operation: TargetOperation,
   method: string,
@@ -31,3 +69,39 @@ export function requestUrl(path: string, descriptor: TargetDiscoveryDescriptor):
   }
   return url;
 }
+
+export function createAdapterRequester(
+  descriptor: TargetDiscoveryDescriptor,
+  tokenProvider: TargetAccessTokenProvider,
+  transport: HttpTransport = DEFAULT_TRANSPORT
+): AdapterRequester {
+  return async ({ method, path, signal, request, accessToken }) => {
+    throwIfAborted(signal);
+    const url = requestUrl(path, descriptor);
+    const token = await resolveAccessToken(tokenProvider, accessToken, signal);
+    const init: RequestInit & { redirect: 'manual' } = {
+      method,
+      headers: {
+        Accept: 'application/json',
+        Authorization: `Bearer ${token}`,
+        ...(request.body === undefined ? {} : { 'Content-Type': 'application/json' }),
+        ...request.headers,
+      },
+      redirect: 'manual',
+    };
+    if (request.body !== undefined) init.body = request.body;
+    if (signal !== undefined) init.signal = signal;
+    try {
+      const response = await transport.fetch(url.href, init);
+      if (response.url && new globalThis.URL(response.url).href !== url.href) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new TargetProtocolError('Capsule response changed target route');
+      }
+      return response;
+    } catch (error) {
+      if (error instanceof TargetAdapterError) throw error;
+      throwIfAborted(signal);
+      throw new TargetTransportError('Capsule transport failed');
+    }
+  };
+}

package/src/hosted-target/adapter-types.ts

@@ -26,6 +26,12 @@ export interface TargetAdapter {
   terminate(capsuleId: string, signal?: AbortSignal): Promise<Capsule>;
   limits(signal?: AbortSignal): Promise<CapsuleLimits>;
   access(capsuleId: string, signal?: AbortSignal): Promise<CapsuleAccess>;
+  installRuntime(
+    capsuleId: string,
+    runtime: unknown,
+    accessToken: string,
+    signal?: AbortSignal
+  ): Promise<void>;
   readonly credentialInstall: CredentialInstallCapability;
 }
 

package/src/hosted-target/response-status.ts

@@ -0,0 +1,21 @@
+import { throwCapsuleServerError } from './capsule-error-response.js';
+import { TargetProtocolError } from './errors.js';
+import type { Clock } from './types.js';
+
+export async function assertCapsuleResponseStatus(
+  response: Response,
+  expectedStatus: number,
+  readJson: (response: Response) => Promise<unknown>,
+  clock: Clock
+): Promise<void> {
+  if (response.status >= 300 && response.status < 400) {
+    await response.body?.cancel().catch(() => undefined);
+    throw new TargetProtocolError('Capsule redirects are forbidden');
+  }
+  if (response.status === expectedStatus) return;
+  if (response.status >= 200 && response.status < 300) {
+    await response.body?.cancel().catch(() => undefined);
+    throw new TargetProtocolError('Target returned an unexpected success status');
+  }
+  await throwCapsuleServerError(response, readJson, clock);
+}

package/src/hosted-target/retry-executor.ts

@@ -2,7 +2,14 @@ import { MAX_RETRY_ELAPSED_MS } from './bounds.js';
 import { TargetAdapterError } from './errors.js';
 import type { Clock, RetryPolicy } from './types.js';
 
-export type TargetOperation = 'allocate' | 'list' | 'inspect' | 'terminate' | 'limits' | 'access';
+export type TargetOperation =
+  | 'allocate'
+  | 'list'
+  | 'inspect'
+  | 'terminate'
+  | 'limits'
+  | 'access'
+  | 'installRuntime';
 
 function throwIfAborted(signal?: AbortSignal): void {
   if (signal?.aborted) {

package/src/hosted-target/runtime-install.ts

@@ -0,0 +1,83 @@
+import type { CredentialInstallDescriptor } from '../target/discovery.js';
+import { readBoundedResponseJson } from '../target/bounded-response.js';
+import { MAX_RESPONSE_BYTES } from './bounds.js';
+import { TargetProtocolError } from './errors.js';
+import { assertCapsuleResponseStatus } from './response-status.js';
+import { withTargetRetry } from './retry-executor.js';
+import type { Clock, RetryPolicy } from './types.js';
+
+type RuntimeInstallOptions = {
+  readonly capsuleId: string;
+  readonly runtime: unknown;
+  readonly accessToken: string;
+  readonly descriptor: CredentialInstallDescriptor;
+  readonly signal?: AbortSignal;
+  readonly clock: Clock;
+  readonly retryPolicy: RetryPolicy;
+  readonly request: (
+    method: string,
+    path: string,
+    signal: AbortSignal | undefined,
+    body: string,
+    accessToken: string
+  ) => Promise<Response>;
+};
+
+function validOpaque(value: string, field: string): void {
+  if (value.length === 0 || value.length > 1024) {
+    throw new TargetProtocolError(`${field} is invalid`);
+  }
+}
+
+function runtimeBody(runtime: unknown, maximum: number): string {
+  let body: string | undefined;
+  try {
+    body = JSON.stringify(runtime);
+  } catch {
+    throw new TargetProtocolError('Runtime bundle is not serializable');
+  }
+  if (body === undefined || Buffer.byteLength(body) > maximum) {
+    throw new TargetProtocolError('Runtime bundle exceeds the advertised size bound');
+  }
+  return body;
+}
+
+export async function installRuntime(options: RuntimeInstallOptions): Promise<void> {
+  validOpaque(options.capsuleId, 'capsule id');
+  validOpaque(options.accessToken, 'capsule access token');
+  let path: string;
+  try {
+    path = options.descriptor.install.routeTemplate.expand({
+      capsule_id: options.capsuleId,
+    });
+  } catch {
+    throw new TargetProtocolError('Runtime install route expansion is unsafe');
+  }
+  const body = runtimeBody(options.runtime, options.descriptor.maxBodyBytes);
+  await withTargetRetry(
+    'installRuntime',
+    async () => {
+      const response = await options.request(
+        options.descriptor.install.method,
+        path,
+        options.signal,
+        body,
+        options.accessToken
+      );
+      await assertCapsuleResponseStatus(
+        response,
+        204,
+        (errorResponse) =>
+          readBoundedResponseJson(
+            errorResponse,
+            MAX_RESPONSE_BYTES,
+            () => new TargetProtocolError('Capsule error response is malformed')
+          ),
+        options.clock
+      );
+      await response.body?.cancel().catch(() => undefined);
+    },
+    options.signal,
+    { clock: options.clock, policy: options.retryPolicy }
+  );
+}

package/src/hosted-target/zero-cloud-v1-adapter.ts

@@ -1,10 +1,5 @@
 import { IDEMPOTENCY_KEY_PATTERN, MAX_RESPONSE_BYTES } from './bounds.js';
-import {
-  TargetAdapterError,
-  TargetAuthError,
-  TargetProtocolError,
-  TargetTransportError,
-} from './errors.js';
+import { TargetProtocolError } from './errors.js';
 import { DefaultRetryPolicy } from './retry.js';
 import {
   assertCapsule,
@@ -20,34 +15,23 @@ import type {
   CapsuleLimits,
   CapsuleListPage,
   Clock,
-  HttpTransport,
   ListRequest,
   RetryPolicy,
-  TargetAccessTokenProvider,
 } from './types.js';
 import type { TargetDiscoveryDescriptor } from '../target/discovery.js';
 import { readBoundedResponseJson } from '../target/bounded-response.js';
-import { throwCapsuleServerError } from './capsule-error-response.js';
 import { validateAccessUrl } from './access-url.js';
 import { withTargetRetry } from './retry-executor.js';
+import { installRuntime as installOpaqueRuntime } from './runtime-install.js';
+import { assertCapsuleResponseStatus } from './response-status.js';
 import {
-  requestUrl,
-  type AdapterRequest,
+  createAdapterRequester,
+  type AdapterRequester,
   type ExecuteArguments,
 } from './adapter-request.js';
 
-const DEFAULT_TRANSPORT: HttpTransport = {
-  fetch(url, init) {
-    return globalThis.fetch(url, init);
-  },
-};
 const DEFAULT_CLOCK: Clock = { now: () => Date.now() };
 
-function throwIfAborted(signal?: AbortSignal): void {
-  if (signal?.aborted)
-    throw signal.reason ?? new globalThis.DOMException('The operation was aborted', 'AbortError');
-}
-
 function validOpaque(value: string, field: string): void {
   if (value.length === 0 || value.length > 1024)
     throw new TargetProtocolError(`${field} is invalid`);
@@ -57,12 +41,10 @@ function jsonRequest(body: unknown): string {
   return JSON.stringify(body);
 }
 
-
 export class ZeroCloudV1TargetAdapter implements TargetAdapter {
   readonly #descriptor: TargetDiscoveryDescriptor;
   readonly #organizationId: string;
-  readonly #tokenProvider: TargetAccessTokenProvider;
-  readonly #transport: HttpTransport;
+  readonly #request: AdapterRequester;
   readonly #clock: Clock;
   readonly #retryPolicy: RetryPolicy;
 
@@ -70,8 +52,11 @@ export class ZeroCloudV1TargetAdapter implements TargetAdapter {
     this.#descriptor = options.descriptor;
     this.#organizationId = options.organization.id;
     validOpaque(this.#organizationId, 'organization id');
-    this.#tokenProvider = options.tokenProvider;
-    this.#transport = options.transport ?? DEFAULT_TRANSPORT;
+    this.#request = createAdapterRequester(
+      options.descriptor,
+      options.tokenProvider,
+      options.transport
+    );
     this.#clock = options.clock ?? DEFAULT_CLOCK;
     this.#retryPolicy = options.retryPolicy ?? new DefaultRetryPolicy();
   }
@@ -199,21 +184,42 @@ export class ZeroCloudV1TargetAdapter implements TargetAdapter {
     return result;
   }
 
+  async installRuntime(
+    capsuleId: string,
+    runtime: unknown,
+    accessToken: string,
+    signal?: AbortSignal
+  ): Promise<void> {
+    const descriptor = this.#descriptor.credentialInstall;
+    if (descriptor === null) {
+      throw new TargetProtocolError('Target does not advertise runtime installation');
+    }
+    await installOpaqueRuntime({
+      capsuleId,
+      runtime,
+      accessToken,
+      descriptor,
+      ...(signal === undefined ? {} : { signal }),
+      clock: this.#clock,
+      retryPolicy: this.#retryPolicy,
+      request: (method, path, requestSignal, body, token) =>
+        this.#request({
+          method,
+          path,
+          signal: requestSignal,
+          request: { body },
+          accessToken: token,
+        }),
+    });
+  }
+
   #execute<T>(...args: ExecuteArguments<T>): Promise<T> {
     return Promise.resolve().then(() => this.#executeExpanded(args));
   }
 
   #executeExpanded<T>(args: ExecuteArguments<T>): Promise<T> {
-    const [
-      operation,
-      method,
-      template,
-      values,
-      expectedStatus,
-      validate,
-      signal,
-      request = {},
-    ] = args;
+    const [operation, method, template, values, expectedStatus, validate, signal, request = {}] =
+      args;
     let path: string;
     try {
       path = template.expand(values);
@@ -223,77 +229,36 @@ export class ZeroCloudV1TargetAdapter implements TargetAdapter {
     return withTargetRetry(
       operation,
       async () => {
-        const response = await this.#request(method, path, signal, request);
-        if (response.status >= 300 && response.status < 400) {
-          await response.body?.cancel().catch(() => undefined);
-          throw new TargetProtocolError('Capsule redirects are forbidden');
-        }
-        if (response.status !== expectedStatus) {
-          if (response.status >= 200 && response.status < 300) {
-            await response.body?.cancel().catch(() => undefined);
-            throw new TargetProtocolError('Target returned an unexpected success status');
-          }
-          await throwCapsuleServerError(
-            response,
-            (errorResponse) => this.#readJson(errorResponse),
-            this.#clock,
-          );
-        }
+        const response = await this.#request({
+          method,
+          path,
+          signal,
+          request,
+          accessToken: undefined,
+        });
+        await assertCapsuleResponseStatus(
+          response,
+          expectedStatus,
+          (errorResponse) => this.#readJson(errorResponse),
+          this.#clock
+        );
         return validate(await this.#readJson(response));
       },
       signal,
-      { clock: this.#clock, policy: this.#retryPolicy },
+      { clock: this.#clock, policy: this.#retryPolicy }
     );
   }
 
-  async #request(
-    method: string,
-    path: string,
-    signal: AbortSignal | undefined,
-    request: AdapterRequest,
-  ): Promise<Response> {
-    throwIfAborted(signal);
-    const url = requestUrl(path, this.#descriptor);
-    let token: string;
-    try {
-      token = await this.#tokenProvider.getAccessToken(signal);
-    } catch {
-      throw new TargetAuthError('Target access authorization failed');
-    }
-    const init: RequestInit & { redirect: 'manual' } = {
-      method,
-      headers: {
-        Accept: 'application/json',
-        Authorization: `Bearer ${token}`,
-        ...(request.body === undefined ? {} : { 'Content-Type': 'application/json' }),
-        ...request.headers,
-      },
-      redirect: 'manual',
-    };
-    if (request.body !== undefined) init.body = request.body;
-    if (signal !== undefined) init.signal = signal;
-    try {
-      const response = await this.#transport.fetch(url.href, init);
-      if (response.url && new globalThis.URL(response.url).href !== url.href) {
-        await response.body?.cancel().catch(() => undefined);
-        throw new TargetProtocolError('Capsule response changed target route');
-      }
-      return response;
-    } catch (error) {
-      if (error instanceof TargetAdapterError) throw error;
-      throwIfAborted(signal);
-      throw new TargetTransportError('Capsule transport failed');
-    }
-  }
-
-
   #readJson(response: Response): Promise<unknown> {
-    return readBoundedResponseJson(response, MAX_RESPONSE_BYTES, (kind) =>
-      new TargetProtocolError(
-        kind === 'size'
-          ? 'Capsule response exceeds the size limit'
-          : 'Capsule response is not valid UTF-8 JSON',
-      ),
+    return readBoundedResponseJson(
+      response,
+      MAX_RESPONSE_BYTES,
+      (kind) =>
+        new TargetProtocolError(
+          kind === 'size'
+            ? 'Capsule response exceeds the size limit'
+            : 'Capsule response is not valid UTF-8 JSON'
+        )
     );
   }
 }

package/src/target/discovery-validation.ts

@@ -3,16 +3,8 @@ import { routeTemplate, type RouteTemplate } from './route-template.js';
 
 export interface CredentialInstallDescriptor {
   readonly kind: 'openengine.capsule-credential-install/v1';
-  readonly grant: { readonly routeTemplate: RouteTemplate; readonly method: 'POST' };
   readonly install: { readonly routeTemplate: RouteTemplate; readonly method: 'PUT' };
-  readonly uploadUrlOrigin: 'same_origin';
-  readonly sealedEnvelopeAlgorithms: readonly ['RSA-OAEP-3072-SHA256'];
-  readonly bounds: {
-    readonly maxEnvelopeBytes: number;
-    readonly maxBodyBytes: number;
-    readonly grantTtlSeconds: number;
-    readonly maxClockSkewSeconds: number;
-  };
+  readonly maxBodyBytes: number;
 }
 
 export function record(value: unknown, field: string): Record<string, unknown> {
@@ -116,29 +108,35 @@ export function sameOriginUrl(
 export function parseCredentialInstall(value: unknown): CredentialInstallDescriptor | null {
   if (value === undefined || value === null) return null;
   const extension = closedRecord(value, 'extensions.credential_install', [
-    'kind', 'grant', 'install', 'upload_url_origin', 'sealed_envelope_algorithms', 'bounds',
+    'kind',
+    'install',
+    'max_body_bytes',
   ]);
-  exact(extension.kind, 'openengine.capsule-credential-install/v1', 'extensions.credential_install.kind');
-  const grant = closedRecord(extension.grant, 'extensions.credential_install.grant', ['route_template', 'method']);
-  const install = closedRecord(extension.install, 'extensions.credential_install.install', ['route_template', 'method']);
-  exact(grant.method, 'POST', 'extensions.credential_install.grant.method');
-  exact(install.method, 'PUT', 'extensions.credential_install.install.method');
-  exact(extension.upload_url_origin, 'same_origin', 'extensions.credential_install.upload_url_origin');
-  exactStringSet(extension.sealed_envelope_algorithms, 'extensions.credential_install.sealed_envelope_algorithms', ['RSA-OAEP-3072-SHA256']);
-  const bounds = closedRecord(extension.bounds, 'extensions.credential_install.bounds', [
-    'max_envelope_bytes', 'max_body_bytes', 'grant_ttl_seconds', 'max_clock_skew_seconds',
+  exact(
+    extension.kind,
+    'openengine.capsule-credential-install/v1',
+    'extensions.credential_install.kind'
+  );
+  const install = closedRecord(extension.install, 'extensions.credential_install.install', [
+    'route_template',
+    'method',
   ]);
+  exact(install.method, 'PUT', 'extensions.credential_install.install.method');
   return Object.freeze({
     kind: 'openengine.capsule-credential-install/v1' as const,
-    grant: Object.freeze({ routeTemplate: routeTemplate(grant.route_template, 'extensions.credential_install.grant.route_template', ['capsule_id']), method: 'POST' as const }),
-    install: Object.freeze({ routeTemplate: routeTemplate(install.route_template, 'extensions.credential_install.install.route_template', ['capsule_id']), method: 'PUT' as const }),
-    uploadUrlOrigin: 'same_origin' as const,
-    sealedEnvelopeAlgorithms: Object.freeze(['RSA-OAEP-3072-SHA256'] as const),
-    bounds: Object.freeze({
-      maxEnvelopeBytes: integer(bounds.max_envelope_bytes, 'extensions.credential_install.bounds.max_envelope_bytes', 1, 1_048_576),
-      maxBodyBytes: integer(bounds.max_body_bytes, 'extensions.credential_install.bounds.max_body_bytes', 1, 1_048_576),
-      grantTtlSeconds: integer(bounds.grant_ttl_seconds, 'extensions.credential_install.bounds.grant_ttl_seconds', 1, 3_600),
-      maxClockSkewSeconds: integer(bounds.max_clock_skew_seconds, 'extensions.credential_install.bounds.max_clock_skew_seconds', 0, 300),
+    install: Object.freeze({
+      routeTemplate: routeTemplate(
+        install.route_template,
+        'extensions.credential_install.install.route_template',
+        ['capsule_id']
+      ),
+      method: 'PUT' as const,
     }),
+    maxBodyBytes: integer(
+      extension.max_body_bytes,
+      'extensions.credential_install.max_body_bytes',
+      1,
+      4 * 1024 * 1024
+    ),
   });
 }

package/task-lib/runner.js

@@ -43,6 +43,8 @@ const {
   partitionPathFor,
   createOmpSessionPartitionDirectory,
 } = require('../src/omp-session-partition');
+const TASK_EXECUTION_CONTEXT_ENV = 'ZEROSHOT_TASK_EXECUTION_CONTEXT';
+const TASK_EXECUTION_CONTEXTS = new Set(['host', 'detached', 'docker', 'benchmark']);
 export {
   isOwnedProcessTreeRunning,
   isProcessRunning,
@@ -413,7 +415,7 @@ function buildProviderOptions(options, runtime, modelSelection) {
     outputFormat: runtime.outputFormat,
     jsonSchema: runtime.jsonSchema,
     cwd: runtime.cwd,
-    executionContext: 'detached',
+    executionContext: resolveTaskExecutionContext(),
     autoApprove: !structuredOutputRecovery,
     ...(modelSelection === undefined ? {} : { modelSpec: modelSelection.modelSpec }),
     ...(structuredOutputRecovery ? {} : mcpConfigOption(options)),
@@ -428,6 +430,17 @@ function buildProviderOptions(options, runtime, modelSelection) {
   };
 }
 
+export function resolveTaskExecutionContext(environment = process.env) {
+  const context = environment[TASK_EXECUTION_CONTEXT_ENV];
+  if (context === undefined) return 'detached';
+  if (!TASK_EXECUTION_CONTEXTS.has(context)) {
+    throw new Error(
+      `${TASK_EXECUTION_CONTEXT_ENV} must be one of: ${[...TASK_EXECUTION_CONTEXTS].join(', ')}.`
+    );
+  }
+  return context;
+}
+
 function claudeSettingsFileOption() {
   const settingsPath = process.env[CLAUDE_SETTINGS_ENV]?.trim();
   return settingsPath ? { claudeSettingsFile: settingsPath } : {};

package/task-lib/watcher-output-runtime.js

@@ -1,4 +1,5 @@
 import { spawn } from 'child_process';
+import { StringDecoder } from 'string_decoder';
 import {
   detectProviderFatalError,
   detectProviderStreamingModeError,
@@ -9,6 +10,8 @@ import { terminateProcess } from './process-termination.js';
 
 export const COMMAND_CLEANUP_UNINITIALIZED = Symbol('command-cleanup-uninitialized');
 
+const MAX_CODEX_CONTROL_RECORD_BYTES = 64 * 1024;
+
 export function spawnWatcherProvider(command, finalArgs, options) {
   return spawn(command, finalArgs, {
     ...options,
@@ -38,6 +41,72 @@ function splitBufferLines(buffer, chunk) {
   return { lines: lines.slice(0, -1), remaining: lines.at(-1) || '' };
 }
 
+function createCodexOutputPassthrough({ log, captureProviderSession }) {
+  const decoder = new StringDecoder('utf8');
+  let atLineStart = true;
+  let inspectable = true;
+  let inspectionBytes = 0;
+  let inspectionParts = [];
+
+  function inspectPart(part) {
+    if (!inspectable || !part) return;
+    inspectionBytes += Buffer.byteLength(part);
+    if (inspectionBytes > MAX_CODEX_CONTROL_RECORD_BYTES) {
+      inspectable = false;
+      inspectionParts = [];
+      return;
+    }
+    inspectionParts.push(part);
+  }
+
+  function finishLine() {
+    if (inspectable) captureProviderSession(inspectionParts.join(''));
+    atLineStart = true;
+    inspectable = true;
+    inspectionBytes = 0;
+    inspectionParts = [];
+  }
+
+  function writeText(text, timestamp) {
+    if (!text) return;
+    const logged = [];
+    let offset = 0;
+    while (offset < text.length) {
+      if (atLineStart) {
+        logged.push(`[${timestamp}]`);
+        atLineStart = false;
+      }
+      const newline = text.indexOf('\n', offset);
+      if (newline === -1) {
+        const part = text.slice(offset);
+        inspectPart(part);
+        logged.push(part);
+        break;
+      }
+      const part = text.slice(offset, newline);
+      inspectPart(part);
+      logged.push(part, '\n');
+      finishLine();
+      offset = newline + 1;
+    }
+    log(logged.join(''));
+  }
+
+  return {
+    consume(chunk) {
+      const text = typeof chunk === 'string' ? chunk : decoder.write(chunk);
+      writeText(text, Date.now());
+    },
+    flush() {
+      writeText(decoder.end(), Date.now());
+      if (!atLineStart) {
+        finishLine();
+        log('\n');
+      }
+    },
+  };
+}
+
 export function resolveWatcherCommand(config, commandSpec, fallbackArgs, normalizeProviderName) {
   return {
     providerName: normalizeProviderName(config.provider || 'claude'),
@@ -189,6 +258,8 @@ export function createWatcherOutputRuntime({
   let streamingModeError = null;
   let fatalError = null;
   const captureProviderSession = providerSessionCapture?.captureLine || (() => {});
+  const codexOutputPassthrough =
+    providerName === 'codex' ? createCodexOutputPassthrough({ log, captureProviderSession }) : null;
 
   function maybeHandleFatalError(line, timestamp) {
     if (fatalError) return false;
@@ -230,6 +301,10 @@ export function createWatcherOutputRuntime({
   }
 
   function consumeOutput(buffer, chunk) {
+    if (codexOutputPassthrough) {
+      codexOutputPassthrough.consume(chunk);
+      return '';
+    }
     const timestamp = Date.now();
     const { lines, remaining } = splitBufferLines(buffer, chunk.toString());
     for (const line of lines) handleOutputLine(line, timestamp);
@@ -284,7 +359,11 @@ export function createWatcherOutputRuntime({
 
   function complete({ code, signal, outputBuffer, stderrBuffer = null }) {
     const timestamp = Date.now();
-    flushOutput(outputBuffer, timestamp);
+    if (codexOutputPassthrough) {
+      codexOutputPassthrough.flush();
+    } else {
+      flushOutput(outputBuffer, timestamp);
+    }
     if (stderrBuffer !== null) flushStderr(stderrBuffer, timestamp);
     const recovered = attemptRecovery(code, timestamp);
     const sessionIdentityError = providerSessionCapture?.getCompletionError() || null;