threadwire 0.1.11 → 0.1.13

package/src/activity-log.js

@@ -3,9 +3,6 @@
 import {closeSync, openSync, writeSync} from "node:fs"
 
 const SESSION_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,511}$/u
-const PROFILE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u
-const REVISION_PATTERN = /^[0-9a-f]{40}$/u
-const SOURCE_IDENTITY_PATTERN = /^[0-9a-f]{40}$|^[0-9a-f]{64}$/u
 
 export class ActivityLog {
   /** @param {string} path */
@@ -14,16 +11,6 @@ export class ActivityLog {
     this.closed = false
   }
 
-  /** @param {string} profile @param {string} repositoryRoot @param {string} revision @param {string} sourceIdentity */
-  recordWorkspace(profile, repositoryRoot, revision, sourceIdentity) {
-    if (!PROFILE_PATTERN.test(profile)) throw new Error("Workspace profile is invalid")
-    if (typeof repositoryRoot !== "string" || repositoryRoot.length === 0) throw new Error("Workspace repository root is invalid")
-    if (!REVISION_PATTERN.test(revision) || !SOURCE_IDENTITY_PATTERN.test(sourceIdentity)) {
-      throw new Error("Workspace provenance is invalid")
-    }
-    this.write({type: "workspace-selected", profile, repositoryRoot, revision, sourceIdentity})
-  }
-
   /** @param {"codex" | "claude" | "kimi" | "opencode"} provider @param {number} pid */
   recordStarted(provider, pid) {
     if (!Number.isSafeInteger(pid) || pid <= 0) throw new Error("Provider child PID is unavailable")
@@ -42,7 +29,7 @@ export class ActivityLog {
     closeSync(this.fileDescriptor)
   }
 
-  /** @param {{type: "workspace-selected", profile: string, repositoryRoot: string, revision: string, sourceIdentity: string} | {type: "provider-started", provider: "codex" | "claude" | "kimi" | "opencode", pid: number} | {type: "session-available", provider: "codex" | "claude" | "kimi" | "opencode", sessionId: string}} fact */
+  /** @param {{type: "provider-started", provider: "codex" | "claude" | "kimi" | "opencode", pid: number} | {type: "session-available", provider: "codex" | "claude" | "kimi" | "opencode", sessionId: string}} fact */
   write(fact) {
     if (this.closed) throw new Error("Activity log is closed")
     writeSync(this.fileDescriptor, `${JSON.stringify(fact)}\n`)

package/src/cli.js

@@ -11,19 +11,16 @@ import {runWorker} from "./run-worker.js"
 import {ActivityLog} from "./activity-log.js"
 import {DelegatedResultAdmission, validateContinuationHandle} from "./delegated-result-admission.js"
 import {buildProviderEnvironment, collectEvidenceRedactions, parseTelegramRequestTimeoutMs, resolveFileBackedSettings} from "./telegram-ingress/config.js"
-import {resolveWorkspaceProfile} from "./workspace-profile.js"
 import {WorkerControl} from "./worker-control.js"
 import {EvidenceStore} from "./evidence-store.js"
 import {ContextBudgetMetrics} from "./context-budget-metrics.js"
-import {isolatedRuntimeClientFromEnvironment, kimiIsolatedRuntimeClientFromEnvironment} from "./isolated-runtime-client.js"
-import {kimiSessionEnvelopeId} from "./providers/kimi.js"
+import {isolatedRuntimeClientFromEnvironment} from "./isolated-runtime-client.js"
 import {validateRelayWriteProviderArguments} from "./relay-write.js"
 import {abortable} from "./absolute-deadline.js"
 import {NormalizedOutput} from "./normalized-output.js"
 
 const HELP = `Usage: threadwire run --provider <codex|claude|kimi|opencode> --target telegram:<chat-id> | telegram:<chat-id>:<thread-id>
   [--process-number <positive-integer>] [--cwd <directory>]
-  [--workspace-profile <name>]
   [--relay-write]
   [--tool-messages] [--max-output-length <positive-integer>]
   [--resume-session <provider-session-id>] [--transcript <normalized-jsonl-path>]
@@ -33,7 +30,7 @@ const HELP = `Usage: threadwire run --provider <codex|claude|kimi|opencode> --ta
        threadwire evidence read --handle <opaque-handle>
   (--bytes <offset>:<limit> | --lines <start>:<limit> | --query <literal> --context-bytes <limit>)`
 
-/** @typedef {{provider: string, target: string, cwd: string, toolMessages: boolean, relayWrite: boolean, workspaceProfile?: string, prompt?: string, promptFile?: string, processNumber?: number, maxOutputLength?: number, resumeSession?: string, transcript?: string, activityLog?: string, providerArguments: string[]}} ParsedArguments */
+/** @typedef {{provider: string, target: string, cwd: string, toolMessages: boolean, relayWrite: boolean, prompt?: string, promptFile?: string, processNumber?: number, maxOutputLength?: number, resumeSession?: string, transcript?: string, activityLog?: string, providerArguments: string[]}} ParsedArguments */
 /** @typedef {{evidenceRead: true, request: unknown}} EvidenceParsedArguments */
 /**
  * @typedef {{
@@ -46,9 +43,7 @@ const HELP = `Usage: threadwire run --provider <codex|claude|kimi|opencode> --ta
  *   evidenceStore?: EvidenceStore,
  *   evidenceOwnerScope?: {destinationId: string, runId: string},
  *   workerControlOptions?: Pick<ConstructorParameters<typeof WorkerControl>[0], "queueOptions">,
- *   workspaceProfileOperations?: import("./workspace-profile.js").WorkspaceProfileOperations,
- *   isolatedRuntimeClient?: Pick<import("./isolated-runtime-client.js").IsolatedRuntimeClient, "preflight" | "run">,
- *   kimiIsolatedRuntimeClient?: Pick<import("./isolated-runtime-client.js").IsolatedRuntimeClient, "preflight" | "run">
+ *   isolatedRuntimeClient?: Pick<import("./isolated-runtime-client.js").IsolatedRuntimeClient, "preflight" | "run">
  * }} MainDependencies
  */
 
@@ -62,7 +57,6 @@ export function parseArguments(arguments_) {
   const providerArguments = separator < 0 ? [] : arguments_.slice(separator + 1)
   /** @type {Partial<ParsedArguments>} */
   const parsed = {providerArguments, cwd: process.cwd(), toolMessages: false, relayWrite: false}
-  let cwdProvided = false
   let transcriptProvided = false
   for (let index = 0; index < ownArguments.length;) {
     const option = ownArguments[index]
@@ -85,8 +79,7 @@ export function parseArguments(arguments_) {
     else if (option === "--target") parsed.target = value
     else if (option === "--cwd") {
       parsed.cwd = resolve(value)
-      cwdProvided = true
-    } else if (option === "--workspace-profile") parsed.workspaceProfile = value
+    } else if (option === "--workspace-profile") throw new Error("--workspace-profile is no longer supported; use --cwd")
     else if (option === "--prompt") parsed.prompt = value
     else if (option === "--prompt-file") parsed.promptFile = resolve(value)
     else if (option === "--process-number") parsed.processNumber = positiveInteger(value, "--process-number")
@@ -107,14 +100,9 @@ export function parseArguments(arguments_) {
   }
   if (!parsed.target) throw new Error("--target is required")
   if (parsed.prompt !== undefined && parsed.promptFile !== undefined) throw new Error("Use exactly one prompt source")
-  if (parsed.workspaceProfile !== undefined && cwdProvided) {
-    throw new Error("--cwd and --workspace-profile are mutually exclusive")
-  }
   if (parsed.transcript !== undefined && parsed.transcript === parsed.activityLog) {
     throw new Error("--transcript and --activity-log must resolve to different paths")
   }
-  if (parsed.relayWrite && parsed.workspaceProfile === undefined) throw new Error("--relay-write requires --workspace-profile")
-  if (parsed.provider === "kimi" && parsed.workspaceProfile === undefined) throw new Error("Kimi requires --workspace-profile")
   if (parsed.relayWrite && parsed.provider !== "codex") throw new Error("--relay-write is only supported for codex")
   return /** @type {ParsedArguments} */ (parsed)
 }
@@ -199,25 +187,17 @@ export async function main(arguments_, dependencies = {}) {
     runAdmission = normalizedOutput === undefined ? undefined : new DelegatedResultAdmission({output: normalizedOutput, metrics})
     const target = parseTelegramTarget(parsed.target)
     if (parsed.relayWrite) validateRelayWriteProviderArguments(parsed.providerArguments)
-    const resolvedWorkspace = parsed.workspaceProfile === undefined
-      ? undefined
-      : await resolveWorkspaceProfile(
-        {provider: /** @type {"codex" | "claude" | "kimi" | "opencode"} */ (parsed.provider), profile: parsed.workspaceProfile},
-        dependencies.workspaceProfileOperations
-      )
     if (validateOnly) return 0
-    const usesIsolatedRuntime = parsed.relayWrite || parsed.provider === "kimi"
+    const usesIsolatedRuntime = parsed.relayWrite
     const isolatedRuntimeClient = usesIsolatedRuntime
-      ? parsed.provider === "kimi"
-        ? dependencies.kimiIsolatedRuntimeClient ?? kimiIsolatedRuntimeClientFromEnvironment(sourceEnvironment)
-        : dependencies.isolatedRuntimeClient ?? isolatedRuntimeClientFromEnvironment(sourceEnvironment)
+      ? dependencies.isolatedRuntimeClient ?? isolatedRuntimeClientFromEnvironment(sourceEnvironment)
       : undefined
     const isolatedPreflight = usesIsolatedRuntime
       ? await /** @type {NonNullable<typeof isolatedRuntimeClient>} */ (isolatedRuntimeClient).preflight({
         provider: parsed.provider,
-        profile: /** @type {string} */ (parsed.workspaceProfile),
-        repositoryRoot: /** @type {import("./workspace-profile.js").ResolvedWorkspaceProfile} */ (resolvedWorkspace).repositoryRoot,
-        cwd: /** @type {import("./workspace-profile.js").ResolvedWorkspaceProfile} */ (resolvedWorkspace).cwd,
+        profile: "explicit-cwd",
+        repositoryRoot: parsed.cwd,
+        cwd: parsed.cwd,
         providerArguments: parsed.providerArguments,
         ...(parsed.resumeSession === undefined ? {} : {resumeSession: parsed.resumeSession})
       })
@@ -257,18 +237,18 @@ export async function main(arguments_, dependencies = {}) {
         await boundedLaunch(evidence.append("prompt", promptEvidence), launchDeadline)
         evidencePayloadBytes += Buffer.byteLength(promptEvidence, "utf8")
       }
-      const providerEnvironment = buildProviderEnvironment(environment)
+      const providerEnvironment = buildProviderEnvironment(environment, {
+        provider: parsed.provider,
+        isolated: usesIsolatedRuntime
+      })
       const provider = createProvider(
         parsed.provider,
         parsed.providerArguments,
         prompt,
         parsed.resumeSession,
-        usesIsolatedRuntime ? {} : providerEnvironment
+        providerEnvironment
       )
       if (parsed.resumeSession !== undefined) admission.setContinuationHandle(parsed.resumeSession)
-      if (parsed.workspaceProfile !== undefined) {
-        if (resolvedWorkspace === undefined) throw new Error("Workspace profile resolution failed")
-      }
       const token = environment.THREADWIRE_TELEGRAM_BOT_TOKEN
       if (!token) throw new Error("THREADWIRE_TELEGRAM_BOT_TOKEN is required")
       const transport = (dependencies.transportFactory ?? createFetchTransport)(token, undefined, parseTelegramRequestTimeoutMs(environment))
@@ -281,20 +261,13 @@ export async function main(arguments_, dependencies = {}) {
         metrics
       })
       activity = parsed.activityLog === undefined ? undefined : new ActivityLog(parsed.activityLog)
-      if (activity && resolvedWorkspace) {
-        activity.recordWorkspace(
-          resolvedWorkspace.profile,
-          resolvedWorkspace.repositoryRoot,
-          resolvedWorkspace.revision,
-          resolvedWorkspace.sourceIdentity
-        )
-      }
       /** @type {import("./run-worker.js").RunWorkerOptions} */
       const workerOptions = {
         executable: provider.executable,
         arguments: provider.arguments,
-        cwd: resolvedWorkspace?.cwd ?? parsed.cwd,
+        cwd: parsed.cwd,
         environment: providerEnvironment,
+        provider: provider.name,
         parse: provider.parse,
         onEvent: (event) => {
           validateNormalizedWorkerEvent(event)
@@ -309,7 +282,7 @@ export async function main(arguments_, dependencies = {}) {
         },
         onRecord: (record) => {
           metrics.recordParsedProviderRecord("provider_stdout")
-          const id = parsed.provider === "kimi" ? kimiSessionEnvelopeId(record) : provider.sessionId(record)
+          const id = provider.sessionId(record)
           if (id !== undefined) {
             admission.setContinuationHandle(id)
             activity?.recordSession(provider.name, id)

package/src/docker-api.js

@@ -60,13 +60,12 @@ export class DockerApi {
       const abort = () => request.destroy(options.signal.reason instanceof Error ? options.signal.reason : new Error("Docker request aborted"))
       if (options.signal?.aborted) abort()
       else options.signal?.addEventListener("abort", abort, {once: true})
-      const deadline = setTimeout(
-        () => request.destroy(new Error(`Docker API ${method} ${path} timed out`)),
-        timeoutMs
-      )
-      deadline.unref()
+      const deadline = timeoutMs > 0
+        ? setTimeout(() => request.destroy(new Error(`Docker API ${method} ${path} timed out`)), timeoutMs)
+        : undefined
+      deadline?.unref()
       request.once("close", () => {
-        clearTimeout(deadline)
+        if (deadline !== undefined) clearTimeout(deadline)
         options.signal?.removeEventListener("abort", abort)
       })
       if (payload !== undefined) request.end(payload)
@@ -77,13 +76,11 @@ export class DockerApi {
   version(options) { return this.request("GET", "/version", undefined, false, options) }
   inspectImage(image, options) { return this.request("GET", `/images/${encodeURIComponent(image)}/json`, undefined, false, options) }
   createNetwork(name, labels = {}, options) {
-    return this.request("POST", "/networks/create", {
-      Name: name,
-      Internal: true,
-      CheckDuplicate: true,
-      EnableIPv6: false,
-      Labels: {"org.threadwire.owner": "isolated-runtime", ...labels}
-    }, false, options)
+    return createNetwork(this.request.bind(this), name, labels, true, options)
+  }
+  /** Create a task-owned non-internal egress network for the per-run Kimi relay. */
+  createEgressNetwork(name, labels = {}, options) {
+    return createNetwork(this.request.bind(this), name, labels, false, options)
   }
   removeNetwork(id, options) { return this.request("DELETE", `/networks/${encodeURIComponent(id)}`, undefined, false, options) }
   inspectNetwork(id, options) { return this.request("GET", `/networks/${encodeURIComponent(id)}`, undefined, false, options) }
@@ -108,8 +105,72 @@ export class DockerApi {
     return this.request("GET", `/networks?filters=${encodeURIComponent(JSON.stringify(filters))}`, undefined, false, options)
   }
   startContainer(id, options) { return this.request("POST", `/containers/${encodeURIComponent(id)}/start`, undefined, false, options) }
-  waitContainer(id, options) { return this.request("POST", `/containers/${encodeURIComponent(id)}/wait?condition=not-running`, undefined, false, options) }
+  waitContainer(id, options = {}) {
+    return this.request("POST", `/containers/${encodeURIComponent(id)}/wait?condition=not-running`, undefined, false, {
+      ...options,
+      timeoutMs: options.timeoutMs ?? 0
+    })
+  }
   logs(id, options) { return this.request("GET", `/containers/${encodeURIComponent(id)}/logs?stdout=1&stderr=1`, undefined, true, options) }
+  /**
+   * Stream a container's multiplexed logs (stdout+stderr, follow) as raw bytes.
+   * Resolves once the follow stream ends (container stop) or rejects on abort,
+   * capacity overflow, or a Docker error. Each `onData` invocation carries one
+   * received chunk; framing/demultiplexing is the caller's responsibility.
+   * @param {string} id @param {(chunk: Buffer) => void} onData @param {{signal?: AbortSignal, timeoutMs?: number}} [options]
+   */
+  streamLogs(id, onData, options = {}) {
+    const timeoutMs = options.timeoutMs
+    const target = dockerTarget(this.host, `/containers/${encodeURIComponent(id)}/logs?stdout=1&stderr=1&follow=1`)
+    return new Promise((resolve, reject) => {
+      let bytes = 0
+      let settled = false
+      const fail = (error) => {
+        if (settled) return
+        settled = true
+        request.destroy()
+        reject(error)
+      }
+      const request = this.requestImplementation({...target, method: "GET", headers: {}}, (response) => {
+        const status = response.statusCode ?? 500
+        if (status < 200 || status >= 300) {
+          response.resume()
+          fail(new Error(`Docker API GET /containers/${id}/logs failed (${status})`))
+          return
+        }
+        response.on("data", (chunk) => {
+          const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+          bytes += buffer.length
+          if (bytes > 8_388_608) {
+            fail(new Error("Docker response exceeded capacity"))
+            return
+          }
+          onData(buffer)
+        })
+        response.on("end", () => {
+          if (settled) return
+          settled = true
+          resolve(undefined)
+        })
+        response.on("error", fail)
+      })
+      request.on("error", (error) => {
+        if (settled) return
+        settled = true
+        reject(error)
+      })
+      const abort = () => fail(options.signal.reason instanceof Error ? options.signal.reason : new Error("Docker request aborted"))
+      if (options.signal?.aborted) abort()
+      else options.signal?.addEventListener("abort", abort, {once: true})
+      const deadline = timeoutMs === undefined ? undefined : setTimeout(() => fail(new Error(`Docker API GET /containers/${id}/logs timed out`)), timeoutMs)
+      deadline?.unref()
+      request.once("close", () => {
+        if (deadline !== undefined) clearTimeout(deadline)
+        options.signal?.removeEventListener("abort", abort)
+      })
+      request.end()
+    })
+  }
   inspectContainer(id, options) { return this.request("GET", `/containers/${encodeURIComponent(id)}/json`, undefined, false, options) }
   removeContainer(id, options) { return this.request("DELETE", `/containers/${encodeURIComponent(id)}?force=1&v=1`, undefined, false, options) }
   createVolume(name, labels = {}, options) {
@@ -119,10 +180,35 @@ export class DockerApi {
     const filters = {label: Object.entries(labels).map(([key, value]) => `${key}=${value}`)}
     return this.request("GET", `/volumes?filters=${encodeURIComponent(JSON.stringify(filters))}`, undefined, false, options)
   }
+  /** List all containers so a volume reference can be inspected fail-closed. */
+  listVolumeReferences(volume, options) {
+    if (typeof volume !== "string" || volume.length === 0) throw new Error("Docker volume reference is invalid")
+    return this.listContainers({}, true, options).then(async (containers) => {
+      if (!Array.isArray(containers)) throw new Error("Docker volume references unavailable")
+      const references = []
+      for (const container of containers) {
+        if (!container || typeof container.Id !== "string") throw new Error("Docker volume references unavailable")
+        const inspection = await this.inspectContainer(container.Id, options)
+        const mounts = Array.isArray(inspection?.Mounts) ? inspection.Mounts : []
+        if (mounts.some((mount) => mount?.Type === "volume" && mount?.Name === volume)) references.push(inspection)
+      }
+      return references
+    })
+  }
   inspectVolume(name, options) { return this.request("GET", `/volumes/${encodeURIComponent(name)}`, undefined, false, options) }
   removeVolume(name, options) { return this.request("DELETE", `/volumes/${encodeURIComponent(name)}?force=0`, undefined, false, options) }
 }
 
+function createNetwork(request, name, labels, internal, options) {
+  return request("POST", "/networks/create", {
+    Name: name,
+    Internal: internal,
+    CheckDuplicate: true,
+    EnableIPv6: false,
+    Labels: {"org.threadwire.owner": "isolated-runtime", ...labels}
+  }, false, options)
+}
+
 function dockerTarget(host, path) {
   const url = new URL(host)
   if (url.protocol === "unix:") return {socketPath: url.pathname, path}

package/src/isolated-runtime-client.js

@@ -1,10 +1,9 @@
 // @ts-nocheck
 /* eslint-disable jsdoc/require-jsdoc */
 
-import {deadlineAfter, abortable, readResponseCapped} from "./absolute-deadline.js"
+import {AbsoluteDeadline, deadlineAfter, abortable, readResponseCapped} from "./absolute-deadline.js"
 
 const MAX_RESPONSE_BYTES = 2_097_152
-const DEFAULT_TIMEOUT_MS = 3_660_000
 const MAX_RAW_OUTPUT_BYTES = 1_048_576
 
 export class IsolatedRuntimeClient {
@@ -13,18 +12,27 @@ export class IsolatedRuntimeClient {
     this.url = normalizedUrl(options.url)
     this.controlToken = nonempty(options.controlToken, "isolated runtime control token")
     this.fetch = options.fetchImplementation ?? fetch
-    this.timeoutMs = positiveDuration(options.timeoutMs, DEFAULT_TIMEOUT_MS)
+    this.timeoutMs = optionalDuration(options.timeoutMs)
   }
 
   /**
-   * @param {{provider: string, profile: string, repositoryRoot: string, cwd: string, providerArguments: string[], resumeSession?: string, signal?: AbortSignal, deadline?: import("./absolute-deadline.js").AbsoluteDeadline}} request
+   * @param {{provider: string, profile: string, repositoryRoot?: string, cwd?: string, binding?: unknown, providerArguments: string[], resumeSession?: string, signal?: AbortSignal, deadline?: import("./absolute-deadline.js").AbsoluteDeadline}} request
    * @returns {Promise<{preflightId: string, deadline?: import("./absolute-deadline.js").AbsoluteDeadline}>}
    */
   async preflight(request) {
-    const deadline = request.deadline ?? deadlineAfter(this.timeoutMs, {signal: request.signal, timeoutMessage: "Isolated runtime launch timeout"})
-    const response = await this.request("/preflight", {...request, launchDeadlineAt: deadline.expiresAt}, deadline)
-    if (response.ok !== true || typeof response.preflightId !== "string") throw new Error("Isolated runtime preflight failed")
-    return {preflightId: response.preflightId, deadline}
+    const deadline = request.deadline ?? (this.timeoutMs === undefined ? undefined : deadlineAfter(this.timeoutMs, {signal: request.signal, timeoutMessage: "Isolated runtime launch timeout"}))
+    const operation = deadline ?? new AbsoluteDeadline(undefined, {signal: request.signal, timeoutMessage: "Isolated runtime launch timeout"})
+    const body = {...request}
+    delete body.signal
+    delete body.deadline
+    if (deadline !== undefined) body.launchDeadlineAt = deadline.expiresAt
+    try {
+      const response = await this.request("/preflight", body, operation)
+      if (response.ok !== true || typeof response.preflightId !== "string") throw new Error("Isolated runtime preflight failed")
+      return deadline === undefined ? {preflightId: response.preflightId} : {preflightId: response.preflightId, deadline}
+    } finally {
+      if (deadline === undefined) operation.close()
+    }
   }
 
   /**
@@ -33,44 +41,42 @@ export class IsolatedRuntimeClient {
    *   resumeSession?: string,
    *   signal?: AbortSignal,
    *   deadline?: import("./absolute-deadline.js").AbsoluteDeadline,
-   *   onEvent: (event: import("./types.js").WorkerEvent) => void | Promise<void>,
-   *   onRecord?: (record: unknown) => void | Promise<void>,
-   *   onStdoutChunk?: (chunk: Buffer) => void | Promise<void>,
-   *   onStderrChunk?: (chunk: Buffer) => void | Promise<void>
+   *   onEvent: (event: import("./types.js").WorkerEvent) => unknown | Promise<unknown>,
+   *   onRecord?: (record: unknown) => unknown | Promise<unknown>,
+   *   onStdoutChunk?: (chunk: Buffer) => unknown | Promise<unknown>,
+   *   onStderrChunk?: (chunk: Buffer) => unknown | Promise<unknown>
    * }} options
+   * @returns {Promise<number>}
    */
   async run(options) {
-    const deadline = options.deadline ?? deadlineAfter(this.timeoutMs, {signal: options.signal, timeoutMessage: "Isolated runtime launch timeout"})
-    const response = await this.request("/run", {
-      preflightId: options.preflightId,
-      prompt: options.prompt,
-      providerArguments: options.providerArguments,
-      ...(options.resumeSession === undefined ? {} : {resumeSession: options.resumeSession})
-    }, deadline)
-    if (!Array.isArray(response.records) || !Array.isArray(response.rawChunks) || !Number.isSafeInteger(response.exitCode)) throw new Error("Isolated runtime emitted an invalid response")
-    let rawBytes = 0
-    const decoded = response.rawChunks.map((item) => {
-      if (!isRecord(item) || Object.keys(item).sort().join(",") !== "channel,data"
-        || (item.channel !== "stdout" && item.channel !== "stderr") || typeof item.data !== "string"
-        || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(item.data)) {
-        throw new Error("Isolated runtime emitted an invalid response")
+    const deadline = options.deadline ?? (this.timeoutMs === undefined ? undefined : deadlineAfter(this.timeoutMs, {signal: options.signal, timeoutMessage: "Isolated runtime launch timeout"}))
+    const operation = deadline ?? new AbsoluteDeadline(undefined, {signal: options.signal, timeoutMessage: "Isolated runtime launch timeout"})
+    try {
+      const response = await abortable(this.fetch(`${this.url}/run`, {
+        method: "POST",
+        redirect: "error",
+        headers: {
+          authorization: `Bearer ${this.controlToken}`,
+          "content-type": "application/json",
+          connection: "close",
+          ...(operation.expiresAt === undefined ? {} : {"x-threadwire-launch-deadline": String(operation.expiresAt)})
+        },
+        body: JSON.stringify({
+          preflightId: options.preflightId,
+          prompt: options.prompt,
+          providerArguments: options.providerArguments,
+          ...(options.resumeSession === undefined ? {} : {resumeSession: options.resumeSession})
+        }),
+        signal: operation.signal
+      }), operation.signal)
+      if (!response.ok) {
+        const bytes = await readResponseCapped(response, MAX_RESPONSE_BYTES, operation.signal)
+        throw new Error(safeRemoteError(bytes))
       }
-      const data = Buffer.from(item.data, "base64")
-      rawBytes += data.length
-      if (rawBytes > MAX_RAW_OUTPUT_BYTES) throw new Error("Isolated runtime emitted an invalid response")
-      return {channel: item.channel, data}
-    })
-    for (const chunk of decoded) {
-      deadline.throwIfAborted()
-      const callback = chunk.channel === "stdout" ? options.onStdoutChunk : options.onStderrChunk
-      await abortable(callback?.(chunk.data), deadline.signal)
+      return await consumeRunStream(response, options, operation)
+    } finally {
+      if (options.deadline === undefined) operation.close()
     }
-    for (const record of response.records) {
-      deadline.throwIfAborted()
-      await abortable(options.onRecord?.(record), deadline.signal)
-      if (isWorkerEventEnvelope(record)) await abortable(options.onEvent(record.event), deadline.signal)
-    }
-    return /** @type {number} */ (response.exitCode)
   }
 
   /** @param {string} path @param {unknown} body */
@@ -83,7 +89,7 @@ export class IsolatedRuntimeClient {
         authorization: `Bearer ${this.controlToken}`,
         "content-type": "application/json",
         connection: "close",
-        "x-threadwire-launch-deadline": String(deadline.expiresAt)
+        ...(deadline.expiresAt === undefined ? {} : {"x-threadwire-launch-deadline": String(deadline.expiresAt)})
       },
       body: JSON.stringify(body),
       signal
@@ -106,8 +112,74 @@ export class IsolatedRuntimeClient {
   }
 }
 
-function positiveDuration(value, fallback) {
-  if (value === undefined) return fallback
+/** @returns {Promise<number>} */
+async function consumeRunStream(response, options, operation) {
+  const reader = response.body?.getReader()
+  if (reader === undefined) throw new Error("Isolated runtime emitted an invalid response")
+  let pending = Buffer.alloc(0)
+  let totalBytes = 0
+  let rawBytes = 0
+  /** @type {number | undefined} */
+  let terminal
+  const consume = async (line) => {
+    if (line.length === 0 || terminal !== undefined) throw new Error("Isolated runtime emitted an invalid response")
+    let frame
+    try { frame = JSON.parse(line.toString("utf8")) } catch { throw new Error("Isolated runtime emitted an invalid response") }
+    if (!isRecord(frame) || typeof frame.type !== "string") throw new Error("Isolated runtime emitted an invalid response")
+    if (frame.type === "chunk") {
+      if (Object.keys(frame).sort().join(",") !== "channel,data,type"
+        || (frame.channel !== "stdout" && frame.channel !== "stderr") || typeof frame.data !== "string"
+        || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(frame.data)) {
+        throw new Error("Isolated runtime emitted an invalid response")
+      }
+      const data = Buffer.from(frame.data, "base64")
+      rawBytes += data.length
+      if (rawBytes > MAX_RAW_OUTPUT_BYTES) throw new Error("Isolated runtime emitted an invalid response")
+      const callback = frame.channel === "stdout" ? options.onStdoutChunk : options.onStderrChunk
+      await abortable(callback?.(data), operation.signal)
+      return
+    }
+    if (frame.type === "record") {
+      if (Object.keys(frame).sort().join(",") !== "record,type") throw new Error("Isolated runtime emitted an invalid response")
+      await abortable(options.onRecord?.(frame.record), operation.signal)
+      if (isWorkerEventEnvelope(frame.record)) await abortable(options.onEvent(frame.record.event), operation.signal)
+      return
+    }
+    if (frame.type === "terminal" && Object.keys(frame).sort().join(",") === "exitCode,type" && Number.isSafeInteger(frame.exitCode)) {
+      terminal = frame.exitCode
+      return
+    }
+    throw new Error("Isolated runtime emitted an invalid response")
+  }
+  try {
+    while (true) {
+      const {done, value} = await abortable(reader.read(), operation.signal)
+      if (done) break
+      const chunk = Buffer.from(value)
+      totalBytes += chunk.length
+      if (totalBytes > MAX_RESPONSE_BYTES) {
+        await reader.cancel(new Error("Response exceeded capacity")).catch(() => {})
+        throw new Error("Isolated runtime response exceeded the configured capacity")
+      }
+      pending = Buffer.concat([pending, chunk])
+      while (true) {
+        const newline = pending.indexOf(0x0a)
+        if (newline < 0) break
+        const line = pending.subarray(0, newline)
+        pending = pending.subarray(newline + 1)
+        await consume(line)
+      }
+    }
+    if (pending.length !== 0 || terminal === undefined) throw new Error("Isolated runtime emitted an invalid response")
+    return terminal
+  } finally {
+    if (operation.signal.aborted) await reader.cancel(operation.signal.reason).catch(() => {})
+    reader.releaseLock()
+  }
+}
+
+function optionalDuration(value) {
+  if (value === undefined || (typeof value === "string" && value.trim().length === 0)) return undefined
   const number = Number(value)
   if (!Number.isSafeInteger(number) || number < 1 || number > 604_800_000) throw new Error("Invalid isolated runtime client timeout")
   return number