openmausbot 0.1.87 → 0.1.89

package/dist-server/server/drivers/pi.js

@@ -26,6 +26,7 @@ import { join } from "node:path";
 import { PROVIDER_CREDENTIAL_ENV, stripWorkspaceCredentialEnv } from "../config.js";
 import { augmentedPath } from "../env-path.js";
 import { describeSpawnFailure, execCli, killCliTree, spawnCli } from "../procs.js";
+import { deletePromptSplitReceipt, promptHalves, readPromptSplitReceipt, splitSessionPrompt, writePromptSplitReceipt, } from "./prompt-split.js";
 import { SPAWNED_PROXIES } from "../proxy-paths.js";
 import { commandSummary, toolDetailPreview } from "../tool-summary.js";
 import { EFFORT_LEVELS } from "../../shared/wire.js";
@@ -37,6 +38,21 @@ const DRIVER_KIND = "piAgent";
 const PI_ARGS = ["--mode", "rpc", "--no-session"];
 const PI_MODEL_UPDATE_ARGS = ["update", "--models", "--no-approve"];
 const NODE_ENV_FLAG = { ELECTRON_RUN_AS_NODE: "1" };
+/** After this many bare turns on one pi session the full prompt rides
+ * again even without a compaction event: any history rewrite the events
+ * miss (an older pi, a missed line) still loses at most this many turns
+ * of standing instructions instead of the rest of the session. */
+const PI_PROMPT_RE_ANCHOR_TURNS = 8;
+/** How long the driver keeps listening after a finished turn_end for the
+ * run's terminal agent_end before settling anyway: a runtime that never
+ * emits agent_end still completes, while one that does cancels the wait. */
+const PI_AGENT_END_GRACE_MS = 60_000;
+/** pi answered a command with success:false — an explicit refusal from a
+ * live runtime, not a transport failure. Only steer branches on the
+ * difference today ("refused": provably not delivered, safe to re-queue);
+ * the handshake commands keep their catch-all ignore. */
+class PiRpcRefusalError extends Error {
+}
 function readPiPromptImages(turn) {
     return (turn.images ?? []).map((image) => ({
         type: "image",
@@ -431,6 +447,13 @@ export const PiDriver = {
             // closure (send, child) alive until it fires.
             const askTimers = new Set();
             let settled = false;
+            // the last turn_end's outcome, replayed when the run's terminal
+            // agent_end (or the grace fallback) settles the turn
+            let endStopReason;
+            let endUsage;
+            let endErrorMessage;
+            // hang insurance for runtimes with no agent_end frame at all
+            let agentEndTimer = null;
             // pi's RPC surface accepts image content directly. Read before spawning
             // so an attachment that disappeared produces one clear dispatch error
             // instead of starting a child that can never receive its prompt.
@@ -493,8 +516,17 @@ export const PiDriver = {
             })();
             let buf = "";
             let assistantText = "";
+            // set when a compaction event arrives this turn; gates the receipt
+            // write below so a compacted-around delivery is never claimed
+            let compactionObserved = false;
             // resolve one-shot RPC responses (new_session / switch_session / set_model)
             const responseWaiters = new Map();
+            // Steer frames correlate by a unique per-request id, not the shared
+            // "steer" command name: two concurrent steers would otherwise overwrite
+            // each other's waiter, and a refusal response could reject the wrong
+            // caller — requeueing words pi already accepted. Every other command
+            // keeps its command-name key.
+            let steerSeq = 0;
             const rejectWaiters = (err) => {
                 for (const waiter of responseWaiters.values()) {
                     clearTimeout(waiter.timer);
@@ -502,13 +534,13 @@ export const PiDriver = {
                 }
                 responseWaiters.clear();
             };
-            const awaitResponse = (command, timeoutMs = 20_000) => new Promise((resolve, reject) => {
+            const awaitResponse = (command, timeoutMs = 20_000, key = command) => new Promise((resolve, reject) => {
                 const timer = setTimeout(() => {
-                    responseWaiters.delete(command);
+                    responseWaiters.delete(key);
                     reject(new Error(`pi ${command} timed out`));
                 }, timeoutMs);
                 timer.unref?.();
-                responseWaiters.set(command, { resolve, reject, timer });
+                responseWaiters.set(key, { resolve, reject, timer });
             });
             child.stdin.on("error", () => rejectWaiters(new Error("pi stdin closed")));
             const send = (obj) => {
@@ -527,6 +559,10 @@ export const PiDriver = {
                 if (settled)
                     return;
                 settled = true;
+                if (agentEndTimer) {
+                    clearTimeout(agentEndTimer);
+                    agentEndTimer = null;
+                }
                 // The turn is over: drop unanswered asks so their 15-minute
                 // fail-safe timers are cancelled outright instead of no-oping on a
                 // dead child while holding the ask closure alive.
@@ -564,6 +600,23 @@ export const PiDriver = {
                 }
                 active.delete(threadId);
             };
+            /** Settle from the last turn_end's recorded outcome. Errors surface
+             * here, at run completion, so a failed run reports exactly once and
+             * only after any scheduled maintenance events had their chance to
+             * arrive. */
+            const finishRun = () => {
+                const sr = endStopReason;
+                if (sr === "error" || sr === "failed") {
+                    emit({
+                        ...base(threadId, turnId),
+                        type: "runtime.error",
+                        message: String(endErrorMessage ?? "pi turn failed").slice(0, 2_000),
+                    });
+                    settle(false, "failed", endUsage);
+                    return;
+                }
+                settle(true, sr === "cancelled" || sr === "aborted" ? "cancelled" : "end_turn", endUsage);
+            };
             const stop = () => {
                 try {
                     send({ type: "abort" });
@@ -579,19 +632,53 @@ export const PiDriver = {
                 }
                 settle(true, "cancelled");
             };
-            active.set(threadId, { stop, turnId, pending, child });
+            // Mid-turn input rides pi's native steer frame — the runtime queues
+            // it into the running agent without aborting the in-flight step, and
+            // answers success only after session.steer() accepted it. A success:
+            // false response is an explicit refusal (nothing consumed the words:
+            // safe to re-queue), while a death or timeout after the frame was
+            // written leaves the outcome unknowable — those are "indeterminate"
+            // so the caller can never run the words twice. Each frame carries a
+            // unique id that pi echoes on its response, so concurrent steers on
+            // the same turn never share or overwrite a waiter.
+            const steerActiveTurn = async (text) => {
+                if (settled || child.exitCode !== null || child.signalCode !== null)
+                    return "refused";
+                let ack;
+                try {
+                    const id = `steer:${++steerSeq}`;
+                    ack = awaitResponse("steer", 20_000, id);
+                    send({ type: "steer", id, message: text });
+                }
+                catch {
+                    // stdin closed before the frame was written: provably undelivered.
+                    return "refused";
+                }
+                try {
+                    await ack;
+                    return "steered";
+                }
+                catch (error) {
+                    return error instanceof PiRpcRefusalError ? "refused" : "indeterminate";
+                }
+            };
+            active.set(threadId, { stop, turnId, pending, child, steer: steerActiveTurn });
             const onEvent = (evt) => {
                 appendNative(threadId, { dir: "in", source: "pi.rpc", msg: evt });
                 switch (evt.type) {
                     case "response": {
-                        if (evt.command && responseWaiters.has(evt.command)) {
-                            const waiter = responseWaiters.get(evt.command);
-                            responseWaiters.delete(evt.command);
+                        // Resolve the echoed request id first (unique per steer);
+                        // fall back to the command name for the handshake-style call
+                        // sites, whose responses carry no id.
+                        const key = typeof evt.id === "string" && responseWaiters.has(evt.id) ? evt.id : evt.command;
+                        if (key && responseWaiters.has(key)) {
+                            const waiter = responseWaiters.get(key);
+                            responseWaiters.delete(key);
                             clearTimeout(waiter.timer);
                             if (evt.success)
                                 waiter.resolve(evt.data);
                             else
-                                waiter.reject(new Error(`pi ${evt.command} failed`));
+                                waiter.reject(new PiRpcRefusalError(`pi ${evt.command} failed`));
                         }
                         return;
                     }
@@ -715,24 +802,81 @@ export const PiDriver = {
                         }
                         return;
                     }
+                    case "compaction_start":
+                    case "compaction_end":
+                    case "auto_compaction_start":
+                    case "auto_compaction_end": {
+                        // pi compaction (manual or automatic) summarizes older
+                        // messages, which can absorb the turn that carried this
+                        // session's standing prompt. Both events ride the RPC surface
+                        // for every compaction kind, so the moment either arrives the
+                        // receipt is dropped and the next turn re-establishes the full
+                        // prompt. The rest of the compacting turn may still answer
+                        // without its standing instructions; that single turn is the
+                        // unavoidable cost of summarizing history mid-session.
+                        if (sessionReady && sessionFile) {
+                            compactionObserved = true;
+                            deletePromptSplitReceipt("pi", JSON.stringify([threadId, sessionFile]));
+                        }
+                        return;
+                    }
                     case "turn_end":
-                    case "agent_end": {
-                        const sr = evt.message?.stopReason;
-                        // toolUse means pi ran a tool and auto-continues next turn to
-                        // answer — settling now would drop the final reply.
-                        if (sr === "toolUse" || sr === "tool_use" || sr === "tool_calls")
+                        {
+                            // a killed child can still flush one buffered frame after the
+                            // turn settled (the abort path's cancelled turn_end is the
+                            // common one); arming the grace timer then would leak it past
+                            // a turn that is already complete.
+                            if (settled)
+                                return;
+                            const sr = evt.message?.stopReason;
+                            // toolUse means pi ran a tool and auto-continues next turn to
+                            // answer — the run is not over, and the next turn_end carries
+                            // the real outcome.
+                            if (sr === "toolUse" || sr === "tool_use" || sr === "tool_calls")
+                                return;
+                            endStopReason = sr;
+                            endUsage = evt.usage ?? evt.message?.usage;
+                            endErrorMessage = evt.message?.errorMessage;
+                            // agent_end, not turn_end, closes the run: pi can schedule
+                            // post-run maintenance (overflow-recovery compaction) after
+                            // the final turn_end, and only the terminal agent_end proves
+                            // the session is done rewriting itself. The grace timer
+                            // settles a runtime that never sends agent_end at all.
+                            if (agentEndTimer)
+                                clearTimeout(agentEndTimer);
+                            agentEndTimer = setTimeout(finishRun, PI_AGENT_END_GRACE_MS);
+                            agentEndTimer.unref?.();
                             return;
-                        const usage = evt.usage ?? evt.message?.usage;
-                        if (sr === "error" || sr === "failed") {
-                            emit({
-                                ...base(threadId, turnId),
-                                type: "runtime.error",
-                                message: String(evt.message?.errorMessage ?? "pi turn failed").slice(0, 2_000),
-                            });
-                            settle(false, "failed", usage);
+                        }
+                    case "agent_end": {
+                        // Two dialects mark a non-terminal agent_end: upstream pi sets
+                        // willRetry: true when an automatic retry follows (overflow
+                        // recovery runs compaction and retries as a fresh run), and the
+                        // omp fork sets isTerminal: false while maintenance or async
+                        // delivery has more work scheduled. Either marker means the
+                        // session may still rewrite the turn that carried this
+                        // session's standing prompt — keep listening so those events
+                        // can drop the prompt-split receipt.
+                        if (evt.isTerminal === false || evt.willRetry === true)
                             return;
+                        if (agentEndTimer) {
+                            clearTimeout(agentEndTimer);
+                            agentEndTimer = null;
+                        }
+                        finishRun();
+                        return;
+                    }
+                    case "agent_settled": {
+                        // upstream pi's explicit fully-settled guarantee: no automatic
+                        // retry, compaction retry, or queued continuation remains.
+                        // Usually settles one frame after the final agent_end already
+                        // did; kept as its own terminal signal so the driver never
+                        // depends on which dialect the configured cli speaks.
+                        if (agentEndTimer) {
+                            clearTimeout(agentEndTimer);
+                            agentEndTimer = null;
                         }
-                        settle(true, sr === "cancelled" || sr === "aborted" ? "cancelled" : "end_turn", usage);
+                        finishRun();
                         return;
                     }
                     default:
@@ -774,6 +918,7 @@ export const PiDriver = {
             // sessionFile, which switch_session expects as `sessionPath`.
             const sessionPath = typeof turn.resumeCursor === "string" ? turn.resumeCursor : null;
             let sessionFile = sessionPath;
+            let sessionReady = false;
             try {
                 const command = sessionPath ? "switch_session" : "new_session";
                 const hsPromise = awaitResponse(command);
@@ -781,6 +926,7 @@ export const PiDriver = {
                 const hs = (await hsPromise);
                 if (hs?.sessionFile)
                     sessionFile = hs.sessionFile;
+                sessionReady = true;
                 emit({
                     ...base(threadId, turnId),
                     type: "session.started",
@@ -816,17 +962,71 @@ export const PiDriver = {
                     /* keep going on the engine default */
                 }
             }
-            // pi compacts long sessions by summarizing older user messages, and
-            // this driver delivers the prompt as the leading user message: a
-            // receipt-based split would let a compacted session keep running
-            // bare, without its standing instructions. Re-deliver the full prompt
-            // every turn until pi exposes a compaction signal the harness can
-            // watch (its extension API has session_before_compact).
-            const message = turn.system ? `${turn.system}\n\n${turn.text}` : turn.text;
+            // The stable/volatile split: the full prompt rides only the turn that
+            // establishes - or re-instructs, after a soul edit - this pi session,
+            // which previously re-sent the whole system prompt on every turn and
+            // let it accumulate in the session file once per turn. pi compacts
+            // long sessions by summarizing older messages, which can absorb the
+            // turn that carried the prompt, so the driver watches pi's
+            // compaction events and drops the receipt the moment one arrives,
+            // and re-anchors the full prompt every PI_PROMPT_RE_ANCHOR_TURNS
+            // bare turns as a backstop for anything the events miss. Receipts
+            // are durable because the session file outlives both the per-turn
+            // child and this process. Without a session the prompt is the
+            // model's only context, so that turn keeps the full block and writes
+            // no receipt.
+            const halves = promptHalves(turn);
+            let message;
+            let pendingReceipt = null;
+            if (halves.stable !== null && sessionReady && sessionFile) {
+                const receiptKey = JSON.stringify([threadId, sessionFile]);
+                const composed = splitSessionPrompt(halves.stable, halves.volatile, readPromptSplitReceipt("pi", receiptKey), turn.system, turn.text, Boolean(turn.mentionTurn), PI_PROMPT_RE_ANCHOR_TURNS);
+                message = composed.text;
+                pendingReceipt = { key: receiptKey, receipt: composed.receipt };
+            }
+            else {
+                message = turn.system ? `${turn.system}\n\n${turn.text}` : turn.text;
+            }
+            // events cannot interleave with this synchronous stretch, so any
+            // compaction recorded above already invalidated what compose read
             try {
+                // pi answers the prompt with an authoritative response only after
+                // preflight accepts it - and rejects it outright while a
+                // compaction runs - so the receipt commits only after that
+                // acceptance: a rejected or compacted-around send redelivers on
+                // the next turn. The wait is long enough to survive a compaction
+                // queue; a dead child rejects it immediately.
+                // sendTurn still resolves once the prompt is written: a child that
+                // dies before replying settles the turn through the close handler,
+                // whose waiter sweep can precede this registration.
+                const accepted = awaitResponse("prompt", 120_000);
                 send({ type: "prompt", message, ...(images.length ? { images } : {}) });
+                void accepted.then(() => {
+                    if (!pendingReceipt || compactionObserved)
+                        return;
+                    try {
+                        writePromptSplitReceipt("pi", pendingReceipt.key, pendingReceipt.receipt);
+                    }
+                    catch {
+                        /* an unwritten receipt only re-delivers the full prompt next turn */
+                    }
+                }, (err) => {
+                    if (settled)
+                        return;
+                    emit({
+                        ...base(threadId, turnId),
+                        type: "runtime.error",
+                        message: String(err?.message ?? err).slice(0, 2_000),
+                    });
+                    settle(false);
+                });
             }
-            catch {
+            catch (err) {
+                emit({
+                    ...base(threadId, turnId),
+                    type: "runtime.error",
+                    message: String(err?.message ?? err).slice(0, 2_000),
+                });
                 settle(false);
             }
             return { turnId };
@@ -899,6 +1099,9 @@ export const PiDriver = {
                     // xhigh/max only land on models that expose them; pi rejects an
                     // unsupported level and the turn keeps the engine default.
                     effortLevels: EFFORT_LEVELS,
+                    // pi's RPC mode takes a mid-turn steer frame the runtime queues
+                    // into the running agent without aborting the current step.
+                    queueing: true,
                 },
                 sendTurn,
                 interruptTurn: async (threadId) => active.get(threadId)?.stop(),
@@ -918,6 +1121,10 @@ export const PiDriver = {
                     });
                     return decision.behavior === "allow" ? "allowed-once" : decision.behavior === "answer" ? "answered" : "rejected";
                 },
+                steer: async (threadId, text) => {
+                    const entry = active.get(threadId);
+                    return entry?.steer ? await entry.steer(text) : "refused";
+                },
                 hasSession: (threadId) => active.has(threadId),
                 stopAll: async () => {
                     for (const { stop } of active.values())

package/dist-server/server/drivers/prompt-split.js

@@ -5,7 +5,7 @@
 // work, recent work) legitimately changes mid-conversation and reaches
 // the model inside the turn that changed it, after the cacheable prefix.
 import { createHash } from "node:crypto";
-import { mkdirSync, readFileSync } from "node:fs";
+import { mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { DATA_DIR } from "../config.js";
 import { writeFileAtomic } from "../atomic.js";
@@ -53,7 +53,11 @@ export function readPromptSplitReceipt(scope, key) {
         if (raw && typeof raw === "object" && !Array.isArray(raw)) {
             const record = raw;
             if (typeof record.stable === "string" && typeof record.volatile === "string") {
-                return { stable: record.stable, volatile: record.volatile };
+                return {
+                    stable: record.stable,
+                    volatile: record.volatile,
+                    ...(typeof record.turnsSinceFull === "number" ? { turnsSinceFull: record.turnsSinceFull } : {}),
+                };
             }
         }
     }
@@ -66,6 +70,18 @@ export function writePromptSplitReceipt(scope, key, receipt) {
     mkdirSync(join(DATA_DIR, "prompt-split"), { recursive: true });
     writeFileAtomic(receiptPath(scope, key), JSON.stringify(receipt), { mode: 0o600 });
 }
+/** Drop a session's receipt: its history was rewritten (pi compaction
+ * summarizes older messages), so what it last carried is unknown and the
+ * next turn re-delivers the full prompt. A missing receipt already reads
+ * as unknown, so deleting one is always safe. */
+export function deletePromptSplitReceipt(scope, key) {
+    try {
+        rmSync(receiptPath(scope, key));
+    }
+    catch {
+        /* a missing receipt is already unknown */
+    }
+}
 /** Compose the prompt for a session that persists its own history (ACP
  * agents, pi): the full system block rides only when this native session
  * has not carried it - or carried a different one, which re-delivers the
@@ -74,14 +90,21 @@ export function writePromptSplitReceipt(scope, key, receipt) {
  * through bare, so an ordinary memory write neither appends a second copy
  * of the prompt to the session nor re-prices its cached prefix.
  * perTurnVolatile marks a turn whose volatile half describes this very
- * turn (a mention): its note is delivered even when the text is unchanged. */
-export function splitSessionPrompt(stable, volatile, previous, fullSystem, text, perTurnVolatile = false) {
-    const receipt = promptSplitFingerprints(stable, volatile);
-    if (previous === null || previous.stable !== receipt.stable) {
-        return { text: fullSystem ? fullSystem + "\n\n" + text : text, receipt };
+ * turn (a mention): its note is delivered even when the text is unchanged.
+ * reAnchorAfterTurns, when positive, re-sends the full prompt after that
+ * many consecutive bare turns: a session that rewrites its own history
+ * without an observable event (an older pi, a missed compaction) still
+ * gets its standing instructions back within a bounded number of turns. */
+export function splitSessionPrompt(stable, volatile, previous, fullSystem, text, perTurnVolatile = false, reAnchorAfterTurns = 0) {
+    const fingerprints = promptSplitFingerprints(stable, volatile);
+    // Legacy receipts predate the turn counter; count them from zero.
+    const turnsSinceFull = typeof previous?.turnsSinceFull === "number" ? previous.turnsSinceFull : 0;
+    const reAnchor = reAnchorAfterTurns > 0 && previous !== null && turnsSinceFull >= reAnchorAfterTurns;
+    if (previous === null || previous.stable !== fingerprints.stable || reAnchor) {
+        return { text: fullSystem ? fullSystem + "\n\n" + text : text, receipt: { ...fingerprints, turnsSinceFull: 0 } };
     }
-    const note = previous.volatile === receipt.volatile && !perTurnVolatile
+    const note = previous.volatile === fingerprints.volatile && !perTurnVolatile
         ? ""
         : volatileContextNote(volatile, previous.volatile !== EMPTY_FINGERPRINT);
-    return { text: withContextNote(note, text), receipt };
+    return { text: withContextNote(note, text), receipt: { ...fingerprints, turnsSinceFull: turnsSinceFull + 1 } };
 }

package/dist-server/server/drivers/session-idle.js

@@ -0,0 +1,29 @@
+// One session-idle policy for every pooled harness process. The Claude
+// driver and the ACP core grew byte-identical copies of this computation
+// with different env prefixes; the policy lives here so the default, the
+// floor, and the env names cannot drift apart again.
+const DEFAULT_IDLE_MS = 10 * 60_000;
+const MINIMUM_IDLE_MS = 10_000;
+/** setTimeout treats anything above 2^31-1 ms as 1 ms, so a larger delay
+ *  would close the session immediately instead of much later. */
+const MAX_TIMER_MS = 2_147_483_647;
+function usableMilliseconds(raw) {
+    const value = Number(raw);
+    return Number.isFinite(value) && value > 0 && value <= MAX_TIMER_MS ? value : null;
+}
+/** The idle policy for one harness. The per-harness names that preceded the
+ *  unified ones (OMB_CLAUDE_SESSION_IDLE_*, OMB_ACP_SESSION_IDLE_*) win when
+ *  both are set, so a harness-specific override keeps working alongside a
+ *  global OMB_SESSION_IDLE_MS / OMB_SESSION_IDLE_MIN_MS; the unified names
+ *  are the default for harnesses that did not set their own. A delay that is
+ *  not a positive finite number of at most 2^31-1 ms is validated away before
+ *  the floor applies — the old arithmetic coerced Infinity and larger values
+ *  into an immediately-firing 1 ms timer. The floor is the greater of the
+ *  built-in ten seconds and any configured minimum, so a per-harness minimum
+ *  can raise the floor but never lower it, and it applies to whatever delay
+ *  wins. */
+export function sessionIdlePolicy(driverPrefix, env = process.env) {
+    const minimumMs = Math.max(MINIMUM_IDLE_MS, usableMilliseconds(env[`OMB_${driverPrefix}_SESSION_IDLE_MIN_MS`] ?? env.OMB_SESSION_IDLE_MIN_MS) ?? 0);
+    const configured = usableMilliseconds(env[`OMB_${driverPrefix}_SESSION_IDLE_MS`] ?? env.OMB_SESSION_IDLE_MS) ?? DEFAULT_IDLE_MS;
+    return { idleMs: Math.max(minimumMs, configured), minimumMs };
+}

package/dist-server/server/env-path.js

@@ -41,6 +41,7 @@ function knownDirs() {
         join(home, ".volta", "bin"),
         join(home, ".bun", "bin"),
         join(home, ".asdf", "shims"),
+        join(home, ".local", "share", "mise", "shims"), // mise installer
         join(home, ".deno", "bin"),
         join(home, "bin"),
         ...nvmBinDirs(),
@@ -144,6 +145,20 @@ export function resetPathCacheForTests() {
     loginShellPath = null;
     registeredDirs.length = 0;
 }
+/** The user's home directory as this platform defines it. Windows keeps the
+ * real profile in USERPROFILE; a HOME that leaks in from a POSIX-flavored
+ * shell is not where Windows CLIs keep their state, so USERPROFILE wins there
+ * and HOME wins everywhere else. */
+export function userHome(env = process.env) {
+    return process.platform === "win32"
+        ? env.USERPROFILE || env.HOME || homedir()
+        : env.HOME || env.USERPROFILE || homedir();
+}
+/** `<user home>/.<name>` — the per-harness state directory every CLI keeps
+ * (`.qwen`, `.grok`, `.codex`…), Windows-correct everywhere. */
+export function harnessHome(name, env = process.env) {
+    return join(userHome(env), `.${name}`);
+}
 /** Every `name` binary on the augmented PATH as absolute paths, in PATH
  * order (first = what a bare name would run). Used by the Engines panel's
  * "detected" dropdown and the /api/cli-candidates endpoint. A path-ish

package/dist-server/server/guarded-requests.js

@@ -54,7 +54,7 @@ export function requestSourceForCard(messages, messageId) {
     return undefined;
 }
 export function requestNeedsInput(message) {
-    return Boolean((message.card?.requestId && !message.card.answered && !message.card.dismissed) ||
+    return Boolean((message.card?.requestId && !message.card.answered && !message.card.dismissed && !message.card.expired) ||
         (message.connector && !message.connector.dismissed && !message.connector.resumed && message.connector.status !== "connected") ||
-        (message.secret && !message.secret.provided && !message.secret.dismissed));
+        (message.secret && !message.secret.provided && !message.secret.dismissed && !message.secret.superseded));
 }

package/dist-server/server/harness-capabilities.js

@@ -0,0 +1,61 @@
+// What a bot gains or loses when its default engine (instanceId, hence
+// driver) changes. Two per-driver facts decide it: whether the driver mounts
+// the agents tool catalog at all (adapter capabilities.agentsMcp — a bot on
+// a driver without it is never even told about the team tools), and which
+// approval levels the destination driver implements. Turn-scoped catalog
+// flags are identical on both sides of a switch, so the comparison below
+// uses one envelope profile and lets the per-driver capability decide the
+// delta; the tool names themselves come from the real catalog, so this
+// never drifts from what a turn is actually shown.
+import { APPROVAL_MODES, supportsApprovalMode as driverKindSupportsApprovalMode } from "../shared/approval-mode.js";
+import { availableTools } from "./drivers/agents-catalog.js";
+/** The widest turn the harness can build: every optional integration on and
+ * a coordinating (room) turn, where the room-only coordination tools exist.
+ * Both sides of a comparison get the same profile; only the driver's own
+ * capability can differ. */
+const ENVELOPE = {
+    externalRuntime: false,
+    coordinating: true,
+    ownThreadCreation: true,
+    skillAuthoring: true,
+    sharedComputers: true,
+    voiceNotes: true,
+    botId: "",
+};
+/** Extra card lines for an engine switch, empty when nothing changes. */
+export function harnessCapabilityLines(from, to) {
+    if (!from || !to)
+        return [];
+    const lines = [];
+    if (from.agentsMcp !== to.agentsMcp) {
+        const names = availableTools(ENVELOPE).map((tool) => tool.name);
+        const coordination = ["coordinate_bots", "ask_bot", "delegate_bot"].filter((name) => names.includes(name));
+        lines.push(to.agentsMcp
+            ? "Gains peer coordination and the other team tools: " + names.length + " tools including " + coordination.join(", ") + "."
+            : "Loses peer coordination and every team tool: " + names.length + " tools including " + coordination.join(", ") + " go away.");
+    }
+    if (from.driverKind !== to.driverKind) {
+        const lost = APPROVAL_MODES.filter((mode) => driverKindSupportsApprovalMode(from.driverKind, mode) && !driverKindSupportsApprovalMode(to.driverKind, mode));
+        const gained = APPROVAL_MODES.filter((mode) => !driverKindSupportsApprovalMode(from.driverKind, mode) && driverKindSupportsApprovalMode(to.driverKind, mode));
+        if (lost.length)
+            lines.push("Loses approval levels: " + lost.join(", ") + ".");
+        if (gained.length)
+            lines.push("Gains approval levels: " + gained.join(", ") + ".");
+    }
+    return lines;
+}
+/** Binds the registry to the approval-support check so each gate passes its
+ * model selection — or a driver view it already holds — and stops
+ * unwrapping registry.cliTarget(...)?.driverKind at every call site. The
+ * lookup prefers shadow state, so a mid-reconfig instance answers with the
+ * driver it would actually run. */
+export function createApprovalModeSupport(registry) {
+    return function supportsApprovalMode(target, mode) {
+        const driverKind = target === undefined
+            ? undefined
+            : "driverKind" in target
+                ? target.driverKind
+                : registry.cliTarget(target.instanceId)?.driverKind;
+        return driverKindSupportsApprovalMode(driverKind, mode);
+    };
+}