team 0.1.1 → 0.2.0

package/dist/herdr.d.ts

@@ -8,6 +8,7 @@ export type HerdrAgent = {
 };
 export declare function agentList(session?: string): HerdrAgent[] | null;
 export declare function paneRootPid(pane: string, session?: string): number | null;
+export declare function foregroundArgv0(result: unknown): string[] | null;
 export declare function paneForeground(pane: string, session?: string): string[] | null;
 export type HerdrWorkspace = {
     id: string;
@@ -26,6 +27,10 @@ export declare function paneRun(pane: string, command: string, session?: string)
 export declare function agentRename(pane: string, name: string, session?: string): boolean;
 export declare function workspaceClose(workspace: string, session?: string): boolean;
 export declare function sessionStop(name: string): boolean;
+export declare function sessionDelete(name: string): boolean;
+export type PaneExec = (args: string[]) => string;
+/** Swaps the process call paneRead makes; null restores the real one. */
+export declare function setPaneExec(exec: PaneExec | null): void;
 export declare function paneRead(pane: string, lines: number, session?: string): string | null;
 export declare function herdrCommand(session: string | undefined, ...args: string[]): string;
 export declare function typeText(pane: string, text: string, session?: string): boolean;

package/dist/herdr.js

@@ -33,15 +33,19 @@ export function paneRootPid(pane, session) {
         return null;
     }
 }
-// argv0 of each foreground process, or null when the pane can't be read. After a CLI exits,
-// herdr keeps the pane and the foreground process is the shell.
+// argv0 of each foreground process, in herdr's order, or null when the pane can't be
+// read. `name` is not the process: a Claude entry's name is its version. After a CLI
+// exits, herdr keeps the pane and the foreground process is the shell.
+export function foregroundArgv0(result) {
+    const list = result
+        ?.process_info?.foreground_processes;
+    if (!Array.isArray(list))
+        return null;
+    return list.map((proc) => (typeof proc?.argv0 === 'string' ? proc.argv0 : ''));
+}
 export function paneForeground(pane, session) {
     try {
-        const result = run(['pane', 'process-info', '--pane', pane], session);
-        const list = result.process_info?.foreground_processes;
-        if (!Array.isArray(list))
-            return null;
-        return list.map((proc) => (typeof proc.argv0 === 'string' ? proc.argv0 : ''));
+        return foregroundArgv0(run(['pane', 'process-info', '--pane', pane], session));
     }
     catch {
         return null;
@@ -167,7 +171,7 @@ export function workspaceClose(workspace, session) {
     const body = parsed(out);
     return body !== null && body.type !== 'error';
 }
-// Stops a session. Never deletes one: clearing a stopped session is the owner's command to run.
+// Stops a session, which herdr keeps listed as stopped.
 export function sessionStop(name) {
     const out = capture(['session', 'stop', name]);
     if (out === null)
@@ -175,15 +179,50 @@ export function sessionStop(name) {
     const body = parsed(out);
     return body === null || body.type !== 'error';
 }
+// Clears a stopped session — the one case `team` deletes: `down`, on the session it has itself
+// just stopped in the same run, so the next `up` starts from the beginning. `up` never deletes:
+// its refusal names this command and leaves it to the owner.
+export function sessionDelete(name) {
+    const out = capture(['session', 'delete', name]);
+    if (out === null)
+        return false;
+    const body = parsed(out);
+    return body !== null && body.type !== 'error';
+}
+const shellPaneExec = (args) => execFileSync('herdr', args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 10_000 });
+let paneExec = shellPaneExec;
+/** Swaps the process call paneRead makes; null restores the real one. */
+export function setPaneExec(exec) {
+    paneExec = exec ?? shellPaneExec;
+}
 // The visible lines of a pane, or null. `session` undefined reaches the caller's own server.
+// The lines keep their ANSI styling, CRLF folded to LF: a greyed suggestion and typed text
+// read the same as plain text, and only their styling tells them apart, so the readers that
+// want plain text strip it (`stripSgr`). An herdr without the `--format` option refuses the
+// styled call and is read by the exact call main makes today — no flag at all — where
+// unstyled text can never read as dim and the placeholder list alone decides. A herdr that
+// hangs is not asked twice: one timeout reads null.
 export function paneRead(pane, lines, session) {
+    const full = [...(session ? ['--session', session] : []), 'pane', 'read', pane, '--source', 'visible', '--lines', String(lines)];
+    let styled;
     try {
-        const full = [...(session ? ['--session', session] : []), 'pane', 'read', pane, '--source', 'visible', '--lines', String(lines)];
-        return execFileSync('herdr', full, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 10_000 });
+        styled = paneExec([...full, '--format', 'ansi']);
     }
-    catch {
-        return null;
+    catch (error) {
+        if (!(error instanceof Error))
+            return null;
+        // execFileSync reports its own timeout as an Error with code ETIMEDOUT — signal SIGTERM,
+        // status null, and no killed field. Observed under Bun, from a run, not from memory.
+        if (error.code === 'ETIMEDOUT')
+            return null;
+        try {
+            return paneExec(full);
+        }
+        catch {
+            return null;
+        }
     }
+    return styled.replace(/\r\n/g, '\n').replace(/\r$/, '');
 }
 // The words to type for a herdr command, for a repair line.
 export function herdrCommand(session, ...args) {

package/dist/launch/agent.d.ts

@@ -0,0 +1 @@
+export declare function reportedLiveAgent(foreground: readonly string[] | null, processNames: readonly string[]): boolean;

package/dist/launch/agent.js

@@ -0,0 +1,13 @@
+// Herdr reports a live agent when one foreground argv0 is that CLI. An unreadable
+// pane, or the shell left after the CLI has exited, is not one: those are the panes
+// a nudge, a first message, or an exit must not be typed into.
+//
+// Null is not a live agent, so nothing is typed, and the watch's quota read asks this
+// same question: a figure is only read where the CLI was seen. `paneStillRunning`
+// reads that same null as still there — an unreadable list is not a departure — and
+// that reading is only for the departure wait in `down` and `remove`.
+export function reportedLiveAgent(foreground, processNames) {
+    if (!foreground || processNames.length === 0)
+        return false;
+    return foreground.some((name) => processNames.includes(name));
+}

package/dist/launch/deliver.d.ts

@@ -3,8 +3,14 @@ export interface Delivery {
     status(): string | null;
     type(text: string): boolean;
     enter(): boolean;
+    /** Foreground argv0 names, or null when the pane can't be read. */
+    foreground(): string[] | null;
     now(): number;
     sleep(ms: number): Promise<void>;
 }
+/** Whether the pane's box holds exactly `text` right now: an unsent composer, no fold marker, and
+ *  rows that read back as the text. The one check the watch's nudge and the exit typing share
+ *  with delivery — false for anything not observed, never `true` on trust. */
+export declare function boxHoldsText(cli: string, text: string, screen: string | undefined): boolean;
 /** A first message is accepted only after working is observed with the composer empty again. */
-export declare function deliverRules(cli: string, text: string, seconds: number, io: Delivery): Promise<boolean>;
+export declare function deliverRules(cli: string, text: string, seconds: number, io: Delivery): Promise<boolean | 'no-agent'>;

package/dist/launch/deliver.js

@@ -1,26 +1,178 @@
-import { classifyComposer, readScreen } from "../watch/screen.js";
+import { reportedLiveAgent } from "./agent.js";
+import { profileFor } from "../profiles/index.js";
+import { classifyComposer, readBox, readFold, readFoldMark, readScreen } from "../watch/screen.js";
+/** The rows a composer shows for `text` at `width` columns: a hard wrap, a line longer than the
+ *  width split into width-sized chunks, no word wrapping. The fold's tail and count are checked
+ *  against this model; the fixtures README names the same one. */
+function rowsOf(text, width) {
+    const rows = [];
+    for (const line of text.split('\n')) {
+        if (line.length === 0) {
+            rows.push('');
+            continue;
+        }
+        for (let at = 0; at < line.length; at += width)
+            rows.push(line.slice(at, at + width));
+    }
+    return rows;
+}
+/** Whether the folded box is exactly `text` at the width the box reports: its visible tail rows
+ *  are the text's last rows, and its hidden-row count closes the gap. Anything else is not the
+ *  typed text and gets no Enter. */
+function holdsText(text, fold) {
+    if (fold.width <= 0 || fold.rows.length === 0)
+        return false;
+    const all = rowsOf(text, fold.width);
+    if (fold.rows.length >= all.length)
+        return false;
+    if (fold.count !== all.length - fold.rows.length)
+        return false;
+    const tail = all.slice(-fold.rows.length);
+    return fold.rows.every((row, i) => row.trimEnd() === (tail[i] ?? '').trimEnd());
+}
+/** The whitespace a row break may stand for: the pane replaces it by the break, or adds the
+ *  continuation row's indentation where the text has none. */
+const BREAK = /[ \t\n\r]/;
+/** Where the text's next row starts after `pos`, or null when `row` is not the text's row there.
+ *  A row that is the text's at that very position is always read as such — that normalises
+ *  nothing. A `word` boundary additionally skips the whitespace run the pane broke at before the
+ *  row; a `hard` one reads the text's next characters as the row carries them; a composer with no
+ *  rule (`null`) reads either way, since no capture showed how that one wraps. Every character
+ *  inside a row must match the text as it is: only the row break may stand for whitespace. */
+function continues(text, pos, row, kind) {
+    if (text.startsWith(row, pos))
+        return pos + row.length;
+    if (kind === 'hard')
+        return null;
+    let at = pos;
+    while (at < text.length && BREAK.test(text[at] ?? ''))
+        at++;
+    return at > pos && text.startsWith(row, at) ? at + row.length : null;
+}
+/** Where a blank row sits in the typed text: the pane draws an empty row only for a blank line
+ *  the text itself has. The line's own content — nothing a box row shows, so only spaces and
+ *  tabs, which a pane need not paint — is consumed; an interior blank line ends at the next
+ *  newline, a blank last line ends with the text. A blank row anywhere else is not the text's
+ *  own and is refused, and a blank line the box does not show a row for is refused after the
+ *  last row (the trailing-newline check in `holdsBox`). */
+function blankLine(text, pos) {
+    if (text[pos] !== '\n')
+        return null;
+    let at = pos + 1;
+    while (at < text.length && (text[at] === ' ' || text[at] === '\t'))
+        at++;
+    return at === text.length || text[at] === '\n' ? at : null;
+}
+/** Whether the box shows exactly `text`: the first line after the prompt and every continuation
+ *  row at the box's own column — no more rows, no fewer, none changed. A continuation row that
+ *  does not start at that column is not the text's own row and the box is not trusted. Only the
+ *  whitespace a row break itself may stand for is normalised — the run a word break was made at,
+ *  or a blank line the text itself has — and inside a row every character must match, runs of
+ *  spaces included. A box that is not the text waits and is refused at the deadline, never
+ *  entered on trust. */
+function holdsBox(text, box) {
+    const pad = ' '.repeat(box.indent);
+    const rows = [];
+    for (const row of box.rows) {
+        if (row === '') {
+            rows.push('');
+            continue;
+        }
+        if (!row.startsWith(pad))
+            return false;
+        rows.push(row.slice(pad.length));
+    }
+    const kind = box.wrap?.kind ?? null;
+    const visual = [box.first, ...rows];
+    let at = 0;
+    for (let i = 0; i < visual.length; i++) {
+        const row = visual[i] ?? '';
+        if (i === 0) {
+            if (!text.startsWith(row))
+                return false;
+            at = row.length;
+            continue;
+        }
+        if (row === '') {
+            const next = blankLine(text, at);
+            if (next === null)
+                return false;
+            at = next;
+            continue;
+        }
+        const next = continues(text, at, row, kind);
+        if (next === null)
+            return false;
+        at = next;
+    }
+    // What is left after the box's last row. Trailing spaces and tabs are not observable in a
+    // box — a pane may not paint the end of a row — so they are not required to match. A newline
+    // is observable: it is the box's next row, and every row has been read above; one left over
+    // is a row the box does not show, and the box is not the typed text.
+    return /^[ \t]*$/.test(text.slice(at));
+}
+/** What the box holds right now: `ready` to submit, still rendering (`wait`), or a state that is
+ *  never the typed text (`no`). A folded box — and one showing a fold marker whatever its count —
+ *  is ready only when its tail and hidden-row count are the ones the text renders to at the width
+ *  the box reports. An ordinary box is ready only when its rows read back as exactly the text
+ *  typed; anything else waits, and a wait that outlives the deadline is a refusal, not an Enter. */
+function boxState(cli, text, screen) {
+    const kind = readScreen(cli, screen).kind;
+    const fold = readFold(cli, screen);
+    if (fold || readFoldMark(cli, screen)) {
+        if (kind !== 'unsent' && kind !== 'unknown')
+            return 'no';
+        return fold !== null && holdsText(text, fold) ? 'ready' : 'wait';
+    }
+    if (kind === 'unsent') {
+        const box = readBox(cli, screen);
+        return box !== null && holdsBox(text, box) ? 'ready' : 'wait';
+    }
+    return kind === 'idle' ? 'wait' : 'no';
+}
+/** Whether the pane's box holds exactly `text` right now: an unsent composer, no fold marker, and
+ *  rows that read back as the text. The one check the watch's nudge and the exit typing share
+ *  with delivery — false for anything not observed, never `true` on trust. */
+export function boxHoldsText(cli, text, screen) {
+    if (readFoldMark(cli, screen))
+        return false;
+    if (readScreen(cli, screen).kind !== 'unsent')
+        return false;
+    const box = readBox(cli, screen);
+    return box !== null && holdsBox(text, box);
+}
 /** A first message is accepted only after working is observed with the composer empty again. */
 export async function deliverRules(cli, text, seconds, io) {
+    const names = profileFor(cli)?.processNames ?? [];
+    const live = () => reportedLiveAgent(io.foreground(), names);
     const free = () => ['idle', 'done'].includes(io.status() ?? '');
+    if (!live())
+        return 'no-agent';
     if (!free() || readScreen(cli, io.screen()).kind !== 'idle' || !io.type(text))
         return false;
     const deadline = io.now() + seconds * 1000;
-    // Terminal rendering can lag send-text. Never send Enter until the pasted text is visible.
+    // Terminal rendering can lag send-text. Never press Enter until the box is verified to hold the
+    // text: an ordinary box reads `unsent`, and a box that folded the paste counts only when the
+    // tail and hidden-row count it shows are the ones the typed text renders to.
     for (;;) {
-        const kind = readScreen(cli, io.screen()).kind;
         if (!free())
             return false;
-        if (kind === 'unsent')
+        const state = boxState(cli, text, io.screen());
+        if (state === 'ready')
             break;
-        if (kind !== 'idle' || io.now() >= deadline)
+        if (state === 'no' || io.now() >= deadline)
             return false;
         const before = io.now();
         await io.sleep(100);
         if (io.now() <= before)
             return false;
     }
-    // Re-read immediately before Enter; a dialog that appeared after the paste gets no key.
-    if (!free() || readScreen(cli, io.screen()).kind !== 'unsent' || !io.enter())
+    // Re-read immediately before Enter. The agent is asked again: it may have exited since the
+    // paste, and a dialog that appeared gets no key; a folded box that no longer matches the text
+    // gets none either.
+    if (!live())
+        return 'no-agent';
+    if (!free() || boxState(cli, text, io.screen()) !== 'ready' || !io.enter())
         return false;
     for (;;) {
         const status = io.status();

package/dist/launch/execute.d.ts

@@ -11,11 +11,13 @@ export type Host = {
         workspace: string;
     } | null;
     paneRun(session: string, pane: string, command: string): boolean;
-    typeLine(session: string, pane: string, text: string): boolean;
-    deliverRules?(session: string, pane: string, cli: string, text: string, seconds: number): Promise<boolean>;
+    typeLine(session: string, pane: string, text: string): boolean | 'no-agent';
+    deliverRules?(session: string, pane: string, cli: string, text: string, seconds: number): Promise<boolean | 'no-agent'>;
     renameAgent(session: string, pane: string, name: string): boolean;
     closeWorkspace(session: string, workspace: string): boolean;
     stopSession(session: string): boolean;
+    /** Clears the session this run has just stopped. Present on `down` only: `up` never deletes. */
+    deleteSession?(session: string): boolean;
     kill(pid: number): boolean;
     /** Pane ids herdr lists an agent in, or null when the list can't be read. */
     agentPanes(session: string): string[] | null;

package/dist/launch/execute.js

@@ -29,14 +29,15 @@ export async function executePlan(steps, session, host) {
         host.say(`${seat}: ${what}\n`);
         host.log(seat, what);
     };
-    const place = (label, pane, workspace) => {
-        const have = places.get(label);
+    // The display label may be shared. The seat's name is the only key; the watch has no seat.
+    const place = (key, pane, workspace) => {
+        const have = places.get(key);
         if (have)
             return have;
         if (!pane)
             return null;
         const made = { pane, workspace };
-        places.set(label, made);
+        places.set(key, made);
         return made;
     };
     for (const step of steps) {
@@ -116,7 +117,7 @@ export async function executePlan(steps, session, host) {
                     }
                     break;
                 }
-                places.set(op.label, made);
+                places.set(op.seat ?? op.label, made);
                 if (op.seat) {
                     host.record(op.seat, { stage: 'launched', pane: made.pane, workspace: made.workspace });
                     host.running(op.seat);
@@ -132,7 +133,7 @@ export async function executePlan(steps, session, host) {
                     finish(op.seat, why);
                     break;
                 }
-                const here = place(op.label, op.pane);
+                const here = place(op.seat, op.pane);
                 if (!here || !host.paneRun(session, here.pane, op.command)) {
                     dropped.add(op.seat);
                     finish(op.seat, 'its launch command did not run; left at launched');
@@ -144,7 +145,7 @@ export async function executePlan(steps, session, host) {
             case 'idle': {
                 if (op.notice)
                     host.say(`${op.seat}: ${op.notice}\n`);
-                const here = place(op.label, op.pane, op.workspace);
+                const here = place(op.seat, op.pane, op.workspace);
                 if (!here) {
                     dropped.add(op.seat);
                     finish(op.seat, 'has no pane to read; left at launched');
@@ -167,7 +168,7 @@ export async function executePlan(steps, session, host) {
                 }
                 if (outcome === 'idle')
                     break;
-                const workspace = here.workspace ?? places.get(op.label)?.workspace;
+                const workspace = here.workspace ?? places.get(op.seat)?.workspace;
                 if (outcome === 'permission' || outcome === 'trust' || outcome === 'question') {
                     // A trust question is closed with no key and no text. The same for a permission or a question.
                     if (workspace)
@@ -185,7 +186,7 @@ export async function executePlan(steps, session, host) {
                 break;
             }
             case 'rename': {
-                const here = place(op.label, op.pane);
+                const here = place(op.seat, op.pane);
                 if (!here) {
                     dropped.add(op.seat);
                     finish(op.seat, 'has no pane to name; left at launched');
@@ -207,8 +208,14 @@ export async function executePlan(steps, session, host) {
             case 'deliver': {
                 if (op.notice)
                     host.say(`${op.seat}: ${op.notice}\n`);
-                const here = place(op.label, op.pane);
-                if (!here || !await host.deliverRules?.(session, here.pane, op.cli, op.rules, op.seconds)) {
+                const here = place(op.seat, op.pane);
+                const delivered = here ? await host.deliverRules?.(session, here.pane, op.cli, op.rules, op.seconds) : false;
+                if (delivered === 'no-agent') {
+                    dropped.add(op.seat);
+                    finish(op.seat, 'no live agent in its pane; its rules were not delivered');
+                    break;
+                }
+                if (!here || !delivered) {
                     dropped.add(op.seat);
                     finish(op.seat, 'its rules were not delivered; left at named');
                     break;
@@ -230,7 +237,14 @@ export async function executePlan(steps, session, host) {
                 break;
             }
             case 'type': {
-                if (!host.typeLine(session, op.pane, op.text)) {
+                const typed = host.typeLine(session, op.pane, op.text);
+                if (typed === 'no-agent') {
+                    held = true;
+                    dropped.add(op.seat);
+                    finish(op.seat, 'no live agent in its pane; its exit was not typed');
+                    break;
+                }
+                if (!typed) {
                     held = true;
                     dropped.add(op.seat);
                     finish(op.seat, 'its exit was not typed; left as it is');
@@ -270,10 +284,19 @@ export async function executePlan(steps, session, host) {
                     host.say(`session ${op.session}: not stopped, something was left in it\n`);
                     break;
                 }
-                if (!host.stopSession(op.session))
+                if (!host.stopSession(op.session)) {
                     host.say(`session ${op.session}: it did not stop\n`);
-                else
+                    break;
+                }
+                // Without a `deleteSession` the stop is the whole step. `down` goes one further and clears
+                // the session it has itself just stopped; a clear that does not happen names the command.
+                if (host.deleteSession === undefined)
                     host.say(`session ${op.session}: stopped\n`);
+                else if (host.deleteSession(op.session))
+                    host.say(`session ${op.session}: stopped and cleared\n`);
+                else {
+                    host.say(`session ${op.session}: stopped; it did not clear, run \`herdr session delete ${op.session}\`\n`);
+                }
                 break;
             }
             default:

package/dist/launch/plan.js

@@ -46,7 +46,7 @@ export function upPlan(input) {
             steps.push({ kind: 'skip', text: `${seat.name}: already ready; left as it is` });
             continue;
         }
-        const pane = seat.pane ?? paneOf(seat.label);
+        const pane = seat.pane ?? paneOf(seat.name);
         const cwd = join(input.root, seat.cwd);
         const fresh = seat.stage === undefined || !seat.pane;
         // The same condition as the launch step below. A seat already running keeps
@@ -202,6 +202,15 @@ export function downPlan(input) {
                 });
                 continue;
             }
+            if (seat.cli === 'unknown') {
+                steps.push({
+                    kind: 'skip',
+                    text: `${seat.name}: the state doesn't say which CLI it runs, so it can't be asked to exit; ` +
+                        'left running (`team down --abandon` closes it without typing)',
+                });
+                left++;
+                continue;
+            }
             steps.push({
                 kind: 'skip',
                 text: `${seat.name}: no launch profile for \`${seat.cli}\` in this version; left running`,
@@ -259,7 +268,12 @@ export function downPlan(input) {
         });
     }
     else {
-        steps.push({ kind: 'run', argv: ['herdr', 'session', 'stop', session], do: { do: 'stop', session } });
+        steps.push({
+            kind: 'run',
+            argv: ['herdr', 'session', 'stop', session],
+            note: 'stopped, then cleared: the session this run stopped, so a later `up` starts from the beginning',
+            do: { do: 'stop', session },
+        });
     }
     return steps;
 }

package/dist/launch/rules.d.ts

@@ -21,5 +21,7 @@ export interface RulesInput {
  * workspace's.
  */
 export declare function seatRules(input: RulesInput): string[];
-/** The rules as the one text a launch option or a first message carries. */
-export declare function rulesText(input: RulesInput): string;
+/** How the rules reach a seat: typed as its first message, or carried as a launch option. */
+export type RulesDelivery = 'message' | 'option';
+/** The rules as the one text a launch option or a first message carries, the closing line last. */
+export declare function rulesText(input: RulesInput, delivery: RulesDelivery): string;

package/dist/launch/rules.js

@@ -30,7 +30,21 @@ export function seatRules(input) {
     }
     return [...own, ...input.rules, ...signing, ...working];
 }
-/** The rules as the one text a launch option or a first message carries. */
-export function rulesText(input) {
-    return ['Rules for this session, from the team file:', ...seatRules(input).map((rule) => `- ${rule}`)].join('\n');
+/**
+ * The line each form ends with. The message says what the rules are and never that they are not a
+ * task, so some models start complying by investigating instead of waiting for a brief. A first
+ * message is answered once, so it can ask for the ready reply; a system prompt (a launch option)
+ * stays in force on every later turn, so it must not: a Claude seat could answer "ready" to its
+ * real brief.
+ */
+const CLOSING = {
+    message: 'These are standing rules, not a task: reply ready and wait for your brief.',
+    option: 'These are standing rules, not a task.',
+};
+/** The rules as the one text a launch option or a first message carries, the closing line last. */
+export function rulesText(input, delivery) {
+    // A file whose own rules already carry the form's closing line gets it once: as the closing line.
+    const closing = CLOSING[delivery];
+    const rules = seatRules(input).filter((rule) => rule !== closing);
+    return ['Rules for this session, from the team file:', ...rules.map((rule) => `- ${rule}`), closing].join('\n');
 }

package/dist/profiles/antigravity.yaml

@@ -43,6 +43,12 @@ screen:
           - 'Do you trust the contents of this project\?'
           - '>\s*Yes, I trust this folder'
         below_last_rule: 'enter Confirm'
+      # The captured trust dialog fills the pane: there is no composer rule.
+      - all:
+          - 'Do you trust the contents of this project\?'
+          - '>\s*Yes, I trust this folder'
+          - 'enter Confirm'
+        without_rule: true
   permission:
     ignore_case: true
     rules:
@@ -50,13 +56,30 @@ screen:
           - 'Requesting permission for:'
           - '^\s*>\s*[0-9]\.\s+Yes\b'
         below_last_rule: '↑/↓ Navigate'
+      # A long command pushes the one rule out of the window. The dialog is the
+      # three lines, with no composer rule left to sit below.
+      - all:
+          - 'Requesting permission for:'
+          - '^\s*>\s*[0-9]\.\s+Yes\b'
+          - '↑/↓ Navigate'
+        without_rule: true
   working:
     - any: ['\bGenerating\.\.\.']
   composer:
     mode: two-rules-footer-below
     ignore_case: true
-    prompt: '^\s*>\s*'
-    rule: '^\s*[─━]{8,}\s*$'
+    # The input row is the box's first row under its opening rule, carrying the prompt at the
+    # pane's first column — unsent.txt draws `> Rules...` there, content at the second — and a
+    # prompt glyph on a continuation row is content, never the input row. The reader anchors
+    # this pattern to the captured column.
+    prompt: '^>\s*'
+    # Both rules are unbroken runs of ─ from the pane's first column (unsent.txt draws them at
+    # rows 7 and 12). A rule-looking row the box holds is drawn at the content column and is
+    # content, never the frame.
+    rule: '^[─━]{8,}\s*$'
+    # A long paste folds: the row reads `↑ N more lines` (with the prompt glyph on the
+    # input row's own marker), the rows below it are the tail. Capture 1 is N.
+    fold: '^\s*(?:>\s*)?↑\s*([0-9]+)\s+more lines\s*$'
     footers:
       - '\? for shortcuts'
       - 'Gemini\s+[0-9]'