openmausbot 0.1.86 → 0.1.88

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

@@ -26,16 +26,33 @@ 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";
 import { newEventId, newId } from "../contracts.js";
+import { parseAskQuestions, parseChoices, questionAnswersByQuestion } from "../../shared/ask-question.js";
 import { decodeInjectId, encodeInjectId, hostApiKey, localHost, mergeLocalInject, } from "./local-inject.js";
 import { appendNative } from "./native.js";
 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",
@@ -425,7 +442,18 @@ export const PiDriver = {
             }
             const turnId = newId();
             const pending = new Map();
+            // Ask fail-safe timers, tracked so settle() can cancel them outright:
+            // a cleared pending map alone leaves each timer holding the ask
+            // 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.
@@ -488,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);
@@ -497,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) => {
@@ -522,6 +559,17 @@ 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.
+                for (const timer of askTimers)
+                    clearTimeout(timer);
+                askTimers.clear();
+                pending.clear();
                 flushAssistantText();
                 emit({
                     ...base(threadId, turnId),
@@ -552,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" });
@@ -567,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;
                     }
@@ -626,48 +725,158 @@ export const PiDriver = {
                         if (evt.method === "select" || evt.method === "confirm" || evt.method === "input") {
                             flushAssistantText();
                             const reqId = evt.id ?? newId();
-                            const isQuestion = evt.method === "input";
+                            const isSelect = evt.method === "select";
+                            const isQuestion = isSelect || evt.method === "input";
+                            const selectOptions = isSelect && Array.isArray(evt.options)
+                                ? evt.options.filter((option) => typeof option === "string") : [];
+                            const summary = String(evt.title ?? (isQuestion ? "pi has a question" : "pi wants confirmation")).slice(0, 200);
+                            // A select is a question with named options; the structured
+                            // card renders from it while the flat choices keep older
+                            // clients answering. An input has nothing to pick from and
+                            // stays the free-text question it always was.
+                            const question = isSelect
+                                ? (parseAskQuestions({
+                                    questions: [{ question: summary, options: selectOptions }],
+                                }) ?? [])[0]
+                                : undefined;
+                            const choices = question?.options.length ? question.options.map((option) => option.label) : undefined;
+                            let timer;
                             // Register BEFORE emitting: the harness may auto-approve from
                             // inside its synchronous request.opened listener. Emitting first
                             // made respondToRequest see no pending ask, return unavailable,
                             // then fall back to a human card on every "Always allow" call.
                             pending.set(reqId, (decision) => {
+                                if (timer) {
+                                    clearTimeout(timer);
+                                    askTimers.delete(timer);
+                                }
                                 if (decision.behavior === "deny")
                                     send({ type: "extension_ui_response", id: reqId, cancelled: true });
-                                else if (isQuestion)
-                                    send({ type: "extension_ui_response", id: reqId, value: decision.message ?? "" });
+                                else if (isQuestion) {
+                                    // Recover the picked label from a structured card's Q:/A:
+                                    // reply; a flat answer or typed text passes through
+                                    // verbatim (questionAnswersByQuestion's single-question
+                                    // fallback does exactly that).
+                                    const value = question
+                                        ? questionAnswersByQuestion(decision.message ?? "", [question])[question.question] ?? decision.message ?? ""
+                                        : decision.message ?? "";
+                                    // Display labels are capped/trimmed; pi expects the
+                                    // original option. Never guess if two normalize alike.
+                                    const matched = selectOptions.filter(option => parseChoices([option], 1)?.[0] === value);
+                                    send(matched.length > 1
+                                        ? { type: "extension_ui_response", id: reqId, cancelled: true }
+                                        : { type: "extension_ui_response", id: reqId, value: matched[0] ?? value });
+                                }
                                 else
                                     send({ type: "extension_ui_response", id: reqId, confirmed: true });
                             });
+                            // The ask must never hold the turn forever: cancel it after 15
+                            // minutes. The pending.delete guard makes this a no-op once the
+                            // turn settled (settle clears pending) or a person answered.
+                            timer = setTimeout(() => {
+                                if (timer)
+                                    askTimers.delete(timer);
+                                if (!pending.delete(reqId))
+                                    return;
+                                send({ type: "extension_ui_response", id: reqId, cancelled: true });
+                                emit({
+                                    ...base(threadId, turnId),
+                                    requestId: reqId,
+                                    type: "request.resolved",
+                                    behavior: "deny",
+                                    source: "timeout",
+                                });
+                            }, 15 * 60_000);
+                            askTimers.add(timer);
+                            timer.unref?.();
                             emit({
                                 ...base(threadId, turnId),
                                 requestId: reqId,
                                 type: "request.opened",
                                 requestType: isQuestion ? "question" : "permission",
                                 tool: String(evt.title ?? "pi"),
-                                summary: String(evt.title ?? "pi wants confirmation"),
+                                summary,
+                                ...(choices ? { choices } : {}),
+                                ...(question ? { questions: [question] } : {}),
                             });
                         }
                         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:
@@ -709,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);
@@ -716,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",
@@ -751,11 +962,71 @@ export const PiDriver = {
                     /* keep going on the engine default */
                 }
             }
-            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 };
@@ -828,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(),
@@ -847,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

@@ -0,0 +1,110 @@
+// The stable/volatile prompt split, shared by the drivers that deliver it.
+// The stable half is everything that must stay byte-identical for a
+// provider's cached prefix (or a spawned CLI's session contract) to
+// survive; the volatile half (memory, mentions, outstanding teammate
+// 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, rmSync } from "node:fs";
+import { join } from "node:path";
+import { DATA_DIR } from "../config.js";
+import { writeFileAtomic } from "../atomic.js";
+/** Read the split off a turn. Both halves must be present: a driver that
+ * receives only the unsplit system field was called through a path that
+ * never split it. */
+export function promptHalves(turn) {
+    const { systemStable, systemVolatile } = turn;
+    if (typeof systemStable !== "string" || typeof systemVolatile !== "string") {
+        return { stable: null, volatile: "" };
+    }
+    return { stable: systemStable, volatile: systemVolatile };
+}
+export const VOLATILE_CONTEXT_NOTE_PREFIX = "Context from OpenMausBot updated since this conversation started; it replaces any earlier copy:";
+export const VOLATILE_CONTEXT_CLEARED_NOTE = "The OpenMausBot context notes from earlier in this conversation (memory, mentions, outstanding teammate work) have been cleared; the standing instructions still apply.";
+/** The labelled block that carries a changed volatile half inside a user
+ * turn. A half that is empty and always was needs no note; one that was
+ * cleared announces the removal so the model stops relying on it. */
+export function volatileContextNote(volatile, hadVolatile) {
+    const text = volatile.trim();
+    if (text)
+        return VOLATILE_CONTEXT_NOTE_PREFIX + "\n\n" + text;
+    return hadVolatile ? VOLATILE_CONTEXT_CLEARED_NOTE : "";
+}
+/** Prepend a delivered note to the turn text: the one composition shape
+ * every split-aware driver uses. */
+export function withContextNote(note, text) {
+    if (!note)
+        return text;
+    return text ? note + "\n\n" + text : note;
+}
+const digest = (value) => createHash("sha256").update(value).digest("hex");
+const EMPTY_FINGERPRINT = digest("");
+export function promptSplitFingerprints(stable, volatile) {
+    return { stable: digest(stable), volatile: digest(volatile) };
+}
+const receiptPath = (scope, key) => join(DATA_DIR, "prompt-split", digest(JSON.stringify([scope, key])) + ".json");
+/** Which halves a native session (an ACP session id, a pi session file)
+ * last carried. Unknown - never tracked, or tracked before this file
+ * existed - reads as null, and the caller re-delivers the full prompt
+ * once. */
+export function readPromptSplitReceipt(scope, key) {
+    try {
+        const raw = JSON.parse(readFileSync(receiptPath(scope, key), "utf8"));
+        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,
+                    ...(typeof record.turnsSinceFull === "number" ? { turnsSinceFull: record.turnsSinceFull } : {}),
+                };
+            }
+        }
+    }
+    catch {
+        /* a missing or corrupt receipt is simply unknown */
+    }
+    return null;
+}
+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
+ * current copy the way a pre-split turn always did - and a changed
+ * volatile half rides as a labelled note. Otherwise the turn text goes
+ * 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.
+ * 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 === fingerprints.volatile && !perTurnVolatile
+        ? ""
+        : volatileContextNote(volatile, previous.volatile !== EMPTY_FINGERPRINT);
+    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