team 0.1.0 → 0.1.2

package/dist/commands/up.js

@@ -7,7 +7,7 @@ import { readArgs } from "../args.js";
 import { callerOf, describeCaller, isOwner } from "../caller.js";
 import { loadTeamFile } from "../file/load.js";
 import { renderSignature } from "../file/signature.js";
-import { agentList, agentStatus, agentRename, paneRead, paneRun, typeText, pressEnter, sessionRunning, sessionState, startServer, workspaceClose, workspaceCreate, workspaceList, } from "../herdr.js";
+import { agentList, agentStatus, agentRename, paneForeground, paneRead, paneRun, typeText, pressEnter, sessionRunning, sessionState, startServer, workspaceClose, workspaceCreate, workspaceList, } from "../herdr.js";
 import { executePlan } from "../launch/execute.js";
 import { formatPlan, upPlan } from "../launch/plan.js";
 import { rulesText } from "../launch/rules.js";
@@ -18,7 +18,7 @@ import { profileFor } from "../profiles/index.js";
 import { readApproval, storePath } from "../store/store.js";
 import { emptySession, readState, updateState } from "../state.js";
 import { seatBudget } from "../budgets/gate.js";
-import { loadReadings } from "../budgets/readings.js";
+import { loadReadings, loadSpendReadings } from "../budgets/readings.js";
 import { blocksLaunch, doctorFindings, realSources as doctorSources } from "./doctor.js";
 import { launchLimit, readMachine } from "../watch/machine.js";
 import { readScreen } from "../watch/screen.js";
@@ -49,6 +49,7 @@ const realLaunch = {
     typeText: (session, pane, text) => typeText(pane, text, aim(session)),
     pressEnter: (session, pane) => pressEnter(pane, aim(session)),
     agentStatus: (session, pane) => agentStatus(pane, aim(session)),
+    foreground: (session, pane) => paneForeground(pane, aim(session)),
     sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     now: () => new Date(),
 };
@@ -77,9 +78,11 @@ export const realSources = {
 export const USAGE = 'Usage: team up [--dry-run] [--session <name>] [--file <path>]\n';
 export const up = (argv, io) => runUp(argv, io, realSources);
 export default up;
-/** The rules one seat gets at launch, with its own signature lines. */
+/** The rules one seat gets at launch, with its own signature lines, as its delivery carries them. */
 export function rulesOf(team, seat) {
     const { commits, pullRequests } = team.identity.signature;
+    const profile = profileFor(seat.cli);
+    const delivery = profile && profile.rulesOption !== null ? 'option' : 'message';
     return rulesText({
         coordinator: team.coordinator,
         rules: team.rules,
@@ -89,7 +92,7 @@ export function rulesOf(team, seat) {
             commitPosition: commits.position,
         },
         workspace: { mode: seat.mode, protected: team.workspace.protected, branch: team.workspace.branch },
-    });
+    }, delivery);
 }
 function resolveState(sources, session) {
     if (sources.sessionState)
@@ -208,7 +211,8 @@ export async function runUp(argv, io, sources) {
     }
     const recorded = readState(dir).sessions[session];
     const workspaces = sources.workspaces?.(session) ?? null;
-    const readings = loadReadings(dir, session);
+    const readings = loadReadings(dir);
+    const spend = loadSpendReadings(dir);
     const seats = [];
     const refused = new Set();
     for (const seat of team.seats) {
@@ -221,7 +225,7 @@ export async function runUp(argv, io, sources) {
         }
         const placed = planned.stage === undefined || !planned.pane;
         if (!placed) {
-            const budget = seatBudget(budgets, readings, seat, readAt());
+            const budget = seatBudget(budgets, readings, seat, readAt(), spend);
             seats.push({ ...planned, ...(budget.kind === 'clear' ? {} : { budget }) });
             continue;
         }
@@ -233,7 +237,7 @@ export async function runUp(argv, io, sources) {
             }
             continue;
         }
-        const budget = seatBudget(budgets, readings, seat, readAt());
+        const budget = seatBudget(budgets, readings, seat, readAt(), spend);
         seats.push({
             ...planned,
             cwd: start.cwd,
@@ -304,6 +308,7 @@ export async function runUp(argv, io, sources) {
             status: () => launch.agentStatus?.(session, pane) ?? null,
             type: (value) => launch.typeText?.(session, pane, value) ?? false,
             enter: () => launch.pressEnter?.(session, pane) ?? false,
+            foreground: () => launch.foreground(session, pane),
             now: () => now().getTime(),
             sleep: sources.sleep ?? launch.sleep,
         }),

package/dist/commands/watch.d.ts

@@ -14,6 +14,8 @@ export type WatchSources = {
     readChecks(team: TeamFile, root: string, now: number): CheckOutcome[];
     screen(pane: string, session: string): string | null;
     status(pane: string, session: string): string | null;
+    /** Foreground argv0 names, or null when the pane can't be read. */
+    foreground(pane: string, session: string): string[] | null;
     typeText(pane: string, text: string, session: string): boolean;
     pressEnter(pane: string, session: string): boolean;
     notify(text: string): void;

package/dist/commands/watch.js

@@ -1,10 +1,11 @@
 import { readArgs } from "../args.js";
 import { budgetsInForce, watchInForce } from "../approve/approval.js";
-import { saveReadings } from "../budgets/readings.js";
+import { callerOf, describeCaller, isOwner } from "../caller.js";
+import { loadReadings, saveSpendReadings, updateReadings } from "../budgets/readings.js";
 import { runChecks } from "../budgets/run.js";
 import { currentTeam } from "../file/current.js";
 import { homedir } from 'node:os';
-import { agentStatus, paneRead, pressEnter, typeText } from "../herdr.js";
+import { agentStatus, paneForeground, paneRead, pressEnter, typeText } from "../herdr.js";
 import { logLine } from "../log.js";
 import { emptySession, readState, updateState } from "../state.js";
 import { readMachine } from "../watch/machine.js";
@@ -13,9 +14,11 @@ import { newMemory, pass } from "../watch/pass.js";
 import { readScreen } from "../watch/screen.js";
 import { judgeTemporary, judgeWorktree } from "../watch/close.js";
 import { readEnd } from "../watch/end.js";
+import { reportedLiveAgent } from "../launch/agent.js";
 import { stopRunning, realSources as removeSources } from "./remove.js";
 import { removeWorktree } from "./worktree.js";
 import { stateOf } from "./down.js";
+import { profileFor } from "../profiles/index.js";
 import { realSources } from "./status.js";
 function waitOrStop(seconds) {
     return new Promise((done) => {
@@ -41,6 +44,7 @@ export const realWatchSources = {
     readChecks: (team, root, now) => runChecks(team, root, now),
     screen: (pane, session) => paneRead(pane, 14, session),
     status: agentStatus,
+    foreground: (pane, session) => paneForeground(pane, session),
     typeText,
     pressEnter,
     notify,
@@ -74,17 +78,30 @@ export async function runWatch(argv, io, sources) {
     }
     const session = args.values.session ?? first.team.session;
     const { dir } = first;
+    // A seat that starts the session's only watch must not be able to drop the operator's nudge
+    // or the operator's desktop notices. The owner's own `--no-notify` still cannot silence a
+    // report addressed to the owner: those are routed below.
+    if (args.flags.has('no-nudge') || args.flags.has('no-notify')) {
+        const caller = callerOf(io, session);
+        if (!isOwner(caller)) {
+            io.stderr(`team watch: --no-nudge and --no-notify are the owner's, from a terminal outside herdr; this call is ${describeCaller(caller)}\n`);
+            return 1;
+        }
+    }
     const other = readState(dir).sessions[session]?.watch;
     if (other && other.pid !== sources.pid && sources.alive(other.pid)) {
         io.stderr(`team watch: a watch already runs for the session "${session}" (pid ${other.pid})\n`);
         return 1;
     }
-    const say = (text, desktop) => {
+    // The log line is written for every report. `--no-notify` never removes it, and it never
+    // removes a desktop notice addressed to the owner. It does silence every other notice.
+    const tell = (text, notify) => {
         io.stdout(`${sources.now().toISOString()} ${text}\n`);
         logLine(dir, 'watch', 'watch', text, sources.now());
-        if (desktop && !args.flags.has('no-notify'))
+        if (notify)
             sources.notify(text);
     };
+    const say = (text, desktop) => tell(text, desktop && !args.flags.has('no-notify'));
     const beat = () => updateState(dir, (state) => {
         const record = (state.sessions[session] ??= emptySession());
         record.watch = { pid: sources.pid, heartbeat: sources.now().toISOString() };
@@ -106,7 +123,16 @@ export async function runWatch(argv, io, sources) {
             if (problem !== notice) {
                 notice = problem;
                 if (problem)
-                    say(problem, true);
+                    tell(problem, true);
+            }
+            // Only the watch of the file's own session saves readings. A watch on another session —
+            // anyone may run one, from any terminal — reads and reports, but the figures it sees are
+            // not the project's cache that `up` and `add` count (§ 4.4): it says so once and writes
+            // none, budget or spend.
+            const foreign = session !== team.session;
+            if (foreign && !told.has('foreign-session')) {
+                told.add('foreign-session');
+                say(`the session "${session}" is not this file's "${team.session}": its readings are not saved`, false);
             }
             // The values in force, read with the file: until the owner approves an edit to `watch`,
             // the watch keeps running with what was approved, or with the defaults.
@@ -117,7 +143,7 @@ export async function runWatch(argv, io, sources) {
             const live = sources.live(session, team);
             if (!live) {
                 if (!silent)
-                    say('herdr doesn\'t answer; the watch keeps trying', true);
+                    tell('herdr doesn\'t answer; the watch keeps trying', true);
                 silent = true;
             }
             else {
@@ -131,6 +157,11 @@ export async function runWatch(argv, io, sources) {
                 if (checksAt === null || now - checksAt >= budget.checkEvery * 1000) {
                     checksAt = now;
                     outcomes = sources.readChecks(team, root, now);
+                    // The money a spend check counted is kept, like the pass's screen readings: the launch
+                    // gate of `up` and `add` reads it later, and one that is stale by then reads unknown
+                    // (§ 5). An account whose check did not run keeps its stored reading.
+                    if (!foreign)
+                        saveSpendReadings(dir, spendOf(outcomes));
                     for (const outcome of outcomes) {
                         const key = `check:${outcome.account}`;
                         if (outcome.state === 'read') {
@@ -145,18 +176,30 @@ export async function runWatch(argv, io, sources) {
                             : `the check for ${outcome.account} is unapproved; that account reads unknown`, false);
                     }
                 }
-                const result = pass(team, state, live, sources.machine(root), now, memory, sources.approval(team, root), inForce, outcomes, budget);
+                const run = (stored) => pass({
+                    team, state, live, machine: sources.machine(root), now, memory,
+                    approval: sources.approval(team, root), watch: inForce, outcomes, budgets: budget,
+                    readings: stored,
+                });
+                // The pass folds its figures where the state is held: two watches of the project fold one
+                // after the other, not over each other. A watch on a foreign session still folds, for its
+                // reports, and saves nothing.
+                const result = foreign
+                    ? run(loadReadings(dir))
+                    : updateReadings(dir, now, (stored) => {
+                        const folded = run(stored);
+                        return { readings: folded.readings, value: folded };
+                    });
                 for (const report of result.reports)
-                    say(report.text, true);
-                saveReadings(dir, session, result.readings, now);
+                    tell(report.text, report.to === 'owner' || !args.flags.has('no-notify'));
                 if (result.nudge) {
                     if (args.flags.has('no-nudge'))
                         say(`nudge not typed (--no-nudge): ${result.nudge.text}`, false);
                     else
-                        deliver(result.nudge, team, session, sources, memory, say);
+                        deliver(result.nudge, team, session, sources, memory, say, tell, told);
                 }
                 if (result.fallback)
-                    say(result.fallback, true);
+                    tell(result.fallback, true);
                 await closeEnded({ team, root, dir, session, live, sources, say, io, told });
             }
             beat();
@@ -170,13 +213,28 @@ export async function runWatch(argv, io, sources) {
             if (record?.watch?.pid === sources.pid)
                 delete record.watch;
         });
-        say(`the watch of "${session}" stopped`, true);
+        tell(`the watch of "${session}" stopped`, true);
     }
     return 0;
 }
+/** The spend readings among a pass's check outcomes, for the state. */
+function spendOf(outcomes) {
+    const list = [];
+    for (const outcome of outcomes) {
+        if (outcome.state !== 'read' || outcome.reading.kind !== 'spend')
+            continue;
+        list.push({
+            account: outcome.account,
+            amount: outcome.reading.amount,
+            currency: outcome.reading.currency,
+            at: outcome.reading.at,
+        });
+    }
+    return list;
+}
 // Types the nudge, after reading the operator's screen once more: the pass saw it free, and a
 // prompt may have appeared since. Anything but an empty idle prompt keeps the nudge pending.
-function deliver(nudge, team, session, sources, memory, say) {
+function deliver(nudge, team, session, sources, memory, say, tell, told) {
     const cli = team.seats.find((seat) => seat.name === team.operator)?.cli ?? '';
     const look = () => readScreen(cli, sources.screen(nudge.pane, session) ?? undefined).kind;
     const status = sources.status(nudge.pane, session);
@@ -186,15 +244,29 @@ function deliver(nudge, team, session, sources, memory, say) {
         memory.pending.push(...nudge.pending);
         memory.pendingSince ??= sources.now().getTime();
     };
+    const names = profileFor(cli)?.processNames ?? [];
+    const live = () => reportedLiveAgent(sources.foreground(nudge.pane, session), names);
+    const noAgent = 'nudge:no-agent';
+    if (!live()) {
+        tellOnce(told, noAgent, 'a nudge was not typed: no live agent in the operator\'s pane', tell);
+        keep();
+        return;
+    }
+    told.delete(noAgent);
     if ((status !== 'idle' && status !== 'done') || look() !== 'idle' || !sources.typeText(nudge.pane, nudge.text, session)) {
         keep();
         return;
     }
-    // The text is in the box. A dialog that opened meanwhile must not get the Enter: the text
-    // then stays unsent, which the next passes report, and the nudge is kept.
+    // The text is in the box. The agent is read again before Enter: it may have exited
+    // since the text was typed, and an unframed line is not a box to send.
+    if (!live()) {
+        tellOnce(told, noAgent, 'a nudge was not typed: no live agent in the operator\'s pane', tell);
+        keep();
+        return;
+    }
     const after = look();
     if (after !== 'idle' && after !== 'unsent') {
-        say('a nudge was typed and not sent: the operator\'s screen changed before the Enter', true);
+        tell('a nudge was typed and not sent: the operator\'s screen changed before the Enter', true);
         keep();
         return;
     }
@@ -203,6 +275,12 @@ function deliver(nudge, team, session, sources, memory, say) {
     else
         keep();
 }
+function tellOnce(told, key, text, tell) {
+    if (told.has(key))
+        return;
+    told.add(key);
+    tell(text, true);
+}
 function noteWorked(dir, session, live) {
     const recorded = readState(dir).sessions[session];
     if (!recorded)

package/dist/file/types.d.ts

@@ -24,6 +24,11 @@ export type Seat = {
     name: string;
     cli: string;
     vendor: string;
+    /**
+     * The account whose budget this seat spends, when one vendor has two (RFC 0003 § 3b). Absent
+     * means the vendor is the account; a seat that names one spends it instead of the vendor.
+     */
+    account?: string;
     model: string;
     version: string;
     display: string;

package/dist/file/validate.js

@@ -175,15 +175,18 @@ function readTeam(root, check) {
             check.fail(item.line, `trust: "${item.value}" ${problem}`);
     }
     const trust = trustItems.map((item) => item.value);
+    // Both are read before the seats: a seat's `account:` must be a key of the budgets' accounts,
+    // and the check needs the names the file declares.
+    const watched = readWatch(top.get('watch'), check);
+    const budget = readBudgets(top.get('budgets'), check, watched.watch.quotaMarks, watched.legacyMarks);
     const broken = new Set();
-    const seats = readSeats(top.get('seats'), check, trust, root.line, broken);
+    const seats = readSeats(top.get('seats'), check, trust, root.line, broken, budget.declared);
     const workspace = readWorkspace(top.get('workspace'), check, project, trust, seats, root.line);
     for (const seat of seats)
         seat.mode ??= workspace.mode;
     const coordinator = readLead(top.get('coordinator'), 'coordinator', seats, broken, check);
     const operator = readLead(top.get('operator'), 'operator', seats, broken, check);
     const limits = readLimits(top.get('limits'), check, seats.length);
-    const watched = readWatch(top.get('watch'), check);
     return {
         format: 1,
         project,
@@ -197,7 +200,7 @@ function readTeam(root, check) {
         trust,
         workspace,
         watch: watched.watch,
-        budgets: readBudgets(top.get('budgets'), check, watched.watch.quotaMarks, watched.legacyMarks),
+        budgets: budget.budgets,
         machine: readMachine(top.get('machine'), check),
         limits,
         seats: seats,
@@ -287,8 +290,9 @@ function readPatterns(entry, name, check) {
     return out;
 }
 // `broken` collects the names of seats left out for their own problems, so that a reference to
-// one is not reported a second time.
-function readSeats(entry, check, trust, topLine, broken) {
+// one is not reported a second time. `accounts` is the names the file's budgets declare: a seat
+// that names an `account:` must name one of these, or it would silently spend nothing budgeted.
+function readSeats(entry, check, trust, topLine, broken, accounts) {
     if (!entry) {
         check.fail(topLine, 'seats is required: at least the coordinator\'s and the operator\'s seat');
         return [];
@@ -300,7 +304,7 @@ function readSeats(entry, check, trust, topLine, broken) {
     const seats = [];
     for (const item of entry.value.items) {
         const fields = check.fields(item, 'a seat', [
-            'role', 'name', 'cli', 'vendor', 'model', 'version', 'display', 'launch', 'cwd', 'label', 'mode',
+            'role', 'name', 'cli', 'vendor', 'account', 'model', 'version', 'display', 'launch', 'cwd', 'label', 'mode',
             'parked', 'stopped', 'count',
         ]);
         if (item.kind !== 'map')
@@ -316,6 +320,14 @@ function readSeats(entry, check, trust, topLine, broken) {
             check.fail(line, `${at}: cli is required`);
         const cli = check.oneOf(fields.get('cli'), `${at}: cli`, CLIS);
         const vendor = check.required(fields.get('vendor'), `${at}: vendor`, line);
+        // The account whose budget the seat spends, when the vendor's name is not it (§ 3b). Optional:
+        // absent, the seat spends its vendor, and the fingerprint of every file written so far is
+        // unchanged. Named, it must be one of the budgets' accounts: a typo would take the seat out of
+        // every budget with no warning at all.
+        const account = check.text(fields.get('account'), `${at}: account`);
+        if (account !== undefined && !accounts.has(account)) {
+            check.fail(fields.get('account')?.line ?? line, `${at}: account "${account}" is not in budgets.accounts`);
+        }
         const model = check.required(fields.get('model'), `${at}: model`, line);
         const version = readVersion(fields.get('version'), at, line, check);
         const launch = check.required(fields.get('launch'), `${at}: launch`, line);
@@ -343,6 +355,7 @@ function readSeats(entry, check, trust, topLine, broken) {
                 declared: name,
                 count,
                 instance,
+                ...(account ? { account } : {}),
                 ...(mode ? { mode } : {}),
             });
         }
@@ -545,17 +558,24 @@ export function defaultBudgets() {
 function readBudgets(entry, check, fallbackMarks, legacyMarks) {
     const base = { ...defaultBudgets(), marks: fallbackMarks };
     if (!entry)
-        return base;
+        return { budgets: base, declared: new Set() };
     const fields = check.fields(entry.value, 'budgets', ['stale_after', 'check_every', 'marks', 'accounts']);
+    // Every name the accounts map writes, whether or not the account itself reads cleanly: a seat
+    // naming one of these is not also told it named nothing.
+    const accounts = fields.get('accounts');
+    const declared = new Set(accounts?.value.kind === 'map' ? accounts.value.entries.map((account) => account.key) : []);
     const marks = percentList(fields.get('marks'), 'budgets.marks', check);
     if (marks && legacyMarks) {
         check.warnings.push({ line: fields.get('marks')?.line ?? entry.line, message: 'budgets.marks replaces watch.quota_marks' });
     }
     return {
-        staleAfter: check.measure(fields.get('stale_after'), 'budgets.stale_after', DURATION, '30m') ?? base.staleAfter,
-        checkEvery: check.measure(fields.get('check_every'), 'budgets.check_every', DURATION, '10m') ?? base.checkEvery,
-        marks: marks ?? fallbackMarks,
-        accounts: readAccounts(fields.get('accounts'), check),
+        budgets: {
+            staleAfter: check.measure(fields.get('stale_after'), 'budgets.stale_after', DURATION, '30m') ?? base.staleAfter,
+            checkEvery: check.measure(fields.get('check_every'), 'budgets.check_every', DURATION, '10m') ?? base.checkEvery,
+            marks: marks ?? fallbackMarks,
+            accounts: readAccounts(fields.get('accounts'), check),
+        },
+        declared,
     };
 }
 function percentList(entry, name, check) {

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,9 @@ 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 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;
@@ -175,15 +179,40 @@ export function sessionStop(name) {
     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,12 @@
+// 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. `paneStillRunning` reads that same
+// null as still there — an unreadable list is not a departure, and the quota work
+// on fix/quota-live-agent keeps that reading. The two questions stay separate.
+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,10 @@ 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>;
 }
 /** 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,7 +1,13 @@
+import { reportedLiveAgent } from "./agent.js";
+import { profileFor } from "../profiles/index.js";
 import { classifyComposer, readScreen } from "../watch/screen.js";
 /** 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;
@@ -19,7 +25,10 @@ export async function deliverRules(cli, text, seconds, io) {
         if (io.now() <= before)
             return false;
     }
-    // Re-read immediately before Enter; a dialog that appeared after the paste gets no key.
+    // 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.
+    if (!live())
+        return 'no-agent';
     if (!free() || readScreen(cli, io.screen()).kind !== 'unsent' || !io.enter())
         return false;
     for (;;) {

package/dist/launch/execute.d.ts

@@ -11,8 +11,8 @@ 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;

package/dist/launch/execute.js

@@ -208,7 +208,13 @@ export async function executePlan(steps, session, host) {
                 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 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 +236,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');

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;