team 0.1.0 → 0.1.2

package/dist/watch/screen-core.js

@@ -1,13 +1,61 @@
+// The screen core. Stage order, dialog primitives, the four composer modes and the
+// safety floor live here, never in a profile. A profile is data: it can add a
+// pattern, and it cannot move a stage or turn the floor off.
+import { allDimAfter, hasSgr, stripSgr } from "../ansi.js";
 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 keeping any ANSI styling. Matching
+ *  runs on each line's plain form, trimmed at the end; the styled form is kept for the one
+ *  question styling can answer, whether the composer's input line is all dim. */
+function plainLines(lines) {
+    return lines.map((line) => stripSgr(line).trimEnd());
+}
 /** `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;
     const budget = clock?.budgetMs ?? BUDGET_MS;
     const start = now();
     const tick = () => now() - start > budget;
+    const plain = plainLines(lines);
     const order = [
         ['unknown', data.unknown],
         ['trust', data.trust],
@@ -19,19 +67,19 @@ 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, plain, rule, tick);
             if (hit === 'stop')
                 return { kind: 'unknown' };
             if (hit)
                 return { kind };
         }
     }
-    const composed = compose(data, lines, tick);
+    const composed = compose(data, plain, lines, tick);
     if (composed.kind === 'stop' || composed.kind === 'unknown')
         return { kind: 'unknown' };
     if (composed.kind !== 'idle' && composed.kind !== 'unsent')
         return { kind: composed.kind };
-    const marked = floorHits(lines, composed.from, composed.input, data.chrome, tick);
+    const marked = floorHits(plain, composed.from, composed.input, data.chrome, tick);
     if (marked === 'stop' || marked)
         return { kind: 'unknown' };
     return { kind: composed.kind };
@@ -45,28 +93,30 @@ export function composeLines(data, lines, clock) {
     const budget = clock?.budgetMs ?? BUDGET_MS;
     const start = now();
     const tick = () => now() - start > budget;
+    const plain = plainLines(lines);
     if (data.unknown) {
         for (const rule of data.unknown.rules) {
-            const hit = ruleMatches(lines, rule, tick);
+            const hit = ruleMatches(data, plain, rule, tick);
             if (hit === 'stop')
                 return { kind: 'unknown' };
             if (hit)
                 return { kind: 'unknown' };
         }
     }
-    const composed = compose(data, lines, tick);
+    const composed = compose(data, plain, lines, tick);
     if (composed.kind === 'stop' || composed.kind === 'unknown')
         return { kind: 'unknown' };
     if (composed.kind !== 'idle' && composed.kind !== 'unsent')
         return { kind: composed.kind };
-    const marked = floorHits(lines, composed.from, composed.input, data.chrome, tick);
+    const marked = floorHits(plain, composed.from, composed.input, data.chrome, tick);
     if (marked === 'stop' || marked)
         return { kind: 'unknown' };
     return { kind: composed.kind };
 }
-function ruleMatches(lines, rule, tick) {
+function ruleMatches(data, lines, rule, tick) {
+    const where = rule.onFooter ? [footerLine(data, lines)] : lines;
     if (rule.any) {
-        const hit = anyLine(lines, rule.any, tick);
+        const hit = anyLine(where, rule.any, tick);
         if (hit === 'stop')
             return 'stop';
         if (!hit)
@@ -74,7 +124,7 @@ function ruleMatches(lines, rule, tick) {
     }
     if (rule.all) {
         for (const pattern of rule.all) {
-            const hit = lineSomewhere(lines, pattern, tick);
+            const hit = lineSomewhere(where, pattern, tick);
             if (hit === 'stop')
                 return 'stop';
             if (!hit)
@@ -82,16 +132,23 @@ 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.withoutRule) {
+        if (tick())
+            return 'stop';
+        if (findLast(lines, (line) => RULE_LINE.test(line)) >= 0)
             return false;
     }
     if (rule.belowLastRule) {
         if (tick())
             return 'stop';
-        // No rule line counts as below one: today's check is `index > lastIndex`, and
-        // lastIndex is -1 when the window has no rule. A later rule still hides a quoted dialog.
+        // A pattern sits below a composer rule. A window with no rule line is not
+        // below one: a dialog that fills the pane says so with `without_rule`.
         const ruleAt = findLast(lines, (line) => RULE_LINE.test(line));
+        if (ruleAt < 0)
+            return false;
         const at = findLast(lines, (line) => rule.belowLastRule?.test(line) ?? false);
         if (at < 0 || at <= ruleAt)
             return false;
@@ -137,6 +194,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';
@@ -150,17 +222,18 @@ function matches(line, pattern, tick) {
     }
     return true;
 }
-function compose(data, lines, tick) {
+/** `plain` is the window's plain form; `styled` the window itself, for the input line's dim question. */
+function compose(data, plain, styled, tick) {
     const composer = data.composer;
     if (composer.mode === 'box-to-rule')
-        return boxToRule(lines, composer, tick);
+        return boxToRule(plain, styled, composer, tick);
     if (composer.mode === 'status-last')
-        return statusLast(lines, composer, tick, false);
+        return statusLast(plain, styled, composer, tick, false);
     if (composer.mode === 'status-then-one')
-        return statusThenOne(lines, composer, tick);
-    return twoRules(lines, composer, tick);
+        return statusThenOne(plain, styled, composer, tick);
+    return twoRules(plain, styled, composer, tick);
 }
-function boxToRule(lines, composer, tick) {
+function boxToRule(lines, styled, composer, tick) {
     let input = -1;
     for (let i = lines.length - 1; i >= 0; i--) {
         if (tick())
@@ -172,39 +245,53 @@ function boxToRule(lines, composer, tick) {
     }
     if (input < 0)
         return { kind: 'unknown' };
-    const from = boundaryBefore(lines, input, composer.rule);
+    // The frame is the box itself: a closing rule under this prompt. A rule anywhere
+    // above, or a rule with shell output under it, is not the box. A shell's last
+    // prompt never has that closing rule.
+    let close = -1;
     for (let i = input + 1; i < lines.length; i++) {
         if (tick())
             return { kind: 'stop' };
-        if (composer.rule.test(lines[i] ?? ''))
+        if (composer.rule.test(lines[i] ?? '')) {
+            close = i;
             break;
-        if ((lines[i] ?? '').trim())
-            return { kind: 'unsent', from, input };
+        }
     }
-    const typed = (lines[input] ?? '').replace(composer.prompt, '').trim();
-    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 (close < 0)
+        return { kind: 'unknown' };
+    const above = input > 0 && composer.rule.test(lines[input - 1] ?? '');
+    let footer = false;
+    for (let j = close + 1; j < lines.length; j++) {
         if (tick())
             return { kind: 'stop' };
-        if (composer.statusLine.test(lines[i] ?? '')) {
-            status = i;
+        if (statusFooter(lines[j] ?? '')) {
+            footer = true;
             break;
         }
     }
-    if (status < 0)
+    // The opening rule on the line directly above, or the status footer when that
+    // rule has scrolled out of the window.
+    if (!above && !footer)
         return { kind: 'unknown' };
-    const trailing = [];
-    for (let i = status + 1; i < lines.length; i++)
+    const from = above ? input - 1 : input;
+    for (let i = input + 1; i < close; 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' };
+            return { kind: 'unsent', from, input };
     }
-    else if (trailing.length > 0)
+    const typed = (lines[input] ?? '').replace(composer.prompt, '').trim();
+    return { kind: placeholder(typed, composer, lines[input] ?? '', styled[input]) ? 'idle' : 'unsent', from, input };
+}
+// The composer footer, not a line of shell output under a stray rule. The model
+// row uses a middot; the permissions line is the other footer.
+function statusFooter(line) {
+    const text = line.trim();
+    return text.includes('·') || /bypass permissions/i.test(text);
+}
+function statusLast(lines, styled, composer, tick, allowOneTrailing) {
+    const status = statusIndex(composer, lines, allowOneTrailing, tick);
+    if (status === 'stop')
+        return { kind: 'stop' };
+    if (status < 0)
         return { kind: 'unknown' };
     let input = status - 1;
     while (input >= 0 && !composer.prompt.test(lines[input] ?? ''))
@@ -214,10 +301,10 @@ function statusLast(lines, composer, tick, allowOneTrailing) {
     for (let i = input + 1; i < status; i++)
         if ((lines[i] ?? '').trim())
             return { kind: 'unsent', from: input, input };
-    return { kind: placeholder(stripTyped(lines[input] ?? '', composer), composer.placeholders) ? 'idle' : 'unsent', from: input, input };
+    return { kind: placeholder(stripTyped(lines[input] ?? '', composer), composer, lines[input] ?? '', styled[input]) ? 'idle' : 'unsent', from: input, input };
 }
-function statusThenOne(lines, composer, tick) {
-    const found = statusLast(lines, composer, tick, true);
+function statusThenOne(lines, styled, composer, tick) {
+    const found = statusLast(lines, styled, composer, tick, true);
     if (found.kind !== 'unknown')
         return found;
     // No status line: the fallback rules decide. Anything they don't name is unknown.
@@ -244,7 +331,7 @@ function statusThenOne(lines, composer, tick) {
     }
     return { kind: 'unknown' };
 }
-function twoRules(lines, composer, tick) {
+function twoRules(lines, styled, composer, tick) {
     let bottom = -1;
     let top = -1;
     let input = -1;
@@ -277,20 +364,24 @@ function twoRules(lines, composer, tick) {
     if (lines.slice(input + 1, bottom).some((line) => line.trim()))
         return { kind: 'unsent', from: top, input };
     const typed = (lines[input] ?? '').replace(composer.prompt, '').trim();
-    return { kind: placeholder(typed, composer.placeholders) ? 'idle' : 'unsent', from: top, input };
-}
-function boundaryBefore(lines, input, rule) {
-    for (let i = input - 1; i >= 0; i--)
-        if (rule.test(lines[i] ?? ''))
-            return i;
-    return input;
+    return { kind: placeholder(typed, composer, lines[input] ?? '', styled[input]) ? 'idle' : 'unsent', from: top, input };
 }
 function stripTyped(line, composer) {
     const stripped = composer.stripSuffix ? line.replace(composer.prompt, '').replace(composer.stripSuffix, '') : line.replace(composer.prompt, '');
     return stripped.trim();
 }
-function placeholder(typed, list) {
-    return list.some((entry) => ('equals' in entry ? typed === entry.equals : typed.startsWith(entry.prefix)));
+// A placeholder, not text. When the composer says its suggestions render dim and the input
+// line carries any styling at all, the styling decides alone: all faint past the prompt is a
+// greyed suggestion, anything else is text — the list is not asked, so no suggestion's
+// styling can lend its words to typed characters after it. A line without styling (a plain
+// read, an old herdr) leaves the list to decide, as does a composer without the style.
+function placeholder(typed, composer, plainLine, styledLine) {
+    if (composer.placeholderStyle === 'dim' && styledLine !== undefined && hasSgr(styledLine)) {
+        const hit = composer.prompt.exec(plainLine);
+        const skip = hit === null ? 0 : plainLine.slice(0, hit.index + hit[0].length).replace(/\s/g, '').length;
+        return allDimAfter(styledLine, skip);
+    }
+    return composer.placeholders.some((entry) => ('equals' in entry ? typed === entry.equals : typed.startsWith(entry.prefix)));
 }
 function floorHits(lines, from, input, chrome, tick) {
     for (let i = Math.max(0, from); i < lines.length; i++) {
@@ -301,7 +392,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-data.d.ts

@@ -7,7 +7,11 @@ export type Rule = {
     any?: LinePattern[];
     all?: LinePattern[];
     footer?: string;
+    /** `any` and `all` are read on the dialog's last line, not on every line. */
+    onFooter?: boolean;
     belowLastRule?: RegExp;
+    /** The window has no composer rule: the dialog is the pane. */
+    withoutRule?: boolean;
     noneAfter?: {
         anchor: LinePattern;
         patterns: LinePattern[];
@@ -25,23 +29,27 @@ export type FallbackRule = {
     all: LinePattern[];
     kind: Screen['kind'];
 };
+export type PlaceholderStyle = 'dim';
 type Box = {
     mode: 'box-to-rule';
     prompt: RegExp;
     rule: RegExp;
     placeholders: Placeholder[];
+    placeholderStyle?: PlaceholderStyle;
 };
 type StatusLast = {
     mode: 'status-last';
     statusLine: RegExp;
     prompt: RegExp;
     placeholders: Placeholder[];
+    placeholderStyle?: PlaceholderStyle;
 };
 type StatusThenOne = {
     mode: 'status-then-one';
     statusLine: RegExp;
     prompt: RegExp;
     placeholders: Placeholder[];
+    placeholderStyle?: PlaceholderStyle;
     stripSuffix: RegExp | null;
     fallback: FallbackRule[];
 };
@@ -51,6 +59,7 @@ type TwoRules = {
     rule: RegExp;
     footers: RegExp[];
     placeholders: Placeholder[];
+    placeholderStyle?: PlaceholderStyle;
 };
 export type Composer = Box | StatusLast | StatusThenOne | TwoRules;
 export type ScreenData = {

package/dist/watch/screen-file.js

@@ -50,14 +50,16 @@ function stageOf(node) {
 }
 function ruleOf(node, ignoreCase) {
     const entries = mapping(node, 'a rule');
-    only(entries, ['any', 'all', 'footer', 'below_last_rule', 'none_after']);
+    only(entries, ['any', 'all', 'footer', 'on_footer', 'below_last_rule', 'without_rule', 'none_after']);
     if (entries.length === 0)
         fail(node.line, 'a rule has no primitive');
     const rule = {};
     const any = optional(entries, 'any');
     const all = optional(entries, 'all');
     const footer = optional(entries, 'footer');
+    const onFooter = optional(entries, 'on_footer');
     const below = optional(entries, 'below_last_rule');
+    const withoutRule = optional(entries, 'without_rule');
     const noneAfter = optional(entries, 'none_after');
     if (any)
         rule.any = patternsOf(any.value, 'any', ignoreCase);
@@ -65,8 +67,12 @@ function ruleOf(node, ignoreCase) {
         rule.all = patternsOf(all.value, 'all', ignoreCase);
     if (footer)
         rule.footer = stringOf(footer.value) ?? fail(footer.line, '"footer" must be a string');
+    if (onFooter)
+        rule.onFooter = boolOf(onFooter.value, 'on_footer');
     if (below)
         rule.belowLastRule = patternOf(stringOf(below.value) ?? fail(below.line, '"below_last_rule" must be a string'), ignoreCase, below.line);
+    if (withoutRule)
+        rule.withoutRule = boolOf(withoutRule.value, 'without_rule');
     if (noneAfter)
         rule.noneAfter = noneAfterOf(noneAfter.value, ignoreCase);
     return rule;
@@ -116,16 +122,20 @@ function composerOf(node) {
     const entries = mapping(node, 'composer');
     const mode = required(entries, 'mode', node.line);
     const name = stringOf(mode.value);
+    // How the CLI renders its greyed suggestions, read off the input line's styling. Optional:
+    // a composer whose suggestions plain text already names needs none of it.
+    const style = optional(entries, 'placeholder_style');
+    const placeholderStyle = style ? placeholderStyleOf(style) : undefined;
     if (name === 'box-to-rule') {
-        only(entries, ['mode', 'prompt', 'rule', 'placeholders']);
-        return { mode: name, prompt: regexField(entries, 'prompt', node.line), rule: regexField(entries, 'rule', node.line), placeholders: placeholdersOf(required(entries, 'placeholders', node.line).value) };
+        only(entries, ['mode', 'prompt', 'rule', 'placeholders', 'placeholder_style']);
+        return { mode: name, prompt: regexField(entries, 'prompt', node.line), rule: regexField(entries, 'rule', node.line), placeholders: placeholdersOf(required(entries, 'placeholders', node.line).value), placeholderStyle };
     }
     if (name === 'status-last') {
-        only(entries, ['mode', 'status_line', 'prompt', 'placeholders']);
-        return { mode: name, statusLine: regexField(entries, 'status_line', node.line), prompt: regexField(entries, 'prompt', node.line), placeholders: placeholdersOf(required(entries, 'placeholders', node.line).value) };
+        only(entries, ['mode', 'status_line', 'prompt', 'placeholders', 'placeholder_style']);
+        return { mode: name, statusLine: regexField(entries, 'status_line', node.line), prompt: regexField(entries, 'prompt', node.line), placeholders: placeholdersOf(required(entries, 'placeholders', node.line).value), placeholderStyle };
     }
     if (name === 'status-then-one') {
-        only(entries, ['mode', 'status_line', 'prompt', 'placeholders', 'strip_suffix', 'fallback']);
+        only(entries, ['mode', 'status_line', 'prompt', 'placeholders', 'placeholder_style', 'strip_suffix', 'fallback']);
         const suffix = optional(entries, 'strip_suffix');
         const fallback = required(entries, 'fallback', node.line);
         return {
@@ -133,12 +143,13 @@ function composerOf(node) {
             statusLine: regexField(entries, 'status_line', node.line),
             prompt: regexField(entries, 'prompt', node.line),
             placeholders: placeholdersOf(required(entries, 'placeholders', node.line).value),
+            placeholderStyle,
             stripSuffix: suffix ? patternOf(stringOf(suffix.value) ?? fail(suffix.line, '"strip_suffix" must be a string'), false, suffix.line) : null,
             fallback: fallbackOf(fallback.value),
         };
     }
     if (name === 'two-rules-footer-below') {
-        only(entries, ['mode', 'ignore_case', 'prompt', 'rule', 'footers', 'placeholders']);
+        only(entries, ['mode', 'ignore_case', 'prompt', 'rule', 'footers', 'placeholders', 'placeholder_style']);
         const flag = optional(entries, 'ignore_case');
         const ignoreCase = flag ? boolOf(flag.value, 'ignore_case') : false;
         const footers = required(entries, 'footers', node.line);
@@ -155,10 +166,17 @@ function composerOf(node) {
                 return patternOf(text, ignoreCase, item.line);
             }),
             placeholders: placeholdersOf(required(entries, 'placeholders', node.line).value),
+            placeholderStyle,
         };
     }
     fail(mode.line, `"mode" must be box-to-rule, status-last, status-then-one or two-rules-footer-below`);
 }
+function placeholderStyleOf(entry) {
+    const text = stringOf(entry.value);
+    if (text !== 'dim')
+        fail(entry.line, '"placeholder_style" must be dim');
+    return text;
+}
 function fallbackOf(node) {
     if (node.kind !== 'seq')
         fail(node.line, '"fallback" must be a list');

package/dist/watch/screen.d.ts

@@ -18,3 +18,8 @@ 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, read plain — a figure is never styled. 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,10 @@
 // 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.
+// The text may keep its ANSI styling, as `herdr pane read --format ansi` reads it: matching
+// runs on the plain form, and the styling tells a greyed suggestion from typed text.
 import { readFileSync } from 'node:fs';
-import { classifyLines, composeLines } from "./screen-core.js";
+import { stripSgr } from "../ansi.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'));
@@ -13,7 +16,8 @@ const DATA = {
     cursor: load('cursor'),
     antigravity: load('antigravity'),
 };
-// The window every pattern sees: the pane's last 20 lines, each trimmed at the end.
+// The window every pattern sees: the pane's last 20 lines. Styled lines are trimmed only past
+// their last escape; the core trims each line's plain form for matching.
 function windowOf(lines) {
     return lines.map((line) => line.trimEnd()).slice(-20);
 }
@@ -36,3 +40,13 @@ 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, read plain — a figure is never styled. 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(stripSgr(screen).split('\n')));
+}

package/examples/team.yaml

@@ -49,6 +49,7 @@ seats:
     label: codex
     cli: codex
     vendor: openai
+    account: openai-team       # the seat's account, when one vendor has two; absent, its vendor
     model: GPT Comet
     version: "3"
     display: GPT-3 Comet       # the vendor's spelling, for the signature
@@ -74,3 +75,10 @@ seats:
     version: "1"
     launch: nimbus-claude      # a launcher on the PATH, holding the account's key and endpoint
     count: 3
+
+budgets:                      # the owner's: what is budgeted, and how long a figure stays fresh
+  accounts:
+    openai-team:              # the account codex-beacon spends
+      kind: subscription
+      reserve: 20%            # refuse a launch on a figure inside it
+      sources: [status_line]  # Codex's status line carries its weekly figure

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "team",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "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": {