openmausbot 0.1.87 → 0.1.88

package/dist-server/server/drivers/codex-identity.js

@@ -3,6 +3,7 @@
 // old file's email. Only the protocol's display email leaves this helper.
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
+import { userHome } from "../env-path.js";
 import { killCliTree, spawnCli } from "../procs.js";
 const MAX_OUTPUT = 16_384;
 const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
@@ -11,7 +12,7 @@ const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 export function codexHome(env) {
     if (env.CODEX_HOME)
         return isAbsolute(env.CODEX_HOME) ? resolve(env.CODEX_HOME) : null;
-    const home = env.HOME || env.USERPROFILE || homedir();
+    const home = userHome(env);
     return isAbsolute(home) ? join(home, ".codex") : null;
 }
 /** Read-only account metadata. Unsupported CLIs and uncertain responses stay

package/dist-server/server/drivers/codex-release.js

@@ -0,0 +1,48 @@
+// Release freshness is independent of account-specific model availability.
+function parseCodexReleaseVersion(value) {
+    const match = /^(?:.*\bcodex-cli\s+)?v?(\d+)\.(\d+)\.(\d+)(-[0-9a-z.-]+)?(?:\+[0-9a-z.-]+)?$/i.exec(value.trim());
+    return match ? { parts: match.slice(1, 4).map(Number), prerelease: Boolean(match[4]) } : null;
+}
+export function codexVersionBehind(installed, latest) {
+    const a = parseCodexReleaseVersion(installed);
+    const b = parseCodexReleaseVersion(latest);
+    if (!a || !b || b.prerelease)
+        return false;
+    for (let i = 0; i < 3; i++) {
+        if (a.parts[i] !== b.parts[i])
+            return a.parts[i] < b.parts[i];
+    }
+    return a.prerelease;
+}
+export function createCodexReleaseReader(fetchImpl = fetch, now = Date.now) {
+    let cached;
+    let expires = 0;
+    return () => {
+        if (cached && now() < expires)
+            return cached;
+        expires = now() + 60 * 60 * 1000;
+        cached = (async () => {
+            try {
+                const response = await fetchImpl("https://registry.npmjs.org/@openai/codex/latest", {
+                    signal: AbortSignal.timeout(3000),
+                    headers: { Accept: "application/json" },
+                });
+                if (!response.ok)
+                    throw new Error("Release lookup failed");
+                const payload = await response.json();
+                const version = typeof payload.version === "string" ? payload.version : "";
+                const parsed = parseCodexReleaseVersion(version);
+                if (!parsed || parsed.prerelease)
+                    throw new Error("Invalid stable release");
+                return version;
+            }
+            catch {
+                // Offline checks must not make an otherwise usable engine unavailable.
+                expires = now() + 5 * 60 * 1000;
+                return null;
+            }
+        })();
+        return cached;
+    };
+}
+export const readLatestCodexRelease = createCodexReleaseReader();

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

@@ -31,10 +31,9 @@ import { codexAccountEmail } from "./codex-identity.js";
 import { classifyResumeFailure, mayReplay, recoveryPromptFor } from "../resume-recovery.js";
 import { extractMcpImages } from "../mcp-tool-images.js";
 import { parseProtocolAskQuestions, questionAnswersById, questionChoices } from "../../shared/ask-question.js";
+import { codexVersionBehind, readLatestCodexRelease } from "./codex-release.js";
 export { decodeCodexSelection, readCodexModelCatalog, STATIC_CODEX_MODELS } from "./codex-catalog.js";
 const DRIVER_KIND = "codex";
-const ASTRA_MODEL_ID = "gpt-6-astra";
-const ASTRA_MIN_CODEX_VERSION = [0, 153, 1];
 class CodexRpcError extends Error {
     code;
     constructor(error) {
@@ -49,23 +48,6 @@ function missingNativeCodexThread(error, cursor) {
     return error instanceof CodexRpcError && error.code === -32600 &&
         error.message === `no rollout found for thread id ${cursor}`;
 }
-/** Whether an installed Codex predates the release that exposes GPT-6 Astra
- * through app-server. Unknown version formats stay quiet: a bad guess should
- * never nag someone whose custom build may already support the model. */
-export function codexPredatesAstra(version) {
-    const value = version.trim();
-    const match = /\bcodex-cli\s+v?(\d+)\.(\d+)\.(\d+)(?:[-+][0-9a-z.-]+)?(?![\d.])\b/i.exec(value)
-        ?? /^v?(\d+)\.(\d+)\.(\d+)(?:[-+][0-9a-z.-]+)?$/i.exec(value);
-    if (!match)
-        return false;
-    const installed = match.slice(1, 4).map(Number);
-    for (let i = 0; i < ASTRA_MIN_CODEX_VERSION.length; i += 1) {
-        if (installed[i] !== ASTRA_MIN_CODEX_VERSION[i]) {
-            return installed[i] < ASTRA_MIN_CODEX_VERSION[i];
-        }
-    }
-    return false;
-}
 /** Ask the configured executable to update itself. This matters when the user
  * selected a non-PATH Codex: installing a second global copy would leave
  * OpenMausBot pointing at the old binary. */
@@ -85,13 +67,13 @@ export function codexUpdateCommand(cli, platform = process.platform) {
     const command = (tokens.length > 0 ? tokens : [trimmed]).map(quote).join(" ");
     return platform === "win32" ? `& ${command} update` : `${command} update`;
 }
-function codexAstraUpdate(version, models, cli) {
-    if (models.options.some((model) => model.id === ASTRA_MODEL_ID) || !codexPredatesAstra(version)) {
+async function codexReleaseUpdate(version, cli) {
+    const latest = await readLatestCodexRelease();
+    if (!latest || !codexVersionBehind(version, latest))
         return undefined;
-    }
     return {
-        title: "Update Codex for GPT-6 Astra",
-        message: "This Codex version predates Astra support. Update it, then refresh models. Astra must also be available to your signed-in ChatGPT account.",
+        title: `Update Codex to ${latest}`,
+        message: `A newer stable Codex CLI is available (installed: ${version}). Update it, then refresh models. Model availability also depends on your signed-in account.`,
         command: codexUpdateCommand(cli),
     };
 }
@@ -1579,7 +1561,7 @@ export const CodexDriver = {
                 version,
                 authenticated,
                 ...(email ? { account: { email } } : {}),
-                update: codexAstraUpdate(version, models, config.cli),
+                update: await codexReleaseUpdate(version, config.cli),
                 billing: "subscription",
             };
         };

package/dist-server/server/drivers/openai-chat.js

@@ -332,7 +332,8 @@ export function createOpenAIChatRuntime(options) {
         });
         let resolveDone;
         const done = new Promise((resolve) => { resolveDone = resolve; });
-        active.set(turn.threadId, { abort, turnId, done, approval });
+        const turnEntry = { abort, turnId, done, approval, asides: [] };
+        active.set(turn.threadId, turnEntry);
         emit({ ...base(turn.threadId, turnId), type: "turn.started" });
         emit({ ...base(turn.threadId, turnId), type: "session.started", sessionId: null, model });
         void (async () => {
@@ -358,6 +359,13 @@ export function createOpenAIChatRuntime(options) {
                 }
                 for (let round = 0; round < 16; round++) {
                     abort.signal.throwIfAborted();
+                    // Drain parked mid-turn input here, before the next completion
+                    // request: the previous round's tool results are complete, so a
+                    // user message lands on a consistent array (never inside a tool
+                    // batch) and the provider sees it as the newest input.
+                    const parked = turnEntry.asides.splice(0);
+                    if (parked.length)
+                        messages.push({ role: "user", content: parked.join("\n\n") });
                     native("out", options.nativeLog.outgoing(turn, messages, model));
                     let attempt = 0;
                     let completion;
@@ -611,7 +619,10 @@ export function createOpenAIChatRuntime(options) {
             provider: options.driverKind,
             capabilities: { ...(options.computerUse ? { computerMcp: options.tools !== false, cloudComputerMcp: options.tools !== false, localComputerMcp: options.tools !== false,
                     browserMcp: options.tools !== false, nativeImageInput: true, images: true } : {}),
-                sessionModelSwitch: "in-session", customMcp: options.tools !== false, agentsMcp: options.tools !== false, composioMcp: options.tools !== false },
+                sessionModelSwitch: "in-session", customMcp: options.tools !== false, agentsMcp: options.tools !== false, composioMcp: options.tools !== false,
+                // The runtime owns the whole tool loop, so it can always take a
+                // user message mid-turn: park it, deliver before the next completion.
+                queueing: true },
             sendTurn,
             interruptTurn: async (threadId, turnId) => {
                 const turn = active.get(threadId);
@@ -621,6 +632,19 @@ export function createOpenAIChatRuntime(options) {
                 await turn.done;
             },
             respondToRequest: async (threadId, requestId, decision) => active.get(threadId)?.approval.answer(requestId, decision.behavior, decision.message) ?? "unavailable",
+            steer: async (threadId, text) => {
+                // This engine has no external session to respect — parking the
+                // words in the live turn's entry IS delivery into the loop, so a
+                // successful park is "steered" and a missing turn is the only
+                // refusal. The words ride the array at the next round boundary;
+                // if the turn settles first, the harness's transcript record
+                // keeps them for the next turn (they are never re-sent here).
+                const running = active.get(threadId);
+                if (!running)
+                    return "refused";
+                running.asides.push(text);
+                return "steered";
+            },
             hasSession: (threadId) => active.has(threadId),
             stopAll: async () => {
                 const turns = [...active.values()];

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 } };
 }