team 0.1.1 → 0.2.0

package/dist/watch/checks/budget.js

@@ -1,4 +1,4 @@
-import { verdict } from "../../budgets/readings.js";
+import { countedFor } from "../../budgets/readings.js";
 import { WINDOWS } from "../../profiles/quota.js";
 import { reported } from "../check.js";
 export const budget = {
@@ -40,65 +40,64 @@ export const budget = {
     },
 };
 /**
- * The account's figure this pass, from the first source that has one (§ 4.3, § 5). A check
- * reading counts while it is fresh; a screen reading counts when the verdict keeps it — fresh,
- * stale, or refusing — and a bare first sight is `unseen`. Null: nothing counts at all.
+ * The account's figures this pass, per window, from the first source that has one for it (§ 4.3,
+ * § 5) — the same rule `countedFor` applies for the launch gate and the table, so the three can't
+ * drift apart. A check reading counts while it is fresh; a screen reading counts when the verdict
+ * keeps it — fresh, stale, or refusing — and a bare first sight is `unseen`. Null: nothing counts
+ * at all. A spend check is one number and no window, fresh by § 5.
  */
 function countedOf(name, account, team, staleMs, now) {
-    for (const source of account.sources) {
-        if (source === 'check') {
-            const outcome = team.outcomes.find((one) => one.account === name);
-            if (!outcome || outcome.state !== 'read')
-                continue;
-            if (outcome.reading.kind === 'spend') {
-                if (now - outcome.reading.at < staleMs) {
-                    return { kind: 'spend', amount: outcome.reading.amount, currency: outcome.reading.currency };
-                }
-                continue;
-            }
-            const windows = outcome.reading.windows
-                .filter((window) => now - window.at < staleMs)
-                .map(({ window, left, used, resetsAt }) => ({ window, left, used, resetsAt }));
-            if (windows.length)
-                return { kind: 'subscription', windows };
+    const outcome = team.outcomes.find((one) => one.account === name);
+    const read = outcome && outcome.state === 'read' ? outcome : null;
+    if (read && read.reading.kind === 'spend' && account.sources.includes('check') && now - read.reading.at < staleMs) {
+        return { kind: 'spend', amount: read.reading.amount, currency: read.reading.currency };
+    }
+    const windows = [];
+    let seen = false;
+    for (const window of WINDOWS) {
+        // The readings of one window, by source: the screen readings the core folded in, and the
+        // check's when this pass's outcome carries that window (§ 5).
+        const screen = team.readings.filter((reading) => reading.account === name && reading.window === window && reading.source === 'status_line');
+        const checks = read && read.reading.kind === 'subscription'
+            ? read.reading.windows
+                .filter((one) => one.window === window)
+                .map((one) => ({
+                account: name,
+                window: one.window,
+                left: one.left,
+                used: one.used,
+                changedAt: one.at,
+                resetsAt: one.resetsAt,
+                seat: null,
+                source: 'check',
+                confirmed: true,
+            }))
+            : [];
+        if (!screen.length && !checks.length)
+            continue;
+        const result = countedFor(account.sources, screen, checks, now, staleMs, account.reserve);
+        if (result.kind === 'unknown')
+            continue;
+        if (result.kind === 'unconfirmed') {
+            seen = true;
             continue;
         }
-        const groups = new Map();
-        for (const reading of team.readings) {
-            if (reading.account !== name)
-                continue;
-            const group = groups.get(reading.window) ?? [];
-            group.push(reading);
-            groups.set(reading.window, group);
-        }
-        const windows = [];
-        let seen = false;
-        for (const group of groups.values()) {
-            const result = verdict(group, now, staleMs, account.reserve);
-            if (result.kind === 'unknown')
-                continue;
-            if (result.kind === 'unconfirmed') {
-                seen = true;
-                continue;
-            }
-            windows.push({
-                window: result.reading.window,
-                left: result.reading.left,
-                used: result.reading.used,
-                resetsAt: result.reading.resetsAt,
-            });
-        }
-        if (windows.length)
-            return { kind: 'subscription', windows };
-        if (seen)
-            return 'unseen';
-        continue;
+        windows.push({
+            window: result.reading.window,
+            left: result.reading.left,
+            used: result.reading.used,
+            resetsAt: result.reading.resetsAt,
+        });
     }
+    if (windows.length)
+        return { kind: 'subscription', windows };
+    if (seen)
+        return 'unseen';
     return null;
 }
 /** 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/dialect.d.ts

@@ -1,5 +1,10 @@
 export declare class DialectError extends Error {
     constructor(message: string);
 }
-/** Compile one pattern. `ignoreCase` is the stage's flag, never an inline `(?i)`. */
+/** Compile one pattern. `ignoreCase` is the stage's flag, never an inline `(?i)`. The
+ *  flag is an ASCII fold: each ASCII letter of the pattern becomes its two-letter class,
+ *  `[Aa]`, exactly what the hand-spelled patterns wrote out. Folding that lives in the
+ *  pattern's own text travels with it — the shared dialect's other engine compiles the
+ *  same source — and the engine's wider Unicode folding (a long s for s, the Kelvin
+ *  sign for k) never applies. */
 export declare function compilePattern(source: string, ignoreCase?: boolean): RegExp;

package/dist/watch/dialect.js

@@ -20,25 +20,31 @@ export class DialectError extends Error {
         this.name = 'DialectError';
     }
 }
-/** Compile one pattern. `ignoreCase` is the stage's flag, never an inline `(?i)`. */
+/** Compile one pattern. `ignoreCase` is the stage's flag, never an inline `(?i)`. The
+ *  flag is an ASCII fold: each ASCII letter of the pattern becomes its two-letter class,
+ *  `[Aa]`, exactly what the hand-spelled patterns wrote out. Folding that lives in the
+ *  pattern's own text travels with it — the shared dialect's other engine compiles the
+ *  same source — and the engine's wider Unicode folding (a long s for s, the Kelvin
+ *  sign for k) never applies. */
 export function compilePattern(source, ignoreCase = false) {
     if (source.length === 0)
         throw new DialectError('a pattern is empty');
     if (source.length > MAX_PATTERN)
         throw new DialectError(`a pattern is longer than ${MAX_PATTERN} characters`);
     refuseSpelling(source);
-    const parser = new Parser(source);
+    const parser = new Parser(source, ignoreCase);
     const body = parser.parseAlt();
     if (!parser.done())
         throw new DialectError('a pattern has an extra ")"');
-    const flags = ignoreCase ? 'iu' : 'u';
-    return new RegExp(body.source, flags);
+    return new RegExp(body.source, 'u');
 }
 class Parser {
     at = 0;
     source;
-    constructor(source) {
+    ignoreCase;
+    constructor(source, ignoreCase) {
         this.source = source;
+        this.ignoreCase = ignoreCase;
     }
     done() {
         return this.at >= this.source.length;
@@ -114,7 +120,15 @@ class Parser {
         if (ch === ')')
             throw new DialectError('a pattern has an extra ")"');
         const cp = this.readCodePoint();
-        return this.leaf(escapeLiteral(cp), true);
+        return this.leaf(this.fold(cp), true);
+    }
+    // A literal under ignore_case: an ASCII letter becomes its two-letter class, `[Aa]`,
+    // as the hand-spelled patterns wrote it; everything else stands as itself.
+    fold(cp) {
+        const other = asciiCaseSwapped(cp);
+        if (!this.ignoreCase || other === null)
+            return escapeLiteral(cp);
+        return emitClass(false, [cp, other]);
     }
     parseGroup() {
         this.expect('(');
@@ -213,7 +227,7 @@ class Parser {
                 parts.push({ kind: 'char', cp: this.readCodePoint() });
         }
         this.expect(']');
-        return classSource(negated, foldRanges(parts));
+        return classSource(negated, foldRanges(parts, this.ignoreCase));
     }
     parseClassEscape() {
         this.expect('\\');
@@ -318,7 +332,9 @@ function refuseSpelling(source) {
 }
 // A class is a finite set, except a complement shorthand (`\S`, `\D`, `\W`), whose
 // negation brings it back to a finite set. `[^\S\n]` is the whitespace set without
-// a newline, which is what the working-line pattern relies on.
+// a newline, which is what the working-line pattern relies on. A positive class that
+// mixed one with other members would compile to a class nobody wrote (`[\D0-9]` is
+// everything), so it is refused rather than rewritten.
 function classSource(negated, parts) {
     const positive = new Set();
     const complements = [];
@@ -333,13 +349,16 @@ function classSource(negated, parts) {
     }
     if (complements.length === 0)
         return emitClass(negated, [...positive]);
+    if (!negated && positive.size > 0) {
+        throw new DialectError('a class cannot mix a complement shorthand with other members: negate the class, or write the shorthand alone');
+    }
     let inter = new Set(complements[0]);
     for (const extra of complements.slice(1))
         inter = new Set([...inter].filter((cp) => extra.includes(cp)));
     const remaining = [...inter].filter((cp) => !positive.has(cp));
     return emitClass(!negated, remaining);
 }
-function foldRanges(parts) {
+function foldRanges(parts, ignoreCase = false) {
     const out = [];
     for (let i = 0; i < parts.length; i++) {
         const part = parts[i];
@@ -358,7 +377,38 @@ function foldRanges(parts) {
         else
             out.push(part);
     }
-    return out;
+    if (!ignoreCase)
+        return out;
+    // Under ignore_case every ASCII letter of the class carries its other case too, as the
+    // letter classes of the hand-spelled patterns did. A complement shorthand (`\S` and
+    // the like) is written as its own set: its members are not the pattern's letters.
+    return out.map((part) => {
+        if (part.kind === 'char') {
+            const other = asciiCaseSwapped(part.cp);
+            return other === null ? part : { kind: 'chars', cps: [part.cp, other] };
+        }
+        if (part.kind === 'chars') {
+            const cps = [...part.cps];
+            for (const cp of part.cps) {
+                const other = asciiCaseSwapped(cp);
+                if (other !== null)
+                    cps.push(other);
+            }
+            return { kind: 'chars', cps };
+        }
+        return part;
+    });
+}
+// The other case of an ASCII letter, or null for every other character: the whole of a
+// pattern's ignore_case fold. The engine's Unicode folding — a long s (U+017F) for s,
+// the Kelvin sign (U+212A) for k — is deliberately not applied; the hand-spelled
+// classes this flag replaced never applied it.
+function asciiCaseSwapped(cp) {
+    if (cp >= 0x41 && cp <= 0x5a)
+        return cp + 0x20;
+    if (cp >= 0x61 && cp <= 0x7a)
+        return cp - 0x20;
+    return null;
 }
 function emitClass(negated, cps) {
     const sorted = [...new Set(cps)].sort((a, b) => a - b);
@@ -395,7 +445,7 @@ function classChar(cp) {
     if (cp === 0x2d || cp === 0x5d || cp === 0x5e || cp === 0x5c)
         return `\\${String.fromCodePoint(cp)}`;
     if (cp < 0x20 || cp > 0x7e)
-        return `\\u${cp.toString(16).padStart(4, '0')}`;
+        return codePointEscape(cp);
     return String.fromCodePoint(cp);
 }
 function escapeLiteral(cp) {
@@ -403,9 +453,15 @@ function escapeLiteral(cp) {
     if ('\\.^$|?*+()[]{}'.includes(ch))
         return `\\${ch}`;
     if (cp < 0x20 || cp > 0x7e)
-        return `\\u${cp.toString(16).padStart(4, '0')}`;
+        return codePointEscape(cp);
     return ch;
 }
+// A code point above U+FFFF needs the "\u{…}" form, which every pattern can carry: the "u"
+// flag is always set (compilePattern). A four-digit escape cannot spell it — the digits
+// would spill into the following character.
+function codePointEscape(cp) {
+    return cp > 0xffff ? `\\u{${cp.toString(16)}}` : `\\u${cp.toString(16).padStart(4, '0')}`;
+}
 function seqSource(atoms) {
     return atoms.map((atom) => atom.source).join('');
 }

package/dist/watch/pass.d.ts

@@ -1,10 +1,12 @@
 import { type Seen } from '../budgets/readings.ts';
 import type { CheckOutcome } from '../budgets/run.ts';
 import type { TeamFile } from '../file/types.ts';
+import { type QuotaPattern } from '../profiles/quota.ts';
 import type { SessionState } from '../state.ts';
 import type { Live } from '../status/compare.ts';
 import { type Report, type SeatCheck, type SeatHistory, type TeamCheck } from './check.ts';
 import type { Machine } from './machine.ts';
+import { type Screen } from './screen.ts';
 export type Memory = {
     history: Record<string, SeatHistory>;
     slots: Record<string, unknown>;
@@ -35,8 +37,14 @@ 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[];
+    foreground?: Readonly<Record<string, readonly string[] | null>>;
+    /** Screen readings with the approved overrides applied. The shipped profiles, when omitted. */
+    readScreen?: (cli: string, screen: string | undefined) => Screen;
+    /** Quota patterns in force, shipped plus the approved override. The shipped list, when omitted. */
+    quotaFor?: (cli: string) => readonly QuotaPattern[];
 };
-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, foreground, readScreen: read, quotaFor: patternsOf, }: PassInput): PassResult;

package/dist/watch/pass.js

@@ -2,9 +2,10 @@
 // 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 { quotaFor } from "../profiles/profile.js";
+import { seatNamed } from "../approve/fingerprint.js";
+import { observe, observeCheck } from "../budgets/readings.js";
+import { reportedLiveAgent } from "../launch/agent.js";
+import { profileFor, quotaFor as shippedQuota } from "../profiles/profile.js";
 import { figuresOf } from "../profiles/quota.js";
 import { seatModel } from "../status/statusline.js";
 import { ALWAYS_ON, } from "./check.js";
@@ -33,8 +34,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
@@ -52,16 +53,20 @@ function attentionOf(screen, status, quiet) {
 }
 // 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)
+// unknown one gives no figures, and neither does a line the seat printed or typed. And only a
+// pane where herdr reports the seat's CLI still running: a shell's last row is a last row by
+// position, not a status row, and a pane herdr could not read gives none either — no figure is
+// invented where the CLI was not seen. (`down` and `remove` read that same null the other way at
+// their departure wait; not knowing must not end a wait.)
+function quotaOf(cli, screen, pane, runs, patterns) {
+    if (pane === undefined || !runs)
         return [];
     if (screen.kind !== 'idle' && screen.kind !== 'unsent' && screen.kind !== 'working')
         return [];
-    return figuresOf(quotaFor(cli), statusRow(cli, pane));
+    return figuresOf(patterns, 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 = [], foreground, readScreen: read = readScreen, quotaFor: patternsOf = shippedQuota, }) {
     const reports = [];
     const current = new Set();
     // Reported when it starts, and again only after it has cleared.
@@ -81,6 +86,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 +94,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 +118,7 @@ export function pass({ team, state, live, machine, now, memory, approval, watch
                 screen: { kind: 'unknown' },
                 cli,
                 vendor,
+                account,
                 quota: [],
                 running: false,
                 quiet: false,
@@ -120,7 +135,7 @@ export function pass({ team, state, live, machine, now, memory, approval, watch
         }
         known.add(agent.pane);
         const pane = live.screens[agent.pane];
-        const screen = readScreen(cli, pane);
+        const screen = read(cli, pane);
         const quiet = agent.status === 'idle' || agent.status === 'done';
         // Working is herdr's word or the screen's: a seat mid-turn is never idle, whatever its
         // status says.
@@ -146,7 +161,8 @@ export function pass({ team, state, live, machine, now, memory, approval, watch
             screen,
             cli,
             vendor,
-            quota: quotaOf(cli, screen, pane),
+            account,
+            quota: quotaOf(cli, screen, pane, reportedLiveAgent(foreground?.[agent.pane] ?? null, profileFor(cli)?.processNames ?? []), patternsOf(cli)),
             running: true,
             quiet,
             working,
@@ -159,19 +175,45 @@ 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));
+    for (const [name, recorded] of Object.entries(state.seats)) {
+        if (recorded.temporary && drift.has(recorded.temporary.like)) {
+            drift.add(name);
+        }
+    }
+    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 +238,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)
@@ -226,7 +267,7 @@ export function pass({ team, state, live, machine, now, memory, approval, watch
         const operator = live.agents.find((agent) => agent.name === team.operator);
         const cli = team.seats.find((seat) => seat.name === team.operator)?.cli ?? '';
         const free = operator !== undefined && (operator.status === 'idle' || operator.status === 'done')
-            && readScreen(cli, live.screens[operator.pane]).kind === 'idle';
+            && read(cli, live.screens[operator.pane]).kind === 'idle';
         if (operator && free) {
             nudge = { pane: operator.pane, text: NUDGE_TEXT, pending: memory.pending.slice() };
         }

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

@@ -1,6 +1,7 @@
 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';
+import type { ScreenData, Wrap } from './screen-data.ts';
+export type { Composer, FallbackRule, LinePattern, Placeholder, PlaceholderStyle, Rule, ScreenData, Stage, Wrap } from './screen-data.ts';
+export type { ScreenProfile, ComposerReading } from './screen-profile.ts';
 export type ReadClock = {
     now(): number;
     budgetMs: number;
@@ -11,10 +12,46 @@ export type ReadClock = {
  * 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;
+export type Fold = {
+    count: number;
+    rows: string[];
+    width: number;
+};
+/** The input box a composer draws for its current text: the first line after the prompt, the
+ *  continuation rows under it, the column those rows start at (the prompt's own width plus
+ *  the separator the input row draws), and the profile's wrap rule when a capture shows how
+ *  the box continues a line onto its next row. */
+export type Box = {
+    first: string;
+    indent: number;
+    rows: string[];
+    wrap?: Wrap;
+};
+/**
+ * The fold a `two-rules-footer-below` composer's window shows, or null. A marker whose count is
+ * zero names no hidden rows to compare against, so it is no fold; it is still a marker, and
+ * `foldMarked` catches it.
+ */
+export declare function foldOf(data: ScreenData, lines: string[]): Fold | null;
+/**
+ * Whether the window shows a fold marker at all, whatever count it names: a marker claiming zero
+ * hidden rows (or a count a fold could not have) is still a box that is not showing the whole
+ * text, and it must never be taken for an ordinary unsent box and submitted unverified.
+ */
+export declare function foldMarked(data: ScreenData, lines: string[]): boolean;
 /** `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;
 /**
- * The composer alone, for a turn that is still running. The unknown stage is
- * read first, as in the full classification, and the floor still applies.
+ * The composer alone, for a turn that is still running. The dialog stages and
+ * floor must not be overridden by composer readings returning idle or unsent.
  */
 export declare function composeLines(data: ScreenData, lines: string[], clock?: ReadClock): Screen;
+/**
+ * The input box a composer draws for its current text, or null when the composer does not read
+ * `unsent`: an idle box holds nothing, and every other shape is not the box. The rows are the
+ * ones the mode's own frame delimits — between the prompt row and the box's closing line; the
+ * `status-then-one` fallback (the captured completion frame) delimits nothing, so its box is
+ * its one input row, the popup rows below it being its filter's to exclude. The caller compares
+ * the box to the text it typed; nothing here decides that.
+ */
+export declare function composerBox(data: ScreenData, lines: string[]): Box | null;