very-happy-cli 0.2.175 → 0.2.177

package/dist/{client-BhLhjj_x.cjs → client-COmgDDy0.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-var configuration = require('./configuration-UV4EE5ui.cjs');
-var persistence = require('./persistence-DweHi8xa.cjs');
+var configuration = require('./configuration-DZPy0T9Z.cjs');
+var persistence = require('./persistence-DXbKOHxl.cjs');
 
 class AutomationsRequestError extends Error {
   constructor(status, code, runStatus) {

package/dist/{client-C4ddTzrD.mjs → client-DG5ndWLw.mjs}

@@ -1,5 +1,5 @@
-import { c as configuration } from './configuration-BNGPXg07.mjs';
-import { c as readCredentialsForConfiguredRelay, r as readSettings } from './persistence-CIIhP0Uw.mjs';
+import { c as configuration } from './configuration-D55F0t16.mjs';
+import { c as readCredentialsForConfiguredRelay, r as readSettings } from './persistence-C_tYtOqK.mjs';
 
 class AutomationsRequestError extends Error {
   constructor(status, code, runStatus) {

package/dist/{client-BHZVyQwi.cjs → client-DyvBTYee.cjs}

@@ -1,9 +1,9 @@
 'use strict';
 
 var node_crypto = require('node:crypto');
-var configuration = require('./configuration-UV4EE5ui.cjs');
-var persistence = require('./persistence-DweHi8xa.cjs');
-var context = require('./context-BmH2BKip.cjs');
+var configuration = require('./configuration-DZPy0T9Z.cjs');
+var persistence = require('./persistence-DXbKOHxl.cjs');
+var context = require('./context-BKbrZ55r.cjs');
 
 async function teamRequest(path, method, token, scoped, body) {
   const response = await fetch(`${configuration.configuration.serverUrl}${path}`, {

package/dist/codex/happyMcpStdioBridge.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
-var tools = require('../tools-C77-Ssan.cjs');
-var reportProgressTool = require('../reportProgressTool-DzMi4mvH.cjs');
-var peerTools = require('../peerTools-BktGmlpd.cjs');
+var tools = require('../tools-DDKTB5aQ.cjs');
+var reportProgressTool = require('../reportProgressTool-Du_zAK4h.cjs');
+var peerTools = require('../peerTools-DtGKWli5.cjs');
 var agentGuidance = require('../agentGuidance-BtBx2xxE.cjs');
 var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
 var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
@@ -10,33 +10,33 @@ var index_js = require('@modelcontextprotocol/sdk/client/index.js');
 var streamableHttp_js = require('@modelcontextprotocol/sdk/client/streamableHttp.js');
 var z = require('zod');
 var limits = require('../limits-C-a7gr04.cjs');
-require('../client-BHZVyQwi.cjs');
+require('../client-DyvBTYee.cjs');
 require('node:crypto');
-require('../configuration-UV4EE5ui.cjs');
+require('../configuration-DZPy0T9Z.cjs');
 require('node:fs');
 require('node:os');
 require('node:path');
-require('../package-VqWv7EI5.cjs');
+require('../package-Ch9WGDV_.cjs');
 require('node:fs/promises');
-require('../persistence-DweHi8xa.cjs');
+require('../persistence-DXbKOHxl.cjs');
 require('../authRelay-BdYkC1Po.cjs');
 require('tweetnacl');
-require('../logger-C7dRaCkE.cjs');
+require('../logger-LvwVeATU.cjs');
 require('chalk');
 require('node:util');
-require('../context-BmH2BKip.cjs');
-require('../index-BZdhwBKa.cjs');
+require('../context-BKbrZ55r.cjs');
+require('../index-De8L5lFK.cjs');
 require('@paralleldrive/cuid2');
-require('../client-BhLhjj_x.cjs');
+require('../client-COmgDDy0.cjs');
 require('../precheckCompat-CWOi5c9L.cjs');
 require('../ids-B6ZC0HGt.cjs');
-require('../controlClient-CtsQMw--.cjs');
-require('../sessionOps-9MChM9Op.cjs');
+require('../controlClient-SX8gSza2.cjs');
+require('../sessionOps-Dmt7WUUs.cjs');
 require('axios');
-require('../time-0szhiPo4.cjs');
+require('../time-Dg5tVB8S.cjs');
 require('socket.io-client');
 require('../backgroundTaskActivity-CBvUdj39.cjs');
-require('../remoteSessionClient-CL3akj0K.cjs');
+require('../remoteSessionClient-B7NvjHD3.cjs');
 require('../trimIdent-4gvk9Wk6.cjs');
 
 function parseArgs(argv) {

package/dist/codex/happyMcpStdioBridge.mjs

@@ -1,6 +1,6 @@
-import { r as registerTeamsTools } from '../tools-Cp0qJeBq.mjs';
-import { r as registerAutomationTools, a as registerReportProgressTool } from '../reportProgressTool-BLLwMQrN.mjs';
-import { r as registerSessionPeerTools } from '../peerTools-B_eiNB3P.mjs';
+import { r as registerTeamsTools } from '../tools-BrM3bZW5.mjs';
+import { r as registerAutomationTools, a as registerReportProgressTool } from '../reportProgressTool-B203EZCR.mjs';
+import { r as registerSessionPeerTools } from '../peerTools-CxmrKnfV.mjs';
 import { P as PREVIEW_TOOL_NAME, a as PREVIEW_TOOL_TITLE, b as PREVIEW_TOOL_DESCRIPTION, c as PREVIEW_DOWNLOAD_PARAM_DESCRIPTION, R as REPORT_PROGRESS_TOOL_NAME } from '../agentGuidance-BDYt2Qy2.mjs';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -8,33 +8,33 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { z } from 'zod';
 import { C as CLIPBOARD_TOOL_NAME, a as CLIPBOARD_TOOL_TITLE, b as CLIPBOARD_TOOL_DESCRIPTION } from '../limits-DIo7rEBR.mjs';
-import '../client-eQjOvC55.mjs';
+import '../client-BPMWutfs.mjs';
 import 'node:crypto';
-import '../configuration-BNGPXg07.mjs';
+import '../configuration-D55F0t16.mjs';
 import 'node:fs';
 import 'node:os';
 import 'node:path';
-import '../package-D0dxZ-W8.mjs';
+import '../package-CjlsAaRe.mjs';
 import 'node:fs/promises';
-import '../persistence-CIIhP0Uw.mjs';
+import '../persistence-C_tYtOqK.mjs';
 import '../authRelay-DSAvg1uv.mjs';
 import 'tweetnacl';
-import '../logger-D5EzMy30.mjs';
+import '../logger-13cBr_ew.mjs';
 import 'chalk';
 import 'node:util';
-import '../context-Ptdnlcv6.mjs';
-import '../index-boE-d8CM.mjs';
+import '../context-CCRpVXFo.mjs';
+import '../index-DMy3OCBe.mjs';
 import '@paralleldrive/cuid2';
-import '../client-C4ddTzrD.mjs';
+import '../client-DG5ndWLw.mjs';
 import '../precheckCompat-DeEbilbr.mjs';
 import '../ids-DU6sLx4C.mjs';
-import '../controlClient-DqtC0pq1.mjs';
-import '../sessionOps-ByZJbkMq.mjs';
+import '../controlClient-C4xB5J6O.mjs';
+import '../sessionOps-CdgbEJgf.mjs';
 import 'axios';
-import '../time-CvrpeD3S.mjs';
+import '../time-yEL6wHUF.mjs';
 import 'socket.io-client';
-import '../backgroundTaskActivity-8PdPxrvy.mjs';
-import '../remoteSessionClient-CUjw1COc.mjs';
+import '../backgroundTaskActivity-BVwJBl02.mjs';
+import '../remoteSessionClient-D01Hso2-.mjs';
 import '../trimIdent-BAjmv_TG.mjs';
 
 function parseArgs(argv) {

package/dist/{codexAppServerClient-CppPl_R6.mjs → codexAppServerClient-D-Z8qSfI.mjs}

@@ -1,12 +1,52 @@
 import { execSync } from 'node:child_process';
 import { spawn } from 'cross-spawn';
 import { createInterface } from 'node:readline';
-import { l as logger } from './logger-D5EzMy30.mjs';
+import { l as logger } from './logger-13cBr_ew.mjs';
 import { e as errorLogMetadata, c as contentLogMetadata } from './contentLogMetadata-BlWI0egu.mjs';
 import { i as initializeSandbox, w as wrapForMcpTransport } from './manager-BEsI4qt3.mjs';
-import { p as packageJson } from './package-D0dxZ-W8.mjs';
-import { s as shouldReadCodexRateLimits, i as isUnsupportedCodexMethodError } from './rateLimitWindows-Bo6XVnie.mjs';
+import { p as packageJson } from './package-CjlsAaRe.mjs';
+import { s as shouldReadCodexRateLimits, i as isUnsupportedCodexMethodError } from './rateLimitWindows-DYHDGuzQ.mjs';
+import { s as stopProcessGracefully, k as killProcessTree } from './processTree-CP5IvQ2Z.mjs';
 
+const CODEX_HELPER_LABEL_MAX_CHARS = 80;
+function codexHelperLabel(prompt) {
+  if (typeof prompt !== "string") return null;
+  const collapsed = prompt.replace(/\s+/g, " ").trim();
+  if (collapsed.length === 0) return null;
+  if (collapsed.length <= CODEX_HELPER_LABEL_MAX_CHARS) return collapsed;
+  const keep = CODEX_HELPER_LABEL_MAX_CHARS - 1;
+  const last = collapsed.charCodeAt(keep - 1);
+  const end = last >= 55296 && last <= 56319 ? keep - 1 : keep;
+  return `${collapsed.slice(0, end)}\u2026`;
+}
+function codexAgentPathSegments(agentPath) {
+  if (typeof agentPath !== "string") return [];
+  return agentPath.split("/").map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+}
+function isRootAgentPath(segments) {
+  return segments.length === 1 && segments[0] === "root";
+}
+function codexChildAnnouncements(item) {
+  if (item.type === "subAgentActivity") {
+    const threadId = item.agentThreadId;
+    if (typeof threadId !== "string" || threadId.length === 0) return [];
+    const segments = codexAgentPathSegments(item.agentPath);
+    if (isRootAgentPath(segments)) return [];
+    const leaf = segments.at(-1);
+    return [{ threadId, label: leaf && leaf.length > 0 ? leaf : null }];
+  }
+  if (item.type === "collabAgentToolCall") {
+    const receivers = Array.isArray(item.receiverThreadIds) ? item.receiverThreadIds.filter((id) => typeof id === "string" && id.length > 0) : [];
+    const label = item.tool === "spawnAgent" ? codexHelperLabel(item.prompt) : null;
+    return [...new Set(receivers)].map((threadId) => ({ threadId, label }));
+  }
+  return [];
+}
+
+function jsonRpcErrorCodeOf(error) {
+  const code = error?.jsonRpcCode;
+  return typeof code === "number" ? code : null;
+}
 function isAppServerAvailable() {
   try {
     const version = execSync("codex --version", { encoding: "utf8", windowsHide: true }).trim();
@@ -121,6 +161,18 @@ class CodexAppServerClient {
   // Approval / elicitation requests we are still answering: a human may take
   // longer than the watchdog to decide, and that is not Codex going silent.
   inflightServerRequests = 0;
+  // B-628: `turn/steer` — a message sent into the running turn (approach from Orca,
+  // src/main/codex/codex-structured-turn-start.ts). This app-server has no such
+  // method (-32601) until it is respawned; a refusal is per call (the turn it named
+  // ended or changed meanwhile, a review/compact turn).
+  steerUnsupported = false;
+  /** Steered inputs Codex has not echoed back as a `userMessage` item yet: clientId → turnId. */
+  steeredAwaitingEcho = /* @__PURE__ */ new Map();
+  /** Waiters for the pending turn to open (steerTurn); released when it opens or ends. */
+  turnOpenWaiters = [];
+  /** B-628: the names Codex gave the child threads it spawned (see codexChildThreads.ts). */
+  childThreadLabels = /* @__PURE__ */ new Map();
+  static MAX_CHILD_LABELS = 128;
   // Handlers set by the consumer (runCodex.ts)
   eventHandler = null;
   approvalHandler = null;
@@ -191,6 +243,58 @@ class CodexAppServerClient {
     const threadId = this.extractThreadId(params);
     return threadId === null || this._threadId === null || threadId === this._threadId;
   }
+  /** B-628: the child thread a frame belongs to, or null for the session's own. */
+  childThreadIdOf(params) {
+    return this.isOwnThreadFrame(params) ? null : this.extractThreadId(params);
+  }
+  /**
+   * B-628: what a child thread's item carries so the mapper files it under the child's
+   * card (`subagent` → the session protocol's sub-agent envelope, as a Claude Task's
+   * children are) instead of in the main conversation as the session's own work.
+   */
+  childItemFields(params) {
+    const child = this.childThreadIdOf(params);
+    if (!child) return {};
+    const label = this.childThreadLabels.get(child);
+    return { subagent: child, ...label ? { subagent_label: label } : {} };
+  }
+  rememberChildLabels(item) {
+    for (const { threadId, label } of codexChildAnnouncements(item)) {
+      if (!label || this.childThreadLabels.has(threadId)) continue;
+      if (this.childThreadLabels.size >= CodexAppServerClient.MAX_CHILD_LABELS) {
+        const oldest = this.childThreadLabels.keys().next().value;
+        if (oldest !== void 0) this.childThreadLabels.delete(oldest);
+      }
+      this.childThreadLabels.set(threadId, label);
+    }
+  }
+  /**
+   * B-628: steered inputs the ended turn never echoed. `report` = the turn did not complete
+   * (interrupted, failed, app-server gone, given up): Codex never read them, tell the runner.
+   * A turn that *completed* drains its pending input before it ends (core/src/session/turn.rs),
+   * so an unechoed input there is a codex that accepted the steer but echoes no `clientId` —
+   * forgotten silently, because a false「not delivered」on a message the model did read would
+   * be worse than today's silence.
+   */
+  dropUnechoedSteers(turnId, report) {
+    const dropped = [];
+    for (const [clientId, steeredTurn] of this.steeredAwaitingEcho) {
+      if (turnId === null || steeredTurn === turnId) {
+        dropped.push(clientId);
+        this.steeredAwaitingEcho.delete(clientId);
+      }
+    }
+    if (dropped.length === 0) return;
+    if (!report) {
+      logger.debug(`[CodexAppServer] ${dropped.length} steered message(s) completed without an echo; not reported`);
+      return;
+    }
+    this.eventHandler?.({
+      type: "steer_dropped",
+      client_ids: dropped,
+      ...turnId ? { turn_id: turnId } : {}
+    });
+  }
   /** Codex's last stderr lines, one line, for a message a person reads. */
   stderrTail() {
     return this.stderrRing.replace(/\x1b\[[0-9;]*m/g, "").replace(/\s+/g, " ").trim();
@@ -225,6 +329,7 @@ class CodexAppServerClient {
       this.completedTurnIds.add(turnId);
       if (failed) this.failedTurnIds.add(turnId);
     }
+    this.dropUnechoedSteers(turnId, aborted || failed);
     if (aborted) {
       this.eventHandler?.({
         type: "turn_aborted",
@@ -264,6 +369,11 @@ class CodexAppServerClient {
     if (method === "turn/completed") {
       if (!this.isOwnThreadFrame(params)) {
         logger.debug(`[CodexAppServer] Child thread ${this.extractThreadId(params)} ended a turn`);
+        this.eventHandler?.({
+          type: "subagent_turn_end",
+          ...this.childItemFields(params),
+          status: this.extractTurnStatus(params)
+        });
         return true;
       }
       this.emitRawTurnCompletion(
@@ -296,6 +406,7 @@ class CodexAppServerClient {
       return true;
     }
     if (method === "thread/tokenUsage/updated") {
+      if (!this.isOwnThreadFrame(params)) return true;
       const tokenUsage = params?.tokenUsage;
       if (tokenUsage && typeof tokenUsage === "object") {
         this.eventHandler?.({
@@ -309,8 +420,15 @@ class CodexAppServerClient {
     if (!item || typeof item !== "object") {
       return method.startsWith("item/");
     }
+    const child = this.childItemFields(params);
     if ((method === "item/started" || method === "item/completed") && (item.type === "collabAgentToolCall" || item.type === "subAgentActivity")) {
-      this.eventHandler?.({ type: "collab_agent_item", item });
+      this.rememberChildLabels(item);
+      this.eventHandler?.({ type: "collab_agent_item", item, ...child });
+      return true;
+    }
+    if (method === "item/completed" && item.type === "userMessage") {
+      const clientId = typeof item.clientId === "string" ? item.clientId : null;
+      if (clientId && !child.subagent) this.steeredAwaitingEcho.delete(clientId);
       return true;
     }
     if (method === "item/started" && item.type === "commandExecution") {
@@ -321,7 +439,8 @@ class CodexAppServerClient {
         callId,
         command: item.command,
         cwd: item.cwd,
-        description: item.command
+        description: item.command,
+        ...child
       });
       return true;
     }
@@ -336,7 +455,8 @@ class CodexAppServerClient {
         duration_ms: item.durationMs ?? null,
         status: item.status,
         cwd: item.cwd,
-        command: item.command
+        command: item.command,
+        ...child
       });
       return true;
     }
@@ -351,7 +471,8 @@ class CodexAppServerClient {
           type: "patch_apply_begin",
           call_id: callId,
           callId,
-          changes: changes ?? {}
+          changes: changes ?? {},
+          ...child
         });
         return true;
       }
@@ -360,7 +481,8 @@ class CodexAppServerClient {
           type: "patch_apply_end",
           call_id: callId,
           callId,
-          status: item.status
+          status: item.status,
+          ...child
         });
         if (callId && (item.status === "completed" || item.status === "failed" || item.status === "declined")) {
           this.rawFileChangesByItemId.delete(callId);
@@ -375,7 +497,8 @@ class CodexAppServerClient {
           type: "agent_message",
           message: text,
           item_id: item.id,
-          phase: item.phase
+          phase: item.phase,
+          ...child
         });
       }
       return true;
@@ -448,6 +571,7 @@ class CodexAppServerClient {
       }
       if (this.pendingTurnCompletion) {
         const turnId = this.pendingTurnCompletion.turnId ?? this._turnId;
+        this.dropUnechoedSteers(null, true);
         this.eventHandler?.({
           type: "turn_aborted",
           reason: "process-exit",
@@ -458,6 +582,9 @@ class CodexAppServerClient {
       this.resolvePendingTurn(true);
     });
     this.stderrRing = "";
+    this.steerUnsupported = false;
+    this.steeredAwaitingEcho.clear();
+    this.childThreadLabels.clear();
     proc.stderr?.on("data", (chunk) => {
       if (this.process !== proc || this.processEpoch !== epoch) return;
       const text = chunk.toString().trim();
@@ -496,20 +623,12 @@ ${text}`.slice(-400);
     logger.debug(`[CodexAppServer] Disconnecting; pid=${pid ?? "none"}`);
     this.readline?.close();
     this.readline = null;
-    try {
-      proc?.stdin?.end();
-      proc?.kill("SIGTERM");
-    } catch {
-    }
-    if (pid) {
-      const killTimer = setTimeout(() => {
-        try {
-          process.kill(pid, 0);
-          process.kill(pid, "SIGKILL");
-        } catch {
-        }
-      }, 2e3);
-      killTimer.unref();
+    if (proc) {
+      stopProcessGracefully(proc);
+      if (pid) {
+        const killTimer = setTimeout(() => killProcessTree(proc), CodexAppServerClient.FORCE_KILL_AFTER_MS);
+        killTimer.unref();
+      }
     }
     this.process = null;
     this.connected = false;
@@ -528,6 +647,7 @@ ${text}`.slice(-400);
       req.reject(new Error(`Codex process disconnected while waiting for ${req.method}`));
       this.pending.delete(id);
     }
+    this.dropUnechoedSteers(null, true);
     this.resolvePendingTurn(true);
     if (this.sandboxCleanup) {
       try {
@@ -731,6 +851,8 @@ ${text}`.slice(-400);
   // ─── Turn management ────────────────────────────────────────
   /** Default grace period after interrupt before forcing a restart (ms). */
   static ABORT_GRACE_MS = 3e3;
+  /** How long the graceful stop gets before the process tree is killed (disconnectInternal). */
+  static FORCE_KILL_AFTER_MS = 2e3;
   hasPendingTurnCompletion() {
     return this.pendingTurnCompletion !== null;
   }
@@ -740,6 +862,7 @@ ${text}`.slice(-400);
     this.clearThreadStopGrace();
     this.pendingTurnCompletion.resolve(aborted);
     this.pendingTurnCompletion = null;
+    this.releaseTurnOpenWaiters();
   }
   markPendingTurnStarted(turnId) {
     if (!this.pendingTurnCompletion) return;
@@ -747,6 +870,86 @@ ${text}`.slice(-400);
     if (turnId) {
       this.pendingTurnCompletion.turnId = turnId;
     }
+    this.releaseTurnOpenWaiters();
+  }
+  // ─── B-628: steering the running turn ───────────────────────
+  /** How long a steer waits for the pending turn to open before the message is queued instead. */
+  static STEER_OPEN_WAIT_MS = 5e3;
+  /** A turn Codex has reported running, under an id `turn/steer` can name. */
+  turnIsOpen() {
+    return this.pendingTurnCompletion?.opened === true && this._turnId !== null;
+  }
+  releaseTurnOpenWaiters() {
+    const waiters = this.turnOpenWaiters;
+    this.turnOpenWaiters = [];
+    for (const release of waiters) release();
+  }
+  /**
+   * Waits for the pending turn to open — `turn/start` is in flight, or the runner is still
+   * bringing a released app-server back before sending it (B-461) — as Orca's send does
+   * (codex-structured-turn-open-wait.ts, 5 s). Resolves early when the turn ends instead.
+   */
+  async waitForTurnOpen(timeoutMs) {
+    if (this.turnIsOpen()) return true;
+    if (timeoutMs <= 0) return false;
+    await new Promise((resolve) => {
+      const release = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      const timer = setTimeout(release, timeoutMs);
+      timer.unref();
+      this.turnOpenWaiters.push(release);
+    });
+    return this.turnIsOpen();
+  }
+  /**
+   * B-628: send a message into the turn running right now (`turn/steer`, codex ≥ 0.148 /
+   * app-server-protocol v2 `TurnSteerParams`). Codex appends it to that turn's pending input
+   * and the model reads it before its next call; the turn keeps its own model, approval
+   * policy and sandbox — the runner applies any change on the next `turn/start`. Codex
+   * refuses before taking any input (expectedTurnId is a precondition), so a non-`steered`
+   * outcome always means "queue it for the next turn as before": `no-turn` (nothing running,
+   * or it ended while we waited), `unsupported` (this app-server has no `turn/steer`,
+   * remembered until it is respawned), `refused` (Codex declined this one), `failed`
+   * (transport — the turn itself is reported through its own events).
+   */
+  async steerTurn(input, opts) {
+    if (this.steerUnsupported) return "unsupported";
+    if (this.pendingInterrupt) return "no-turn";
+    const opened = await this.waitForTurnOpen(opts?.waitForTurnMs ?? CodexAppServerClient.STEER_OPEN_WAIT_MS);
+    const threadId = this._threadId;
+    const turnId = this._turnId;
+    if (!opened || !threadId || !turnId || !this.connected || this.pendingInterrupt) return "no-turn";
+    const params = {
+      threadId,
+      expectedTurnId: turnId,
+      ...input.clientId ? { clientUserMessageId: input.clientId } : {},
+      input: [
+        { type: "text", text: input.text },
+        ...(input.images ?? []).map((path) => ({ type: "localImage", path }))
+      ]
+    };
+    try {
+      const result = await this.request("turn/steer", params);
+      const steeredTurnId = typeof result?.turnId === "string" && result.turnId.length > 0 ? result.turnId : turnId;
+      if (input.clientId) this.steeredAwaitingEcho.set(input.clientId, steeredTurnId);
+      logger.debug(`[CodexAppServer] Steered a message into turn ${steeredTurnId}`);
+      return "steered";
+    } catch (error) {
+      const code = jsonRpcErrorCodeOf(error);
+      if (code === -32601) {
+        this.steerUnsupported = true;
+        logger.debug("[CodexAppServer] turn/steer is not supported by this codex; queuing instead");
+        return "unsupported";
+      }
+      if (code !== null) {
+        logger.debug("[CodexAppServer] turn/steer refused:", errorLogMetadata(error));
+        return "refused";
+      }
+      logger.debug("[CodexAppServer] turn/steer failed:", errorLogMetadata(error));
+      return "failed";
+    }
   }
   /** Default wait for Codex's `turn/completed` after its thread reported idle/systemError. */
   static THREAD_STOP_GRACE_MS = 1500;
@@ -909,6 +1112,7 @@ ${text}`.slice(-400);
     } catch (err) {
       this.clearTurnWatchdog();
       this.pendingTurnCompletion = null;
+      this.releaseTurnOpenWaiters();
       throw err;
     }
     const aborted = await completion;
@@ -926,6 +1130,7 @@ ${text}`.slice(-400);
       }
       logger.warn(`[CodexAppServer] No notification from Codex for ${timeoutMs}ms \u2014 giving the turn up as aborted`);
       const turnId = this.pendingTurnCompletion.turnId ?? this._turnId;
+      this.dropUnechoedSteers(turnId, true);
       this.eventHandler?.({
         type: "turn_aborted",
         reason: "timeout",
@@ -976,6 +1181,7 @@ ${text}`.slice(-400);
     logger.debug(
       `[CodexAppServer] Clearing thread state: thread=${this._threadId ?? "none"} turn=${this._turnId ?? "none"}`
     );
+    this.dropUnechoedSteers(null, true);
     this.resolvePendingTurn(true);
     this._threadId = null;
     this._turnId = null;
@@ -984,6 +1190,7 @@ ${text}`.slice(-400);
     this.failedTurnIds.clear();
     this.lastTurnError = null;
     this.rawFileChangesByItemId.clear();
+    this.childThreadLabels.clear();
   }
   // ─── JSON-RPC transport ─────────────────────────────────────
   /** Default timeout for RPC requests (ms). */
@@ -1064,7 +1271,9 @@ ${text}`.slice(-400);
         }
         this.pending.delete(msg.id);
         if (msg.error) {
-          pending.reject(new Error(`${pending.method}: ${msg.error.message} (code=${msg.error.code})`));
+          const error = new Error(`${pending.method}: ${msg.error.message} (code=${msg.error.code})`);
+          if (typeof msg.error.code === "number") error.jsonRpcCode = msg.error.code;
+          pending.reject(error);
         } else {
           pending.resolve(msg.result);
         }