## What Problem This Solves The app-server worker awaits a CrabFleet work-state POST before sending `turn/start`. A status endpoint that accepts the socket but never responds can consume the entire review budget without starting the model turn. Heartbeat and completion updates share the same unbounded helper. ## Why This Change Was Made Apply the existing action-session client's 15-second native fetch deadline to the worker's shared work-state helper. Status-update failures remain non-fatal, so the turn can proceed and later status updates can refresh the display. The contributor branch is integrated with main `e1e4250868f1c6783d9570fd9a1f62d904487c4c`. Conflict repair preserves current permission-profile handling and the consume-on-read worker handoff. @Yigtwxx's original commit is retained; the final notes PR carries the changelog thanks. ## User Impact A stalled optional status update no longer blocks useful work indefinitely. A valid status response taking more than 15 seconds is abandoned, matching the established adjacent client contract. No OpenClaw Bay schema, route, or control changes are needed. ## Real Behavior Proof Executed against integrated head `51f325bd50bbb60b4aee8d3c9974cf43188054d6` on macOS with Node 24.20.0 and pinned pnpm 11.10.0. The compiled parent and worker use native fetch and timers against a real loopback HTTP server. A synthetic app-server process provides the external model protocol. The first status request never responds; subsequent requests return 204. Both arms use a 20-second process budget. | Arm | Result | Elapsed | turn/start | Stalled socket | |---|---|---:|---|---| | Main worker | ETIMEDOUT, no output | 20,102 ms | Never sent | Closed only when worker terminated | | Integrated candidate | Exit 0, planned result written | 15,308 ms | Sent once | Closed after 14,985 ms | The candidate records one non-fatal timeout, then emits active and completion status updates with the expected synthetic authorization. The driver below reproduces the compiled baseline/candidate comparison; its baseline is pinned to current main. Local receipts record the process result, RPC methods, status summaries, timing, and output, without exposing credentials. Limits: native transport and process integration, not live CrabFleet or model inference. The 60-second heartbeat timer is not waited out; it uses the same exercised helper. This does not claim hosted-runner deployment. ## Evidence - `node --test test/codex-process.test.ts`: 13 passed, including the stalled HTTP regression and both permission-profile cases. - Builds, static checks, and all lint targets pass. - Pre-commit independent review is clean through P2. Final branch review and exact-head full `pnpm check` CI are recorded in the proof follow-up. - No accepted finding remains unresolved. The availability tradeoff matches the already established 15-second action-session contract.

Reproducible compiled transport proof

```bash #!/usr/bin/env bash # Crabbox local-container proof for PR 1423 (app-server worker work-state deadline). # Runs inside a Node 24 Linux container on a fresh checkout of the PR head, builds the # main lane, compiles the PRE-FIX worker from the base commit so the before/after # contrast is measured, then runs the two-arm driver and the focused suite. set -euo pipefail ART=".artifacts/csw-work-state-container" mkdir -p "$ART" BASE_SHA="${CSW_PROOF_BASE:-e1e4250868f1c6783d9570fd9a1f62d904487c4c}" WORKER="src/codex-app-server-worker.ts" echo "== environment ==" uname -a node --version echo "head: $(git rev-parse HEAD)" echo "base: $BASE_SHA" echo echo "== toolchain ==" export PNPM_HOME="$HOME/.local/bin" mkdir -p "$PNPM_HOME" export PATH="$PNPM_HOME:$PATH" if ! command -v pnpm >/dev/null 2>&1; then corepack enable --install-directory "$PNPM_HOME" >/dev/null 2>&1 || true fi if ! command -v pnpm >/dev/null 2>&1; then npm install -g --prefix "$HOME/.local" pnpm@11.10.0 >"$ART/pnpm-install.log" 2>&1 || true fi command -v pnpm >/dev/null 2>&1 || { echo "FAIL: pnpm unavailable"; exit 1; } echo "pnpm: $(pnpm --version)" pnpm install --frozen-lockfile >"$ART/install.log" 2>&1 || { echo "FAIL: pnpm install"; tail -30 "$ART/install.log"; exit 1; } pnpm run build >"$ART/build.log" 2>&1 || { echo "FAIL: pnpm run build"; tail -30 "$ART/build.log"; exit 1; } echo "candidate worker AbortSignal references: $(grep -c 'AbortSignal.timeout' dist/codex-app-server-worker.js)" echo echo "== compile pre-fix worker from $BASE_SHA ==" git cat-file -e "$BASE_SHA" 2>/dev/null || git fetch --quiet origin "$BASE_SHA" git show "$BASE_SHA:$WORKER" >"$ART/baseline-worker.ts" echo "diff lines between base and head worker: $(diff "$ART/baseline-worker.ts" "$WORKER" | grep -c '^[<>]' || true)" cp "$WORKER" "$ART/head-worker.ts" cp "$ART/baseline-worker.ts" "$WORKER" ./node_modules/.bin/tsc -p tsconfig.json --outDir "$ART/baseline-dist" >"$ART/baseline-build.log" 2>&1 \ || { echo "FAIL: baseline tsc"; tail -30 "$ART/baseline-build.log"; cp "$ART/head-worker.ts" "$WORKER"; exit 1; } cp "$ART/head-worker.ts" "$WORKER" git diff --quiet -- "$WORKER" || { echo "FAIL: worker source not restored"; exit 1; } echo "baseline worker AbortSignal references: $(grep -c 'AbortSignal.timeout' "$ART/baseline-dist/codex-app-server-worker.js" || true)" echo echo "== two-arm driver ==" cat >"$ART/proof.mjs" <<'EOF' import { spawn, execFileSync } from "node:child_process"; import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; import { tmpdir } from "node:os"; import { dirname, join, resolve } from "node:path"; import { fileURLToPath, pathToFileURL } from "node:url"; const here = dirname(fileURLToPath(import.meta.url)); const repoRoot = resolve(here, "..", ".."); const arms = [ { name: "baseline (base commit worker)", dist: join(here, "baseline-dist") }, { name: "candidate (PR head)", dist: join(repoRoot, "dist") }, ]; const WORKER_TIMEOUT_MS = 20_000; const fakeAppServer = ` const fs = require("node:fs"); const readline = require("node:readline"); const requestsPath = process.env.CODEX_TEST_REQUESTS_PATH; const rl = readline.createInterface({ input: process.stdin }); function send(value) { process.stdout.write(JSON.stringify(value) + "\\n"); } rl.on("line", (line) => { const message = JSON.parse(line); fs.appendFileSync(requestsPath, JSON.stringify({ at: Date.now(), method: message.method }) + "\\n"); if (message.method === "initialize") { send({ id: message.id, result: { userAgent: "fake", codexHome: "/tmp", platformFamily: "unix", platformOs: "linux" } }); } else if (message.method === "thread/start") { send({ id: message.id, result: { thread: { id: "thread-1", sessionId: "session-1" } } }); } else if (message.method === "turn/start") { send({ id: message.id, result: { turn: { id: "turn-1", status: "inProgress", items: [] } } }); setTimeout(() => { send({ method: "item/completed", params: { threadId: "thread-1", turnId: "turn-1", completedAtMs: Date.now(), item: { type: "agentMessage", id: "message-1", text: '{"status":"planned"}' } } }); send({ method: "turn/completed", params: { threadId: "thread-1", turn: { id: "turn-1", status: "completed", items: [] } } }); }, 5); } }); `; const workStateServer = ` const fs = require("node:fs"); const http = require("node:http"); const logPath = process.env.WORK_STATE_LOG_PATH; let updates = 0; const server = http.createServer((request, response) => { let body = ""; request.setEncoding("utf8"); request.on("data", (chunk) => { body += chunk; }); request.on("end", () => { updates += 1; fs.appendFileSync(logPath, JSON.stringify({ event: "request", at: Date.now(), authorization: request.headers.authorization, summary: JSON.parse(body).summary }) + "\\n"); if (updates === 1) { request.socket.once("close", () => { fs.appendFileSync(logPath, JSON.stringify({ event: "stalled-socket-closed", at: Date.now() }) + "\\n"); }); return; } response.writeHead(204); response.end(); }); }); server.listen(0, "127.0.0.1", () => { fs.writeFileSync(process.env.WORK_STATE_PORT_PATH, String(server.address().port)); }); `; async function runArm(arm) { const { runCodexProcess, codexProcessErrorCode } = await import( pathToFileURL(join(arm.dist, "codex-process.js")).href ); const root = mkdtempSync(join(tmpdir(), "csw-work-state-proof-")); const binDir = join(root, "node_modules", ".bin"); mkdirSync(binDir, { recursive: true }); const scriptPath = join(root, "app-server-codex.cjs"); writeFileSync(scriptPath, fakeAppServer); const codexPath = join(binDir, "codex"); writeFileSync(codexPath, `#!/usr/bin/env node\n${fakeAppServer}`, { mode: 0o755 }); const serverPath = join(root, "work-state-server.cjs"); writeFileSync(serverPath, workStateServer); const logPath = join(root, "work-state.jsonl"); const portPath = join(root, "port.txt"); const requestsPath = join(root, "requests.jsonl"); const outputPath = join(root, "last-message.json"); const server = spawn(process.execPath, [serverPath], { env: { ...process.env, WORK_STATE_LOG_PATH: logPath, WORK_STATE_PORT_PATH: portPath }, stdio: "ignore", }); try { for (let attempt = 0; attempt < 200 && !existsSync(portPath); attempt += 1) { await new Promise((r) => setTimeout(r, 25)); } const port = Number(readFileSync(portPath, "utf8")); const startedAt = Date.now(); const result = runCodexProcess({ args: ["exec", "--cd", root, "--output-last-message", outputPath, "--json", "-"], cwd: root, env: { ...process.env, CODEX_BIN: codexPath, CODEX_TEST_REQUESTS_PATH: requestsPath }, input: "Plan the repair.", timeoutMs: WORKER_TIMEOUT_MS, appServer: { statePath: join(root, "session", "state.json"), label: "proof worker", workStateUrl: `http://127.0.0.1:${port}/work-state`, agentToken: "proof-agent-token", }, }); const elapsedMs = Date.now() - startedAt; for (let attempt = 0; attempt < 100; attempt += 1) { if (existsSync(logPath) && readFileSync(logPath, "utf8").includes("stalled-socket-closed")) break; await new Promise((r) => setTimeout(r, 25)); } const events = existsSync(logPath) ? readFileSync(logPath, "utf8").trim().split("\n").filter(Boolean).map((l) => JSON.parse(l)) : []; const rpc = existsSync(requestsPath) ? readFileSync(requestsPath, "utf8").trim().split("\n").filter(Boolean).map((l) => JSON.parse(l)) : []; const firstRequest = events.find((e) => e.event === "request"); const closed = events.find((e) => e.event === "stalled-socket-closed"); return { arm: arm.name, status: result.status, signal: result.signal, errorCode: codexProcessErrorCode(result.error), errorMessage: result.error?.message ?? null, elapsedMs, outputWritten: existsSync(outputPath) ? readFileSync(outputPath, "utf8") : null, rpcMethods: rpc.map((r) => r.method), workStateSummaries: events.filter((e) => e.event === "request").map((e) => e.summary), authorizationValid: events.filter((e) => e.event === "request").every((e) => e.authorization === "Bearer proof-agent-token"), stalledSocketClosedAfterMs: firstRequest && closed ? closed.at - firstRequest.at : null, stderr: result.stderr.trim().split("\n").filter(Boolean), }; } finally { server.kill(); rmSync(root, { recursive: true, force: true }); } } const head = execFileSync("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8" }).trim(); const results = []; for (const arm of arms) results.push(await runArm(arm)); const [baseline, candidate] = results; const pass = baseline.errorCode === "ETIMEDOUT" && baseline.status !== 0 && !baseline.rpcMethods.includes("turn/start") && baseline.workStateSummaries.length === 1 && baseline.stalledSocketClosedAfterMs !== null && baseline.stalledSocketClosedAfterMs >= WORKER_TIMEOUT_MS - 500 && candidate.status === 0 && candidate.errorCode === null && candidate.rpcMethods.filter((m) => m === "turn/start").length === 1 && candidate.outputWritten === '{"status":"planned"}' && JSON.stringify(candidate.workStateSummaries) === JSON.stringify(["Codex turn starting", "Codex turn active", "Codex turn complete; validating result"]) && candidate.stalledSocketClosedAfterMs !== null && candidate.stalledSocketClosedAfterMs >= 14_500 && candidate.stalledSocketClosedAfterMs < 16_000 && candidate.elapsedMs < 20_000 && candidate.stderr.filter((l) => l.includes("CrabFleet work-state update failed")).length === 1 && /timeout/i.test(candidate.stderr.find((l) => l.includes("CrabFleet work-state update failed")) ?? ""); const summary = { head, node: process.version, platform: `${process.platform} ${process.arch}`, workerTimeoutMs: WORKER_TIMEOUT_MS, results, pass, }; writeFileSync(join(here, "summary.json"), JSON.stringify(summary, null, 2)); console.log(JSON.stringify(summary, null, 2)); console.log(`PROOF_RESULT=${pass ? "PASS" : "FAIL"}`); process.exit(pass ? 0 : 1); EOF node "$ART/proof.mjs" 2>&1 | tee "$ART/proof.log" echo echo "== focused suite ==" node --test --test-name-pattern "app-server mode" test/codex-process.test.ts 2>&1 | tee "$ART/focused-test.log" | grep -E "^(ok|not ok|# )|✔|✖|ℹ (pass|fail)" || true grep -q "^# fail 0" "$ART/focused-test.log" || grep -q "ℹ fail 0" "$ART/focused-test.log" || { echo "FAIL: focused suite"; exit 1; } echo echo "CSW_1423_PROOF_COMPLETE" ```

steipete analysis page

Peter Steinberger