openmausbot 0.1.95 → 0.1.97

package/dist/assets/swimlanesDiagram-TC7HE7FX-C6bZtBXk.js

@@ -1,8 +0,0 @@
-import{c as r,s as e}from"./flowDiagram-KWPJA3E3-Bdw9DqEl.js";import{_ as a}from"./mermaid.core-C6yU5FSS.js";import"./chunk-5VM5RSS4-BmVYJ0f8.js";import"./chunk-XXDRQBXY-CPqxINpA.js";import"./chunk-WEXAMYUT-C7ZvuguH.js";import"./chunk-GWA4HPMP-DFYSb6J6.js";import"./channel-DS2NbT5x.js";import"./index-X_5ydXIE.js";var o=a(t=>`${e(t)}
-  .swimlane.cluster:not([data-color-id]) rect {
-    stroke: ${t.clusterBorder} !important;
-  }
-  [data-look="neo"].cluster rect {
-    filter: none;
-  }
-`,"getStyles"),s=o,u=r({styles:s});export{u as diagram};

package/dist-server/server/claim-idle.js

@@ -1,33 +0,0 @@
-/** Quiet-window policy for releasing a held seat while its turn lives.
- *
- * The policy is deliberately synchronous and clock-injected: like the
- * claim map it serves, expiry is evaluated when a claim is touched
- * (claim, blocker, owns) rather than by a timer, so the server's single
- * thread decides every transition and tests pin time exactly. Slice
- * #1655 reuses this window math for its own idle release; keep this
- * module free of server imports. */
-/** Default quiet window: no screen activity for this long releases the seat. */
-export const COMPUTER_CLAIM_QUIET_MS = 90_000;
-/** Default reclaim window: the previous holder re-claims directly for this long. */
-export const COMPUTER_CLAIM_RECLAIM_MS = 10 * 60_000;
-export class IdleReleasePolicy {
-    quietMs;
-    reclaimMs;
-    constructor(quietMs = COMPUTER_CLAIM_QUIET_MS, reclaimMs = COMPUTER_CLAIM_RECLAIM_MS) {
-        if (!Number.isFinite(quietMs) || quietMs <= 0)
-            throw new Error("Idle release quiet window must be positive");
-        if (!Number.isFinite(reclaimMs) || reclaimMs <= 0)
-            throw new Error("Idle release reclaim window must be positive");
-        this.quietMs = quietMs;
-        this.reclaimMs = reclaimMs;
-    }
-    /** True once the seat has been quiet for the full window. Screen-poller
-     * frames never refresh the activity clock, so they cannot keep a seat. */
-    quietElapsed(lastActivityAt, now) {
-        return now - lastActivityAt >= this.quietMs;
-    }
-    /** True while a released seat's previous holder still re-claims directly. */
-    reclaimLive(releasedAt, now) {
-        return now < releasedAt + this.reclaimMs;
-    }
-}

package/dist-server/server/cloud-overflow.js

@@ -1,167 +0,0 @@
-/** Consent, cost, and idle-stop policy for overflowing a local computer
- * wait onto a per-second-billed cloud seat (#1655).
- *
- * Like server/claim-idle.ts this module is deliberately synchronous and
- * clock-injected: the server decides every transition on its single
- * thread and tests pin time exactly. Nothing here starts or stops a
- * machine — the wiring does, and only when the decision says to. Keep
- * this module free of server imports. */
-import { computerWaitDuration } from "./computer-wait.js";
-/** Default idle stop: a cloud seat no real screen work has touched for
- * this long is stopped (archived), because billing runs per second while
- * it runs. "A few idle minutes" per the issue. */
-export const CLOUD_SEAT_IDLE_STOP_MS = 5 * 60_000;
-/** Retry cadence for an idle stop that failed (#1655): the first retry
- * after one minute, doubling per failure up to ten. A failed stop keeps
- * its lease — the seat still bills — so the sweep always retries instead
- * of abandoning a running machine. */
-export const CLOUD_SEAT_SLEEP_RETRY_MS = 60_000;
-export const CLOUD_SEAT_SLEEP_RETRY_MAX_MS = 10 * 60_000;
-export function cloudOverflowAction(situation) {
-    if (!situation.featureEnabled || !situation.cloudConfigured || situation.perSecondCostUsd === null)
-        return { kind: "off" };
-    if (situation.started)
-        return { kind: "none" };
-    if (situation.consented)
-        return { kind: "start" };
-    if (situation.offered)
-        return { kind: "none" };
-    return { kind: "offer" };
-}
-/** Per-conversation consent plus the offer bookkeeping that keeps the
- * card to one per conversation until it is revoked. A thread the operator
- * allowlisted in config carries standing consent and never needs the
- * card. */
-export class CloudOverflowConsent {
-    grants = new Map();
-    offers = new Map();
-    revocations = new Set();
-    /** Consent for this conversation. With `perSecondCostUsd`, a card
-     * consent counts only at the rate its card showed — an allowlisted
-     * thread carries the operator's standing consent, and the operator is
-     * also the one who sets the rate. */
-    consented(threadId, allowlistedThreads = new Set(), perSecondCostUsd) {
-        if (this.revocations.has(threadId))
-            return false;
-        if (allowlistedThreads.has(threadId))
-            return true;
-        const grant = this.grants.get(threadId);
-        if (!grant)
-            return false;
-        return perSecondCostUsd === undefined || grant.perSecondCostUsd === perSecondCostUsd;
-    }
-    /** `perSecondCostUsd` is the rate the answered card showed. */
-    grant(threadId, perSecondCostUsd, now = Date.now()) {
-        this.revocations.delete(threadId);
-        this.grants.set(threadId, { at: now, perSecondCostUsd });
-    }
-    /** Revoking also clears the offered mark, so a later wait in the same
-     * conversation may ask again instead of meeting silence. */
-    revoke(threadId) {
-        const had = this.grants.delete(threadId);
-        this.revocations.add(threadId);
-        this.offers.delete(threadId);
-        return had;
-    }
-    /** A card is outstanding for this conversation — at the given rate
-     * when one is supplied, so a config change re-offers with the new
-     * price instead of meeting silence at the old one. */
-    offered(threadId, perSecondCostUsd) {
-        const offer = this.offers.get(threadId);
-        if (!offer)
-            return false;
-        return perSecondCostUsd === undefined || offer.perSecondCostUsd === perSecondCostUsd;
-    }
-    /** The rate the outstanding card showed, or null when no card is out. */
-    offeredRate(threadId) {
-        return this.offers.get(threadId)?.perSecondCostUsd ?? null;
-    }
-    markOffered(threadId, perSecondCostUsd, now = Date.now()) {
-        this.offers.set(threadId, { at: now, perSecondCostUsd });
-    }
-}
-/** One running cloud seat started by overflow. `touch` is called only
- * for real computer tool completions on that seat — screen-poller frames
- * never reach it, exactly like #1653's activity clock, so preview
- * traffic cannot keep a paid machine awake. */
-export class CloudSeatLease {
-    botId;
-    threadId;
-    /** The claim generation that started the seat: a stop releases the Box
-     * claim for exactly this owner, never a newer turn's. */
-    generation;
-    startedAt;
-    idleStopMs;
-    lastActivityAt;
-    sleepRetryNotBefore = 0;
-    sleepRetryMs = CLOUD_SEAT_SLEEP_RETRY_MS;
-    constructor(init) {
-        const idleStopMs = init.idleStopMs ?? CLOUD_SEAT_IDLE_STOP_MS;
-        if (!Number.isFinite(idleStopMs) || idleStopMs <= 0)
-            throw new Error("Cloud seat idle stop window must be positive");
-        this.botId = init.botId;
-        this.threadId = init.threadId;
-        this.generation = init.generation;
-        this.startedAt = init.now ?? Date.now();
-        this.lastActivityAt = this.startedAt;
-        this.idleStopMs = idleStopMs;
-    }
-    touch(now = Date.now()) {
-        this.lastActivityAt = now;
-        // Real work earns a fresh stop attempt: the backoff only paces
-        // retries against an idle seat that keeps failing to sleep.
-        this.sleepRetryNotBefore = 0;
-        this.sleepRetryMs = CLOUD_SEAT_SLEEP_RETRY_MS;
-    }
-    /** An idle stop may run now — true until a failure defers it. */
-    sleepDue(now = Date.now()) {
-        return now >= this.sleepRetryNotBefore;
-    }
-    /** The idle stop failed: keep the lease and back off, bounded, so the
-     * sweep retries gently instead of hammering a sick Box — and never
-     * abandons a seat that still bills. */
-    deferSleep(now = Date.now()) {
-        this.sleepRetryNotBefore = now + this.sleepRetryMs;
-        this.sleepRetryMs = Math.min(this.sleepRetryMs * 2, CLOUD_SEAT_SLEEP_RETRY_MAX_MS);
-    }
-    idleFor(now = Date.now()) {
-        return Math.max(0, now - this.lastActivityAt);
-    }
-    idleElapsed(now = Date.now()) {
-        return now - this.lastActivityAt >= this.idleStopMs;
-    }
-}
-/** Dollars per second at rate-card precision: enough places for small
- * per-second rates to stay visible, trailing zeros trimmed but never
- * past two decimals. */
-export function formatPerSecondUsd(perSecondCostUsd) {
-    let text = perSecondCostUsd.toFixed(6).replace(/0+$/, "");
-    if (text.endsWith("."))
-        text += "00";
-    else {
-        const decimals = text.length - text.indexOf(".") - 1;
-        if (decimals < 2)
-            text += "0".repeat(2 - decimals);
-    }
-    return "$" + text;
-}
-/** The consent card (#1655): the per-second cost sits beside the local
- * wait picture before any choice is made, and nothing starts without an
- * explicit consent the person still has to give. */
-export function cloudOverflowOfferText(opts) {
-    const idleStopMs = opts.idleStopMs ?? CLOUD_SEAT_IDLE_STOP_MS;
-    const estimate = opts.waitEstimateMs === undefined ? "" : ` Recent local waits here have taken about ${computerWaitDuration(opts.waitEstimateMs)}.`;
-    return `This computer is busy. Its work can overflow to a cloud computer for ${formatPerSecondUsd(opts.perSecondCostUsd)} per second.${estimate} Nothing starts without your consent — allow cloud overflow for this conversation to start it; the cloud computer stops after ${computerWaitDuration(idleStopMs)} idle.`;
-}
-export function cloudSeatStartedText(opts) {
-    const idleStopMs = opts.idleStopMs ?? CLOUD_SEAT_IDLE_STOP_MS;
-    return `Cloud computer started at ${formatPerSecondUsd(opts.perSecondCostUsd)} per second. It stops automatically after ${computerWaitDuration(idleStopMs)} idle, and the local wait continues until this computer is free.`;
-}
-export function cloudSeatStoppedText(idleMs) {
-    return `Cloud computer stopped after ${computerWaitDuration(idleMs)} idle — billing pauses while it sleeps.`;
-}
-export function cloudOverflowConsentText(allowed, idleStopMs = CLOUD_SEAT_IDLE_STOP_MS) {
-    return allowed
-        ? `Cloud overflow allowed for this conversation. A waiting turn may start the cloud computer; it stops after ${computerWaitDuration(idleStopMs)} idle.`
-        : "Cloud overflow consent revoked. Waits stay local, and no cloud computer starts without a new consent.";
-}

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

@@ -1,443 +0,0 @@
-import { newEventId, newId } from "../contracts.js";
-import { boatCredential, boatProviderApi } from "../included-services.js";
-import { appendNative } from "./native.js";
-import { assertToolScopeSupported } from "../../shared/tool-scope-support.js";
-import { OMB_ASK_TOOL, answerWithoutPreamble, askQuestionSummary, capAnswerEcho, ombAskProtocolPrompt, parseOmbAskQuestions, questionChoices, stripOmbAskBlock, } from "../../shared/ask-question.js";
-// "boxAgent" is Boat's historical driver kind (catalog and wire); keep it.
-const DRIVER_KIND = "boxAgent";
-const MODELS = {
-    default: "claude-fable-5",
-    options: [
-        { id: "claude-fable-5", label: "Claude Fable 5 · on the box" },
-        { id: "sonnet", label: "Claude Sonnet · on the box" },
-        { id: "gpt-5.4", label: "GPT-5.4 (Codex) · on the box" },
-    ],
-};
-/** Any fence whose info string names the ask protocol, even when its body
- * does not parse: the marker for "the model tried to ask and failed". */
-const ASK_FENCE_ANY = /(^|\n)[ \t]{0,3}(`{3,}|~{3,})[ \t]*omb-ask\b/;
-/** The boat runs every harness boat.dev ships (claude-code, codex, pi, opencode,
- * prime-agent, kimi). Which one a model id belongs to comes from the public
- * catalog, `GET /api/provider-models` at the API root: an object keyed by
- * harness, each with its `models`. A bot that arrives here from another engine
- * carries that engine's model id, so this is what lets it keep its model. The
- * root is the API in use (Boat, or Cloud Pro's relay), so it is cached per root. */
-let catalog = null;
-let catalogRoot = "";
-async function loadCatalog(api) {
-    const root = api.replace(/\/api\/box\/v1\/?$/, "");
-    if (catalog && catalogRoot === root)
-        return;
-    catalogRoot = root;
-    catalog = await fetch(`${root}/api/provider-models`, { signal: AbortSignal.timeout(15_000) })
-        .then((res) => (res.ok ? res.json() : null))
-        .catch(() => null);
-}
-const providerFor = (model) => {
-    const slash = model.indexOf("/");
-    if (slash > 0 && catalog?.[model.slice(0, slash)])
-        return { provider: model.slice(0, slash), model: model.slice(slash + 1) };
-    for (const [provider, harness] of Object.entries(catalog ?? {})) {
-        if (harness.models?.some((m) => m?.id === model))
-            return { provider, model };
-    }
-    return { provider: model.startsWith("gpt") ? "codex" : "claude-code", model };
-};
-/** Boat answers a prompt it cannot run with 409 provider_not_configured: the
- * Boat has no AI sign-in for the harness the model needs. Say that, and the
- * one thing the person can do about it here. */
-export const PROVIDER_NOT_CONFIGURED_MESSAGE = "The Computer engine has no AI sign-in on its cloud computer. Choose another engine in this bot's settings.";
-/** An OMB Cloud's included Boat account has no agent sign-ins and never
- * will: the operator's account must not run (or pay for) customers' models. */
-export const COMPUTER_ENGINE_CLOUD_UNAVAILABLE = "The Computer engine isn't available on OpenMaus Cloud — choose another engine.";
-/** The words of a Boat error envelope ({code, message, error:{code,
- * message}}), never a bare code when Boat sent a sentence. */
-export function boatErrorMessage(body, status) {
-    const code = body?.code ?? body?.error?.code;
-    if (code === "provider_not_configured")
-        return PROVIDER_NOT_CONFIGURED_MESSAGE;
-    const message = body?.message ?? body?.error?.message ?? (typeof body?.error === "string" ? body.error : undefined) ?? code;
-    return typeof message === "string" && message.trim() ? message : `box HTTP ${status}`;
-}
-function decodeConfig(raw) {
-    const o = (raw ?? {});
-    return {
-        pollMs: typeof o.pollMs === "number" ? o.pollMs : 2500,
-        ...(typeof o.askTimeoutMs === "number" ? { askTimeoutMs: o.askTimeoutMs } : {}),
-    };
-}
-export const BoatAgentDriver = {
-    driverKind: DRIVER_KIND,
-    metadata: { displayName: "Computer", supportsMultipleInstances: false },
-    models: MODELS,
-    decodeConfig,
-    defaultConfig: () => decodeConfig({}),
-    async create(input) {
-        const { instanceId, config } = input;
-        // The person's own token (instanceConfigs injects it), else Cloud Pro's
-        // included one, with the one base URL each may be sent to. Resolved per
-        // request, like every other Boat call.
-        const ownToken = input.environment.BOX_TOKEN ?? process.env.BOX_TOKEN;
-        const account = () => boatCredential(ownToken);
-        const listeners = new Set();
-        const active = new Map();
-        /** One open ask per thread: the turn-held transport's pending card. The
-         * thread is busy for exactly as long as the ask is open, so a second
-         * block can never race the first. */
-        const heldAsks = new Map();
-        /** Threads whose last run ended with an unparseable omb-ask fence: the
-         * next prompt carries the correction so the ask is never lost silently. */
-        const malformedAsks = new Set();
-        const emit = (event) => {
-            for (const l of Array.from(listeners))
-                l(event);
-        };
-        const base = (threadId, turnId) => ({
-            eventId: newEventId(),
-            provider: DRIVER_KIND,
-            threadId,
-            turnId,
-            createdAt: new Date().toISOString(),
-        });
-        const api = async (path, opts = {}) => {
-            const credential = account();
-            const res = await fetch(`${credential?.api ?? boatProviderApi()}${path}`, {
-                ...opts,
-                headers: { authorization: `Bearer ${credential?.token ?? ""}`, "content-type": "application/json", ...opts.headers },
-                signal: opts.signal ?? AbortSignal.timeout(30_000),
-            });
-            const body = await res.json().catch(() => null);
-            if (!res.ok || body?.ok === false)
-                throw new Error(boatErrorMessage(body, res.status));
-            return body;
-        };
-        const sendTurn = async (turn) => {
-            turn = { ...turn, toolScope: assertToolScopeSupported(DRIVER_KIND, turn.toolScope) };
-            const { threadId } = turn;
-            const computer = turn.integrations?.computer;
-            const boxId = computer && (!computer.kind || computer.kind === "box") ? computer.boxId : undefined;
-            if (!account())
-                throw new Error('box not configured — add {"box":{"token":"…"}} to ~/.openmausbot/config.json');
-            if (account()?.included)
-                throw new Error(COMPUTER_ENGINE_CLOUD_UNAVAILABLE);
-            if (!boxId) {
-                throw new Error("this bot has no computer yet — open the Computer panel and provision one");
-            }
-            if (active.has(threadId))
-                throw new Error("a turn is already running on this thread");
-            const turnId = newId();
-            const model = turn.model || MODELS.default;
-            const correction = malformedAsks.delete(threadId)
-                ? "Your previous omb-ask block was malformed or empty, so the person never saw it. Ask again with a valid fenced omb-ask JSON block, or ask in plain words."
-                : "";
-            const prompt = [
-                turn.system,
-                "You are working on the assigned cloud computer — use its desktop, Chrome, and shell within the access described above.",
-                ombAskProtocolPrompt(),
-                ...(correction ? [correction] : []),
-                "",
-                turn.text,
-            ]
-                .filter((s) => s !== undefined)
-                .join("\n");
-            const postPrompt = async (promptText) => {
-                await loadCatalog(account()?.api ?? boatProviderApi());
-                const started = await api(`/boxes/${boxId}/prompt`, {
-                    method: "POST",
-                    body: JSON.stringify({ ...providerFor(model), prompt: promptText }),
-                });
-                appendNative(threadId, { dir: "out", source: "box.prompt", msg: { model, prompt: promptText, response: started } });
-                // real shape (2026-08): {type:"prompt.queued", promptId, promptRun:{id,…},
-                // id:<boat id>} — never fall back to the bare id, it's the boat's
-                return started?.promptRun?.id ?? started?.prompt?.id ?? started?.promptId ?? null;
-            };
-            const promptId = await postPrompt(prompt);
-            let cancelled = false;
-            active.set(threadId, {
-                turnId,
-                boxId,
-                cancel: () => {
-                    cancelled = true;
-                    heldAsks.get(threadId)?.settle(null, "system");
-                    void api(`/boxes/${boxId}/interrupt`, { method: "POST" }).catch(() => { });
-                },
-            });
-            emit({ ...base(threadId, turnId), type: "turn.started" });
-            emit({ ...base(threadId, turnId), type: "session.started", sessionId: promptId, model });
-            // poll events + run status until the prompt settles — and, when the
-            // run ends on an omb-ask block, until the person answers it: the OMB
-            // turn is the unit the whole server already understands (busy thread,
-            // waiting-on-you, routines waiting), so it stays open across the ask
-            // and the continuation prompt continues it rather than starting a
-            // driver-initiated turn nobody accounts for.
-            (async () => {
-                // Event ids seen this TURN. The events stream is the whole
-                // conversation, so a continuation run must not re-ingest history;
-                // `taskId` normally filters it, but ids survive even shape drift.
-                const seen = new Set();
-                let lastText = "";
-                let pendingText = "";
-                /** Why the boat could not answer (login expired, model refused, …). */
-                let problem = null;
-                /** Emit unflushed deltas as assistant_text and reset pendingText.
-                 * The omb-ask block is protocol, not prose: it streamed raw (the
-                 * card is its readable form), and the settled message shows the
-                 * words around it, never the JSON. */
-                const flushAssistantText = () => {
-                    const text = stripOmbAskBlock(pendingText);
-                    pendingText = "";
-                    if (!text.trim())
-                        return;
-                    emit({ ...base(threadId, turnId), type: "item.completed", itemType: "assistant_text", text });
-                };
-                /** Stream a full-text snapshot as a delta and accumulate it for flush. */
-                const ingest = (text) => {
-                    const delta = text.startsWith(lastText) ? text.slice(lastText.length) : text;
-                    lastText = text;
-                    if (!delta)
-                        return;
-                    pendingText += delta;
-                    emit({ ...base(threadId, turnId), type: "content.delta", streamKind: "assistant_text", delta });
-                };
-                /** The run has settled: flush its prose, then hold the OMB turn open
-                 * on an omb-ask block (if any) until the person answers or the ask
-                 * times out. An answer chains the continuation run under this same
-                 * turn; a deny or timeout ends it. */
-                const finishRun = async (ok, stopReason) => {
-                    flushAssistantText();
-                    // An interrupt that lands between ask text streaming and settle
-                    // finds no heldAsks entry to settle; without this check the run
-                    // would register a fresh ask for a dead turn and hold stop pending
-                    // for the ask timeout.
-                    if (cancelled) {
-                        return { ok: false, stopReason: "interrupted" };
-                    }
-                    // A remotely interrupted or failed run must stay stopped, even
-                    // if its partial output already contains a complete question.
-                    if (!ok)
-                        return { ok, stopReason };
-                    const questions = parseOmbAskQuestions(lastText);
-                    if (!questions) {
-                        // A fence that did not parse is a question the person never saw.
-                        // Say so on the next prompt instead of losing it silently. (An
-                        // over-cap block does not land here: the parser caps it at six
-                        // questions and still shows the card.)
-                        if (ASK_FENCE_ANY.test(lastText))
-                            malformedAsks.add(threadId);
-                        return { ok: ok && !cancelled, stopReason: cancelled ? "interrupted" : stopReason };
-                    }
-                    const requestId = newId();
-                    let settleHeld;
-                    const held = new Promise((resolve) => {
-                        const timer = setTimeout(() => settleHeld(null, "timeout"), config.askTimeoutMs ?? 15 * 60_000);
-                        timer.unref?.();
-                        settleHeld = (reply, source) => {
-                            heldAsks.delete(threadId);
-                            clearTimeout(timer);
-                            resolve([reply, source]);
-                        };
-                    });
-                    // register before emitting — an answer can race the emit
-                    heldAsks.set(threadId, { requestId, settle: settleHeld });
-                    const choices = questionChoices(questions);
-                    emit({
-                        ...base(threadId, turnId),
-                        requestId,
-                        type: "request.opened",
-                        requestType: "question",
-                        tool: OMB_ASK_TOOL,
-                        summary: askQuestionSummary(questions),
-                        questions,
-                        ...(choices?.length ? { choices } : {}),
-                        origin: "output",
-                    });
-                    const [reply, source] = await held;
-                    emit({ ...base(threadId, turnId), requestId, type: "request.resolved", behavior: reply !== null ? "answer" : "deny", source });
-                    if (reply === null || cancelled) {
-                        return { ok: ok && !cancelled, stopReason: cancelled ? "interrupted" : stopReason };
-                    }
-                    // The turn is still open, so this prompt continues it: same turnId,
-                    // same accounting, and the answer reaches the boat the way the ask
-                    // contract promised — Q:/A: blocks, capped for echo.
-                    const continuation = [
-                        capAnswerEcho(answerWithoutPreamble(reply)),
-                        "",
-                        "The person answered the omb-ask questions above (Q:/A:). Continue the task with their answers; end with another omb-ask block only if you truly need more.",
-                    ].join("\n");
-                    const nextPromptId = await postPrompt(continuation);
-                    // Stop can land while the continuation POST is in flight: the
-                    // interrupt inside cancel() then hits a boat with no active run,
-                    // and the continuation would start after it. Interrupt the run
-                    // that just started before ending the turn.
-                    if (cancelled) {
-                        void api(`/boxes/${boxId}/interrupt`, { method: "POST" }).catch(() => { });
-                        return { ok: false, stopReason: "interrupted" };
-                    }
-                    return await settleRun(nextPromptId);
-                };
-                /** Poll one boat run to its settle. */
-                const settleRun = async (runPromptId) => {
-                    const startedAt = Date.now(); // one 30-min ceiling per boat run, ask chains included
-                    lastText = "";
-                    pendingText = "";
-                    problem = null;
-                    for (;;) {
-                        if (cancelled)
-                            break;
-                        await new Promise((r) => setTimeout(r, config.pollMs));
-                        const events = await api(`/boxes/${boxId}/events`).catch(() => null);
-                        const list = events?.events ?? events?.items ?? [];
-                        for (const ev of list) {
-                            // The stream is the whole conversation from its start; `taskId`
-                            // names the prompt run an event belongs to. Earlier turns are
-                            // history, not this answer.
-                            if (runPromptId && ev.taskId && String(ev.taskId) !== runPromptId)
-                                continue;
-                            const id = String(ev.id ?? ev.eventId ?? JSON.stringify(ev).slice(0, 120));
-                            if (seen.has(id))
-                                continue;
-                            seen.add(id);
-                            appendNative(threadId, { dir: "in", source: "box.events", msg: ev });
-                            const kind = String(ev.type ?? ev.kind ?? "");
-                            // "response" events carry the agent's text at data.content —
-                            // the FULL text so far, not a chunk. Clients accumulate
-                            // deltas, so forward only the growth; a drifted (non-prefix)
-                            // event re-sends whole and the settled message replaces the
-                            // stream anyway.
-                            const text = ev.text ?? ev.message ?? ev.data?.text ?? ev.data?.content ?? null;
-                            if (/assistant|message|output|response/i.test(kind) && typeof text === "string" && text.trim()) {
-                                ingest(text);
-                            }
-                            else if (/usage_limit|error|fail/i.test(kind)) {
-                                const why = ev.data?.summary ?? ev.data?.message ?? ev.data?.error ?? ev.message;
-                                if (typeof why === "string" && why.trim())
-                                    problem = why.trim();
-                            }
-                            else if (/tool|command|exec|browse/i.test(kind)) {
-                                flushAssistantText();
-                                emit({
-                                    ...base(threadId, turnId),
-                                    type: "item.started",
-                                    itemType: "tool",
-                                    itemId: id,
-                                    title: String(ev.title ?? ev.command ?? kind).slice(0, 80),
-                                });
-                            }
-                            // shape-drift backstop: without a promptId the status poll
-                            // below can never see a terminal state, so settle off the
-                            // events themselves instead of hanging to the 30-min ceiling
-                            if (!runPromptId && /complete|finish|done|success|fail|error/i.test(kind)) {
-                                const failed = /fail|error/i.test(kind);
-                                return await finishRun(!failed, failed ? kind : null);
-                            }
-                        }
-                        if (runPromptId) {
-                            const status = await api(`/boxes/${boxId}/prompts/${runPromptId}`).catch(() => null);
-                            appendNative(threadId, { dir: "in", source: "box.prompt.status", msg: status });
-                            // real shape (2026-08): {promptRun:{status:"finished",…}} —
-                            // flat fallbacks kept for drift
-                            const run = status?.promptRun ?? status?.prompt ?? status ?? {};
-                            const state = String(run?.status ?? "");
-                            if (/completed|succeeded|done|finished/i.test(state)) {
-                                const result = run?.result ?? run?.output ?? lastText;
-                                if (typeof result === "string" && result.trim() && result !== lastText) {
-                                    ingest(result);
-                                }
-                                if (!pendingText.trim() && !lastText.trim()) {
-                                    // a run that ends with nothing said and a recorded problem
-                                    // (login expired, …) is a failure the person must see
-                                    if (problem)
-                                        throw new Error(problem);
-                                    pendingText = "(finished)";
-                                }
-                                return await finishRun(true, null);
-                            }
-                            if (/failed|error|cancelled|interrupted/i.test(state)) {
-                                const runError = [run?.error, run?.failureReason, run?.message].find((v) => typeof v === "string" && v.trim());
-                                if (problem || runError || /failed|error/i.test(state))
-                                    throw new Error(problem ?? runError ?? `the box run ${state}`);
-                                return await finishRun(false, state);
-                            }
-                        }
-                        if (Date.now() - startedAt > 30 * 60_000) {
-                            throw new Error("box run exceeded 30 minutes — interrupted");
-                        }
-                    }
-                    // cancelled
-                    return await finishRun(false, "interrupted");
-                };
-                try {
-                    const outcome = await settleRun(promptId);
-                    active.delete(threadId);
-                    emit({ ...base(threadId, turnId), type: "turn.completed", ok: outcome.ok, stopReason: outcome.stopReason, cost: null });
-                }
-                catch (e) {
-                    flushAssistantText();
-                    heldAsks.delete(threadId);
-                    active.delete(threadId);
-                    emit({ ...base(threadId, turnId), type: "runtime.error", message: e.message });
-                    emit({ ...base(threadId, turnId), type: "turn.completed", ok: false, stopReason: "error", cost: null });
-                }
-            })();
-            return { turnId };
-        };
-        const snapshot = async () => {
-            if (!account()) {
-                return { state: "unavailable", reason: 'no Boat token — add {"box":{"token":"…"}} to ~/.openmausbot/config.json' };
-            }
-            if (account()?.included)
-                return { state: "unavailable", reason: COMPUTER_ENGINE_CLOUD_UNAVAILABLE };
-            try {
-                await api("/me");
-                return { state: "available", authenticated: true, version: null };
-            }
-            catch (e) {
-                return { state: "unavailable", reason: `box API unreachable: ${e.message}` };
-            }
-        };
-        return {
-            instanceId,
-            driverKind: DRIVER_KIND,
-            displayName: input.displayName,
-            enabled: input.enabled,
-            models: MODELS,
-            snapshot,
-            adapter: {
-                provider: DRIVER_KIND,
-                capabilities: { sessionModelSwitch: "in-session", remoteAgent: true },
-                sendTurn,
-                interruptTurn: async (threadId) => active.get(threadId)?.cancel(),
-                respondToRequest: async (threadId, requestId, decision) => {
-                    const held = heldAsks.get(threadId);
-                    if (!held || held.requestId !== requestId)
-                        return "unavailable"; // settled, timed out, or restarted away
-                    const reply = decision.message?.trim();
-                    if (decision.behavior === "answer" && reply) {
-                        held.settle(decision.message, "user");
-                        return "answered";
-                    }
-                    if (decision.behavior === "deny") {
-                        held.settle(null, "user");
-                        return "rejected";
-                    }
-                    // "allow" is not an answer to a question, and blank text is not either
-                    return "unavailable";
-                },
-                hasSession: (threadId) => active.has(threadId),
-                stopAll: async () => {
-                    for (const { cancel } of active.values())
-                        cancel();
-                },
-                onEvent: (listener) => {
-                    listeners.add(listener);
-                    return () => listeners.delete(listener);
-                },
-            },
-            dispose: async () => {
-                for (const { cancel } of active.values())
-                    cancel();
-                listeners.clear();
-            },
-        };
-    },
-};