@mnemom/mnemom 0.17.34 → 0.17.35

package/dist/host/inbox-delivery.js

@@ -0,0 +1,453 @@
+/**
+ * The homed inbox delivery (S1 amendment 60, signed off by Wassim 2026-11-02): the host daemon gives each
+ * seat it hosts the messages in its session's durable inbox, one at a time, as the seat's next
+ * prompt, and acks each once the turn answering it has ended. It replaces the Slack wake's pane
+ * typing (draft PR #3145's host/seat-wake.ts): Slack, the CLI and allowlisted agents all send
+ * through ROUTES.own_inbox_send, and the api, not a local file, holds what is waiting.
+ *
+ * Per seat, each pass:
+ *   1. Nothing in flight: when the seat is idle (its proxy said hello, the transcript's last turn
+ *      finished, claude's input line is drawn and no turn is running) on two consecutive passes,
+ *      read exec_inbox (content-free) and, when anything waits, exec_inbox_take one message. The api
+ *      marks it delivered at the seat's epoch and journals inbox.delivered BEFORE the paste, so its
+ *      sha is in the resolver's inbox_open by the time the turn reaches the gateway.
+ *   2. Paste the api's text (bracketed paste, then Enter), with every control character but TAB
+ *      and LF removed first (`pasteSafe`), so no byte of a body can end the bracketed paste. Its
+ *      first line is `[mnemom inbox <sha>] from ...`; the seat proxy stamps `inbox=<sha>` on that
+ *      transcript entry (durable/turn-chain.ts), which A60 admits unattended while the sha is open.
+ *   3. Confirm the prompt landed: a transcript entry carrying the marker within CONFIRM_MS, else
+ *      paste again while the seat is idle, waiting twice as long after each paste (at most
+ *      PASTE_TRIES = INBOX_DELIVERY_LIMIT pastes). After that it is released (unconfirmed), so the
+ *      api offers it again or, at its delivery limit, marks it dead. A paste whose Enter failed is
+ *      submitted with Enter alone, never pasted again; a seat that is never idle again releases an
+ *      unconfirmed message after INBOX_STALL_MS.
+ *   4. Once the turn after the marker has ended (idle again), exec_inbox_ack. A 409
+ *      durable_inbox_not_open (already acked, or the epoch moved) also settles it.
+ *
+ * What is in flight is kept per session in `stateDir` (inbox id, sha, epoch, text), so a daemon
+ * restart neither pastes a message twice nor loses its ack. A record from an older epoch is dropped:
+ * the api re-offers that message to the new seat. When the dropped record's prompt had already
+ * reached the transcript, its sha is kept as handled first, and the re-offer is acked at the new
+ * epoch instead of pasted, so the conversation never sees one message twice.
+ *
+ * A take whose answer is lost or malformed may still have marked messages delivered at this epoch.
+ * Nothing is dropped on it: any message the answer does name is released (undeliverable), and the
+ * empty-take latch below lapses after INBOX_REOFFER_S, when the api re-offers the rest.
+ *
+ * Pure over injected deps; host/run.ts wires the executor API, tmux, the transcript and the log.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { INBOX_DELIVERY_LIMIT, INBOX_REOFFER_S, inboxAckResponseOk, inboxMarkerOf, inboxReleaseResponseOk, inboxSummaryResponseOk, inboxTakeResponseOk, } from "../vendor/shared/durable-contract/inbox.js";
+import { HEX64_RE, UUID_RE } from "../vendor/shared/durable-contract/canonical.js";
+import { CODE } from "./s1-names.js";
+/** How long a first paste has to show up in the transcript before it is pasted again (doubling). */
+export const CONFIRM_MS = 15_000;
+/** The longest wait between two pastes of one message. */
+export const CONFIRM_MAX_MS = 300_000;
+/** Pastes of one taken message at most (the api's own take limit, S1 INBOX_DELIVERY_LIMIT). */
+export const PASTE_TRIES = INBOX_DELIVERY_LIMIT;
+/** How long paste number `tries` (1-based) has to show up before the next one. */
+export const confirmWindow = (tries) => Math.min(CONFIRM_MS * 2 ** Math.max(0, tries - 1), CONFIRM_MAX_MS);
+/**
+ * The delivery text as it may be pasted into a terminal: CR LF and CR become LF, and every other
+ * control character but TAB and LF (C0 including ESC, DEL, C1) is removed. ESC[201~ inside a
+ * bracketed paste would end it and the bytes after it would reach claude as typed keys (a CR
+ * submits, `!` runs a shell command, Shift+Tab changes the permission mode). S1 inboxBodyOk refuses
+ * these at send; this holds whatever the api admitted.
+ */
+export function pasteSafe(text) {
+    // eslint-disable-next-line no-control-regex
+    return text.replace(/\r\n?/g, "\n").replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, "");
+}
+/** At most one exec_inbox read per seat in this period while idle. */
+export const INBOX_POLL_MS = 5_000;
+/**
+ * An unconfirmed paste on a seat that never shows idle again (a hung turn) is released after this
+ * long, so the api re-offers it and a later pass takes it again, instead of parking it forever.
+ */
+export const INBOX_STALL_MS = 30 * 60_000;
+/** The handled shas kept per session (a re-offer comes within one epoch change of its paste). */
+export const HANDLED_MAX = 32;
+/** claude's input line, and the footer it shows while a turn runs. */
+const PROMPT_MARK = "❯";
+const RUNNING_RE = /esc to interrupt/i;
+const PASTE_OPEN_RE = /^<pasted_content id="[^"\n]{0,128}">\n?/;
+function firstText(r) {
+    const c = r.message?.content;
+    if (typeof c === "string")
+        return c;
+    if (Array.isArray(c))
+        for (const b of c)
+            if (b && b.type === "text" && typeof b.text === "string")
+                return b.text;
+    return null;
+}
+/** The marker sha a user record's prompt carries, or null. */
+export function recordInboxSha(r) {
+    if (r.type !== "user" || r.isMeta === true)
+        return null;
+    const t = firstText(r);
+    return t === null ? null : inboxMarkerOf(t.replace(PASTE_OPEN_RE, ""));
+}
+function records(transcript) {
+    const out = [];
+    for (const line of transcript.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const r = JSON.parse(line);
+            if ((r.type === "user" || r.type === "assistant") && r.message && r.isMeta !== true)
+                out.push(r);
+        }
+        catch {
+            /* a torn tail line or not JSON */
+        }
+    }
+    return out;
+}
+const finishedBy = (r) => {
+    if (!r || r.type !== "assistant")
+        return false;
+    const b = Array.isArray(r.message?.content)
+        ? r.message.content
+        : [];
+    return !b.some((x) => x?.type === "tool_use") && b.some((x) => x?.type === "text");
+};
+/**
+ * What a transcript says about a delivery: whether its last turn finished (the last conversation
+ * record is the assistant's own text with no tool call; an empty transcript is a fresh session,
+ * which is idle too), whether a prompt carrying `sha` is in it, and whether the turn that prompt
+ * started has ended.
+ */
+export function transcriptView(transcript, sha) {
+    const recs = records(transcript);
+    const finished = recs.length === 0 || finishedBy(recs[recs.length - 1]);
+    if (sha === null)
+        return { finished, seen: false, answered: false };
+    let at = -1;
+    for (let i = recs.length - 1; i >= 0; i--)
+        if (recordInboxSha(recs[i]) === sha) {
+            at = i;
+            break;
+        }
+    const seen = at >= 0;
+    return { finished, seen, answered: seen && finished && recs.length - 1 > at };
+}
+/** claude's input line is drawn and no turn is running. */
+export function paneIdle(screen) {
+    return screen !== null && screen.includes(PROMPT_MARK) && !RUNNING_RE.test(screen);
+}
+// ---- the in-flight record, one file per session ---------------------------------------------
+/**
+ * A stored in-flight record, or null when any field is missing or out of range (a record from
+ * another daemon version, say): it is then treated as absent, so it can never re-paste unbounded.
+ * A record written before `submitted` existed was submitted (its paste and Enter were one step).
+ */
+export function inFlightOf(v) {
+    if (!v || typeof v !== "object" || Array.isArray(v))
+        return null;
+    const r = v;
+    const ok = typeof r.inboxId === "string" &&
+        UUID_RE.test(r.inboxId) &&
+        typeof r.sha === "string" &&
+        HEX64_RE.test(r.sha) &&
+        Number.isSafeInteger(r.epoch) &&
+        r.epoch >= 0 &&
+        typeof r.text === "string" &&
+        typeof r.pastedAt === "number" &&
+        Number.isFinite(r.pastedAt) &&
+        Number.isSafeInteger(r.tries) &&
+        r.tries >= 1 &&
+        r.tries <= PASTE_TRIES &&
+        typeof r.confirmed === "boolean" &&
+        (r.submitted === undefined || typeof r.submitted === "boolean");
+    if (!ok)
+        return null;
+    return {
+        inboxId: r.inboxId,
+        sha: r.sha,
+        epoch: r.epoch,
+        text: r.text,
+        pastedAt: r.pastedAt,
+        tries: r.tries,
+        confirmed: r.confirmed,
+        submitted: r.submitted !== false,
+    };
+}
+export function fileInFlight(dir) {
+    const file = (id, kind = "") => path.join(dir, `${id.replace(/[^A-Za-z0-9-]/g, "_")}${kind}.json`);
+    const write = (f, v) => {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const tmp = `${f}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(v), { mode: 0o600 });
+        fs.renameSync(tmp, f);
+    };
+    return {
+        load: (id) => {
+            try {
+                return inFlightOf(JSON.parse(fs.readFileSync(file(id), "utf8")));
+            }
+            catch {
+                return null;
+            }
+        },
+        save: (id, f) => {
+            if (f === null) {
+                fs.rmSync(file(id), { force: true });
+                return;
+            }
+            write(file(id), f);
+        },
+        loadHandled: (id) => {
+            try {
+                const v = JSON.parse(fs.readFileSync(file(id, ".handled"), "utf8"));
+                return Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+            }
+            catch {
+                return [];
+            }
+        },
+        saveHandled: (id, shas) => {
+            if (shas.length === 0)
+                fs.rmSync(file(id, ".handled"), { force: true });
+            else
+                write(file(id, ".handled"), shas);
+        },
+    };
+}
+/** The messages a malformed take answer still names well enough to release. */
+function namedInTake(body) {
+    const ms = body?.messages;
+    if (!Array.isArray(ms))
+        return [];
+    return ms.filter((m) => typeof m?.inbox_id === "string" &&
+        UUID_RE.test(m.inbox_id) &&
+        typeof m.sha === "string" &&
+        HEX64_RE.test(m.sha));
+}
+export class InboxDelivery {
+    d;
+    state = new Map();
+    constructor(d) {
+        this.d = d;
+    }
+    /** One pass over the daemon's seats. Returns what it did (for logs and tests). */
+    async sync(seats) {
+        const did = [];
+        const live = new Set(seats.map((s) => s.sessionId));
+        for (const id of this.state.keys())
+            if (!live.has(id))
+                this.state.delete(id);
+        for (const s of seats) {
+            if (!s.ready)
+                continue;
+            const st = this.state.get(s.sessionId) ?? {
+                idlePasses: 0,
+                lastPoll: -Infinity,
+                busy: false,
+                emptyDelivered: null,
+                emptyAt: -Infinity,
+            };
+            this.state.set(s.sessionId, st);
+            if (st.busy)
+                continue;
+            st.busy = true;
+            try {
+                const r = await this.seat(s, st);
+                if (r)
+                    did.push(r);
+            }
+            catch (e) {
+                this.d.log(`inbox ${s.sessionId}: ${e.message}`);
+            }
+            finally {
+                st.busy = false;
+            }
+        }
+        return did;
+    }
+    async seat(s, st) {
+        let f = this.d.load(s.sessionId);
+        const text = this.d.transcript(s.sessionId);
+        if (f && f.epoch !== s.epoch) {
+            // A delivery to an earlier seat: the api re-offers it to this one (delivered_epoch < epoch).
+            // Its prompt may already be in the conversation (the restart fell between the turn and the
+            // ack): keep its sha as handled before the record goes, so the re-offer is acked, not pasted.
+            const seen = f.confirmed || (text !== null && transcriptView(text, f.sha).seen);
+            if (seen)
+                this.markHandled(s.sessionId, f.sha);
+            this.d.log(`inbox ${s.sessionId}: dropping ${f.inboxId} from epoch ${f.epoch} (now ${s.epoch})${seen ? ", handled" : ""}`);
+            this.d.save(s.sessionId, null);
+            f = null;
+        }
+        const view = transcriptView(text ?? "", f?.sha ?? null);
+        const idleNow = view.finished && paneIdle(await this.d.capture(s.tmuxSession));
+        st.idlePasses = idleNow ? st.idlePasses + 1 : 0;
+        const now = this.d.now();
+        if (f) {
+            // Without the transcript nothing can be confirmed or acked: wait for it (never re-paste blind).
+            if (text === null)
+                return null;
+            if (!f.confirmed && view.seen) {
+                f.confirmed = true;
+                this.d.save(s.sessionId, f);
+            }
+            if (!f.confirmed) {
+                if (!f.submitted) {
+                    // The paste is in the input line but its Enter failed (or a restart came in between).
+                    if (!idleNow)
+                        return null;
+                    await this.d.submit(s.tmuxSession);
+                    f.submitted = true;
+                    this.d.save(s.sessionId, f);
+                    st.idlePasses = 0;
+                    return `submit:${f.inboxId}`;
+                }
+                if (now - f.pastedAt < confirmWindow(f.tries))
+                    return null;
+                if (f.tries >= PASTE_TRIES) {
+                    this.d.log(`inbox ${s.sessionId}: ${f.inboxId} never reached the transcript after ${f.tries} pastes; releasing it`);
+                    await this.release(s, f.inboxId, f.sha, "unconfirmed");
+                    this.d.save(s.sessionId, null);
+                    return `unconfirmed:${f.inboxId}`;
+                }
+                if (st.idlePasses < 2) {
+                    if (now - f.pastedAt < INBOX_STALL_MS)
+                        return null;
+                    this.d.log(`inbox ${s.sessionId}: ${f.inboxId} unconfirmed and the seat not idle for ${Math.round((now - f.pastedAt) / 60_000)} min; releasing it`);
+                    await this.release(s, f.inboxId, f.sha, "unconfirmed");
+                    this.d.save(s.sessionId, null);
+                    return `stalled:${f.inboxId}`;
+                }
+                // Counted before the paste, as a first delivery is recorded before its paste: a restart in
+                // between never pastes more than PASTE_TRIES times.
+                f.tries += 1;
+                f.pastedAt = now;
+                await this.put(s, st, f);
+                return `repaste:${f.inboxId}`;
+            }
+            if (!(view.answered && st.idlePasses >= 2))
+                return null;
+            const a = await this.d.api.inboxAck(s.sessionId, {
+                epoch: s.epoch,
+                nonce: this.d.nonce(),
+                inbox_id: f.inboxId,
+                sha: f.sha,
+            });
+            if ((a.status === 200 && inboxAckResponseOk(a.body)) ||
+                a.code === CODE.durable_inbox_not_open) {
+                this.d.save(s.sessionId, null);
+                this.d.log(`inbox ${s.sessionId}: acked ${f.inboxId}${a.status === 200 ? "" : ` (${a.code})`}`);
+                return `ack:${f.inboxId}`;
+            }
+            this.d.log(`inbox ${s.sessionId}: ack ${f.inboxId} failed: ${a.code ?? a.networkError ?? a.status}`);
+            return null;
+        }
+        // Nothing is taken blind: without the transcript a paste could never be confirmed or acked, and
+        // an empty-looking transcript would pass for an idle one. A seated session always has one (the
+        // daemon seats only a session with a cc_session_id and resumes its transcript).
+        if (text === null)
+            return null;
+        if (st.idlePasses < 2 || now - st.lastPoll < INBOX_POLL_MS)
+            return null;
+        st.lastPoll = now;
+        const sum = await this.d.api.inboxSummary(s.sessionId);
+        if (sum.status !== 200 || !inboxSummaryResponseOk(sum.body)) {
+            if (sum.status !== 404)
+                this.d.log(`inbox ${s.sessionId}: summary ${sum.code ?? sum.networkError ?? sum.status}`);
+            return null;
+        }
+        const b = sum.body;
+        // delivered counts a message delivered to an earlier seat too, which take re-offers.
+        if (b.admitted + b.delivered === 0)
+            return null;
+        if (b.admitted === 0 &&
+            b.delivered === st.emptyDelivered &&
+            now - st.emptyAt < INBOX_REOFFER_S * 1000)
+            return null;
+        const t = await this.d.api.inboxTake(s.sessionId, {
+            epoch: s.epoch,
+            nonce: this.d.nonce(),
+            limit: 1,
+        });
+        if (t.status !== 200 || !inboxTakeResponseOk(t.body)) {
+            // The api may have marked messages delivered all the same: hand back what the answer names,
+            // and never latch on it, so the next poll takes again (and gets the rest once re-offered).
+            this.d.log(`inbox ${s.sessionId}: take ${t.code ?? t.networkError ?? t.status}`);
+            st.emptyDelivered = null;
+            for (const n of namedInTake(t.body))
+                await this.release(s, n.inbox_id, n.sha, "undeliverable");
+            return null;
+        }
+        const m = t.body.messages[0];
+        if (!m) {
+            st.emptyDelivered = b.admitted === 0 ? b.delivered : null;
+            st.emptyAt = now;
+            return null;
+        }
+        st.emptyDelivered = null;
+        const handled = this.d.loadHandled(s.sessionId);
+        if (handled.includes(m.sha))
+            return this.ackHandled(s, m, handled);
+        const rec = {
+            inboxId: m.inbox_id,
+            sha: m.sha,
+            epoch: s.epoch,
+            text: m.text,
+            pastedAt: now,
+            tries: 1,
+            confirmed: false,
+            submitted: false,
+        };
+        // Recorded before the paste: a restart in between re-pastes at most once, never loses the ack.
+        await this.put(s, st, rec);
+        this.d.log(`inbox ${s.sessionId}: delivered ${m.inbox_id} (attempt ${m.attempt})`);
+        return `deliver:${m.inbox_id}`;
+    }
+    /** Save `f` as not yet submitted, paste it, press Enter, then save it as submitted. */
+    async put(s, st, f) {
+        f.submitted = false;
+        this.d.save(s.sessionId, f);
+        await this.d.paste(s.tmuxSession, pasteSafe(f.text));
+        st.idlePasses = 0;
+        await this.d.submit(s.tmuxSession);
+        f.submitted = true;
+        this.d.save(s.sessionId, f);
+    }
+    markHandled(sessionId, sha) {
+        const shas = this.d.loadHandled(sessionId).filter((x) => x !== sha);
+        shas.push(sha);
+        this.d.saveHandled(sessionId, shas.slice(-HANDLED_MAX));
+    }
+    /**
+     * A re-offer of a message whose prompt is already in the conversation: ack it at this epoch
+     * without pasting. A failed ack keeps the sha handled; the api re-offers it again later.
+     */
+    async ackHandled(s, m, handled) {
+        const a = await this.d.api.inboxAck(s.sessionId, {
+            epoch: s.epoch,
+            nonce: this.d.nonce(),
+            inbox_id: m.inbox_id,
+            sha: m.sha,
+        });
+        if (!(a.status === 200 && inboxAckResponseOk(a.body)) &&
+            a.code !== CODE.durable_inbox_not_open) {
+            this.d.log(`inbox ${s.sessionId}: ack of handled ${m.inbox_id} failed: ${a.code ?? a.networkError ?? a.status}`);
+            return null;
+        }
+        this.d.saveHandled(s.sessionId, handled.filter((x) => x !== m.sha));
+        this.d.log(`inbox ${s.sessionId}: acked handled ${m.inbox_id} without pasting it again`);
+        return `ack-handled:${m.inbox_id}`;
+    }
+    async release(s, inboxId, sha, reason) {
+        const r = await this.d.api.inboxRelease(s.sessionId, {
+            epoch: s.epoch,
+            nonce: this.d.nonce(),
+            inbox_id: inboxId,
+            sha,
+            reason,
+        });
+        this.d.log(`inbox ${s.sessionId}: release ${inboxId} (${reason}) ${r.status === 200 && inboxReleaseResponseOk(r.body) ? "ok" : `failed: ${r.code ?? r.networkError ?? r.status}`}`);
+    }
+}

package/dist/host/run.d.ts

@@ -1,6 +1,8 @@
 import { type HostPaths, type HostInstance } from "./instance.js";
 import { type LoadedState } from "./state.js";
+import { Tmux } from "./tmux.js";
 import { type AutoContinueDeps } from "./auto-continue.js";
+import { type InboxDeliveryDeps } from "./inbox-delivery.js";
 import { resolveClaudeBin } from "../lib/claude-bin.js";
 export interface RunIo {
     readonly env: Readonly<Record<string, string | undefined>>;
@@ -38,6 +40,22 @@ export declare function publishIfLockHeld(held: () => boolean, write: () => void
 /** For tests and status: the OS boot id (macOS sysctl). */
 export declare function sysctlBootId(): string;
 export declare const defaultHome: () => string;
+/** The inbox delivery's deps over the daemon's own: transcript tails, the seat's pane, a file store. */
+export declare function inboxDeliveryDeps(o: {
+    api: InboxDeliveryDeps["api"];
+    nonce: () => string;
+    transcriptPath: (sessionId: string) => string | null;
+    tmux: Pick<Tmux, "capturePane" | "pasteText" | "pressEnter">;
+    sleep: (ms: number) => Promise<void>;
+    dir: string;
+    log: (line: string) => void;
+}): InboxDeliveryDeps;
+/** The pause between an inbox paste and the Enter that submits it. */
+export declare const INBOX_PASTE_SETTLE_MS = 300;
+/** How much of a transcript's end the inbox delivery reads (a turn and its prompt fit in it). */
+export declare const INBOX_TRANSCRIPT_TAIL_BYTES: number;
+/** The last `bytes` of a file as text, from a line start; null when unreadable. */
+export declare function readTail(p: string, bytes: number): string | null;
 /** The interrupted turn of the transcript at `p` (auto-continue.ts), or null when it cannot be read. */
 export declare function interruptedAtFile(p: string, read: (p: string) => string): string | null;
 /** The fs calls the auto-continue markers make. */

package/dist/host/run.js

@@ -24,6 +24,7 @@ import { buildSeatLaunch, seatDoor } from "./seat.js";
 import { socketDir, ensureSocketDir, controlSocketPath, releaseControlSocket, startControlServer, } from "./control.js";
 import { writeRuntime } from "./runtime.js";
 import { autoContinue, interruptedTurnId, turnContinuedJournal, } from "./auto-continue.js";
+import { InboxDelivery, fileInFlight } from "./inbox-delivery.js";
 import { hostTestPauseAt } from "../durable/test-mode.mjs";
 import { resolvePluginDir } from "../lib/claude-plugin.js";
 import { liveCwdDeps, spawnCwdCause } from "../durable/cwd-rule.js";
@@ -130,6 +131,9 @@ export async function hostRun(io) {
     // One file per continued turn (<session>.<turn uuid>); kept across respawns and daemon restarts.
     const continuedDir = path.join(path.dirname(paths.stateFile), "continued");
     const pauseAt = hostTestPauseAt({ ...env });
+    // S1 amendment 60: the in-flight inbox delivery per session (host/inbox-delivery.ts), across restarts.
+    const inboxDir = path.join(path.dirname(paths.stateFile), "inbox");
+    let inboxDelivery = null;
     const deps = {
         api: executorApi({
             apiUrl,
@@ -202,6 +206,18 @@ export async function hostRun(io) {
                 await sleep(3600_000);
         },
         interruptedAt: (p) => interruptedAtFile(p, (f) => fs.readFileSync(f, "utf8")),
+        inbox: (seats) => {
+            inboxDelivery ??= new InboxDelivery(inboxDeliveryDeps({
+                api: deps.api,
+                nonce: () => deps.nonce,
+                transcriptPath: (id) => lastKnown.get(id) ?? null,
+                tmux,
+                sleep,
+                dir: inboxDir,
+                log,
+            }));
+            return inboxDelivery.sync(seats);
+        },
         autoContinue: (seat, turnId) => autoContinue(seat, turnId, {
             ...fileContinuedMarkers(continuedDir, fs),
             journal: turnContinuedJournal(deps.api, () => deps.nonce),
@@ -256,6 +272,51 @@ export function sysctlBootId() {
     }).trim();
 }
 export const defaultHome = () => os.homedir();
+/** The inbox delivery's deps over the daemon's own: transcript tails, the seat's pane, a file store. */
+export function inboxDeliveryDeps(o) {
+    return {
+        api: o.api,
+        nonce: o.nonce,
+        transcript: (id) => {
+            const p = o.transcriptPath(id);
+            return p ? readTail(p, INBOX_TRANSCRIPT_TAIL_BYTES) : null;
+        },
+        capture: (t) => o.tmux.capturePane(t),
+        paste: async (t, text) => {
+            await o.tmux.pasteText(t, text);
+            // Let claude take the paste before the Enter that submits it.
+            await o.sleep(INBOX_PASTE_SETTLE_MS);
+        },
+        submit: (t) => o.tmux.pressEnter(t),
+        ...fileInFlight(o.dir),
+        now: () => Date.now(),
+        log: o.log,
+    };
+}
+/** The pause between an inbox paste and the Enter that submits it. */
+export const INBOX_PASTE_SETTLE_MS = 300;
+/** How much of a transcript's end the inbox delivery reads (a turn and its prompt fit in it). */
+export const INBOX_TRANSCRIPT_TAIL_BYTES = 512 * 1024;
+/** The last `bytes` of a file as text, from a line start; null when unreadable. */
+export function readTail(p, bytes) {
+    let fd = null;
+    try {
+        fd = fs.openSync(p, "r");
+        const size = fs.fstatSync(fd).size;
+        const start = Math.max(0, size - bytes);
+        const buf = Buffer.alloc(size - start);
+        fs.readSync(fd, buf, 0, buf.length, start);
+        const text = buf.toString("utf8");
+        return start === 0 ? text : text.slice(text.indexOf("\n") + 1);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== null)
+            fs.closeSync(fd);
+    }
+}
 /** The interrupted turn of the transcript at `p` (auto-continue.ts), or null when it cannot be read. */
 export function interruptedAtFile(p, read) {
     try {

package/dist/host/s1-names.d.ts

@@ -21,3 +21,5 @@ export { spawnIdempotencyKey, type ExecAppendBody } from "../lib/runner/exec-app
  * daemon and its seat proxy, never a wire code, so it is not a durable_* code (S1 owns those).
  */
 export declare const SEAT_UNKNOWN = "seat_unknown";
+/** The control socket's answer when the api's answer to a relayed question op is malformed. Local too. */
+export declare const SEAT_BAD_ANSWER = "seat_bad_answer";

package/dist/host/s1-names.js

@@ -20,3 +20,5 @@ export { spawnIdempotencyKey } from "../lib/runner/exec-append.js";
  * daemon and its seat proxy, never a wire code, so it is not a durable_* code (S1 owns those).
  */
 export const SEAT_UNKNOWN = "seat_unknown";
+/** The control socket's answer when the api's answer to a relayed question op is malformed. Local too. */
+export const SEAT_BAD_ANSWER = "seat_bad_answer";

package/dist/host/tmux.d.ts

@@ -52,5 +52,12 @@ export declare class Tmux {
     capturePane(name: string): Promise<string | null>;
     /** Type `text` literally into a session's pane, then press Enter. */
     sendLine(name: string, text: string): Promise<void>;
+    /**
+     * Paste `text` into a session's pane as bracketed paste (a multi-line prompt stays one prompt; a
+     * newline inside it never submits). The caller presses Enter (pressEnter) once claude took it.
+     * From draft PR #3145 (host/seat-wake.ts), now used by the durable inbox delivery.
+     */
+    pasteText(name: string, text: string): Promise<void>;
+    pressEnter(name: string): Promise<void>;
     killSession(name: string): Promise<void>;
 }

package/dist/host/tmux.js

@@ -176,6 +176,25 @@ export class Tmux {
         if (e.code !== 0)
             throw new Error(`tmux send-keys failed: ${e.stderr.trim()}`);
     }
+    /**
+     * Paste `text` into a session's pane as bracketed paste (a multi-line prompt stays one prompt; a
+     * newline inside it never submits). The caller presses Enter (pressEnter) once claude took it.
+     * From draft PR #3145 (host/seat-wake.ts), now used by the durable inbox delivery.
+     */
+    async pasteText(name, text) {
+        const buf = `mnm-inbox-${process.pid}`;
+        const b = await this.run(["set-buffer", "-b", buf, "--", text]);
+        if (b.code !== 0)
+            throw new Error(`tmux set-buffer failed: ${b.stderr.trim()}`);
+        const p = await this.run(["paste-buffer", "-p", "-d", "-b", buf, "-t", `=${name}:`]);
+        if (p.code !== 0)
+            throw new Error(`tmux paste-buffer failed: ${p.stderr.trim()}`);
+    }
+    async pressEnter(name) {
+        const e = await this.run(["send-keys", "-t", `=${name}:`, "Enter"]);
+        if (e.code !== 0)
+            throw new Error(`tmux send-keys failed: ${e.stderr.trim()}`);
+    }
     async killSession(name) {
         await this.run(["kill-session", "-t", `=${name}`]);
     }