team 0.1.2 → 0.2.0

package/dist/watch/pass.js

@@ -4,7 +4,8 @@
 // handed (RFC 0002 § 4.2).
 import { seatNamed } from "../approve/fingerprint.js";
 import { observe, observeCheck } from "../budgets/readings.js";
-import { quotaFor } from "../profiles/profile.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";
@@ -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, outcomes = [], budgets = team.budgets, readings: stored = [], }) {
+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.
@@ -130,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.
@@ -157,7 +162,7 @@ export function pass({ team, state, live, machine, now, memory, approval, watch,
             cli,
             vendor,
             account,
-            quota: quotaOf(cli, screen, pane),
+            quota: quotaOf(cli, screen, pane, reportedLiveAgent(foreground?.[agent.pane] ?? null, profileFor(cli)?.processNames ?? []), patternsOf(cli)),
             running: true,
             quiet,
             working,
@@ -183,6 +188,11 @@ export function pass({ team, state, live, machine, now, memory, approval, watch,
     // 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 || drift.has(seat.name))
@@ -257,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, PlaceholderStyle, 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;