@sagentlab/navarch-runtime 0.1.130 → 0.1.132

package/README.md

@@ -286,10 +286,70 @@ files. A supervisor also pins its starting identity into replacement workers,
 so an accidental later edit to `machine.json` cannot change that running
 instance during an automatic-update handoff.
 
+## Live steering
+
+A person can send a message to a session that is already running, from the
+task page, Slack or the user MCP, without stopping it. A project opts in with
+`projects.steering_live_enabled`; while that is off, guidance behaves as
+described under [Active-task guidance](#active-task-guidance). The design is in
+[`docs/navarch/live-steering.md`](../docs/navarch/live-steering.md).
+
+The runtime sends a **capability record** with every claim, and the control
+plane resolves each message against it, so a message is never silently
+downgraded. Every adapter except the retired Gemini tombstone says
+`queue: boundary, interrupt: restart`. Claude Code on the host also says
+`steer: native` once a startup probe finds that the installed CLI accepts
+streaming input.
+
+| Sent as | Claude Code (host) | Every other adapter, and Claude Code in Docker |
+|---|---|---|
+| `steer` | Written to the running agent, which reads it at its next step. The turn is not stopped. | Becomes `queue`, with the fallback reason `steer_unsupported`. |
+| `queue` | Waits for the current turn to end, then the next turn resumes the conversation with it. | The same: the next turn carries it (`codex exec resume` for Codex; a fresh invocation with the full brief for the rest). |
+| `interrupt` | The agent process is stopped and the next turn, in the same lease and worktree, starts with the message (`claude -p --resume`). | The same. In Docker the sandbox container is restarted first, because stopping the agent stops the container. |
+
+How it works:
+
+- A long-poll (`GET /api/dispatch/:leaseId/steering?wait=20`) delivers a message
+  within about a second. The lease heartbeat carries the same payload as a
+  fallback, so a lost long-poll does not lose a message, but the heartbeat is
+  `NAVARCH_LEASE_HEARTBEAT_INTERVAL_MS` apart (five minutes by default) and the
+  control plane gives a `steer` or `interrupt` 90 s to be acknowledged, so such a
+  message then falls back to the next session. A control plane without the
+  endpoint answers 404 three times in a row and the runtime stops long-polling.
+- Each message is **acknowledged** once the agent has it: when the agent process
+  first produces output after starting with the message in its prompt (or five
+  seconds after it started without failing), or, for a native steer, when Claude
+  Code echoes the message back (`--replay-user-messages`) as proof that it read
+  it. A message the runtime cannot deliver, including one whose agent never
+  started, is acknowledged `failed`, and the control plane hands it to the next
+  session; nothing is dropped silently.
+- A message is introduced to the agent with a header that names the sender, the
+  time, a short id and the mode, for example
+  `[Message from Alex at 2026-10-21T12:03:00.000Z, id a1b2c3d4, sent as queue]`.
+  The id lets the agent ignore a repeat. After an interrupt the prompt also says
+  that the previous turn was stopped, so the agent inspects `git status`.
+- A completion that races a message is refused with `409 steering_pending`; the
+  runtime runs another turn instead of finishing.
+- A sender can cancel a queued message until it reaches the agent. The runtime
+  answers the cancel instead of delivering it.
+
+Set `NAVARCH_LIVE_STEERING=off` to make a machine a legacy runtime: it sends no
+capability record and only an explicit interrupt reaches it. Native steering
+needs host mode, a `claude` that lists `--input-format` and
+`--replay-user-messages` in `--help`, and no `--input-format` or
+`--output-format` in `NAVARCH_CLAUDE_EXTRA_ARGS`; otherwise Claude Code keeps
+the baseline above.
+
+`NAVARCH_LIVE_STEERING_SMOKE=1 npx vitest run tests/steering-live-smoke.test.cts`
+runs steer, queue and interrupt against the installed `claude` (add
+`NAVARCH_LIVE_STEERING_SMOKE_CODEX=1` for Codex) and an in-process port of the
+control-plane contract, and `NAVARCH_LIVE_SMOKE_REPORT=<file>` writes the
+evidence. It spends a few cents of provider usage per scenario.
+
 ## Active-task guidance
 
-Guidance added to a task that is already running is delivered on that
-task's next lease heartbeat (every
+Guidance added to a task that is already running, on a project without live
+steering, is delivered on that task's next lease heartbeat (every
 `NAVARCH_LEASE_HEARTBEAT_INTERVAL_MS`, five minutes by default). The runtime
 stops the current agent process and starts a **new agent turn**. This is a
 turn restart, not a new dispatch:
@@ -471,6 +531,7 @@ unchanged across the deployment.
 | `NAVARCH_POLL_INTERVAL_MS` | `30000` | Claim-loop poll interval. |
 | `NAVARCH_HEARTBEAT_INTERVAL_MS` | `60000` | Machine-level heartbeat interval. |
 | `NAVARCH_LEASE_HEARTBEAT_INTERVAL_MS` | `300000` | Per-lease heartbeat interval; must stay well under the 60-minute lease TTL (schema-design.md §4). |
+| `NAVARCH_LIVE_STEERING` | on | Tell the control plane this runtime takes live-steering messages (see [Live steering](#live-steering)). `off` makes it a legacy runtime. |
 | `NAVARCH_SESSION_TIMEOUT_MS` | `0` (disabled) | Optional absolute runtime budget across agent turns in a claimed session. |
 | `NAVARCH_SESSION_IDLE_TIMEOUT_MS` | `2700000` (45 min) | Stop after a continuously observed window with no stdout/stderr or process-tree CPU activity. `0` disables idle detection. |
 | `NAVARCH_OPENCODE_STARTUP_TIMEOUT_MS` | `120000` (2 min) | Stop OpenCode when it produces no stdout/stderr during startup. This catches provider auth/quota failures that leave its CLI process alive. `0` disables the startup deadline. |

package/dist/adapters/acp.cjs

@@ -6,6 +6,7 @@ const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_stream_1 = require("node:stream");
 const kill_agent_cjs_1 = require("../kill-agent.cjs");
+const types_cjs_1 = require("./types.cjs");
 /**
  * How long a cancelled agent may take to observe `session/cancel` and settle
  * the in-flight `session/prompt` before the subprocess is terminated. The
@@ -276,4 +277,5 @@ function describeError(error) {
 exports.acpAdapter = {
     agentType: "acp",
     run: runAcpAdapter,
+    steering: types_cjs_1.TURN_RESTART_STEERING,
 };

package/dist/adapters/antigravity.cjs

@@ -12,6 +12,7 @@ const node_string_decoder_1 = require("node:string_decoder");
 const config_cjs_1 = require("../config.cjs");
 const kill_agent_cjs_1 = require("../kill-agent.cjs");
 const antigravity_mcp_cjs_1 = require("./antigravity-mcp.cjs");
+const types_cjs_1 = require("./types.cjs");
 /** Documented agy 1.3.1 contract, not Gemini CLI's similarly named format.
  * https://antigravity.google/docs/cli/headless/
  * https://antigravity.google/docs/changelog (1.1.27, 1.1.28, 1.2.6, 1.2.10)
@@ -345,4 +346,4 @@ async function runDocker(options, args, input) {
     }
 }
 function quote(value) { return `'${value.replace(/'/g, `'\\''`)}'`; }
-exports.antigravityAdapter = { agentType: "antigravity", run: runAntigravityAdapter };
+exports.antigravityAdapter = { agentType: "antigravity", run: runAntigravityAdapter, steering: types_cjs_1.TURN_RESTART_STEERING };

package/dist/adapters/claude.cjs

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.claudeCodeAdapter = void 0;
 exports.runClaudeCodeAdapter = runClaudeCodeAdapter;
+exports.probeClaudeSteering = probeClaudeSteering;
 const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
 const exit_conditions_cjs_1 = require("../exit-conditions.cjs");
 const kill_agent_cjs_1 = require("../kill-agent.cjs");
+const types_cjs_1 = require("./types.cjs");
 const claude_conversation_cjs_1 = require("./claude-conversation.cjs");
 const adapter_capacity_cjs_1 = require("../adapter-capacity.cjs");
 const DEFAULT_CLAUDE_MODEL = "claude-opus-5-5";
@@ -163,6 +166,16 @@ async function runClaudeAttempt(options, automaticFallback) {
         if (!hasFlag(options.extraArgs, "--verbose"))
             args.push("--verbose");
     }
+    // Native steering (docs/navarch/live-steering.md section 5.3). The prompt then
+    // travels as the first stream-json user message and stdin stays open, so a
+    // later message reaches the agent at its next step. Only on the host path and
+    // only when the operator has not chosen the stream formats themselves.
+    const liveInput = options.liveInput && !options.dockerExec && !hasFlag(options.extraArgs, "--input-format") &&
+        !hasFlag(options.extraArgs, "--output-format")
+        ? options.liveInput
+        : undefined;
+    if (liveInput)
+        args.push("--input-format", "stream-json", "--replay-user-messages");
     args.push(...options.extraArgs);
     if (options.resumeSessionId)
         args.push("--resume", options.resumeSessionId);
@@ -180,7 +193,11 @@ async function runClaudeAttempt(options, automaticFallback) {
             env: { ...options.env, CLAUDE_CODE_EFFORT_LEVEL: options.reasoningEffort },
         }
         : options;
-    const raw = runOptions.dockerExec ? await runViaDocker(runOptions, args) : await runOnHost(runOptions, args);
+    const raw = runOptions.dockerExec
+        ? await runViaDocker(runOptions, args)
+        : liveInput
+            ? await runOnHostStreaming(runOptions, args, liveInput)
+            : await runOnHost(runOptions, args);
     return attachSession(attachUsage(raw), options);
 }
 /**
@@ -230,12 +247,25 @@ function attachSession(result, options) {
         ...(rejected ? { resumeRejected: true } : {}),
     };
 }
-/** Parses the final `claude -p --output-format stream-json` result record for usage and folds it onto the raw result (best-effort; leaves tokensIn/tokensOut/costUsd unset when parsing fails). */
+/**
+ * Parses the `claude -p --output-format stream-json` result records for usage
+ * and folds them onto the raw result (best-effort; leaves
+ * tokensIn/tokensOut/costUsd unset when parsing fails). A streaming launch runs
+ * one turn per interrupt or late message, each ending in its own `result`:
+ * `usage` covers that turn alone, so the tokens are summed, while
+ * `total_cost_usd` is already the process's running total, so the last one counts.
+ */
 function attachUsage(result) {
     const parsed = (0, exit_conditions_cjs_1.parseClaudeJsonResult)(result.stdout);
     if (!parsed)
         return result;
     const usage = (0, exit_conditions_cjs_1.extractUsageFromClaudeJson)(parsed);
+    const turns = streamResultRecords(result.stdout).map(exit_conditions_cjs_1.extractUsageFromClaudeJson);
+    if (turns.length > 1) {
+        usage.tokensIn = turns.reduce((sum, turn) => sum + turn.tokensIn, 0);
+        usage.tokensOut = turns.reduce((sum, turn) => sum + turn.tokensOut, 0);
+        usage.cacheHitTokensIn = turns.reduce((sum, turn) => sum + turn.cacheHitTokensIn, 0);
+    }
     return {
         ...result,
         tokensIn: usage.tokensIn,
@@ -244,6 +274,26 @@ function attachUsage(result) {
         costUsd: usage.costUsd,
     };
 }
+/** Every stream-json `type: "result"` record, one per turn the process ran. */
+function streamResultRecords(stdout) {
+    const records = [];
+    for (const line of stdout.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{"))
+            continue;
+        try {
+            const record = JSON.parse(trimmed);
+            if (typeof record === "object" && record !== null && !Array.isArray(record) &&
+                record.type === "result") {
+                records.push(record);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return records;
+}
 async function runOnHost(options, args) {
     return new Promise((resolve) => {
         let stdout = "";
@@ -297,6 +347,333 @@ async function runOnHost(options, args) {
         });
     });
 }
+/** How long the process may stay open for a written message the agent has not echoed after its turn ended. */
+const UNECHOED_INPUT_GRACE_MS = 30_000;
+/**
+ * How long an interrupt waits for the stopped turn's `result` before its input
+ * is written anyway. Spike S1 saw the result at once; a CLI that ignores the
+ * request then reads the message at its next step, which the ack reports as a steer.
+ */
+const INTERRUPT_RESULT_TIMEOUT_MS = 15_000;
+/**
+ * `claude -p --input-format stream-json --replay-user-messages`: the prompt is
+ * the first user message, and stdin stays open so a steering message written
+ * during the turn is injected at the agent's next step (spike S1 in
+ * docs/navarch/live-steering.md, verified against claude 2.1.304).
+ *
+ * `--replay-user-messages` makes Claude Code echo each user message back, with
+ * its uuid, when it takes the message into the conversation. That echo is the
+ * only proof of consumption, so the process is closed to input only once every
+ * written message has been echoed: Claude Code reads a message that is already
+ * in the pipe even after stdin ends and runs it as a further turn, but a
+ * message written after the process has finished is silently dropped, which is
+ * why `send` refuses once input is closed.
+ *
+ * Native interrupt (spike S1, claude 2.1.284 and 2.1.304): the control request
+ * `{"type":"control_request","request":{"subtype":"interrupt"}}` stops the
+ * running tool and ends the turn with a `result` of subtype
+ * `error_during_execution`, and the process and conversation stay. The
+ * interrupt's message is written only after that `result`, so it starts the
+ * next turn instead of joining the stopped one, and every message sent while
+ * the interrupt is pending waits behind it, in order (as the hosted relay does).
+ */
+async function runOnHostStreaming(options, args, live) {
+    return new Promise((resolve) => {
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        let killedByLeaseLoss = false;
+        let inputOpen = true;
+        let lineBuffer = "";
+        let graceTimer;
+        let interruptTimer;
+        let interruptRequests = 0;
+        // A turn is running: the prompt starts one, and a `result` ends it.
+        let turnRunning = true;
+        // Written steering messages the agent has not echoed yet.
+        const pending = new Map();
+        // Inputs waiting for the turn an interrupt is stopping, in the order they were sent.
+        const held = [];
+        const child = (0, node_child_process_1.spawn)(options.bin, args, {
+            detached: process.platform !== "win32",
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+        });
+        let attached = false;
+        const detach = () => {
+            if (!attached)
+                return;
+            attached = false;
+            live.attach(null);
+        };
+        child.stdin?.on("error", () => {
+            // The child exited before reading; `close` reports it, and the session
+            // takes back every message it never echoed.
+            inputOpen = false;
+            detach();
+        });
+        const writeUser = (id, text) => {
+            child.stdin?.write(`${JSON.stringify({
+                type: "user",
+                uuid: id,
+                message: { role: "user", content: [{ type: "text", text }] },
+            })}\n`);
+        };
+        const closeInput = () => {
+            if (!inputOpen)
+                return;
+            inputOpen = false;
+            clearTimeout(graceTimer);
+            detach();
+            child.stdin?.end();
+        };
+        const canWrite = () => inputOpen && child.exitCode === null && !child.killed;
+        /** Writes one steering input. A message written while no turn runs starts the next one. */
+        const writeInput = (input, state) => {
+            try {
+                writeUser(input.id, input.text);
+            }
+            catch {
+                return false;
+            }
+            pending.set(input.id, state);
+            return true;
+        };
+        /**
+         * Writes what waited for the interrupted turn. `stopped` is null when the
+         * turn has not ended (no `result` came in time), so the inputs join it.
+         */
+        const releaseHeld = (stopped) => {
+            clearTimeout(interruptTimer);
+            interruptTimer = undefined;
+            // Input closed meanwhile: nothing is written, and the session takes them back.
+            if (!canWrite()) {
+                held.length = 0;
+                return;
+            }
+            // The first input (the interrupt that sent the request) starts the next
+            // turn and owns the stop; the rest join that turn.
+            let first = true;
+            for (const { input } of held.splice(0)) {
+                writeInput(input, {
+                    afterTurnEnd: first && stopped !== null,
+                    stoppedTurn: first && stopped === true,
+                });
+                first = false;
+            }
+            turnRunning = true;
+        };
+        const promptId = (0, node_crypto_1.randomUUID)();
+        writeUser(promptId, options.prompt);
+        attached = true;
+        live.attach({
+            send: (input) => {
+                if (!canWrite())
+                    return false;
+                // Behind a pending interrupt, so the interrupt stays the next input.
+                if (held.length > 0) {
+                    held.push({ input, interrupt: false });
+                    return true;
+                }
+                return writeInput(input, { afterTurnEnd: !turnRunning, stoppedTurn: false });
+            },
+            interrupt: (input) => {
+                if (!canWrite())
+                    return false;
+                // Nothing to stop: the message starts the next turn, a boundary delivery.
+                if (!turnRunning)
+                    return writeInput(input, { afterTurnEnd: true, stoppedTurn: false });
+                held.push({ input, interrupt: true });
+                if (held.length > 1)
+                    return true;
+                try {
+                    interruptRequests += 1;
+                    child.stdin?.write(`${JSON.stringify({
+                        type: "control_request",
+                        request_id: `navarch-interrupt-${interruptRequests}`,
+                        request: { subtype: "interrupt" },
+                    })}\n`);
+                }
+                catch {
+                    held.length = 0;
+                    return false;
+                }
+                interruptTimer = setTimeout(() => releaseHeld(null), INTERRUPT_RESULT_TIMEOUT_MS);
+                return true;
+            },
+        });
+        options.onProcessStarted?.(child.pid);
+        /** Reads one stdout line. Returns false for the line that must stay out of the transcript. */
+        const handleRecord = (line) => {
+            if (!line.startsWith("{"))
+                return true;
+            let record;
+            try {
+                record = JSON.parse(line);
+            }
+            catch {
+                return true;
+            }
+            if (typeof record !== "object" || record === null || Array.isArray(record))
+                return true;
+            const { type, subtype, uuid, isReplay } = record;
+            if (type === "user" && isReplay === true && typeof uuid === "string") {
+                // The echo of the task brief would copy the whole prompt into every
+                // transcript; a one-shot launch never prints it. Steering messages are
+                // kept: the echo shows where in the turn the agent took them in.
+                if (uuid === promptId)
+                    return false;
+                const entry = pending.get(uuid);
+                if (!entry)
+                    return true;
+                pending.delete(uuid);
+                // The agent took it in, so a turn is running again; its `result`
+                // decides whether input can close.
+                turnRunning = true;
+                clearTimeout(graceTimer);
+                live.consumed(uuid, entry.afterTurnEnd, entry.stoppedTurn);
+            }
+            else if (type === "control_response" && held.length > 0) {
+                // A CLI that refuses the interrupt stops nothing: the waiting inputs
+                // join the running turn now instead of after the 15 s fallback.
+                const response = record.response;
+                if (response?.subtype === "error" && response.request_id === `navarch-interrupt-${interruptRequests}`) {
+                    releaseHeld(null);
+                }
+            }
+            else if (type === "result") {
+                // A turn ended. A message written during it that was not echoed will
+                // start the next turn, so it now counts as consumed after the boundary,
+                // and that next turn counts as running before its echo arrives: an
+                // interrupt in that gap must still stop it.
+                turnRunning = pending.size > 0;
+                for (const entry of pending.values())
+                    entry.afterTurnEnd = true;
+                // An interrupt was waiting for this turn to end. Only a turn the request
+                // cut short ends in `error_during_execution`; one that finished first
+                // was not stopped, and its message is a boundary delivery.
+                if (held.length > 0)
+                    releaseHeld(subtype === "error_during_execution");
+                if (pending.size === 0)
+                    closeInput();
+                else {
+                    clearTimeout(graceTimer);
+                    graceTimer = setTimeout(closeInput, UNECHOED_INPUT_GRACE_MS);
+                }
+            }
+            return true;
+        };
+        /** Passes on a stdout line to the result and the live transcript, unless it is withheld. */
+        const forwardLine = (line, terminator) => (handleRecord(line.trim()) ? line + terminator : "");
+        const timer = options.timeoutMs > 0 ? setTimeout(() => {
+            timedOut = true;
+            (0, kill_agent_cjs_1.killAgent)(child);
+        }, options.timeoutMs) : undefined;
+        const onAbort = () => {
+            killedByLeaseLoss = true;
+            (0, kill_agent_cjs_1.killAgent)(child);
+        };
+        options.signal?.addEventListener("abort", onAbort, { once: true });
+        if (options.signal?.aborted)
+            onAbort();
+        child.stdout.on("data", (d) => {
+            options.onActivity?.();
+            lineBuffer += d.toString();
+            let forwarded = "";
+            let newline = lineBuffer.indexOf("\n");
+            while (newline >= 0) {
+                forwarded += forwardLine(lineBuffer.slice(0, newline), "\n");
+                lineBuffer = lineBuffer.slice(newline + 1);
+                newline = lineBuffer.indexOf("\n");
+            }
+            if (forwarded) {
+                stdout += forwarded;
+                options.onOutput?.("stdout", forwarded);
+            }
+        });
+        child.stderr.on("data", (d) => {
+            options.onActivity?.();
+            const text = d.toString();
+            stderr += text;
+            options.onOutput?.("stderr", text);
+        });
+        const finish = (exitCode) => {
+            clearTimeout(timer);
+            // An input still waiting for an interrupted turn was never written: the
+            // session takes it back with every message the agent did not echo.
+            held.length = 0;
+            inputOpen = false;
+            detach();
+            if (lineBuffer) {
+                // A final line with no newline.
+                const rest = forwardLine(lineBuffer, "");
+                lineBuffer = "";
+                if (rest) {
+                    stdout += rest;
+                    options.onOutput?.("stdout", rest);
+                }
+            }
+            // After the last line: a trailing `result` there can arm the grace timer.
+            clearTimeout(graceTimer);
+            clearTimeout(interruptTimer);
+            options.signal?.removeEventListener("abort", onAbort);
+            resolve({ exitCode, timedOut, killedByLeaseLoss, stdout, stderr });
+        };
+        child.on("error", (err) => {
+            stderr += `\n${String(err)}`;
+            finish(null);
+        });
+        child.on("close", (code) => finish(code));
+    });
+}
+/** `claude --help`, cached per binary: it lists the flags this version accepts. */
+const claudeHelpCache = new Map();
+function readClaudeHelp(bin, env) {
+    const cached = claudeHelpCache.get(bin);
+    if (cached)
+        return cached;
+    const help = new Promise((resolve) => {
+        let output = "";
+        let settled = false;
+        const done = (text) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(text);
+        };
+        const child = (0, node_child_process_1.spawn)(bin, ["--help"], { env: { ...process.env, ...env }, stdio: ["ignore", "pipe", "ignore"] });
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+            done("");
+        }, 10_000);
+        child.stdout?.on("data", (chunk) => { output += chunk.toString(); });
+        child.on("error", () => done(""));
+        child.on("close", (code) => done(code === 0 ? output : ""));
+    });
+    // A failed probe is not remembered: the CLI may be installed or fixed later.
+    void help.then((text) => { if (!text)
+        claudeHelpCache.delete(bin); });
+    claudeHelpCache.set(bin, help);
+    return help;
+}
+/**
+ * Native steering needs `--input-format stream-json` and
+ * `--replay-user-messages`, the host path (Docker `exec -i` has no streaming
+ * runner here), and the stream formats left to Navarch. The same streaming
+ * process takes the interrupt control request (spike S1), so native steering
+ * also brings native interrupt; without it, interrupt stays `restart`.
+ */
+async function probeClaudeSteering(context) {
+    if (context.sandboxMode !== "host")
+        return null;
+    if (hasFlag(context.extraArgs, "--input-format") || hasFlag(context.extraArgs, "--output-format"))
+        return null;
+    const help = await readClaudeHelp(context.bin, context.env);
+    if (!/--input-format\b/.test(help) || !/--replay-user-messages\b/.test(help))
+        return null;
+    return { steer: "native", queue: "boundary", interrupt: "native" };
+}
 async function runViaDocker(options, args) {
     const { containerName, runner } = options.dockerExec;
     const quoted = [options.bin, ...args].map(shellQuote).join(" ");
@@ -351,6 +728,8 @@ exports.claudeCodeAdapter = {
     agentType: "claude-code",
     run: runClaudeCodeAdapter,
     resumesTurns: true,
+    steering: types_cjs_1.TURN_RESTART_STEERING,
+    probeSteering: probeClaudeSteering,
     // `usage` is per turn; `total_cost_usd` covers the whole resumed conversation.
     cumulativeResumeUsage: ["costUsd"],
     conversation: claude_conversation_cjs_1.claudeConversationRunner,

package/dist/adapters/codex.cjs

@@ -8,6 +8,7 @@ const node_fs_1 = require("node:fs");
 const exit_conditions_cjs_1 = require("../exit-conditions.cjs");
 const codex_pricing_cjs_1 = require("../codex-pricing.cjs");
 const kill_agent_cjs_1 = require("../kill-agent.cjs");
+const types_cjs_1 = require("./types.cjs");
 /**
  * Headless OpenAI Codex CLI adapter — the Codex sibling of claude.cts's
  * `runClaudeCodeAdapter`, implementing the same AgentAdapter interface
@@ -364,6 +365,7 @@ exports.codexAdapter = {
     agentType: "codex",
     run: runCodexAdapter,
     resumesTurns: true,
+    steering: types_cjs_1.TURN_RESTART_STEERING,
     // `exec resume` reports the thread's total_token_usage, not the turn's.
     cumulativeResumeUsage: ["tokensIn", "tokensOut", "cacheHitTokensIn", "costUsd"],
 };

package/dist/adapters/gemini.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.geminiAdapter = void 0;
 exports.runGeminiAdapter = runGeminiAdapter;
+const types_cjs_1 = require("./types.cjs");
 /** Tombstone for stale claims. Provider IDs and credentials are never aliased. */
 async function runGeminiAdapter(options) {
     return {
@@ -12,4 +13,4 @@ async function runGeminiAdapter(options) {
         stderr: "Gemini CLI is retired. Explicitly install and authenticate Antigravity, select antigravity, and update the task's runtime pin. No Gemini credentials or conversation IDs are transferred.",
     };
 }
-exports.geminiAdapter = { agentType: "gemini", run: runGeminiAdapter };
+exports.geminiAdapter = { agentType: "gemini", run: runGeminiAdapter, steering: types_cjs_1.NO_STEERING };

package/dist/adapters/muse.cjs

@@ -12,6 +12,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const node_crypto_1 = require("node:crypto");
 const kill_agent_cjs_1 = require("../kill-agent.cjs");
 const version_cjs_1 = require("../version.cjs");
+const types_cjs_1 = require("./types.cjs");
 const CANCEL_GRACE_MS = 2_000;
 const SHUTDOWN_GRACE_MS = 30_000;
 const TERMINATE_GRACE_MS = 2_000;
@@ -430,4 +431,4 @@ function spawnMuse(options) {
 }
 // Read-only Navi conversations are deliberately absent: an approval mode is
 // not a filesystem read boundary, and the SDK cannot yet prove that contract.
-exports.museAdapter = { agentType: "muse", run: runMuseAdapter };
+exports.museAdapter = { agentType: "muse", run: runMuseAdapter, steering: types_cjs_1.TURN_RESTART_STEERING };

package/dist/adapters/opencode.cjs

@@ -13,6 +13,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const config_cjs_1 = require("../config.cjs");
 const kill_agent_cjs_1 = require("../kill-agent.cjs");
 const opencode_providers_cjs_1 = require("./opencode-providers.cjs");
+const types_cjs_1 = require("./types.cjs");
 /**
  * Headless OpenCode adapter, fixture-pinned to the OpenCode JSON event
  * contract shared by V1 and V2 (verified against 1.19.1, 2.0.6 and 2.0.17):
@@ -541,4 +542,5 @@ function shellQuote(value) {
 exports.openCodeAdapter = {
     agentType: "opencode",
     run: runOpenCodeAdapter,
+    steering: types_cjs_1.TURN_RESTART_STEERING,
 };

package/dist/adapters/pi-local.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.localPiAdapter = void 0;
 exports.runLocalPiAdapter = runLocalPiAdapter;
+const types_cjs_1 = require("./types.cjs");
 const pi_cjs_1 = require("./pi.cjs");
 /** BYO Pi: native MCP, operator provider catalog, and a local OpenAI-compatible default. */
 async function runLocalPiAdapter(options) {
@@ -18,4 +19,4 @@ async function runLocalPiAdapter(options) {
     args.push("-p");
     return (0, pi_cjs_1.attachPiOutput)(await (0, pi_cjs_1.runOnHost)(options, args, true));
 }
-exports.localPiAdapter = { agentType: "pi-local", run: runLocalPiAdapter };
+exports.localPiAdapter = { agentType: "pi-local", run: runLocalPiAdapter, steering: types_cjs_1.TURN_RESTART_STEERING };

package/dist/adapters/pi.cjs

@@ -16,6 +16,7 @@ const node_fs_1 = require("node:fs");
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const kill_agent_cjs_1 = require("../kill-agent.cjs");
+const types_cjs_1 = require("./types.cjs");
 /**
  * Headless Pi coding-agent adapter (#885) — the process-side twin of the
  * Cloudflare hosted executor (worker/hosted-pi/lifecycle.ts). It invokes
@@ -444,4 +445,5 @@ function shellQuote(value) {
 exports.piAdapter = {
     agentType: "pi",
     run: runPiAdapter,
+    steering: types_cjs_1.TURN_RESTART_STEERING,
 };

package/dist/adapters/qoder.cjs

@@ -5,6 +5,7 @@ exports.runQoderAdapter = runQoderAdapter;
 const node_child_process_1 = require("node:child_process");
 const exit_conditions_cjs_1 = require("../exit-conditions.cjs");
 const kill_agent_cjs_1 = require("../kill-agent.cjs");
+const types_cjs_1 = require("./types.cjs");
 function hasFlag(args, flag) {
     return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
 }
@@ -175,4 +176,5 @@ function shellQuote(value) {
 exports.qoderAdapter = {
     agentType: "qoder",
     run: runQoderAdapter,
+    steering: types_cjs_1.TURN_RESTART_STEERING,
 };