team 0.1.0 → 0.1.1

package/README.md

@@ -18,7 +18,7 @@ Node 22 or later runs the built command.
 
 ```sh
 npm install -g team       # or run it without installing: npx team
-team --version            # 0.1.0
+team --version            # 0.1.1
 ```
 
 ## The file is private to each clone
@@ -249,7 +249,7 @@ cd team
 bun install
 bun run build
 npm install -g .          # puts `team` on the PATH
-team --version            # 0.1.0
+team --version            # 0.1.1
 ```
 
 Bun builds and tests the sources:

package/dist/budgets/gate.d.ts

@@ -1,5 +1,5 @@
 import type { Seat, TeamFile } from '../file/types.ts';
-import { type Seen } from './readings.ts';
+import { type Seen, type SpendReading } from './readings.ts';
 export type LaunchDecision = {
     kind: 'clear';
 } | {
@@ -13,8 +13,12 @@ export type LaunchDecision = {
 /**
  * The seat's account is its vendor. There is no separate account field on a seat. `budgets` is
  * the section in force: an unapproved edit to a reserve refuses no one until it is approved,
- * and an account only the unapproved edit names is not an account at all.
+ * and an account only the unapproved edit names is not an account at all. `spend` holds the
+ * stored spend check readings; a subscription account never looks at them.
  */
-export declare function seatBudget(budgets: TeamFile['budgets'], readings: readonly Seen[], seat: Seat, now: number): LaunchDecision;
-/** Subscription accounts whose counted windows are all outside the reserve. */
-export declare function accountsWithRoom(budgets: TeamFile['budgets'], readings: readonly Seen[], now: number): string[];
+export declare function seatBudget(budgets: TeamFile['budgets'], readings: readonly Seen[], seat: Seat, now: number, spend?: readonly SpendReading[]): LaunchDecision;
+/**
+ * Accounts whose counted figures leave room: a subscription with every counted window outside
+ * its reserve, a spend account with a fresh reading above its floor.
+ */
+export declare function accountsWithRoom(budgets: TeamFile['budgets'], readings: readonly Seen[], now: number, spend?: readonly SpendReading[]): string[];

package/dist/budgets/gate.js

@@ -3,15 +3,31 @@ const RANK = { session: 0, daily: 1, weekly: 2 };
 /**
  * The seat's account is its vendor. There is no separate account field on a seat. `budgets` is
  * the section in force: an unapproved edit to a reserve refuses no one until it is approved,
- * and an account only the unapproved edit names is not an account at all.
+ * and an account only the unapproved edit names is not an account at all. `spend` holds the
+ * stored spend check readings; a subscription account never looks at them.
  */
-export function seatBudget(budgets, readings, seat, now) {
+export function seatBudget(budgets, readings, seat, now, spend = []) {
     const name = seat.vendor;
     const account = budgets.accounts[name];
     if (!account)
         return { kind: 'clear' };
-    if (account.kind === 'spend')
-        return { kind: 'unknown', account: name, text: `${name} is unknown` };
+    if (account.kind === 'spend') {
+        const floor = account.floor;
+        const reading = spend.find((item) => item.account === name);
+        // § 5's freshness rule for a check reading, applied to the floor: a reading with no floor to
+        // measure against, one read longer ago than `stale_after`, and one in another currency than
+        // the floor's are the same answer — unknown, said, never a refusal.
+        if (!floor || !reading || reading.currency !== floor.currency || now - reading.at >= budgets.staleAfter * 1000) {
+            return { kind: 'unknown', account: name, text: `${name} is unknown` };
+        }
+        if (reading.amount > floor.amount)
+            return { kind: 'clear' };
+        const room = accountsWithRoom(budgets, readings, now, spend).filter((accountName) => accountName !== name);
+        return {
+            kind: 'refuse',
+            why: `${name} spend ${money(reading.amount)} ${reading.currency}, at or below its ${money(floor.amount)} ${floor.currency} floor, read ${age(now - reading.at)} ago; accounts with room: ${room.length ? room.join(', ') : 'none'}`,
+        };
+    }
     const staleAfterMs = budgets.staleAfter * 1000;
     const mine = readings.filter((item) => item.account === name);
     let unknown = mine.length === 0;
@@ -52,12 +68,23 @@ export function seatBudget(budgets, readings, seat, now) {
         return { kind: 'unknown', account: name, text: `${name}: first sight only, not yet counted` };
     return { kind: 'clear' };
 }
-/** Subscription accounts whose counted windows are all outside the reserve. */
-export function accountsWithRoom(budgets, readings, now) {
+/**
+ * Accounts whose counted figures leave room: a subscription with every counted window outside
+ * its reserve, a spend account with a fresh reading above its floor.
+ */
+export function accountsWithRoom(budgets, readings, now, spend = []) {
     const staleAfterMs = budgets.staleAfter * 1000;
     const names = [];
     for (const [name, account] of Object.entries(budgets.accounts)) {
-        if (account.kind !== 'subscription' || account.reserve === null)
+        if (account.kind === 'spend') {
+            const floor = account.floor;
+            const reading = spend.find((item) => item.account === name);
+            if (floor && reading && reading.currency === floor.currency && now - reading.at < staleAfterMs && reading.amount > floor.amount) {
+                names.push(name);
+            }
+            continue;
+        }
+        if (account.reserve === null)
             continue;
         const groups = windowsOf(readings.filter((item) => item.account === name));
         let counted = 0;
@@ -94,3 +121,7 @@ function age(ms) {
         return `${hours}h`;
     return `${minutes}m`;
 }
+/** A money figure in a refusal: the cents are shown even when the file wrote none. */
+function money(amount) {
+    return amount.toFixed(2);
+}

package/dist/budgets/readings.d.ts

@@ -25,6 +25,20 @@ export type Verdict = {
 } | {
     kind: 'unknown';
 };
+/** A spend check reading (RFC 0003 § 5): the money the account still holds. */
+export type SpendReading = {
+    account: string;
+    amount: number;
+    currency: string;
+    /** When the check ran: a spend line carries no time of its own (§ 5). */
+    at: number;
+};
+export type StoredSpend = {
+    account: string;
+    amount: number;
+    currency: string;
+    at: string;
+};
 /** Fold one seat's figure into the readings kept for this pass. */
 export declare function observe(list: readonly Seen[], figure: QuotaFigure, seat: string, now: number): Seen[];
 /**
@@ -41,6 +55,14 @@ export declare function recall(stored: Record<string, StoredReading> | undefined
 /** Write the readings that still count. The state file is the per-project cache. */
 export declare function saveReadings(dir: string, session: string, list: readonly Seen[], now?: number): void;
 export declare function loadReadings(dir: string, session: string): Seen[];
+/**
+ * Write the spend readings a pass's checks read, merging by account: an account whose check did
+ * not run this pass keeps the reading the state already holds. Nothing read, nothing written.
+ */
+export declare function saveSpendReadings(dir: string, session: string, list: readonly SpendReading[]): void;
+export declare function loadSpendReadings(dir: string, session: string): SpendReading[];
+export declare function storeSpend(reading: SpendReading): StoredSpend;
+export declare function recallSpend(stored: Record<string, StoredSpend> | undefined): SpendReading[];
 export declare function store(reading: Seen): StoredReading;
 export declare function revive(stored: StoredReading): Seen;
 /** When a duration such as `114h4m` ends, counted from a time. Null for no or an odd duration. */

package/dist/budgets/readings.js

@@ -82,6 +82,43 @@ export function saveReadings(dir, session, list, now = Date.now()) {
 export function loadReadings(dir, session) {
     return recall(readState(dir).sessions[session]?.budgets);
 }
+/**
+ * Write the spend readings a pass's checks read, merging by account: an account whose check did
+ * not run this pass keeps the reading the state already holds. Nothing read, nothing written.
+ */
+export function saveSpendReadings(dir, session, list) {
+    if (!list.length)
+        return;
+    updateState(dir, (state) => {
+        const current = state.sessions[session] ?? emptySession();
+        const spend = current.spend ?? {};
+        for (const reading of list)
+            spend[reading.account] = storeSpend(reading);
+        current.spend = spend;
+        state.sessions[session] = current;
+    });
+}
+export function loadSpendReadings(dir, session) {
+    return recallSpend(readState(dir).sessions[session]?.spend);
+}
+export function storeSpend(reading) {
+    return {
+        account: reading.account,
+        amount: reading.amount,
+        currency: reading.currency,
+        at: new Date(reading.at).toISOString(),
+    };
+}
+export function recallSpend(stored) {
+    if (!stored)
+        return [];
+    return Object.values(stored).map((one) => ({
+        account: one.account,
+        amount: one.amount,
+        currency: one.currency,
+        at: Date.parse(one.at),
+    }));
+}
 export function store(reading) {
     return {
         account: reading.account,

package/dist/commands/add.js

@@ -6,7 +6,7 @@ import { readArgs } from "../args.js";
 import { callerOf, describeCaller, isOwner, mayChangeTeam } from "../caller.js";
 import { blocksLaunch, doctorFindings, realSources as doctorSources } from "../commands/doctor.js";
 import { seatBudget } from "../budgets/gate.js";
-import { loadReadings } from "../budgets/readings.js";
+import { loadReadings, loadSpendReadings } from "../budgets/readings.js";
 import { rulesOf } from "../commands/up.js";
 import { branchPresent, readMerge } from "../end/condition.js";
 import { clearStopped, hasSeat, restoreSeat, seatIsStopped } from "../file/lines.js";
@@ -198,7 +198,7 @@ export async function runAdd(argv, io, sources = realSources) {
     // The gate reads the approved budgets, never the edited file's: the seat this `add` inserts
     // changes no section of its own, and no unapproved reserve may unblock a launch (#50).
     const budgets = budgetsInForce(prepared.team, root, sources.home);
-    const decision = seatBudget(budgets, loadReadings(dir, session), built.seat, sources.now().getTime());
+    const decision = seatBudget(budgets, loadReadings(dir, session), built.seat, sources.now().getTime(), loadSpendReadings(dir, session));
     const stray = unnamedIn(built.seat.label, agents, workspaces);
     const starting = seatPlan(prepared.team, built.seat, start);
     const planned = stray

package/dist/commands/up.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";
@@ -209,6 +209,7 @@ 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 spend = loadSpendReadings(dir, session);
     const seats = [];
     const refused = new Set();
     for (const seat of team.seats) {
@@ -221,7 +222,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 +234,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,

package/dist/commands/watch.js

@@ -1,6 +1,6 @@
 import { readArgs } from "../args.js";
 import { budgetsInForce, watchInForce } from "../approve/approval.js";
-import { saveReadings } from "../budgets/readings.js";
+import { saveReadings, saveSpendReadings } from "../budgets/readings.js";
 import { runChecks } from "../budgets/run.js";
 import { currentTeam } from "../file/current.js";
 import { homedir } from 'node:os';
@@ -131,6 +131,10 @@ 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.
+                    saveSpendReadings(dir, session, spendOf(outcomes));
                     for (const outcome of outcomes) {
                         const key = `check:${outcome.account}`;
                         if (outcome.state === 'read') {
@@ -145,7 +149,10 @@ 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 result = pass({
+                    team, state, live, machine: sources.machine(root), now, memory,
+                    approval: sources.approval(team, root), watch: inForce, outcomes, budgets: budget,
+                });
                 for (const report of result.reports)
                     say(report.text, true);
                 saveReadings(dir, session, result.readings, now);
@@ -174,6 +181,21 @@ export async function runWatch(argv, io, sources) {
     }
     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) {

package/dist/profiles/quota.d.ts

@@ -18,5 +18,10 @@ export type QuotaFigure = {
     used: number;
     resets: string | null;
 };
-/** Figures from the last six lines. A cut line, or a figure over 100, is absent. */
-export declare function figuresOf(patterns: readonly QuotaPattern[], screen: string): QuotaFigure[];
+/**
+ * Figures from one line: the composer's own status row, handed over by the caller (`statusRow`
+ * in the watch's screen core). Nothing else on the pane is ever read — a seat can print or type
+ * a line that only looks like a quota, and such a line is not the row. A row that is null, and
+ * a figure over 100, gives no figure.
+ */
+export declare function figuresOf(patterns: readonly QuotaPattern[], row: string | null): QuotaFigure[];

package/dist/profiles/quota.js

@@ -3,22 +3,23 @@
 export const WINDOWS = ['session', 'daily', 'weekly'];
 const RESET = /^(?:[0-9]+h(?:[0-9]+m)?|[0-9]+m)$/;
 const PERCENT = /^([0-9]+)%$/;
-/** Figures from the last six lines. A cut line, or a figure over 100, is absent. */
-export function figuresOf(patterns, screen) {
-    const lines = screen.split('\n').map((line) => line.trimEnd()).slice(-6);
+/**
+ * Figures from one line: the composer's own status row, handed over by the caller (`statusRow`
+ * in the watch's screen core). Nothing else on the pane is ever read — a seat can print or type
+ * a line that only looks like a quota, and such a line is not the row. A row that is null, and
+ * a figure over 100, gives no figure.
+ */
+export function figuresOf(patterns, row) {
+    if (row === null)
+        return [];
     const found = [];
     for (const pattern of patterns) {
-        let hit = null;
-        for (const line of lines) {
-            const match = pattern.match.exec(line);
-            if (!match)
-                continue;
-            const next = figureOf(pattern, match);
-            if (next)
-                hit = next;
-        }
-        if (hit)
-            found.push(hit);
+        const match = pattern.match.exec(row);
+        if (!match)
+            continue;
+        const next = figureOf(pattern, match);
+        if (next)
+            found.push(next);
     }
     return found;
 }

package/dist/state.d.ts

@@ -1,4 +1,4 @@
-import type { StoredReading } from './budgets/readings.ts';
+import type { StoredReading, StoredSpend } from './budgets/readings.ts';
 export type SeatState = {
     stage: 'launched' | 'named' | 'ready';
     pane?: string;
@@ -37,6 +37,8 @@ export type SessionState = {
     };
     /** The last screen readings for this project, keyed by account, window and seat. */
     budgets?: Record<string, StoredReading>;
+    /** The last spend check readings for this project, keyed by account. */
+    spend?: Record<string, StoredSpend>;
 };
 export type State = {
     format: 1;

package/dist/watch/pass.d.ts

@@ -27,4 +27,16 @@ export type PassResult = {
 };
 export declare const SEAT_CHECKS: SeatCheck[];
 export declare const TEAM_CHECKS: TeamCheck[];
-export declare function pass(team: TeamFile, state: SessionState, live: Live, machine: Machine, now: number, memory: Memory, approval?: string[] | null, watch?: TeamFile['watch'], outcomes?: readonly CheckOutcome[], budgets?: TeamFile['budgets']): PassResult;
+export type PassInput = {
+    team: TeamFile;
+    state: SessionState;
+    live: Live;
+    machine: Machine;
+    now: number;
+    memory: Memory;
+    approval?: string[] | null;
+    watch?: TeamFile['watch'];
+    outcomes?: readonly CheckOutcome[];
+    budgets?: TeamFile['budgets'];
+};
+export declare function pass({ team, state, live, machine, now, memory, approval, watch, outcomes, budgets, }: PassInput): PassResult;

package/dist/watch/pass.js

@@ -23,7 +23,7 @@ import { swapFree } from "./checks/swap-free.js";
 import { swapGrowth } from "./checks/swap-growth.js";
 import { teamIdle } from "./checks/team-idle.js";
 import { unsent } from "./checks/unsent.js";
-import { readScreen } from "./screen.js";
+import { readScreen, statusRow } from "./screen.js";
 export function newMemory() {
     return { history: {}, slots: {}, active: new Set(), pending: [], pendingSince: null };
 }
@@ -50,13 +50,18 @@ function attentionOf(screen, status, quiet) {
         return 'unknown';
     return null;
 }
+// The figures off a seat's own pane: only a composer screen — idle, unsent or working — shows a
+// status row at all, and only that row's line is read. A dialog, a question, a trust screen or an
+// unknown one gives no figures, and neither does a line the seat printed or typed.
+function quotaOf(cli, screen, pane) {
+    if (pane === undefined)
+        return [];
+    if (screen.kind !== 'idle' && screen.kind !== 'unsent' && screen.kind !== 'working')
+        return [];
+    return figuresOf(quotaFor(cli), statusRow(cli, pane));
+}
 // One pass of the watch. Pure: it reads what it is handed and changes only `memory`.
-// `approval` is how the file differs from the approved one: [] when it doesn't, null when it was
-// never approved, undefined when that wasn't looked at. `watch` and `budgets` are the sections in
-// force — the approved ones, or the defaults while the file's own are not approved — and the
-// checks read those, never the file's. `outcomes` is what the accounts' check commands read
-// outside the pass, when the watch last ran them.
-export function pass(team, state, live, machine, now, memory, approval, watch = team.watch, outcomes = [], budgets = team.budgets) {
+export function pass({ team, state, live, machine, now, memory, approval, watch = team.watch, outcomes = [], budgets = team.budgets, }) {
     const reports = [];
     const current = new Set();
     // Reported when it starts, and again only after it has cleared.
@@ -141,7 +146,7 @@ export function pass(team, state, live, machine, now, memory, approval, watch =
             screen,
             cli,
             vendor,
-            quota: pane === undefined ? [] : figuresOf(quotaFor(cli), pane),
+            quota: quotaOf(cli, screen, pane),
             running: true,
             quiet,
             working,

package/dist/watch/screen-core.d.ts

@@ -5,6 +5,12 @@ export type ReadClock = {
     now(): number;
     budgetMs: number;
 };
+/**
+ * The one line a quota figure may be read from: the composer's own status row, or null when the
+ * window shows none. A dialog, a transcript line, the input box — anything the seat printed or
+ * typed — is never the row. The caller still has to know the screen is a composer screen.
+ */
+export declare function statusRowOf(data: ScreenData, lines: string[]): string | null;
 /** `lines` is already the window: the last 20 lines, each trimmed at the end. */
 export declare function classifyLines(data: ScreenData, lines: string[], clock?: ReadClock): Screen;
 /**

package/dist/watch/screen-core.js

@@ -1,7 +1,44 @@
 const BUDGET_MS = 100;
 // The rule a `below_last_rule` pattern has to sit under. It is the core's, not the profile's.
 const RULE_LINE = /^\s*[─━]{8,}\s*$/;
-const FLOOR_PHRASES = ['Do you want to', 'Esc to cancel', 'enter Confirm', 'enter continue', 'esc quit', 'esc skip', '↑/↓'];
+// The safety floor's markers, matched without case: a dialog's wording is not always title-case
+// (`Press enter to confirm or esc to cancel`). RFC 0002 § 4.1 permits it.
+const FLOOR_PHRASES = ['do you want to', 'esc to cancel', 'enter confirm', 'enter continue', 'esc quit', 'esc skip', '↑/↓'];
+/**
+ * The index of the composer's status line in the window, or -1. A `status-last` composer pins it
+ * as the last non-blank line; a `status-then-one` composer allows one chrome line below it. The
+ * classification and the quota read both take their line from here, so the two cannot disagree
+ * about which line the composer's status line is.
+ */
+function statusIndex(composer, lines, allowOneTrailing, tick) {
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (tick())
+            return 'stop';
+        if (!composer.statusLine.test(lines[i] ?? ''))
+            continue;
+        const trailing = lines.slice(i + 1).filter((line) => line.trim());
+        if (allowOneTrailing) {
+            if (trailing.length > 0 && (trailing.length > 1 || composer.prompt.test(trailing[0] ?? '')))
+                return -1;
+        }
+        else if (trailing.length > 0)
+            return -1;
+        return i;
+    }
+    return -1;
+}
+/**
+ * The one line a quota figure may be read from: the composer's own status row, or null when the
+ * window shows none. A dialog, a transcript line, the input box — anything the seat printed or
+ * typed — is never the row. The caller still has to know the screen is a composer screen.
+ */
+export function statusRowOf(data, lines) {
+    const composer = data.composer;
+    if (composer.mode !== 'status-last' && composer.mode !== 'status-then-one')
+        return null;
+    const at = statusIndex(composer, lines, composer.mode === 'status-then-one', () => false);
+    return at === 'stop' || at < 0 ? null : (lines[at] ?? null);
+}
 /** `lines` is already the window: the last 20 lines, each trimmed at the end. */
 export function classifyLines(data, lines, clock) {
     const now = clock?.now ?? Date.now;
@@ -19,7 +56,7 @@ export function classifyLines(data, lines, clock) {
         if (!stage)
             continue;
         for (const rule of stage.rules) {
-            const hit = ruleMatches(lines, rule, tick);
+            const hit = ruleMatches(data, lines, rule, tick);
             if (hit === 'stop')
                 return { kind: 'unknown' };
             if (hit)
@@ -47,7 +84,7 @@ export function composeLines(data, lines, clock) {
     const tick = () => now() - start > budget;
     if (data.unknown) {
         for (const rule of data.unknown.rules) {
-            const hit = ruleMatches(lines, rule, tick);
+            const hit = ruleMatches(data, lines, rule, tick);
             if (hit === 'stop')
                 return { kind: 'unknown' };
             if (hit)
@@ -64,7 +101,7 @@ export function composeLines(data, lines, clock) {
         return { kind: 'unknown' };
     return { kind: composed.kind };
 }
-function ruleMatches(lines, rule, tick) {
+function ruleMatches(data, lines, rule, tick) {
     if (rule.any) {
         const hit = anyLine(lines, rule.any, tick);
         if (hit === 'stop')
@@ -82,8 +119,7 @@ function ruleMatches(lines, rule, tick) {
         }
     }
     if (rule.footer !== undefined) {
-        const last = [...lines].reverse().find((line) => line.trim());
-        if ((last ?? '').trim() !== rule.footer)
+        if (footerLine(data, lines) !== rule.footer)
             return false;
     }
     if (rule.belowLastRule) {
@@ -137,6 +173,21 @@ function lineSomewhere(lines, pattern, tick) {
     }
     return false;
 }
+/**
+ * The line a rule's footer must be: the last non-blank one. The composer's own chrome is the one
+ * thing allowed below it — a `status-last` mode pins the status line to the pane's last line, and
+ * a dialog drawn above it is still the dialog its footer belongs to. Any other line below the
+ * footer means the footer is not the dialog's, and the rule doesn't match.
+ */
+function footerLine(data, lines) {
+    const nonBlank = lines.filter((line) => line.trim());
+    const last = nonBlank[nonBlank.length - 1] ?? '';
+    const composer = data.composer;
+    if (composer.mode === 'status-last' && composer.statusLine.test(last)) {
+        return (nonBlank[nonBlank.length - 2] ?? '').trim();
+    }
+    return last.trim();
+}
 function matches(line, pattern, tick) {
     if (tick())
         return 'stop';
@@ -185,27 +236,11 @@ function boxToRule(lines, composer, tick) {
     return { kind: placeholder(typed, composer.placeholders) ? 'idle' : 'unsent', from, input };
 }
 function statusLast(lines, composer, tick, allowOneTrailing) {
-    let status = -1;
-    for (let i = lines.length - 1; i >= 0; i--) {
-        if (tick())
-            return { kind: 'stop' };
-        if (composer.statusLine.test(lines[i] ?? '')) {
-            status = i;
-            break;
-        }
-    }
+    const status = statusIndex(composer, lines, allowOneTrailing, tick);
+    if (status === 'stop')
+        return { kind: 'stop' };
     if (status < 0)
         return { kind: 'unknown' };
-    const trailing = [];
-    for (let i = status + 1; i < lines.length; i++)
-        if ((lines[i] ?? '').trim())
-            trailing.push(lines[i] ?? '');
-    if (allowOneTrailing) {
-        if (trailing.length > 1 || trailing.some((line) => composer.prompt.test(line)))
-            return { kind: 'unknown' };
-    }
-    else if (trailing.length > 0)
-        return { kind: 'unknown' };
     let input = status - 1;
     while (input >= 0 && !composer.prompt.test(lines[input] ?? ''))
         input--;
@@ -301,7 +336,8 @@ function floorHits(lines, from, input, chrome, tick) {
             continue;
         if (i !== input && choiceLine(line) && lines.slice(i + 1).some((later) => twoLine(later)))
             return true;
-        if (FLOOR_PHRASES.some((phrase) => line.includes(phrase)))
+        const lower = line.toLowerCase();
+        if (FLOOR_PHRASES.some((phrase) => lower.includes(phrase)))
             return true;
     }
     return false;

package/dist/watch/screen.d.ts

@@ -18,3 +18,7 @@ export declare function classify(cli: string, lines: string[]): Screen;
 /** The composer alone. A running turn would otherwise hide an empty input box. */
 export declare function classifyComposer(cli: string, lines: string[]): Screen;
 export declare function readScreen(cli: string, screen: string | undefined): Screen;
+/** The one line a quota figure may come from: the composer's own status row, in the pane's last
+ * 20 lines. Null for a CLI with no status line, and for a window that shows no status row — a
+ * dialog, a question, a trust screen, a shell or an unknown one reads no figures. */
+export declare function statusRow(cli: string, screen: string | undefined): string | null;

package/dist/watch/screen.js

@@ -1,7 +1,7 @@
 // What a pane's visible text shows, read against the shapes of its CLI. A screen that matches no
 // shape is "unknown": never ready, never idle, and never grounds for typing anything.
 import { readFileSync } from 'node:fs';
-import { classifyLines, composeLines } from "./screen-core.js";
+import { classifyLines, composeLines, statusRowOf } from "./screen-core.js";
 import { loadScreen } from "./screen-file.js";
 function load(name) {
     return loadScreen(readFileSync(new URL(`../profiles/${name}.yaml`, import.meta.url), 'utf8'));
@@ -36,3 +36,12 @@ export function readScreen(cli, screen) {
         return { kind: 'unknown' };
     return classify(cli, screen.split('\n'));
 }
+/** The one line a quota figure may come from: the composer's own status row, in the pane's last
+ * 20 lines. Null for a CLI with no status line, and for a window that shows no status row — a
+ * dialog, a question, a trust screen, a shell or an unknown one reads no figures. */
+export function statusRow(cli, screen) {
+    const data = DATA[cli];
+    if (data === undefined || screen === undefined)
+        return null;
+    return statusRowOf(data, windowOf(screen.split('\n')));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "team",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Set up, change and watch a project's team of AI agents from one file",
   "keywords": [
     "ai-agents",
@@ -23,7 +23,7 @@
     "typecheck": "tsc --noEmit",
     "test": "bun test",
     "e2e": "bun scripts/e2e.ts",
-    "build": "tsc -p tsconfig.build.json && mkdir -p dist/profiles && cp src/profiles/*.yaml dist/profiles/",
+    "build": "bun scripts/build.ts",
     "ci": "bun run typecheck && bun test && bun run build && node dist/cli.js --version"
   },
   "devDependencies": {