@wastedcode/claudemux 0.2.0

package/dist/io/interrupt.js

@@ -0,0 +1,60 @@
+import { sleep } from "../util/sleep.js";
+/**
+ * Fixed best-effort settle after firing ESC, mirroring `send`'s post-submit
+ * window (`io/send.ts` / `io/baseline.ts`, ~the time for the input box to
+ * clear, typically ≤250ms). claude does not tear down the `"esc to interrupt"`
+ * affordance instantaneously; without this beat an *immediate* following
+ * `state()` can read the mid-interrupt frame and still report `working`.
+ *
+ * This is a FIXED delay, not a poll-until-not-working loop — "did the interrupt
+ * take" retry/backoff is the consumer's job. It never fails the interrupt.
+ */
+const INTERRUPT_SETTLE_MS = 250;
+/**
+ * Fire a single `Escape` at the pane — claude's own documented interrupt key
+ * (the classifier detects `working` by the literal `"esc to interrupt"`
+ * affordance, `agents/claude.ts`). ESC is already in `SendPayload`'s key union
+ * (`backends/types.ts`) and `sendKey` already sends it, so there is no backend
+ * change.
+ *
+ * ESC is sent **unconditionally** — no state-check guard. A guard would bake
+ * policy into the substrate and open a TOCTOU race (state read, then ESC, with
+ * the agent free to change state in between). ESC on an idle claude is harmless
+ * (it clears the input box). Gating on `state()` is the consumer's call. This
+ * is a mechanism, not a policy
+ * (`brain/decisions/0013-mechanism-not-policy-substrate-boundary.md`).
+ *
+ * That consumer-side gate is also not atomic with the ESC: a turn can finish
+ * between a `state()===working` read and the ESC landing — most easily across
+ * separate CLI processes (a short turn completes in the gap), so the ESC hits
+ * an already-idle agent. That is a harmless no-op, not a failure; a consumer
+ * that needs the interrupt to catch a turn should read `state()` and call this
+ * in one tight in-process sequence, not trust a stale prior-process reading.
+ *
+ * Blocks on **write delivery** plus a brief fixed settle ({@link
+ * INTERRUPT_SETTLE_MS}); it guarantees ESC was delivered, NOT that an in-flight
+ * abort has fully completed. This verb does exactly one named action — stop the
+ * turn — and nothing more (`brain/decisions/0013`, "a primitive does exactly the
+ * keystroke it names").
+ *
+ * **After interrupt(), claude does NOT return to a clean idle prompt.** It
+ * restores the interrupted message back into the composer, and the classifier
+ * reads that frame as `unknown` (never `idle`, never `working`). Two
+ * consequences the consumer must know:
+ *   - `wait()` after interrupt() resolves `{ kind: "aborted" }` immediately (the
+ *     handle records the interrupt authoritatively) — it does NOT hang waiting for
+ *     an idle that won't come.
+ *   - Do **not** naively `send()` a replacement after interrupt(): `send`
+ *     pastes into the *non-empty* composer (the restored message), so the
+ *     submission is the two texts concatenated. For a clean "interrupt and
+ *     replace" the composer must first be cleared to empty. claude's only
+ *     substrate-reachable composer clear is repeated ESC (its "Esc again to
+ *     clear" ladder), so the recipe is consumer-composed and claude-specific —
+ *     see the README "Interrupting a working agent" note. It is deliberately
+ *     NOT bundled into this agent-agnostic verb.
+ */
+export async function interruptOnce(backend, ref) {
+    await backend.send(ref, { kind: "key", key: "Escape" });
+    await sleep(INTERRUPT_SETTLE_MS);
+}
+//# sourceMappingURL=interrupt.js.map

package/dist/io/interrupt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interrupt.js","sourceRoot":"","sources":["../../src/io/interrupt.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC;;;;;;;;;GASG;AACH,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,OAAgB,EAAE,GAAe;IACnE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;IACxD,MAAM,KAAK,CAAC,mBAAmB,CAAC,CAAC;AACnC,CAAC"}

package/dist/io/respond.d.ts

@@ -0,0 +1,28 @@
+import type { Backend, SendPayload } from "../backends/types.js";
+/** The keystroke a `key` payload can carry (the agent picks which one). */
+type KeyName = Extract<SendPayload, {
+    kind: "key";
+}>["key"];
+/**
+ * Answer an agent prompt: fire the single keystroke that selects the choice,
+ * then **self-confirm** the prompt cleared before returning — the analog of
+ * {@link import('./send.js').sendOnce} anchoring its own user record.
+ *
+ * Without the confirm, the call returns while the menu is still painted (the
+ * agent repaints prompt→working only after processing the key), so a following
+ * `wait()` latches the STALE prompt and reports `awaiting` again. The reliable
+ * signal is SEMANTIC — `stillPrompted()` (the caller's belief check) returning
+ * false — NOT a raw pane diff: a cursor blink between two captures fires a
+ * spurious change before the key takes effect (the race this exists to close).
+ *
+ * The mechanism owns *delivery + settle*; it stays agnostic of (a) which key
+ * means what — the agent maps choice→key and hands `key` in — and (b) how
+ * "still prompted" is decided — the caller injects `stillPrompted` (the
+ * Observer's belief). Bounded + best-effort: if the prompt never clears (a
+ * second prompt stacked, or the key was dropped) it returns anyway and the
+ * caller's next `wait()` re-reads. It does exactly the one keystroke it names
+ * (`brain/decisions/0013` — a primitive does exactly the keystroke it names).
+ */
+export declare function respondOnce(backend: Backend, ref: Parameters<Backend["send"]>[0], key: KeyName, stillPrompted: () => Promise<boolean>): Promise<void>;
+export {};
+//# sourceMappingURL=respond.d.ts.map

package/dist/io/respond.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"respond.d.ts","sourceRoot":"","sources":["../../src/io/respond.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAGjE,2EAA2E;AAC3E,KAAK,OAAO,GAAG,OAAO,CAAC,WAAW,EAAE;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC,CAAC,KAAK,CAAC,CAAC;AAM5D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,EACnC,GAAG,EAAE,OAAO,EACZ,aAAa,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,CAMf"}

package/dist/io/respond.js

@@ -0,0 +1,33 @@
+import { sleep } from "../util/sleep.js";
+/** Confirm-window: poll up to ~5s for the answered prompt to clear. */
+const CONFIRM_POLLS = 20;
+const CONFIRM_POLL_MS = 250;
+/**
+ * Answer an agent prompt: fire the single keystroke that selects the choice,
+ * then **self-confirm** the prompt cleared before returning — the analog of
+ * {@link import('./send.js').sendOnce} anchoring its own user record.
+ *
+ * Without the confirm, the call returns while the menu is still painted (the
+ * agent repaints prompt→working only after processing the key), so a following
+ * `wait()` latches the STALE prompt and reports `awaiting` again. The reliable
+ * signal is SEMANTIC — `stillPrompted()` (the caller's belief check) returning
+ * false — NOT a raw pane diff: a cursor blink between two captures fires a
+ * spurious change before the key takes effect (the race this exists to close).
+ *
+ * The mechanism owns *delivery + settle*; it stays agnostic of (a) which key
+ * means what — the agent maps choice→key and hands `key` in — and (b) how
+ * "still prompted" is decided — the caller injects `stillPrompted` (the
+ * Observer's belief). Bounded + best-effort: if the prompt never clears (a
+ * second prompt stacked, or the key was dropped) it returns anyway and the
+ * caller's next `wait()` re-reads. It does exactly the one keystroke it names
+ * (`brain/decisions/0013` — a primitive does exactly the keystroke it names).
+ */
+export async function respondOnce(backend, ref, key, stillPrompted) {
+    await backend.send(ref, { kind: "key", key });
+    for (let i = 0; i < CONFIRM_POLLS; i++) {
+        if (!(await stillPrompted()))
+            return;
+        await sleep(CONFIRM_POLL_MS);
+    }
+}
+//# sourceMappingURL=respond.js.map

package/dist/io/respond.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"respond.js","sourceRoot":"","sources":["../../src/io/respond.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAKzC,uEAAuE;AACvE,MAAM,aAAa,GAAG,EAAE,CAAC;AACzB,MAAM,eAAe,GAAG,GAAG,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,OAAgB,EAChB,GAAmC,EACnC,GAAY,EACZ,aAAqC;IAErC,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;IAC9C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,EAAE,CAAC,EAAE,EAAE,CAAC;QACvC,IAAI,CAAC,CAAC,MAAM,aAAa,EAAE,CAAC;YAAE,OAAO;QACrC,MAAM,KAAK,CAAC,eAAe,CAAC,CAAC;IAC/B,CAAC;AACH,CAAC"}

package/dist/io/send.d.ts

@@ -0,0 +1,44 @@
+import type { AgentDef } from "../agents/types.js";
+import type { Backend, SessionRef } from "../backends/types.js";
+/**
+ * Deliver `text` as one logical user turn: a `paste` of the body, then a
+ * separate `Enter`. The two backend calls happen sequentially — there is
+ * no path by which the paste body can self-submit.
+ *
+ * Blocks on **write delivery** (and a short post-submit settle, below), not on
+ * the agent's response. Callers who want to know when the agent is done should
+ * call `wait()` next.
+ *
+ * **Post-submit baseline.** After delivery, `send` records a fingerprint of
+ * the post-submit pane (see {@link captureSendBaseline}) under a session-scoped
+ * key. This lets a *stateless* `wait()` — the CLI reattaches in a fresh process
+ * — detect a turn that completed before its first poll, instead of hanging to
+ * `ReplTimeout` (bug 8a500a52). It adds a brief settle (~the time for the input
+ * box to clear, typically ≤250ms) to `send`; it is best-effort and never fails
+ * the send.
+ *
+ * @remarks
+ * The two-call sequence (paste-then-Enter) is load-bearing per
+ * `docs/decisions/0001-tmux-paste-mechanism.md` — bracketed paste lets the
+ * receiver distinguish typed `\n`
+ * (submit) from pasted `\n` (literal newline). Folding submission into the
+ * paste body would re-introduce the per-line-submit failure mode.
+ */
+export declare function sendOnce(backend: Backend, agent: AgentDef, ref: SessionRef, text: string): Promise<void>;
+/**
+ * Re-fire the submit key (Enter) alone — the recovery for a **lost submit**: the
+ * paste reached the composer but the Enter keystroke didn't register, so the turn
+ * sits there un-submitted and no user record is ever written.
+ *
+ * Critically it does NOT re-paste the body. A re-`send()` would paste the text a
+ * second time and submit `texttext`; pressing Enter only submits whatever the
+ * composer already holds, so the recovery can never duplicate content. On an
+ * already-empty composer (a genuine non-delivery, not a lost Enter) it is a
+ * harmless no-op — the agent ignores an empty submit.
+ *
+ * Mechanism, not policy: this owns only the keystroke. The caller decides *when*
+ * to use it (its own user record never appeared AND the message wasn't queued)
+ * and re-checks delivery afterward — this does not poll or confirm.
+ */
+export declare function submitOnce(backend: Backend, ref: SessionRef): Promise<void>;
+//# sourceMappingURL=send.d.ts.map

package/dist/io/send.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../src/io/send.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAIhE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,QAAQ,EACf,GAAG,EAAE,UAAU,EACf,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAqBf;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjF"}

package/dist/io/send.js

@@ -0,0 +1,66 @@
+import { CLASSIFIER_CAPTURE } from "../session/constants.js";
+import { captureSendBaseline, writeSendBaseline } from "./baseline.js";
+/**
+ * Deliver `text` as one logical user turn: a `paste` of the body, then a
+ * separate `Enter`. The two backend calls happen sequentially — there is
+ * no path by which the paste body can self-submit.
+ *
+ * Blocks on **write delivery** (and a short post-submit settle, below), not on
+ * the agent's response. Callers who want to know when the agent is done should
+ * call `wait()` next.
+ *
+ * **Post-submit baseline.** After delivery, `send` records a fingerprint of
+ * the post-submit pane (see {@link captureSendBaseline}) under a session-scoped
+ * key. This lets a *stateless* `wait()` — the CLI reattaches in a fresh process
+ * — detect a turn that completed before its first poll, instead of hanging to
+ * `ReplTimeout` (bug 8a500a52). It adds a brief settle (~the time for the input
+ * box to clear, typically ≤250ms) to `send`; it is best-effort and never fails
+ * the send.
+ *
+ * @remarks
+ * The two-call sequence (paste-then-Enter) is load-bearing per
+ * `docs/decisions/0001-tmux-paste-mechanism.md` — bracketed paste lets the
+ * receiver distinguish typed `\n`
+ * (submit) from pasted `\n` (literal newline). Folding submission into the
+ * paste body would re-introduce the per-line-submit failure mode.
+ */
+export async function sendOnce(backend, agent, ref, text) {
+    // Pre-send pane: the baseline poll uses it to skip the previous idle and
+    // capture the *post-submit* frame instead. Best-effort — if it fails, the
+    // baseline is simply not recorded and wait falls back to working-arm.
+    let pre;
+    try {
+        pre = await backend.capture(ref, CLASSIFIER_CAPTURE);
+    }
+    catch {
+        pre = undefined;
+    }
+    await backend.send(ref, { kind: "paste", text });
+    await backend.send(ref, { kind: "key", key: "Enter" });
+    // Always (over)write — this turn's baseline replaces any prior turn's, and
+    // an empty value clears it when we couldn't establish a fresh one (e.g. the
+    // pre-send capture failed). Otherwise a later wait could arm on a *stale*
+    // fingerprint and return the previous turn's idle. Empty == "no baseline",
+    // so wait falls back to arming on an observed working frame.
+    const fingerprint = await captureSendBaseline(backend, agent, ref, pre);
+    await writeSendBaseline(backend, ref, fingerprint ?? "");
+}
+/**
+ * Re-fire the submit key (Enter) alone — the recovery for a **lost submit**: the
+ * paste reached the composer but the Enter keystroke didn't register, so the turn
+ * sits there un-submitted and no user record is ever written.
+ *
+ * Critically it does NOT re-paste the body. A re-`send()` would paste the text a
+ * second time and submit `texttext`; pressing Enter only submits whatever the
+ * composer already holds, so the recovery can never duplicate content. On an
+ * already-empty composer (a genuine non-delivery, not a lost Enter) it is a
+ * harmless no-op — the agent ignores an empty submit.
+ *
+ * Mechanism, not policy: this owns only the keystroke. The caller decides *when*
+ * to use it (its own user record never appeared AND the message wasn't queued)
+ * and re-checks delivery afterward — this does not poll or confirm.
+ */
+export async function submitOnce(backend, ref) {
+    await backend.send(ref, { kind: "key", key: "Enter" });
+}
+//# sourceMappingURL=send.js.map

package/dist/io/send.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"send.js","sourceRoot":"","sources":["../../src/io/send.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAC5B,OAAgB,EAChB,KAAe,EACf,GAAe,EACf,IAAY;IAEZ,yEAAyE;IACzE,0EAA0E;IAC1E,sEAAsE;IACtE,IAAI,GAAuB,CAAC;IAC5B,IAAI,CAAC;QACH,GAAG,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAC;IACvD,CAAC;IAAC,MAAM,CAAC;QACP,GAAG,GAAG,SAAS,CAAC;IAClB,CAAC;IAED,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;IACjD,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,CAAC;IAEvD,2EAA2E;IAC3E,4EAA4E;IAC5E,0EAA0E;IAC1E,2EAA2E;IAC3E,6DAA6D;IAC7D,MAAM,WAAW,GAAG,MAAM,mBAAmB,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IACxE,MAAM,iBAAiB,CAAC,OAAO,EAAE,GAAG,EAAE,WAAW,IAAI,EAAE,CAAC,CAAC;AAC3D,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,OAAgB,EAAE,GAAe;IAChE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,CAAC;AACzD,CAAC"}

package/dist/io/stabilize.d.ts

@@ -0,0 +1,28 @@
+import type { Backend, SessionRef } from "../backends/types.js";
+/**
+ * "Pane unchanged for windowMs" probe. Captures the bottom-N pane region at
+ * `pollMs` intervals; returns `{ stable: true, text }` once the captured
+ * text has not changed across an entire `windowMs` window, or
+ * `{ stable: false, reason: "timeout" }` once `timeoutMs` elapses.
+ *
+ * Shared by `session/boot.ts` (post-dialog advancement check) and `io/wait.ts`
+ * (idle stabilization).
+ */
+export interface StabilizeResult {
+    stable: boolean;
+    text: string;
+    reason?: "timeout";
+}
+export declare function stabilize(backend: Backend, ref: SessionRef, opts: {
+    /** Bottom-N lines to capture. */
+    lines: number;
+    /** How long the pane must stay identical to declare stable. */
+    windowMs: number;
+    /** Capture interval. */
+    pollMs: number;
+    /** Overall budget; returns `{ stable: false, reason: "timeout" }` past it. */
+    timeoutMs: number;
+    /** Capture with ANSI styling on (so the returned `text` feeds idle checks). */
+    ansi?: boolean;
+}): Promise<StabilizeResult>;
+//# sourceMappingURL=stabilize.d.ts.map

package/dist/io/stabilize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stabilize.d.ts","sourceRoot":"","sources":["../../src/io/stabilize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAGhE;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB;AAED,wBAAsB,SAAS,CAC7B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,UAAU,EACf,IAAI,EAAE;IACJ,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,QAAQ,EAAE,MAAM,CAAC;IACjB,wBAAwB;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,SAAS,EAAE,MAAM,CAAC;IAClB,+EAA+E;IAC/E,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,GACA,OAAO,CAAC,eAAe,CAAC,CAkB1B"}

package/dist/io/stabilize.js

@@ -0,0 +1,20 @@
+import { sleep } from "../util/sleep.js";
+export async function stabilize(backend, ref, opts) {
+    const start = Date.now();
+    const capOpts = { lines: opts.lines, ...(opts.ansi === true ? { ansi: true } : {}) };
+    let lastText = await backend.capture(ref, capOpts);
+    let unchangedSince = Date.now();
+    while (Date.now() - start < opts.timeoutMs) {
+        if (Date.now() - unchangedSince >= opts.windowMs) {
+            return { stable: true, text: lastText };
+        }
+        await sleep(opts.pollMs);
+        const now = await backend.capture(ref, capOpts);
+        if (now !== lastText) {
+            lastText = now;
+            unchangedSince = Date.now();
+        }
+    }
+    return { stable: false, text: lastText, reason: "timeout" };
+}
+//# sourceMappingURL=stabilize.js.map

package/dist/io/stabilize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stabilize.js","sourceRoot":"","sources":["../../src/io/stabilize.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAiBzC,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,OAAgB,EAChB,GAAe,EACf,IAWC;IAED,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACzB,MAAM,OAAO,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;IACrF,IAAI,QAAQ,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IACnD,IAAI,cAAc,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAEhC,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAC3C,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,cAAc,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YACjD,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;QAC1C,CAAC;QACD,MAAM,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACzB,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;QAChD,IAAI,GAAG,KAAK,QAAQ,EAAE,CAAC;YACrB,QAAQ,GAAG,GAAG,CAAC;YACf,cAAc,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC9B,CAAC;IACH,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;AAC9D,CAAC"}

package/dist/io/wait.d.ts

@@ -0,0 +1,47 @@
+import type { Backend, SessionRef } from "../backends/types.js";
+import type { Belief } from "../observe/observer.js";
+import type { ReadyOpts, TurnOutcome } from "../types.js";
+import type { stabilize as defaultStabilize } from "./stabilize.js";
+interface WaitDeps {
+    stabilize: typeof defaultStabilize;
+}
+/**
+ * Reads the fused {@link Belief} for one poll, plus the raw pane text the
+ * fingerprint/arming need. Injected by the handle so `wait()` shares the handle's
+ * **incremental** observer (bounded per-poll reads) and never re-reads files or
+ * touches the agent itself.
+ */
+export type BeliefReader = () => Promise<{
+    belief: Belief;
+    paneText: string;
+}>;
+/**
+ * Wait until the turn reaches a terminal {@link TurnOutcome} — the **compound
+ * owner** of "the turn stopped, and why." It composes two atomic sub-owners and
+ * re-derives neither's internals:
+ *   - the **observe** sub-owner (the injected {@link BeliefReader}: hooks +
+ *     transcript + pane) yields `completed` / `awaiting` / `aborted`;
+ *   - the **policy** sub-owner — the CONSUMER's patience ({@link ReadyOpts}) —
+ *     yields `budget-exceeded`: `reason:"max"` (wall-clock `maxMs`) vs `"idle"`
+ *     (no progress for `idleMs`). The library owns NO patience: with neither
+ *     bound supplied, `wait()` blocks until a terminal belief (it never invents a
+ *     deadline; "time is the policy's").
+ *
+ * **Completion is hook-first, flush-safe.** The `stop` hook edge is the reliable
+ * "turn ended" trigger; but the edge fires ~100ms before the transcript flushes
+ * the reply, so `completed` is only declared once the pane has *also* settled to
+ * a stable idle box — which trails the flush — guaranteeing a following
+ * `messagesSince(cursor)` is race-free. With hooks off there is no edge, so a
+ * pane-idle that has *armed* (left idle, or diverged from the post-submit
+ * baseline) is the completion signal instead — the stateless-CLI fast-turn path
+ * (bug 8a500a52). Either way, the previous turn's lingering idle never counts:
+ * `completed` requires a `stop` edge newer than this wait, or a fresh arm.
+ *
+ * `dialog`/`permission-prompt`/`aborted` are actionable and return immediately
+ * (no settle). Never throws on timeout: a budget overrun is a returned
+ * `budget-exceeded`, not an exception. (A capture failure inside the reader DOES
+ * propagate — a gone session is terminal, not a budget matter.)
+ */
+export declare function waitForOutcome(backend: Backend, ref: SessionRef, opts: ReadyOpts, deps: WaitDeps, readBelief: BeliefReader): Promise<TurnOutcome>;
+export {};
+//# sourceMappingURL=wait.d.ts.map

package/dist/io/wait.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait.d.ts","sourceRoot":"","sources":["../../src/io/wait.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG1D,OAAO,KAAK,EAAmB,SAAS,IAAI,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAQrF,UAAU,QAAQ;IAChB,SAAS,EAAE,OAAO,gBAAgB,CAAC;CACpC;AAED;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,UAAU,EACf,IAAI,EAAE,SAAS,EAGf,IAAI,EAAE,QAAQ,EACd,UAAU,EAAE,YAAY,GACvB,OAAO,CAAC,WAAW,CAAC,CAkFtB"}

package/dist/io/wait.js

@@ -0,0 +1,117 @@
+import { CLASSIFIER_BOTTOM_N } from "../session/constants.js";
+import { sleep } from "../util/sleep.js";
+import { paneFingerprint, readSendBaseline } from "./baseline.js";
+/** How long the idle box must hold steady before "completed" (guards mid-stream returns). */
+const IDLE_STABLE_WINDOW_MS = 250;
+/** Polling cadence while waiting. */
+const POLL_MS = 150;
+/**
+ * Wait until the turn reaches a terminal {@link TurnOutcome} — the **compound
+ * owner** of "the turn stopped, and why." It composes two atomic sub-owners and
+ * re-derives neither's internals:
+ *   - the **observe** sub-owner (the injected {@link BeliefReader}: hooks +
+ *     transcript + pane) yields `completed` / `awaiting` / `aborted`;
+ *   - the **policy** sub-owner — the CONSUMER's patience ({@link ReadyOpts}) —
+ *     yields `budget-exceeded`: `reason:"max"` (wall-clock `maxMs`) vs `"idle"`
+ *     (no progress for `idleMs`). The library owns NO patience: with neither
+ *     bound supplied, `wait()` blocks until a terminal belief (it never invents a
+ *     deadline; "time is the policy's").
+ *
+ * **Completion is hook-first, flush-safe.** The `stop` hook edge is the reliable
+ * "turn ended" trigger; but the edge fires ~100ms before the transcript flushes
+ * the reply, so `completed` is only declared once the pane has *also* settled to
+ * a stable idle box — which trails the flush — guaranteeing a following
+ * `messagesSince(cursor)` is race-free. With hooks off there is no edge, so a
+ * pane-idle that has *armed* (left idle, or diverged from the post-submit
+ * baseline) is the completion signal instead — the stateless-CLI fast-turn path
+ * (bug 8a500a52). Either way, the previous turn's lingering idle never counts:
+ * `completed` requires a `stop` edge newer than this wait, or a fresh arm.
+ *
+ * `dialog`/`permission-prompt`/`aborted` are actionable and return immediately
+ * (no settle). Never throws on timeout: a budget overrun is a returned
+ * `budget-exceeded`, not an exception. (A capture failure inside the reader DOES
+ * propagate — a gone session is terminal, not a budget matter.)
+ */
+export async function waitForOutcome(backend, ref, opts, 
+// Both required — the handle (and tests) always inject them. A throwing default
+// would just move a programmer error from compile time to runtime.
+deps, readBelief) {
+    // The CONSUMER's patience — both optional, NO library default. `timeoutMs` is
+    // a deprecated alias for `maxMs`. With neither set, `wait()` owns no deadline
+    // and blocks until a terminal belief ("time is the policy's").
+    const maxMs = opts.maxMs ?? opts.timeoutMs;
+    const idleMs = opts.idleMs;
+    const start = Date.now();
+    // "armed" = evidence this turn ran (pane left idle, or diverged from the
+    // post-submit baseline) — needed for the hooks-off path; the hook `stop` edge
+    // makes it moot when hooks are healthy.
+    let armed = false;
+    let lastProgressAt = start;
+    let lastSignature = "";
+    const baseline = await readSendBaseline(backend, ref);
+    while (true) {
+        const now = Date.now();
+        // ── observe sub-owner: the one belief (incremental, via the handle) ──────
+        const { belief, paneText } = await readBelief();
+        // ── terminal verdicts the observe sub-owner already settles ─────────────
+        if (belief.state === "dialog")
+            return { kind: "awaiting", on: "dialog" };
+        if (belief.state === "permission-prompt")
+            return { kind: "awaiting", on: "permission-prompt" };
+        if (belief.interrupted)
+            return { kind: "aborted" };
+        // ── progress heartbeat (drives stuck detection) ─────────────────────────
+        const signature = `${belief.lastActivityAt ?? 0}|${belief.transcriptCount}|${paneFingerprint(paneText)}`;
+        if (signature !== lastSignature) {
+            lastSignature = signature;
+            lastProgressAt = now;
+        }
+        // ── completion: a hook done-edge OR an armed pane-idle, confirmed settled ─
+        // KNOWN LIMITATION (F42, single-host assumption): `lastStopAt` is the hook's
+        // own clock (`date +%s.%N` on the SESSION's host); `start` is the consumer's
+        // `Date.now()`. They agree only on one host / one clock. Under cross-host
+        // clock skew (a distributed deployment driving a remote agent), a real `stop`
+        // can read as before/after this wait → completion mis-fires; the pane-idle arm
+        // path still recovers it, but the reliable hook trigger is degraded. The fix
+        // is to baseline the stop-edge ORDER/count at wait-start instead of comparing
+        // wall-clocks (the S9 pattern); deferred until a distributed consumer needs it.
+        const hookDone = belief.lastStopAt !== undefined && belief.lastStopAt >= start;
+        if (belief.state !== "idle")
+            armed = true;
+        else if (baseline !== undefined && paneFingerprint(paneText) !== baseline)
+            armed = true;
+        if (belief.state === "idle" && (hookDone || armed)) {
+            // The stabilize debounce is a transport detail (legitimately the library's,
+            // per the read/write-split RFC); cap it by any remaining wall-clock budget.
+            const remaining = maxMs === undefined ? IDLE_STABLE_WINDOW_MS * 4 : Math.max(0, maxMs - (now - start));
+            const r = await deps.stabilize(backend, ref, {
+                lines: CLASSIFIER_BOTTOM_N,
+                windowMs: IDLE_STABLE_WINDOW_MS,
+                pollMs: POLL_MS,
+                timeoutMs: Math.min(remaining, IDLE_STABLE_WINDOW_MS * 4),
+                ansi: true,
+            });
+            // Re-confirm via the belief (the one owner), not raw pane rules.
+            if (r.stable && (await readBelief()).belief.state === "idle")
+                return { kind: "completed" };
+        }
+        // ── policy sub-owner: the CONSUMER's patience (the library owns none) ─────
+        // Wall-clock cap.
+        if (maxMs !== undefined && now - start > maxMs)
+            return { kind: "budget-exceeded", reason: "max" };
+        // No-progress cap. Gated on `state==="unknown" && !toolInFlight` so it means
+        // "stuck too long," never "still working too long": a `working` pane (the live
+        // `esc to interrupt` spinner) or a tool in flight is never counted as idle,
+        // and the heartbeat keys on the pane fingerprint so a still-animating spinner
+        // keeps resetting it even when a frame classifies `unknown`. The THRESHOLD is
+        // the consumer's (`idleMs`); the library only distinguishes stuck-from-working.
+        if (idleMs !== undefined &&
+            belief.state === "unknown" &&
+            !belief.toolInFlight &&
+            now - lastProgressAt > idleMs) {
+            return { kind: "budget-exceeded", reason: "idle" };
+        }
+        await sleep(POLL_MS);
+    }
+}
+//# sourceMappingURL=wait.js.map

package/dist/io/wait.js.map

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

package/dist/observe/incremental.d.ts

@@ -0,0 +1,28 @@
+/**
+ * An incremental line reader for an **append-only** file (a hook rendezvous or a
+ * transcript). Each {@link poll} reads only the bytes appended since the last
+ * call and returns the new *complete* lines — so a long-lived session's
+ * `progress()`/`wait()` re-parse O(delta) per poll instead of O(file) (the
+ * unbounded-growth trap, F39). A trailing partial line (mid-flush write) is held
+ * back and completed on the next poll.
+ *
+ * Correct ONLY for append-only files: it trusts that bytes before its offset
+ * never change. If the file **shrinks** (truncation / rotation / an overwrite to
+ * a shorter body) it resets and re-reads from the start, signalling `reset` so
+ * the caller can discard whatever it accumulated. A claude transcript/rendezvous
+ * is append-only by construction (compaction summarizes the context window, it
+ * never rewrites the log), so the reset path is purely defensive.
+ */
+export declare class TailReader {
+    #private;
+    /**
+     * The new complete lines since the last poll. `reset: true` means the file
+     * shrank and `lines` is the WHOLE file again — the caller must drop its
+     * accumulated state first. Absent/unreadable file → no change (`[]`).
+     */
+    poll(path: string): {
+        reset: boolean;
+        lines: string[];
+    };
+}
+//# sourceMappingURL=incremental.d.ts.map

package/dist/observe/incremental.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"incremental.d.ts","sourceRoot":"","sources":["../../src/observe/incremental.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,qBAAa,UAAU;;IAIrB;;;;OAIG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE;CA6BxD"}

package/dist/observe/incremental.js

@@ -0,0 +1,57 @@
+import { closeSync, openSync, readSync, statSync } from "node:fs";
+/**
+ * An incremental line reader for an **append-only** file (a hook rendezvous or a
+ * transcript). Each {@link poll} reads only the bytes appended since the last
+ * call and returns the new *complete* lines — so a long-lived session's
+ * `progress()`/`wait()` re-parse O(delta) per poll instead of O(file) (the
+ * unbounded-growth trap, F39). A trailing partial line (mid-flush write) is held
+ * back and completed on the next poll.
+ *
+ * Correct ONLY for append-only files: it trusts that bytes before its offset
+ * never change. If the file **shrinks** (truncation / rotation / an overwrite to
+ * a shorter body) it resets and re-reads from the start, signalling `reset` so
+ * the caller can discard whatever it accumulated. A claude transcript/rendezvous
+ * is append-only by construction (compaction summarizes the context window, it
+ * never rewrites the log), so the reset path is purely defensive.
+ */
+export class TailReader {
+    #offset = 0;
+    #partial = "";
+    /**
+     * The new complete lines since the last poll. `reset: true` means the file
+     * shrank and `lines` is the WHOLE file again — the caller must drop its
+     * accumulated state first. Absent/unreadable file → no change (`[]`).
+     */
+    poll(path) {
+        let size;
+        try {
+            size = statSync(path).size;
+        }
+        catch {
+            return { reset: false, lines: [] }; // absent — degrade, never throw
+        }
+        let reset = false;
+        if (size < this.#offset) {
+            this.#offset = 0;
+            this.#partial = "";
+            reset = true;
+        }
+        if (size <= this.#offset)
+            return { reset, lines: [] };
+        const fd = openSync(path, "r");
+        try {
+            const len = size - this.#offset;
+            const buf = Buffer.allocUnsafe(len);
+            const n = readSync(fd, buf, 0, len, this.#offset);
+            this.#offset += n;
+            const chunk = this.#partial + buf.subarray(0, n).toString("utf8");
+            const lines = chunk.split("\n");
+            this.#partial = lines.pop() ?? ""; // last element = an incomplete line → hold
+            return { reset, lines };
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+}
+//# sourceMappingURL=incremental.js.map

package/dist/observe/incremental.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"incremental.js","sourceRoot":"","sources":["../../src/observe/incremental.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAElE;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,UAAU;IACrB,OAAO,GAAG,CAAC,CAAC;IACZ,QAAQ,GAAG,EAAE,CAAC;IAEd;;;;OAIG;IACH,IAAI,CAAC,IAAY;QACf,IAAI,IAAY,CAAC;QACjB,IAAI,CAAC;YACH,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC;QAC7B,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC,gCAAgC;QACtE,CAAC;QACD,IAAI,KAAK,GAAG,KAAK,CAAC;QAClB,IAAI,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YACxB,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;YACjB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;YACnB,KAAK,GAAG,IAAI,CAAC;QACf,CAAC;QACD,IAAI,IAAI,IAAI,IAAI,CAAC,OAAO;YAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;QAEtD,MAAM,EAAE,GAAG,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAC/B,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC;YAChC,MAAM,GAAG,GAAG,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;YACpC,MAAM,CAAC,GAAG,QAAQ,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;YAClD,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC;YAClB,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;YAClE,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAChC,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,2CAA2C;YAC9E,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;QAC1B,CAAC;gBAAS,CAAC;YACT,SAAS,CAAC,EAAE,CAAC,CAAC;QAChB,CAAC;IACH,CAAC;CACF"}