threadwire 0.1.12 → 0.1.14

package/src/isolated-runtime.js

@@ -29,6 +29,7 @@ const GRANT_LEASE_MS = 60_000
 const GRANT_LEASE_MAX_MS = 3_600_000
 const PREFLIGHT_TIMEOUT_MS = 30_000
 const MAX_RAW_OUTPUT_BYTES = 1_048_576
+const WORKER_STOP_GRACE_SECONDS = 3
 
 /** @param {{environment?: NodeJS.ProcessEnv, docker?: DockerApi, fetchImplementation?: typeof fetch, now?: () => number}} [options] */
 export async function startIsolatedRuntime(options = {}) {
@@ -160,21 +161,32 @@ export async function startIsolatedRuntime(options = {}) {
         const releaseIncoming = incomingRequests.acquire("run")
         const bodyOperation = new AbsoluteDeadline(Date.now() + preflightTimeoutMs, {signal: shutdown.signal, request, response, timeoutMessage: "Isolated runtime operation timed out"})
         let body
+        let runLifecycle
         try {
-          body = parseRun(await readJson(request, MAX_RUN_BYTES, bodyOperation.signal))
+          if (request.headers["x-threadwire-run-lifecycle"] === "1") {
+            runLifecycle = await readRunLifecycle(request, MAX_RUN_BYTES, bodyOperation.signal)
+            body = parseRun(runLifecycle.value)
+          } else {
+            body = parseRun(await readJson(request, MAX_RUN_BYTES, bodyOperation.signal))
+          }
         } finally {
           bodyOperation.close()
           releaseIncoming()
         }
         const preflight = preflights.consume(body.preflightId)
         if (!preflight) throw new ClientError("Isolated runtime preflight expired")
+        const operationSignal = runLifecycle === undefined
+          ? shutdown.signal
+          : AbortSignal.any([shutdown.signal, runLifecycle.signal])
         const operation = new AbsoluteDeadline(minimumDeadline(preflight.launchDeadlineAt,
           requestedDeadline(request.headers["x-threadwire-launch-deadline"], workerTimeoutMs)), {
-          signal: shutdown.signal, request, response, timeoutMessage: "Isolated runtime launch timed out", disconnectMessage: "Isolated runtime caller disconnected"
+          signal: operationSignal, request, response, timeoutMessage: "Isolated runtime launch timed out", disconnectMessage: "Isolated runtime caller disconnected",
+          destroyRequestOnAbort: runLifecycle === undefined
         })
         const task = taskIdentity(preflight)
         let releaseRun
         let releaseLineage
+        let retainLineage = false
         try {
           releaseRun = activeRuns.acquire(task)
           releaseLineage = activeLineages.acquire(preflight.state.lineage)
@@ -188,6 +200,7 @@ export async function startIsolatedRuntime(options = {}) {
             if (!response.headersSent) response.writeHead(200, {"content-type": "application/x-ndjson"})
             if (!response.write(`${JSON.stringify(frame)}\n`)) await abortable(once(response, "drain"), operation.signal)
           }
+          if (runLifecycle !== undefined && !response.headersSent) response.writeHead(200, {"content-type": "application/x-ndjson"})
           const result = await runIsolatedWorker({
             docker, workerImage, brokerUrl, brokerAdminToken, brokerContainer, relayImage, relayWorkerUrl,
             fetchImplementation, preflight, ...body, task, now, stateRegistry, sessionTtlMs, operation, grantLeaseMs,
@@ -197,9 +210,13 @@ export async function startIsolatedRuntime(options = {}) {
           for (const chunk of result.rawChunks) await writeFrame({type: "chunk", ...chunk})
           await writeFrame({type: "terminal", exitCode: result.exitCode})
           response.end()
+        } catch (error) {
+          if (error instanceof ContainerCleanupConfirmationError) retainLineage = true
+          throw error
         } finally {
           operation.close()
-          releaseLineage?.()
+          runLifecycle?.close()
+          if (!retainLineage) releaseLineage?.()
           releaseRun?.()
           void collectState()
         }
@@ -209,7 +226,9 @@ export async function startIsolatedRuntime(options = {}) {
       response.end()
     } catch (error) {
       if (response.headersSent) {
-        if (!response.writableEnded && !response.destroyed) response.end(`${JSON.stringify({type: "terminal", exitCode: 1})}\n`)
+        if (!response.writableEnded && !response.destroyed) {
+          response.end(error instanceof ContainerCleanupConfirmationError ? undefined : `${JSON.stringify({type: "terminal", exitCode: 1})}\n`)
+        }
         return
       }
       sendJson(response, error instanceof ClientError ? 400 : 503, {
@@ -367,6 +386,9 @@ export async function runIsolatedWorker(options) {
   let grantRenewalTimer
   let runTracked = false
   let runStage = "state"
+  let workerResult
+  let runError
+  let cleanupFailure
   const operation = options.operation
   const worktreeSubpath = options.worktreeVolume === undefined
     ? ""
@@ -632,10 +654,10 @@ export async function runIsolatedWorker(options) {
         throw error
       }
     }
-    return result
+    workerResult = result
   } catch (error) {
     process.stderr.write(`threadwire-runtime: isolated run failed at ${runStage}\n`)
-    throw error
+    runError = error
   } finally {
     let resourcesRemoved = true
     if (grantRenewalTimer !== undefined) clearInterval(grantRenewalTimer)
@@ -658,10 +680,17 @@ export async function runIsolatedWorker(options) {
       resourcesRemoved = false
       process.stderr.write("threadwire-isolated-runtime: validator cleanup failed\n")
     })
-    if (containerId !== undefined) await cleanupDocker(() => options.docker.removeContainer(containerId, cleanupOptions())).catch(() => {
-      resourcesRemoved = false
-      process.stderr.write("threadwire-isolated-runtime: worker cleanup failed\n")
-    })
+    if (containerId !== undefined) {
+      try {
+        await stopAndRemoveWorkerContainer(options.docker, containerId, cleanupOptions())
+      } catch (error) {
+        resourcesRemoved = false
+        cleanupFailure = error instanceof ContainerCleanupConfirmationError
+          ? error
+          : new ContainerCleanupConfirmationError({cause: error})
+        process.stderr.write("threadwire-isolated-runtime: worker cleanup failed\n")
+      }
+    }
     if (relayId !== undefined) await cleanupDocker(() => options.docker.removeContainer(relayId, cleanupOptions())).catch(() => {
       resourcesRemoved = false
       process.stderr.write("threadwire-isolated-runtime: relay cleanup failed\n")
@@ -677,16 +706,43 @@ export async function runIsolatedWorker(options) {
       resourcesRemoved = false
       process.stderr.write("threadwire-isolated-runtime: egress network cleanup failed\n")
     })
-    if (freshState && !keepFreshState) await cleanupDocker(() => options.docker.removeVolume(state.volume, cleanupOptions())).catch(() => { resourcesRemoved = false })
+    if (freshState && !keepFreshState && resourcesRemoved) await cleanupDocker(() => options.docker.removeVolume(state.volume, cleanupOptions())).catch(() => { resourcesRemoved = false })
     if (runTracked && resourcesRemoved) await options.stateRegistry.completeRun(runId, cleanupOperation.signal).catch(() => {})
     emergencyCleanup?.close()
   }
+  if (cleanupFailure !== undefined) throw cleanupFailure
+  if (runError !== undefined) throw runError
+  return workerResult
 }
 
 async function cleanupDocker(operation) {
   return operation()
 }
 
+async function stopAndRemoveWorkerContainer(docker, containerId, requestOptions) {
+  let inspection = await docker.inspectContainer(containerId, requestOptions)
+  if (typeof inspection?.State?.Running !== "boolean") throw new Error("Worker container state unavailable")
+  if (inspection.State.Running) {
+    await docker.stopContainer(containerId, WORKER_STOP_GRACE_SECONDS, requestOptions)
+    inspection = await docker.inspectContainer(containerId, requestOptions)
+    if (typeof inspection?.State?.Running !== "boolean") throw new Error("Worker container state unavailable")
+    if (inspection.State.Running) {
+      await docker.killContainer(containerId, "KILL", requestOptions)
+      inspection = await docker.inspectContainer(containerId, requestOptions)
+      if (inspection?.State?.Running !== false) throw new ContainerCleanupConfirmationError()
+    }
+  }
+  await docker.removeContainer(containerId, requestOptions)
+}
+
+class ContainerCleanupConfirmationError extends Error {
+  /** @param {{cause?: unknown}} [options] */
+  constructor(options = {}) {
+    super("Worker container cleanup could not be confirmed", options)
+    this.name = "ContainerCleanupConfirmationError"
+  }
+}
+
 export async function prepareStateVolume(docker, state, fresh, requestOptions) {
   if (fresh) await docker.createVolume(state.volume, state.labels, requestOptions)
   const volume = await docker.inspectVolume(state.volume, requestOptions).catch(() => undefined)
@@ -1069,6 +1125,84 @@ async function readJson(request, capacity, signal) {
   }
 }
 
+function readRunLifecycle(request, capacity, signal) {
+  const cancellation = new AbortController()
+  /** @type {Buffer[]} */
+  const chunks = []
+  let bytes = 0
+  let parsed = false
+  let settled = false
+  const cancel = (reason) => cancellation.abort(reason instanceof Error ? reason : new Error("Isolated runtime caller cancelled"))
+  const close = () => {
+    request.off("data", onData)
+    request.off("end", onEnd)
+    request.off("aborted", onAborted)
+    request.off("error", onError)
+    signal?.removeEventListener("abort", onSignal)
+  }
+  /** @type {(value: {value: unknown, signal: AbortSignal, close: () => void}) => void} */
+  let resolveLifecycle
+  /** @type {(error: Error) => void} */
+  let rejectLifecycle
+  const fail = (error) => {
+    if (parsed) {
+      cancel(error)
+      return
+    }
+    if (settled) return
+    settled = true
+    close()
+    rejectLifecycle(error)
+  }
+  const onData = (chunk) => {
+    if (parsed) {
+      fail(new ClientError("Invalid request"))
+      return
+    }
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+    bytes += buffer.length
+    if (bytes > capacity) {
+      fail(new ClientError("Request exceeded capacity"))
+      return
+    }
+    chunks.push(buffer)
+    const combined = Buffer.concat(chunks, bytes)
+    const newline = combined.indexOf(0x0a)
+    if (newline < 0) return
+    if (newline !== combined.length - 1) {
+      fail(new ClientError("Invalid request"))
+      return
+    }
+    let value
+    try {
+      value = JSON.parse(combined.subarray(0, newline).toString("utf8"))
+    } catch {
+      fail(new ClientError("Invalid request"))
+      return
+    }
+    parsed = true
+    settled = true
+    resolveLifecycle({value, signal: cancellation.signal, close})
+  }
+  const onEnd = () => parsed
+    ? cancel(new Error("Isolated runtime caller cancelled"))
+    : fail(new ClientError("Invalid request"))
+  const onAborted = () => fail(new Error("Isolated runtime caller disconnected"))
+  const onError = (error) => fail(error)
+  const onSignal = () => fail(signal.reason instanceof Error ? signal.reason : new Error("Isolated runtime operation aborted"))
+  const lifecycle = new Promise((resolve, reject) => {
+    resolveLifecycle = resolve
+    rejectLifecycle = reject
+  })
+  request.on("data", onData)
+  request.once("end", onEnd)
+  request.once("aborted", onAborted)
+  request.once("error", onError)
+  if (signal?.aborted) onSignal()
+  else signal?.addEventListener("abort", onSignal, {once: true})
+  return lifecycle
+}
+
 function requireControl(value, expected) {
   if (value !== `Bearer ${expected}`) throw new ClientError("Request denied")
 }

package/src/jsonl-record-spool.js

@@ -0,0 +1,178 @@
+// @ts-check
+
+import {closeSync, mkdtempSync, openSync, readFileSync, rmSync, unlinkSync, writeSync} from "node:fs"
+import {tmpdir} from "node:os"
+import {isAbsolute, join, normalize} from "node:path"
+
+/**
+ * Single-owner byte-oriented spool for one worker's pending JSONL record.
+ *
+ * Worker stdout is consumed as raw bytes. A pending record (bytes not yet
+ * terminated by `\n`) is kept in bounded memory while it stays below
+ * `memoryBytes`; beyond that threshold it spills exactly once to one private
+ * run-scoped file, writing every byte segment exactly once. Newline scanning
+ * happens on raw bytes: `0x0a` can never appear inside a multibyte UTF-8
+ * sequence, so newline boundaries are preserved across arbitrary chunk splits
+ * and completed records always decode as well-formed UTF-8.
+ *
+ * `maxBytes` is a separate absolute pending-record cap: unterminated or
+ * malformed output can never consume unbounded memory, disk, or JSON.parse
+ * allocation. `close()` is idempotent and removes every spool artifact; the
+ * owner calls it on every settlement path.
+ */
+export class JsonlRecordSpool {
+  /** @param {{memoryBytes: number, maxBytes: number, directory?: string}} options */
+  constructor(options) {
+    this.memoryBytes = positiveSafeInteger(options.memoryBytes, "memoryBytes")
+    this.maxBytes = positiveSafeInteger(options.maxBytes, "maxBytes")
+    const directory = options.directory ?? tmpdir()
+    if (!isAbsolute(directory) || normalize(directory) !== directory) throw new Error("directory must be a normalized absolute path")
+    this.directory = directory
+    /** @type {Buffer[]} */
+    this.segments = []
+    this.pendingBytes = 0
+    /** @type {{fd: number, path: string} | null} */
+    this.file = null
+    /** @type {string | null} */
+    this.ownedDirectory = null
+    this.closed = false
+  }
+
+  /**
+   * Consume one stdout chunk and yield each completed record in order, decoded
+   * as UTF-8 without the terminating newline. Scanning advances only as the
+   * owner consumes records, so terminal protocol completion can leave trailing
+   * bytes in the same chunk untouched.
+   * @param {Buffer} chunk
+   * @returns {Generator<string>}
+   * @yields {string}
+   */
+  *push(chunk) {
+    if (this.closed) throw new Error("JSONL record spool is closed")
+    let segmentStart = 0
+    for (let index = 0; index < chunk.length; index += 1) {
+      if (chunk[index] !== 0x0a) continue
+      const record = this.completeRecord(chunk.subarray(segmentStart, index))
+      segmentStart = index + 1
+      try {
+        yield record
+      } finally {
+        this.removeOwnedDirectory()
+      }
+    }
+    if (segmentStart < chunk.length) this.append(chunk.subarray(segmentStart))
+  }
+
+  /**
+   * End of stream: return the pending record ("" when none) and release it.
+   * @returns {string}
+   */
+  end() {
+    if (this.closed || this.pendingBytes === 0) return ""
+    let record
+    if (this.file === null) {
+      record = Buffer.concat(this.segments, this.pendingBytes).toString("utf8")
+      this.segments = []
+    } else {
+      const file = this.file
+      this.file = null
+      closeSync(file.fd)
+      record = readFileSync(file.path, "utf8")
+      unlinkSync(file.path)
+      this.removeOwnedDirectory()
+    }
+    this.pendingBytes = 0
+    return record
+  }
+
+  /** Idempotent: close the spool file and remove every run-scoped artifact. */
+  close() {
+    if (this.closed) return
+    this.closed = true
+    this.segments = []
+    const file = this.file
+    this.file = null
+    if (file !== null) {
+      closeSync(file.fd)
+      rmSync(file.path, {force: true})
+    }
+    this.removeOwnedDirectory()
+  }
+
+  /**
+   * Finish one record: combine the pending bytes with the final segment and
+   * decode exactly once. A spilled record is closed, read back, and unlinked;
+   * the next oversized record spills into a freshly created file, so at most
+   * one private file ever exists for the run.
+   * @param {Buffer} finalSegment @returns {string}
+   */
+  completeRecord(finalSegment) {
+    const recordBytes = this.pendingBytes + finalSegment.length
+    if (recordBytes > this.maxBytes) throw new StdoutRecordTooLargeError()
+    if (this.file === null && recordBytes <= this.memoryBytes) {
+      const record = this.pendingBytes === 0
+        ? finalSegment.toString("utf8")
+        : Buffer.concat([...this.segments, finalSegment], recordBytes).toString("utf8")
+      this.segments = []
+      this.pendingBytes = 0
+      return record
+    }
+    if (this.file === null) this.append(finalSegment)
+    else {
+      this.pendingBytes = recordBytes
+      writeSync(this.file.fd, finalSegment)
+    }
+    const file = this.file
+    if (file === null) throw new Error("JSONL record spool file is unavailable")
+    this.file = null
+    closeSync(file.fd)
+    const record = readFileSync(file.path, "utf8")
+    unlinkSync(file.path)
+    this.pendingBytes = 0
+    return record
+  }
+
+  /** @param {Buffer} segment */
+  append(segment) {
+    this.pendingBytes += segment.length
+    if (this.pendingBytes > this.maxBytes) throw new StdoutRecordTooLargeError()
+    if (this.file !== null) {
+      writeSync(this.file.fd, segment)
+      return
+    }
+    if (this.pendingBytes <= this.memoryBytes) {
+      this.segments.push(segment)
+      return
+    }
+    // First threshold crossing: create the private run-scoped file and write
+    // each buffered segment exactly once, in order.
+    this.ownedDirectory = mkdtempSync(join(this.directory, "threadwire-record-"))
+    const path = join(this.ownedDirectory, "pending-record")
+    const fd = openSync(path, "wx", 0o600)
+    this.file = {fd, path}
+    for (const buffered of this.segments) writeSync(fd, buffered)
+    this.segments = []
+    writeSync(fd, segment)
+  }
+
+  /** Remove the current record's private spill directory, if one exists. */
+  removeOwnedDirectory() {
+    const directory = this.ownedDirectory
+    if (directory === null) return
+    rmSync(directory, {recursive: true, force: true})
+    this.ownedDirectory = null
+  }
+}
+
+export class StdoutRecordTooLargeError extends Error {
+  constructor() {
+    super("Worker stdout record exceeded the configured byte capacity")
+    this.name = "StdoutRecordTooLargeError"
+  }
+}
+
+/** @param {number} value @param {string} name */
+function positiveSafeInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) throw new Error(`${name} must be a positive safe integer`)
+  return value
+}

package/src/kimi-oauth-store.js

@@ -7,6 +7,7 @@ import {dirname, isAbsolute, join} from "node:path"
 
 const MAX_CREDENTIAL_BYTES = 65_536
 const MAX_TOKEN_BYTES = 8_192
+const CURRENT_TOKEN_SAFETY_MARGIN_SECONDS = 30
 const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098"
 const TOKEN_URL = "https://auth.kimi.com/api/oauth/token"
 const EXACT_KEYS = ["access_token", "expires_at", "expires_in", "refresh_token", "scope", "token_type"]
@@ -117,6 +118,19 @@ export async function openKimiOAuthStore(options) {
       refreshInFlight = operation
       return operation
     },
+    /**
+     * Non-mutating read for observational callers: returns the already-loaded
+     * access token only when it stays valid beyond a fixed 30-second safety
+     * margin. It never fetches, refreshes, persists, renames, chmods, or
+     * tombstones; logged-out credentials fail with the fixed needs-login error
+     * and expired or near-expiry credentials fail with the fixed
+     * refresh-required error.
+     */
+    async getCurrentAccessToken() {
+      if (credential.access_token.length === 0) throw needsLogin()
+      if (credential.expires_at - now() <= CURRENT_TOKEN_SAFETY_MARGIN_SECONDS) throw refreshRequired()
+      return credential.access_token
+    },
     async health() {
       return credential.access_token.length === 0
         ? {ready: false, needsLogin: true}
@@ -263,5 +277,7 @@ function record(value) { return typeof value === "object" && value !== null && !
 function unavailable() { return new Error("Kimi OAuth credential file is unavailable") }
 /** @returns {Error} */
 function needsLogin() { return new Error("Kimi OAuth credential was rejected; re-login required") }
+/** @returns {Error} */
+function refreshRequired() { return new Error("Kimi OAuth credential requires refresh") }
 /** @param {unknown} [cause] @returns {Error} */
 function refreshUnavailable(cause) { return new Error("Kimi OAuth refresh is unavailable", cause === undefined ? undefined : {cause}) }

package/src/provider-capacity-codex.js

@@ -0,0 +1,176 @@
+// @ts-check
+
+import {spawn} from "node:child_process"
+import {providerExecutable} from "./providers/executable.js"
+import {CapacityProbeError, DEFAULT_CAPACITY_TIMEOUT_MS, normalizeCodexRateLimits} from "./provider-capacity.js"
+
+const DEFAULT_EXECUTABLE = "/opt/data/libexec/threadwire/codex"
+const MAX_LINE_BYTES = 65_536
+const MAX_LINES = 1_024
+
+/**
+ * Probe live Codex account capacity through `codex app-server` JSON-RPC over
+ * stdio: `initialize` followed by `account/rateLimits/read`. The child is
+ * always killed, its stderr is consumed but never forwarded, and server error
+ * detail (which can carry account or credential material) is never propagated —
+ * failures classify with fixed, credential-free messages.
+ * @param {{
+ *   env?: NodeJS.ProcessEnv,
+ *   spawnImplementation?: typeof spawn | undefined,
+ *   timeoutMs?: number
+ * }} options
+ * @returns {Promise<import("./provider-capacity.js").CapacityWindows>}
+ */
+export async function probeCodexCapacity(options) {
+  const environment = options.env ?? process.env
+  const spawnImplementation = options.spawnImplementation ?? spawn
+  const timeoutMs = options.timeoutMs ?? DEFAULT_CAPACITY_TIMEOUT_MS
+  const executable = providerExecutable("THREADWIRE_CODEX_BIN", DEFAULT_EXECUTABLE, environment)
+  const result = await appServerExchange(spawnImplementation, executable, environment, timeoutMs)
+  return normalizeCodexRateLimits(result)
+}
+
+/**
+ * Run the bounded two-request JSON-RPC exchange and resolve with the raw
+ * `account/rateLimits/read` result for fail-closed normalization.
+ * @param {typeof spawn} spawnImplementation
+ * @param {string} executable
+ * @param {NodeJS.ProcessEnv} environment
+ * @param {number} timeoutMs
+ * @returns {Promise<unknown>}
+ */
+function appServerExchange(spawnImplementation, executable, environment, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    /** @type {ReturnType<typeof spawn>} */
+    let child
+    try {
+      child = spawnImplementation(executable, ["app-server"], {env: environment, stdio: ["pipe", "pipe", "pipe"]})
+    } catch {
+      reject(new CapacityProbeError("unavailable", "Codex app-server is unavailable"))
+      return
+    }
+    let settled = false
+    let buffer = ""
+    let lines = 0
+    let phase = "initialize"
+    // The timer is always cleared by finish, so it never outlives the exchange.
+    const timer = setTimeout(() => {
+      fail(new CapacityProbeError("unavailable", "Codex app-server capacity probe timed out"))
+    }, timeoutMs)
+
+    /**
+     * @param {(value: unknown) => void} settle
+     * @param {unknown} value
+     */
+    function finish(settle, value) {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      child.kill()
+      settle(value)
+    }
+
+    /** @param {CapacityProbeError} error */
+    function fail(error) {
+      finish(reject, error)
+    }
+
+    /** @param {Record<string, unknown>} request */
+    function write(request) {
+      try {
+        child.stdin?.write(`${JSON.stringify(request)}\n`)
+      } catch {
+        fail(new CapacityProbeError("unavailable", "Codex app-server is unavailable"))
+      }
+    }
+
+    /** @param {string} line */
+    function handleLine(line) {
+      if (line.trim().length === 0) return
+      /** @type {unknown} */
+      let message
+      try {
+        message = JSON.parse(line)
+      } catch {
+        fail(new CapacityProbeError("protocol", "Codex app-server emitted a malformed record"))
+        return
+      }
+      if (!isRecord(message) || (message.id !== 1 && message.id !== 2)) return
+      if (message.error !== undefined) {
+        if (message.id === 1 || phase === "initialize") {
+          fail(new CapacityProbeError("protocol", "Codex app-server initialize failed"))
+        } else if (isAuthRejection(message.error)) {
+          fail(new CapacityProbeError("auth", "Codex rate-limits credential was rejected"))
+        } else {
+          fail(new CapacityProbeError("protocol", "Codex rate-limits request failed"))
+        }
+        return
+      }
+      if (message.id === 1) {
+        if (phase !== "initialize") {
+          fail(new CapacityProbeError("protocol", "Codex app-server answered out of order"))
+          return
+        }
+        phase = "read"
+        write({jsonrpc: "2.0", id: 2, method: "account/rateLimits/read"})
+        return
+      }
+      if (phase !== "read") {
+        fail(new CapacityProbeError("protocol", "Codex app-server answered out of order"))
+        return
+      }
+      finish(resolve, message.result)
+    }
+
+    child.on("error", () => fail(new CapacityProbeError("unavailable", "Codex app-server is unavailable")))
+    child.on("close", () => fail(new CapacityProbeError("unavailable", "Codex app-server exited before answering")))
+    child.stdin?.on("error", () => {})
+    child.stderr?.on("data", () => {})
+    child.stdout?.on("data", (chunk) => {
+      if (settled) return
+      buffer += /** @type {Buffer} */ (chunk).toString("utf8")
+      let index = buffer.indexOf("\n")
+      while (index >= 0 && !settled) {
+        const line = buffer.slice(0, index)
+        buffer = buffer.slice(index + 1)
+        lines += 1
+        if (line.length > MAX_LINE_BYTES || lines > MAX_LINES) {
+          fail(new CapacityProbeError("protocol", "Codex app-server exceeded the bounded exchange"))
+          return
+        }
+        handleLine(line)
+        index = buffer.indexOf("\n")
+      }
+      if (!settled && buffer.length > MAX_LINE_BYTES) {
+        fail(new CapacityProbeError("protocol", "Codex app-server exceeded the bounded exchange"))
+      }
+    })
+
+    write({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "initialize",
+      params: {clientInfo: {name: "threadwire-capacity", version: "1"}}
+    })
+  })
+}
+
+/**
+ * A JSON-RPC error whose server message indicates an authentication or login
+ * failure classifies as `auth`; everything else stays `protocol`. The server
+ * message itself is only inspected, never propagated.
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+function isAuthRejection(value) {
+  if (!isRecord(value) || typeof value.message !== "string") return false
+  return /auth|login|unauthorized|token/iu.test(value.message)
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is Record<string, unknown>}
+ */
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}