waterplane 0.0.1 → 0.1.6

package/packages/host/dist/deliver/deliverscreen.js

@@ -0,0 +1,428 @@
+import { PASTE_CHIT, pastedNewlines, pasteCollapsible, echoAmbiguous, echoProbe, squash, tailProbe, } from "../echo.js";
+import { FALLBACK_ROWS, ROW_WINDOW, composerEcho, composerHeld, liveComposerEcho, } from "../composer.js";
+import { rivalTexts } from "../opendeliveries.js";
+import { resolveBackend } from "../backends/index.js";
+import { FALLBACK_HOLD_MS, sleep } from "./deliverknobs.js";
+/** A prompt this long whose words contain the held text whole is our own text
+ *  drawn in a way no echo rule placed (a viewport slice under `SLICE_MIN`) —
+ *  left to the paths that existed before. Short holdings (`y`) never qualify:
+ *  one letter is inside almost any prompt. */
+const OURS_MIN = 8;
+const QUOTE_MAX = 40;
+/**
+ * The anchors the session's OWN descriptor finds its composer by (absent id ⇒
+ * claude, as everywhere) — or null when there is no reader: a backend this host
+ * no longer knows, or one that declares neither anchor.
+ */
+export function composerAnchorsOf(sessions, sessionId) {
+    try {
+        const d = resolveBackend(sessions.get(sessionId)?.backend).delivery;
+        if (!d.composerCursorRe && !d.composerRuleRe)
+            return null;
+        return { cursor: d.composerCursorRe, rule: d.composerRuleRe, placeholder: d.composerPlaceholderRe ?? null };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Is the live composer holding text that is not this delivery's? The words if
+ * so (cut for a sentence), else null — and null whenever the screen gives no
+ * composer the backend's anchors can place, so a backend with no reader keeps
+ * exactly the behaviour it had.
+ *
+ * Two reads, the second only when the first finds something: the plain render
+ * cannot tell a typed `y` from an EMPTY box's hint (claude's `Try "…"`, Codex's
+ * `Ask Codex to do anything` — both DIM, measured), so a non-empty answer is
+ * asked again of the rows with dim cells blanked (`RenderRow.undimmed`), and
+ * only what survives that is foreign. The common case, an empty box with no
+ * hint, costs no second replay.
+ */
+export async function foreignInComposer(sessions, sessionId, text, rows) {
+    const anchors = composerAnchorsOf(sessions, sessionId);
+    if (!anchors)
+        return null;
+    const plain = composerHeld(rows.length ? rows : (await sessions.screenText(sessionId, ROW_WINDOW)).split("\n"), anchors);
+    if (!plain)
+        return null;
+    let held = plain;
+    if (typeof sessions.screenCells === "function") {
+        held = composerHeld((await sessions.screenCells(sessionId, ROW_WINDOW)).map((r) => r.undimmed), anchors);
+        if (!held)
+            return null; // empty once the hint is discounted — or no box to speak of in this read
+    }
+    const mine = squash(text);
+    const theirs = squash(held);
+    if (!theirs)
+        return null;
+    if (theirs.length >= OURS_MIN && mine.includes(theirs))
+        return null;
+    return held.length > QUOTE_MAX ? `${held.slice(0, QUOTE_MAX - 1)}…` : held;
+}
+/**
+ * Is the live composer holding ONLY dim text — a hint, not typing?
+ *
+ * claude proposes the next prompt in an EMPTY composer, drawn dim
+ * (`clisuggest.ts`), and the phone offers that proposal as one tap — so the
+ * words about to be delivered are, letter for letter, the words already drawn
+ * in the box. On the plain render that reads as `exact`, "already typed", and
+ * the delivery typed nothing and pressed Return into an empty composer: the
+ * prompt never ran (measured, the first live tap). The same two reads
+ * `foreignInComposer` makes: words on the plain render, none once dim cells
+ * are blanked ⇒ the box is empty. False whenever either read cannot place a box.
+ */
+export async function composerHoldsOnlyHint(sessions, sessionId) {
+    const anchors = composerAnchorsOf(sessions, sessionId);
+    if (!anchors || typeof sessions.screenCells !== "function")
+        return false;
+    const cells = await sessions.screenCells(sessionId, ROW_WINDOW);
+    const plain = composerHeld(cells.map((r) => r.text), anchors);
+    if (!plain)
+        return false;
+    return composerHeld(cells.map((r) => r.undimmed), anchors) === "";
+}
+/**
+ * The closures `runDelivery` declared over its screen, in the order it
+ * declared them. Every one captures only consts (the session, the text, the
+ * delivery's `key` and `shape`), so the run destructures what it uses and
+ * each call site reads as it did.
+ */
+export function makeScreenReader(sessions, sessionId, text, key, shape, 
+/** A SHELL's multi-line paste: the shell draws each line on its own row with
+ *  nothing spliced between, so the needle is cut from the FIRST line — a
+ *  head that straddles the newline is on no single row (`PROBE_LEN`). */
+opts = {}) {
+    // Detection reads the RENDERED current screen, not an ANSI-stripped byte
+    // window. One claude-TUI repaint of a busy screen is tens of KB, so every
+    // byte window is wrong in one direction or the other: too small and text
+    // that is plainly on screen sits above the window (read as "not echoed" →
+    // the text gets retyped ON TOP of itself, stacking a copy per attempt AND
+    // per fire retry — the repeated-prompt bug), too big and stale scrollback
+    // false-positives. Rendering the screen removes the guess.
+    const screen = async () => squash(await sessions.screenText(sessionId, 40));
+    const probe = echoProbe(opts.firstLineProbe ? text.split(/\r?\n|\r/)[0] : text);
+    // How many rendered rows each of the two rules gets — `echo.ts`'s
+    // `ROW_WINDOW` for the anchored one, `FALLBACK_ROWS` for the distance one.
+    // The numbers differ on purpose and the reason is written down there; both
+    // are shared with `settle.ts`, which must not read a narrower screen than
+    // this file does or a tear becomes confirmable here and invisible there.
+    // The composer check reads only the BOTTOM of the screen — where the input
+    // box is — so an identical prompt echoed higher in the visible conversation
+    // can't read as "already typed" (which would submit an empty composer and
+    // leave the caller waiting forever). Deep enough to hold the wrapped text plus
+    // the box borders and hint line; the probe is at the text's head, i.e. the
+    // box's first row.
+    //
+    // This is the OLD way of asking that question — distance from the bottom of
+    // the render — and it is kept for exactly one case: a screen on which no `❯`
+    // box can be found at all. See `placeEcho`.
+    const composerRows = Math.min(40, 10 + Math.ceil(text.length / 40));
+    /**
+     * Rows of the rendered screen, squashed line by line. Line structure is what
+     * lets the composer check say HOW FAR from the bottom the echo sits, which a
+     * single squashed blob throws away.
+     */
+    const screenRows = async (n) => (await sessions.screenText(sessionId, n)).split("\n").map(squash);
+    /**
+     * Is the text in the composer?
+     *
+     * The naive version sliced the bottom `composerRows` rows — right for a
+     * prompt, wrong for a slash command: typing `/cost` opens the completion
+     * menu BELOW the input box (one row per command plus wrapped description),
+     * which pushes the echo ~20 rows up and out of the window. The text was
+     * plainly on screen, read as never typed, and the sweep below then ESC'd the
+     * menu away — the "something presses Esc for me" report.
+     *
+     * That fix widened the window and kept the yardstick, and the yardstick is
+     * what was wrong. **Distance from the bottom of the render measures the TEAR,
+     * not the composer.** A capture of a delivery this check declared a miss —
+     * the text "Yes all 3", interjected into a working session, well inside the
+     * echo window — had the words sitting in the composer with a DUPLICATED
+     * footer and rows of streaming turn output below them: `render.ts` replays
+     * the whole buffer into a fixed 50-row VT, so mid-turn the repaint tears and
+     * stale rows land under the newest composer frame. The echo was found and
+     * then refused for being eleven rows too high. `unconfirmed` for a prompt in
+     * plain sight, and then the sweep's Esc into a running turn.
+     *
+     * So ask the structural question instead: is the text inside the box the CLI
+     * draws to take typing (`composer.ts`'s `composerEcho`, which is also what
+     * `settle.ts` asks minutes later — one rule, not two opinions). The old
+     * distance test stays as the fallback for a screen with no `❯` box on it at
+     * all, because an upstream redraw we stop recognising must degrade to the
+     * previous behaviour and never brick delivery.
+     *
+     * It answers with the RULE that matched, not a boolean, because the rules are
+     * not equally good evidence. `"exact"` means the whole squashed text is in
+     * the composer, which nothing but this text can produce; `"head"` means only
+     * the fourteen-character probe matched, which every prompt sharing that head
+     * would have produced too — including a re-send, and including a stranger's
+     * prompt left in the composer by an earlier delivery that could not be
+     * confirmed. `proven()` below is what decides whether a rule is allowed to
+     * mean anything.
+     *
+     * `newestOnly` is the difference between the two questions asked with it.
+     * After our own write, any frame will do — we typed the text moments ago, so
+     * the only doubt is which half of a torn repaint drew it. BEFORE typing,
+     * "this composer already holds my text" is a claim about the LIVE box, so it
+     * is asked of the newest frame and of nothing else.
+     */
+    const anchors = composerAnchorsOf(sessions, sessionId);
+    const fullReader = !!anchors?.cursor && !!anchors?.rule;
+    /** Did the last `placeEcho` answer by the no-box rule — no composer frame on
+     *  that screen at all? `waitForEcho` holds such an answer (FALLBACK_HOLD_MS). */
+    let fellBack = false;
+    const placeEcho = (raw, newestOnly) => {
+        // BEFORE typing, "already in the composer" is judged on the LIVE box only,
+        // by the backend's own anchors, and a head match only where the box holds
+        // a prefix of our text (`echo.ts`'s `liveComposerEcho`). Measured: the
+        // distance rule below found the PREVIOUS prompt — same first fourteen
+        // characters, or the same words re-sent — still drawn in the transcript
+        // above the live box, typed nothing, and pressed Return into an empty
+        // composer (`unsubmitted`, the prompt never ran). With no reader at all
+        // there is no composer to make that claim about, so it is never made.
+        if (newestOnly) {
+            if (!anchors)
+                return "none";
+            const live = liveComposerEcho(raw, text, anchors);
+            // A box holding ANOTHER open delivery's words that share our head is not
+            // ours either — but it is reported as the rival it is ("cannot tell
+            // apart"), which `proven()` then refuses, rather than as a stranger's.
+            if (live === "none" && liveComposerEcho(raw, text, anchors, { looseHead: true }) === "head"
+                && echoAmbiguous("head", text, rivals()))
+                return "head";
+            if (live !== null)
+                return live;
+            // A box a cursor-only or rule-only reader cannot place is not evidence
+            // that our text is in one. Only claude's full reader keeps the old
+            // degrade (a stub, an unrecognised redraw), below.
+            if (!fullReader)
+                return "none";
+        }
+        else if (anchors && !fullReader) {
+            // After our write, a reader that CAN place its box is asked of the box —
+            // the transcript row above it is the previous prompt, not this echo.
+            const live = liveComposerEcho(raw, text, anchors);
+            if (live !== null)
+                return live;
+        }
+        const anchored = composerEcho(raw, text, { newestOnly });
+        fellBack = anchored === null;
+        if (anchored !== null)
+            return anchored;
+        // No composer frame anywhere on this screen — a picker covering it, a stub
+        // TUI, or an upstream redraw. Back to the old rule, and back to the old
+        // DEPTH with it: a rule that places a hit by counting rows from the bottom
+        // is not "unchanged" when it is handed twice the rows, and the slash branch
+        // below accepts a hit at ANY height as long as two rows under it start with
+        // `/` — which is how every file path in every tool result starts. Why the
+        // two windows differ is written out at `composer.ts`'s `FALLBACK_ROWS`.
+        const rows = raw.slice(-FALLBACK_ROWS).map(squash);
+        let hit = -1;
+        for (let i = rows.length - 1; i >= 0; i--)
+            if (rows[i].includes(probe)) {
+                hit = i;
+                break;
+            }
+        // A backend with no composer at all (a shell) draws the line it is given
+        // HARD-WRAPPED at the terminal's width, after a prompt of any length — so
+        // the probe's fourteen characters straddle a row boundary whenever the
+        // wrap falls inside them (measured: `…news % cd /Users/joha` | `nnes/…` at
+        // 70 cols, `unconfirmed`, no Return, for a command plainly on screen).
+        // Asked of the joined rows, and only where no box exists to be torn across.
+        if (hit < 0 && !anchors)
+            hit = wrappedHit(rows, probe);
+        if (hit < 0)
+            return pastedNearBottom(rows) ? "paste" : "none";
+        // Corroborate before deciding, and corroborate from the hit DOWNWARDS: the
+        // composer holds the text wrapped over consecutive rows, so joining from
+        // the head row to the bottom and looking for the whole squashed text costs
+        // one more comparison and upgrades a prefix guess into an identification.
+        // This is what makes the ordinary short prompt immune to the collision
+        // entirely, rival or no rival. It does NOT always succeed — the composer
+        // draws a border, so a prompt wrapped over several rows has box characters
+        // spliced into the middle of it — and that is fine: failing to corroborate
+        // falls back to `"head"`, i.e. exactly the evidence this had before, with
+        // the rival check in front of it.
+        const whole = rows.slice(hit).join("");
+        const exact = whole.includes(squash(text));
+        // BEFORE typing, a bare head on a screen with no box is not "already
+        // typed": it is the PREVIOUS prompt's transcript row when the new one
+        // shares its first fourteen characters (the codex plugin's "Host bug found
+        // by the harness", `SAME_HEAD=1`: nothing typed, Return pressed into an
+        // empty composer, `unsubmitted`). Only `exact`/`paste` may short-circuit
+        // the write from here; a head an open RIVAL shares is still reported, so
+        // `proven()` refuses it in words as before. After our write the head
+        // stays evidence — we typed the text moments ago.
+        const head = () => (newestOnly && !echoAmbiguous("head", text, rivals()) ? "none" : "head");
+        if (rows.length - 1 - hit <= composerRows)
+            return exact ? "exact" : head();
+        if (!text.startsWith("/"))
+            return "none";
+        const below = rows.slice(hit + 1).filter(Boolean);
+        if (below.filter((l) => l.startsWith("/")).length < 2)
+            return "none";
+        return exact ? "exact" : head();
+    };
+    /** The after-write poll: any frame will do, we typed the text moments ago.
+     *  The BEFORE-typing question renders its own rows, because it has a second
+     *  question to ask of them — see `composerFramesAmbiguous` at that site. */
+    /** The rendered screen the newest echo read was made on, as drawn — the
+     *  `deliver.echo` fixture capture keeps the one the rule proved on. */
+    let seen = "";
+    const onScreen = async () => {
+        if (!probe)
+            return "none";
+        seen = await sessions.screenText(sessionId, ROW_WINDOW);
+        return placeEcho(seen.split("\n"), false);
+    };
+    /**
+     * Is a match evidence about OUR text?
+     *
+     * A prefix match says "text starting like this is here". With another
+     * delivery into this session whose text starts the same way — an open
+     * question whose prompt may literally be sitting in that composer, or a
+     * second delivery in flight — the sentence is not about this prompt, and
+     * acting on it produces the failure this app exists to prevent: the live run
+     * caught `deliverPrompt` returning `ok` for a prompt that never ran, because
+     * a stranger's echo was read as its own and the Return that followed
+     * submitted somebody else's words. An `ok` is the one verdict nothing ever
+     * revisits.
+     */
+    const rivals = () => rivalTexts(sessionId, key);
+    const proven = (rule) => rule !== "none" && !echoAmbiguous(rule, text, rivals());
+    /**
+     * The multi-line case: the TUI HIDES the text it echoed.
+     *
+     * A write of several lines in one chunk is indistinguishable from a paste, and
+     * the claude TUI collapses a paste into a placeholder — the composer reads
+     * `[Pasted text #1 +11 lines]` followed by whatever tail still fits, and the
+     * HEAD of the text (which `probe` is cut from) is nowhere on screen. So a
+     * long, multi-line instruction — the "set up this repo's build commands"
+     * prompt is one — echoed perfectly, read as never typed, and came back
+     * `"unconfirmed"`: sitting in the composer, never submitted, and never
+     * auto-retried. That is the whole failure; a Return would have run it.
+     *
+     * **And LENGTH alone triggers it, with no line clause on the placeholder.**
+     * A write past `PASTE_MIN_CHARS` collapses whatever its shape, and the
+     * clause is omitted when the text holds no newline — a long message typed on
+     * a phone shows as a bare `[Pasted text #5]`. Every rule here has to read
+     * that as zero newlines rather than as no information.
+     *
+     * The placeholder is therefore an echo like any other, but it names no text,
+     * so it is only accepted with a second fact tying it to THIS instruction: the
+     * tail of the text on screen (the placeholder hides the head, so the tail is
+     * what is still drawn), or a hidden-line count that accounts for essentially
+     * all of it (the whole thing collapsed, nothing left to match). A stale
+     * placeholder from an earlier, different paste satisfies neither.
+     *
+     * Only the NO-BOX fallback needs this spelled out here: when a composer frame
+     * is found, `composerEcho` asks `screenEcho` of the frame's own contents and
+     * the placeholder is one of the rules it already knows. So this takes the
+     * rows `placeEcho` has already rendered rather than rendering again — the
+     * whole point of the wider window is to pay for one replay, not two.
+     */
+    const pasteLines = text.split("\n").length;
+    const tail = tailProbe(text);
+    const pastedNearBottom = (rows) => {
+        // Collapsible is LENGTH or shape, never shape alone: the composer collapses
+        // anything past `PASTE_MIN_CHARS` whether or not it holds a newline, and
+        // treating one-liners as exempt is what hid every long single-line send
+        // behind a bare `[Pasted text #5]` — see `echo.ts`'s `PASTE_CHIT`.
+        if (!pasteCollapsible(text) || !tail)
+            return false;
+        let hit = -1;
+        for (let i = rows.length - 1; i >= 0; i--)
+            if (PASTE_CHIT.test(rows[i])) {
+                hit = i;
+                break;
+            }
+        if (hit < 0)
+            return false;
+        if (rows.length - 1 - hit > composerRows)
+            return false;
+        // The whole run of chits, not the first one (`echo.ts`'s `pastedNewlines`):
+        // one write is several pastes, and a chit wraps across rows (`+2` / `lines]`),
+        // so the count is read off the joined rows down to the newest chit.
+        const hidden = pastedNewlines(rows.slice(Math.max(0, hit - composerRows), hit + 1).join("")) ?? 0;
+        if (hidden > pasteLines + 1)
+            return false; // far more than we ever wrote
+        if (hidden >= pasteLines - 1)
+            return true; // it swallowed the lot
+        return rows.join("").includes(tail);
+    };
+    /** The whole rendered screen as one string — the local-command submit proof. */
+    const snapshot = async () => (await screenRows(40)).join("\n");
+    /**
+     * Wait for the echo, re-reading the rendered screen until it shows up.
+     *
+     * LOOKING again is free — it is RETYPING that stacks copies, and this never
+     * writes. One look 500 ms after the write is what a mid-turn interjection
+     * loses to: the composer of a working session redraws on the TUI's own
+     * schedule (a spinner frame, a tool result, a token counter all take the
+     * paint first), so the text is genuinely there and simply not on screen yet.
+     * That read came back `"unconfirmed"` — the one verdict that is never
+     * auto-retried — and the prompt was reported not delivered while sitting in
+     * the composer of a session that was working fine.
+     */
+    const waitForEcho = async (ms) => {
+        const deadline = Date.now() + ms;
+        let heldSince;
+        for (;;) {
+            // `proven`, not merely "matched": a prefix hit that a rival could equally
+            // have produced is not our echo, and keeps polling — the composer may
+            // still finish drawing the rest of the text and upgrade the answer to
+            // `exact`. If the window runs out on an ambiguous hit the delivery falls
+            // through to the conversation log, which compares the WHOLE text and is
+            // not confusable at all.
+            //
+            // WHICH rule answered is kept on the audit row: "the composer was a
+            // viewport scrolled onto the tail" and "the placeholder stood in for the
+            // whole paste" are different facts about what this CLI draws, and the
+            // measurement that sent anyone looking here could only count the misses.
+            const rule = await onScreen();
+            // A proof by the no-box rule, for a backend whose reader CAN place its
+            // composer, is held a moment for a framed one. Measured on 2.1.304: a
+            // prompt typed just after the trust box closed was drawn bare at the
+            // top of a cleared screen (the tty's echo, the CLI between frames — no
+            // `❯`, no rules), the distance rule read that as `exact`, and the
+            // composer drew it properly 400 ms later. The bare read is still
+            // accepted if no frame ever comes (a stub, an unrecognised redraw), so
+            // nothing that degraded to it before stops delivering.
+            if (proven(rule) && fellBack && fullReader) {
+                heldSince ??= Date.now();
+                if (Date.now() - heldSince < FALLBACK_HOLD_MS && Date.now() < deadline) {
+                    await sleep(200);
+                    continue;
+                }
+            }
+            if (proven(rule)) {
+                shape.echo = rule;
+                return true;
+            }
+            if (Date.now() >= deadline) {
+                shape.echo = "none";
+                return false;
+            }
+            await sleep(200);
+        }
+    };
+    return { screen, probe, placeEcho, proven, snapshot, waitForEcho, lastSeen: () => seen };
+}
+/** The row the NEWEST occurrence of `probe` starts on, searching the rows as
+ *  one hard-wrapped line (squashed rows joined with nothing between); -1 if
+ *  absent. Only for a screen with no composer box — see `placeEcho`. */
+export function wrappedHit(rows, probe) {
+    if (!probe)
+        return -1;
+    const at = rows.join("").lastIndexOf(probe);
+    if (at < 0)
+        return -1;
+    let off = 0;
+    for (let i = 0; i < rows.length; i++) {
+        off += rows[i].length;
+        if (at < off)
+            return i;
+    }
+    return -1;
+}
+//# sourceMappingURL=deliverscreen.js.map

package/packages/host/dist/deliver/deliverscreen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deliverscreen.js","sourceRoot":"","sources":["../../src/deliver/deliverscreen.ts"],"names":[],"mappings":"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"}

package/packages/host/dist/deliver/delivertypes.d.ts

@@ -0,0 +1,119 @@
+/**
+ * The delivery contract's types (`deliver.ts` re-exports the two public ones).
+ * Types only — `tools/hostshape.test.mjs` holds it to that.
+ */
+import type { DeliveryShape, HistoryEntry, SendView, SentCommand, SentSource } from "@waterplane/shared";
+import type { SessionManager } from "../sessions.js";
+import type { noteHealth } from "../clihealth.js";
+import type { makeLogProof, makeSubmitProof } from "./deliverproof.js";
+/** What a delivery attempt did — see `deliverPrompt()` for the contract. */
+export type DeliveryResult = "ok" | "retry" | "unconfirmed" | "unsubmitted";
+/**
+ * Options for one delivery.
+ *
+ * `interactive` is the COMPOSE-BAR case, and it exists because the automation
+ * case and the human case want opposite things from a busy session.
+ *
+ * The backlog and the fan-out must never type into a session mid-turn: their
+ * instruction is a new task, and dropping it into the composer while the agent
+ * is answering is how an item gets lost or half-read. So they wait for the turn
+ * to end (up to 45 s) and report `"retry"` if it never does.
+ *
+ * A person typing in the compose bar means the opposite. Typing at a working
+ * agent is a normal, useful thing to do — you interject, and the TUI holds the
+ * line until the turn ends. Making that send WAIT would silently turn every
+ * compose send into the "hold until idle" mode the app offers as an explicit,
+ * separate choice, and a prompt that sits on the host for 45 s and then comes
+ * back "not ready" is a worse outcome than the raw write it replaced.
+ *
+ * So `interactive` waits only for the TUI to stop mid-draw, not for the turn to
+ * finish. The echo check is unchanged and still does the work that matters. What
+ * it costs is the Return PROOF: `turnActive` is already true when you interject,
+ * so "the turn started" cannot distinguish a landed Return from a swallowed one,
+ * and the delivery falls back to the same press-and-look guess a non-hooked
+ * session gets — which is still strictly better than the old path, where nothing
+ * checked anything at all.
+ *
+ * It is not, however, a fact about the CLI, and the health record is told so:
+ * a proof that cannot exist for this input is a rule declining to fire, not a
+ * rule failing. See the submit branch in `runDelivery`.
+ */
+export interface DeliverOpts {
+    /** Human-typed: don't wait for the turn to end (see above). */
+    interactive?: boolean;
+    /**
+     * The client's row key for this send, when it has one.
+     *
+     * Carried only so that a verdict settled MINUTES later can name the row it
+     * retires. The phone keys its queue by ackId; without it a resolution the
+     * host works out on its own arrives as a fact about a session and a string of
+     * text, which is not something a client can match against the red row it is
+     * showing.
+     */
+    ackId?: string;
+    /**
+     * Register an open question when the verdict comes back unconfirmable
+     * (default true).
+     *
+     * False for exactly one caller: the sweep's own re-delivery of a prompt it
+     * proved never ran. Its verdict updates the row that ordered it — a second
+     * row would make one prompt look like two, and a re-send that came back
+     * ambiguous would open a question whose answer is another re-send.
+     */
+    watch?: boolean;
+    /**
+     * Who is sending this and why — stamped onto the sent-command log entry.
+     *
+     * Optional so no call site can fail to compile, but every caller passes it:
+     * an unlabelled delivery still gets logged (falling back to the history kind
+     * below), because a command missing from the audit trail is worse than one
+     * with a vague source.
+     */
+    audit?: {
+        source: SentSource;
+        actor?: SentCommand["actor"];
+        detail?: string;
+    };
+    /**
+     * Hand the caller the sentence this delivery wrote about itself, when it
+     * wrote one.
+     *
+     * The four-value return is a contract about what may be RETRIED, and it
+     * cannot carry a reason — but two `retry`s can mean completely different
+     * things ("the session never reached its prompt" and "that composer already
+     * holds text I cannot tell apart from yours"), and the second is the one a
+     * person has to act on. A callback rather than a fifth enum member, because
+     * the retry contract is right as it stands and every caller that does not
+     * care may keep ignoring it.
+     */
+    onDetail?: (detail: string) => void;
+    /**
+     * Which screen the person composed this on — `term` or `read`.
+     *
+     * Carried for the AUDIT ROW and for nothing else: no branch in this file may
+     * read it. The reader unmounts the xterm, so a send composed over it is
+     * indistinguishable here from one composed over the live grid, and whether
+     * the two confirm at different rates is a question this log could not be
+     * asked. Measuring it is the point; acting on an unmeasured hunch about it
+     * would be the mistake.
+     */
+    view?: SendView;
+}
+/**
+ * What `runDelivery` hands its tail (`deliverreturn.ts`): its own locals, by
+ * name. Every member is a const there; the proof's mutable facts are read
+ * through `proof`'s getters, never copied out.
+ */
+export interface DeliveryRun {
+    sessions: SessionManager;
+    sessionId: string;
+    text: string;
+    historyKind: HistoryEntry["kind"];
+    shape: DeliveryShape;
+    note: typeof noteHealth;
+    snapshot: () => Promise<string>;
+    noTurn: boolean;
+    unannounced: boolean;
+    proof: ReturnType<typeof makeSubmitProof>;
+    ranAnyway: ReturnType<typeof makeLogProof>;
+}

package/packages/host/dist/deliver/delivertypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=delivertypes.js.map

package/packages/host/dist/deliver/delivertypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivertypes.js","sourceRoot":"","sources":["../../src/deliver/delivertypes.ts"],"names":[],"mappings":""}

package/packages/host/dist/deliver.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Instruction delivery into a live `claude` session — the shared "type this
+ * prompt as if a human typed it, and CONFIRM it landed" path.
+ *
+ * Extracted from `backlog.ts` (it was `BacklogManager.feed`) when the fan-out
+ * runner needed the exact same guarantees: the text reaches the session AT MOST
+ * ONCE, and the caller is told whether it definitely landed, definitely didn't,
+ * or couldn't be confirmed. Every trap the backlog hit is the same here, so the
+ * code must stay one implementation, not two drifting copies.
+ */
+import type { SessionManager } from "./sessions.js";
+import type { HistoryEntry } from "@waterplane/shared";
+import type { DeliverOpts, DeliveryResult } from "./deliver/delivertypes.js";
+export type { DeliverOpts, DeliveryResult } from "./deliver/delivertypes.js";
+/**
+ * Deliver instruction text into a session as if typed + Enter, and CONFIRM it
+ * landed:
+ *  - `"ok"`          — the text echoed in the composer and the turn started.
+ *  - `"retry"`       — nothing was typed (the session never became ready), so
+ *                      re-running deliverPrompt() later is free of side effects.
+ *  - `"unconfirmed"` — the text was written but never showed up on screen. It
+ *                      may or may not be sitting in the session; the caller
+ *                      MUST NOT auto-retry, because retrying is what stacked
+ *                      the same prompt over and over.
+ *  - `"unsubmitted"` — the text is provably IN the composer but every Return we
+ *                      sent was swallowed, so nothing is running. The prompt is
+ *                      there, one keypress from starting; the caller must say so
+ *                      rather than report a turn that isn't happening, and MUST
+ *                      NOT retype (that would stack a second copy under the
+ *                      first).
+ *
+ * Two traps avoided:
+ *  - `claude`'s TUI may not be ready instantly (trust prompt on first launch
+ *    etc.) — wait for the session to go quiet, signalling it's awaiting input.
+ *  - text+CR in one chunk reads as a paste in the TUI — split into two writes
+ *    so Return is recognized as the submit keystroke. Bypass the remote-control
+ *    gate (this is automation, not user input).
+ */
+/**
+ * Deliver into a session that was JUST spawned — the fan-out's per-repo fire and
+ * the "open a session here and run this" create both need the identical dance.
+ *
+ * The only difference from `deliverPrompt()` is the single retry on `"retry"`:
+ * a session seconds old is legitimately still booting (trust prompt, MCP
+ * servers), and `"retry"` means provably NOTHING was typed, so a second attempt
+ * cannot stack a copy. `"unconfirmed"` is never retried — that is the exact path
+ * that used to type the same prompt five times.
+ */
+export declare function deliverToNewSession(sessions: SessionManager, sessionId: string, text: string, historyKind?: HistoryEntry["kind"], opts?: DeliverOpts): Promise<DeliveryResult>;
+export declare function deliverPrompt(sessions: SessionManager, sessionId: string, text: string, historyKind?: HistoryEntry["kind"], opts?: DeliverOpts): Promise<DeliveryResult>;