team 0.1.1 → 0.1.2

package/dist/state.d.ts

@@ -35,10 +35,6 @@ export type SessionState = {
     nudge?: {
         pending_since: string | null;
     };
-    /** 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;
@@ -46,6 +42,13 @@ export type State = {
         read_at: string;
         file: string;
     };
+    /**
+     * The project's last readings, whatever session saw them: a screen reading keyed by account,
+     * window and seat, a check reading by account and window (§ 4.4).
+     */
+    budgets?: Record<string, StoredReading>;
+    /** The project's last spend check readings, keyed by account. */
+    spend?: Record<string, StoredSpend>;
     sessions: Record<string, SessionState>;
 };
 export declare const STATE_FILE = "team.state.json";

package/dist/state.js

@@ -26,9 +26,46 @@ export function readState(dir) {
     for (const session of Object.values(state.sessions)) {
         session.seats ??= {};
         session.worktrees ??= {};
+        // Read old, write new: readings used to be held under a session. They are the project's
+        // (§ 4.4), so every session's records are merged to the top level here — no reader loses one,
+        // and the next write persists the new shape.
+        const held = session;
+        if (held.budgets) {
+            state.budgets = mergeReadings(state.budgets, held.budgets);
+            delete held.budgets;
+        }
+        if (held.spend) {
+            state.spend = mergeSpend(state.spend, held.spend);
+            delete held.spend;
+        }
     }
     return state;
 }
+/**
+ * One record per slot when two sessions hold the same account, window and seat: the reading that
+ * counts wins — a confirmed one, and among those the newest change (§ 4.3).
+ */
+function mergeReadings(top, held) {
+    const merged = top ?? {};
+    for (const [key, reading] of Object.entries(held)) {
+        const current = merged[key];
+        merged[key] = !current
+            || (reading.confirmed && !current.confirmed)
+            || (reading.confirmed === current.confirmed && Date.parse(reading.changedAt) > Date.parse(current.changedAt))
+            ? reading
+            : current;
+    }
+    return merged;
+}
+/** The same for spend: one record per account, the reading whose check ran last winning. */
+function mergeSpend(top, held) {
+    const merged = top ?? {};
+    for (const [key, reading] of Object.entries(held)) {
+        const current = merged[key];
+        merged[key] = !current || Date.parse(reading.at) > Date.parse(current.at) ? reading : current;
+    }
+    return merged;
+}
 // Reads the state, lets `change` edit it, and writes it back, all under the lock.
 export function updateState(dir, change) {
     return withLock(dir, () => {

package/dist/status/statusline.js

@@ -2,10 +2,12 @@
 // visible text into the file's two fields, `model` and `version`, or null when the text doesn't
 // show them: "unread" is never a mismatch. The last six lines are the window. A line the rules
 // claim but cannot name clears an earlier match; that is how an unknown Codex footer stays unread.
+import { stripSgr } from "../ansi.js";
 import { statusOnLine } from "../profiles/profile.js";
 export function runningModel(cli, screen) {
     let found = null;
-    for (const line of screen.split('\n').slice(-6)) {
+    // The pane's text may keep its ANSI styling; the model is read from the plain form.
+    for (const line of stripSgr(screen).split('\n').slice(-6)) {
         const hit = statusOnLine(cli, line);
         if (hit === 'unreadable')
             found = null;

package/dist/watch/check.d.ts

@@ -29,6 +29,7 @@ export type SeatObservation = {
     screen: Screen;
     cli: string;
     vendor: string;
+    account: string;
     quota: QuotaFigure[];
     running: boolean;
     quiet: boolean;

package/dist/watch/checks/budget.js

@@ -67,6 +67,9 @@ function countedOf(name, account, team, staleMs, now) {
         for (const reading of team.readings) {
             if (reading.account !== name)
                 continue;
+            // The check readings of the same account live in this slot too: this source reads screens.
+            if (reading.source !== 'status_line')
+                continue;
             const group = groups.get(reading.window) ?? [];
             group.push(reading);
             groups.set(reading.window, group);
@@ -98,7 +101,7 @@ function countedOf(name, account, team, staleMs, now) {
 }
 /** The account reads unknown while a seat that spends it is running: the operator can stop it. */
 function unknown(name, team, ctx) {
-    const on = team.seats.filter((seat) => seat.running && seat.vendor === name).map((seat) => seat.name);
+    const on = team.seats.filter((seat) => seat.running && seat.account === name).map((seat) => seat.name);
     if (!on.length)
         return null;
     const verb = on.length === 1 ? 'runs' : 'run';

package/dist/watch/pass.d.ts

@@ -35,8 +35,9 @@ export type PassInput = {
     now: number;
     memory: Memory;
     approval?: string[] | null;
-    watch?: TeamFile['watch'];
+    watch: TeamFile['watch'];
     outcomes?: readonly CheckOutcome[];
     budgets?: TeamFile['budgets'];
+    readings?: readonly Seen[];
 };
-export declare function pass({ team, state, live, machine, now, memory, approval, watch, outcomes, budgets, }: PassInput): PassResult;
+export declare function pass({ team, state, live, machine, now, memory, approval, watch, outcomes, budgets, readings: stored, }: PassInput): PassResult;

package/dist/watch/pass.js

@@ -2,8 +2,8 @@
 // runs the registered checks in the order it owns, applies the report-once rule, and dials the
 // nudge. A check never reads herdr, a screen or the file itself — only the observation it is
 // handed (RFC 0002 § 4.2).
-import { WATCH_CHECKS_CHANGED } from "../approve/fingerprint.js";
-import { observe, recall } from "../budgets/readings.js";
+import { seatNamed } from "../approve/fingerprint.js";
+import { observe, observeCheck } from "../budgets/readings.js";
 import { quotaFor } from "../profiles/profile.js";
 import { figuresOf } from "../profiles/quota.js";
 import { seatModel } from "../status/statusline.js";
@@ -33,8 +33,8 @@ export function newMemory() {
 export const NUDGE_TEXT = 'Team watch: reports are waiting in .agents/team.log';
 // The seat checks, in the order their reports land in the log; the team checks, after them. The
 // order is the core's: a seat's wrong model is reported before its permission prompt, and every
-// seat before the team. Disabling a check in the file's `watch.checks` takes it out of the run,
-// except the four that can't be turned off.
+// seat before the team. Disabling a check in the `watch` section in force takes it out of the
+// run, except the four that can't be turned off.
 export const SEAT_CHECKS = [missing, modelDrift, attention, unsent, idle];
 export const TEAM_CHECKS = [extra, teamIdle, approval, load, memoryCheck, disk, swapFree, swapGrowth, budget];
 // The one exclusive reading of a seat's screen and herdr status. herdr can report a seat at a
@@ -61,7 +61,7 @@ function quotaOf(cli, screen, pane) {
     return figuresOf(quotaFor(cli), statusRow(cli, pane));
 }
 // One pass of the watch. Pure: it reads what it is handed and changes only `memory`.
-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, outcomes = [], budgets = team.budgets, readings: stored = [], }) {
     const reports = [];
     const current = new Set();
     // Reported when it starts, and again only after it has cleared.
@@ -81,6 +81,7 @@ export function pass({ team, state, live, machine, now, memory, approval, watch
             name: seat.name,
             cli: seat.cli,
             vendor: seat.vendor,
+            account: seat.account ?? seat.vendor,
             parked: seat.parked || seat.stopped,
             stopped: seat.stopped,
             seat,
@@ -88,10 +89,18 @@ export function pass({ team, state, live, machine, now, memory, approval, watch
         ...Object.entries(state.seats).filter(([, recorded]) => recorded.temporary).map(([name, recorded]) => {
             // A temporary seat signs like the seat it is like: its CLI, and its account.
             const like = team.seats.find((seat) => seat.name === recorded.temporary?.like);
-            return { name, cli: like?.cli ?? '', vendor: like?.vendor ?? '', parked: false, stopped: false, seat: undefined };
+            return {
+                name,
+                cli: like?.cli ?? '',
+                vendor: like?.vendor ?? '',
+                account: like?.account ?? like?.vendor ?? '',
+                parked: false,
+                stopped: false,
+                seat: undefined,
+            };
         }),
     ];
-    for (const { name, cli, vendor, parked, stopped, seat } of seats) {
+    for (const { name, cli, vendor, account, parked, stopped, seat } of seats) {
         const agent = live.agents.find((candidate) => candidate.name === name);
         const lead = name === team.coordinator || name === team.operator;
         if (!agent) {
@@ -104,6 +113,7 @@ export function pass({ team, state, live, machine, now, memory, approval, watch
                 screen: { kind: 'unknown' },
                 cli,
                 vendor,
+                account,
                 quota: [],
                 running: false,
                 quiet: false,
@@ -146,6 +156,7 @@ export function pass({ team, state, live, machine, now, memory, approval, watch
             screen,
             cli,
             vendor,
+            account,
             quota: quotaOf(cli, screen, pane),
             running: true,
             quiet,
@@ -159,19 +170,40 @@ export function pass({ team, state, live, machine, now, memory, approval, watch
             history: { lastWorking: history.lastWorking, idleSince: history.idleSince },
         });
     }
-    // The figures this pass saw, folded into the readings the state keeps (§ 4.3). Only an account
-    // whose `sources` name `status_line` takes a screen reading: a check-only account never records
-    // one here, and neither does an account the budgets in force don't name (#50).
-    let readings = recall(state.budgets);
+    // The figures this pass saw, folded into the readings the project keeps (§ 4.3, § 4.4). Only an
+    // account whose `sources` name `status_line` takes a screen reading: a check-only account never
+    // records one here, and neither does an account the budgets in force don't name (#50). A figure
+    // names the account its pattern measures (§ 3b): one that measures this seat's vendor is this
+    // seat's account — its own `account:` when the file names one, so two accounts of one vendor
+    // keep two buckets — while a figure on another account (a launcher showing the vendor it really
+    // runs on) stays that account's, whichever seat's screen showed it.
+    //
+    // A seat the approval lists as changed — or as not in the approved file — is drift, and its
+    // figures are read as they are but none is folded: an unapproved edit to its `account:` must
+    // not move its figure into another account's bucket, where `up` and `add` would count it.
+    // Nothing is saved for that seat until the owner approves.
+    const drift = new Set((Array.isArray(approval) ? approval : []).map(seatNamed).filter((name) => name !== null));
+    let readings = stored.slice();
     for (const seat of observations) {
-        if (!seat.running)
+        if (!seat.running || drift.has(seat.name))
             continue;
         for (const figure of seat.quota) {
-            if (budgets.accounts[figure.account]?.sources.includes('status_line')) {
-                readings = observe(readings, figure, seat.name, now);
+            const account = figure.account === seat.vendor ? seat.account : figure.account;
+            if (budgets.accounts[account]?.sources.includes('status_line')) {
+                readings = observe(readings, { ...figure, account }, seat.name, now);
             }
         }
     }
+    // A check reading lands in the same slot (§ 5): what an approved check read outlives the watch,
+    // so `up` and `add` count it after the watch has exited. Only an account whose sources name
+    // `check`, and only when its check actually read this pass.
+    for (const outcome of outcomes) {
+        if (outcome.state !== 'read' || outcome.reading.kind !== 'subscription')
+            continue;
+        if (!budgets.accounts[outcome.account]?.sources.includes('check'))
+            continue;
+        readings = observeCheck(readings, outcome.account, outcome.reading.windows);
+    }
     const teamObservation = {
         team,
         state,
@@ -196,15 +228,14 @@ export function pass({ team, state, live, machine, now, memory, approval, watch
             return memory.slots[kind];
         },
     };
-    // The four § 4.2 keeps out of `watch.checks` run whatever the file says: the validation refuses
+    // The four § 4.2 keeps out of `watch.checks` run whatever the list says: the validation refuses
     // them, and this holds even for a file that reached memory another way.
     //
-    // And nothing is turned off until the owner approves (RFC 0002 § 4.2): a file whose
-    // `watch.checks` differs from the approved one, a file never approved, and an approval that
-    // wasn't looked at keep every check running and report the difference instead. A difference in
-    // some other section leaves the checks turned off as approved — the owner owns both questions.
-    const approved = Array.isArray(approval) && !approval.includes(WATCH_CHECKS_CHANGED);
-    const off = approved ? new Set(team.watch.checks) : new Set();
+    // The off list is the section in force, which the caller passes as `watch`. A file that was
+    // approved — `approval` is a list, empty or not — runs that list. An unapproved `watch.checks`
+    // edit does not turn anything new off, and a check the approved list turned off stays off.
+    // A file never approved, or whose approval was not looked at, turns nothing off.
+    const off = Array.isArray(approval) ? new Set(watch.checks) : new Set();
     const enabled = (name) => ALWAYS_ON.includes(name) || !off.has(name);
     for (const seat of observations) {
         for (const check of SEAT_CHECKS)

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

@@ -1,6 +1,6 @@
 import type { Screen } from './screen.ts';
 import type { ScreenData } from './screen-data.ts';
-export type { Composer, FallbackRule, LinePattern, Placeholder, Rule, ScreenData, Stage } from './screen-data.ts';
+export type { Composer, FallbackRule, LinePattern, Placeholder, PlaceholderStyle, Rule, ScreenData, Stage } from './screen-data.ts';
 export type ReadClock = {
     now(): number;
     budgetMs: number;

package/dist/watch/screen-core.js

@@ -1,3 +1,7 @@
+// 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*$/;
@@ -39,12 +43,19 @@ export function statusRowOf(data, lines) {
     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],
@@ -56,19 +67,19 @@ export function classifyLines(data, lines, clock) {
         if (!stage)
             continue;
         for (const rule of stage.rules) {
-            const hit = ruleMatches(data, 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 };
@@ -82,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(data, 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(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)
@@ -111,7 +124,7 @@ function ruleMatches(data, 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)
@@ -122,12 +135,20 @@ function ruleMatches(data, lines, rule, tick) {
         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;
@@ -201,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())
@@ -223,19 +245,49 @@ 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 (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 (statusFooter(lines[j] ?? '')) {
+            footer = true;
             break;
+        }
+    }
+    // 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 from = above ? input - 1 : input;
+    for (let i = input + 1; i < close; i++) {
         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 };
+    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, composer, tick, allowOneTrailing) {
+function statusLast(lines, styled, composer, tick, allowOneTrailing) {
     const status = statusIndex(composer, lines, allowOneTrailing, tick);
     if (status === 'stop')
         return { kind: 'stop' };
@@ -249,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.
@@ -279,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;
@@ -312,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++) {

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 = {