team 0.1.0 → 0.1.2

package/dist/launch/rules.js

@@ -30,7 +30,21 @@ export function seatRules(input) {
     }
     return [...own, ...input.rules, ...signing, ...working];
 }
-/** The rules as the one text a launch option or a first message carries. */
-export function rulesText(input) {
-    return ['Rules for this session, from the team file:', ...seatRules(input).map((rule) => `- ${rule}`)].join('\n');
+/**
+ * The line each form ends with. The message says what the rules are and never that they are not a
+ * task, so some models start complying by investigating instead of waiting for a brief. A first
+ * message is answered once, so it can ask for the ready reply; a system prompt (a launch option)
+ * stays in force on every later turn, so it must not: a Claude seat could answer "ready" to its
+ * real brief.
+ */
+const CLOSING = {
+    message: 'These are standing rules, not a task: reply ready and wait for your brief.',
+    option: 'These are standing rules, not a task.',
+};
+/** The rules as the one text a launch option or a first message carries, the closing line last. */
+export function rulesText(input, delivery) {
+    // A file whose own rules already carry the form's closing line gets it once: as the closing line.
+    const closing = CLOSING[delivery];
+    const rules = seatRules(input).filter((rule) => rule !== closing);
+    return ['Rules for this session, from the team file:', ...rules.map((rule) => `- ${rule}`), closing].join('\n');
 }

package/dist/profiles/antigravity.yaml

@@ -43,6 +43,12 @@ screen:
           - 'Do you trust the contents of this project\?'
           - '>\s*Yes, I trust this folder'
         below_last_rule: 'enter Confirm'
+      # The captured trust dialog fills the pane: there is no composer rule.
+      - all:
+          - 'Do you trust the contents of this project\?'
+          - '>\s*Yes, I trust this folder'
+          - 'enter Confirm'
+        without_rule: true
   permission:
     ignore_case: true
     rules:
@@ -50,6 +56,13 @@ screen:
           - 'Requesting permission for:'
           - '^\s*>\s*[0-9]\.\s+Yes\b'
         below_last_rule: '↑/↓ Navigate'
+      # A long command pushes the one rule out of the window. The dialog is the
+      # three lines, with no composer rule left to sit below.
+      - all:
+          - 'Requesting permission for:'
+          - '^\s*>\s*[0-9]\.\s+Yes\b'
+          - '↑/↓ Navigate'
+        without_rule: true
   working:
     - any: ['\bGenerating\.\.\.']
   composer:

package/dist/profiles/claude-code.yaml

@@ -50,12 +50,38 @@ screen:
       footer: 'Esc to cancel · Tab to amend'
       below_last_rule: 'Esc to cancel · Tab to amend'
     - below_last_rule: '^\s*❯?\s*[0-9]\. (Yes|No)\b'
+    # A pane with no composer rule whose choice is the dialog, including the
+    # unmarked "1. Yes" while up is running. A choice quoted above an empty
+    # prompt is a transcript: the empty prompt comes after it.
+    - all:
+        - '^\s*❯?\s*[0-9]\. (Yes|No)\b'
+      without_rule: true
+      none_after:
+        anchor: '^\s*❯?\s*[0-9]\. (Yes|No)\b'
+        patterns:
+          - '^\s*[❯›>]\s*$'
   question:
+    # The phrase is the dialog's last line, as a permission footer is. Prose
+    # above the box is not a question.
+    - any:
+        - 'Enter to select'
+        - '↑/↓ to navigate'
+        - 'Enter to confirm'
+        - 'Esc to cancel'
+      on_footer: true
+    - below_last_rule: 'Enter to select|↑/↓ to navigate|Enter to confirm|Esc to cancel'
+    # The footer has a status line under it and the rule is out of the window.
+    # A phrase quoted above an empty prompt is a transcript.
     - any:
         - 'Enter to select'
         - '↑/↓ to navigate'
         - 'Enter to confirm'
         - 'Esc to cancel'
+      without_rule: true
+      none_after:
+        anchor: 'Enter to select|↑/↓ to navigate|Enter to confirm|Esc to cancel'
+        patterns:
+          - '^\s*[❯›>]\s*$'
   working:
     - any:
         - '\besc to interrupt\b'
@@ -64,6 +90,10 @@ screen:
     mode: box-to-rule
     prompt: '^\s*[❯›>]'
     rule: '^\s*[─━]{8,}'
+    # Claude Code greys every suggestion it shows — "Try …", "Resume briefly.", any other —
+    # with faint styling, while typed text carries none. The list below stays the fallback
+    # for a source without styling.
+    placeholder_style: dim
     placeholders:
       - equals: ''
       - prefix: 'Try "'

package/dist/profiles/cursor.yaml

@@ -48,8 +48,11 @@ screen:
           - '^\s*→'
           - '^\s+Grok\s+[0-9]'
   working:
+    # The running turn is the braille spinner, or the prompt line ending in
+    # "ctrl+c to stop". Idle and rules-accepted captures do not paint that suffix.
+    # The same words quoted in the transcript are not a turn.
     - any:
-        - 'ctrl\+c to stop'
+        - '^\s*→.*\s{2,}ctrl\+c to stop\s*$'
         - '^\s*[⠀-⣿]+\s+(Working|Thinking)\b'
   composer:
     mode: status-then-one

package/dist/profiles/quota.d.ts

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

package/dist/profiles/quota.js

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

package/dist/state.d.ts

@@ -1,4 +1,4 @@
-import type { StoredReading } from './budgets/readings.ts';
+import type { StoredReading, StoredSpend } from './budgets/readings.ts';
 export type SeatState = {
     stage: 'launched' | 'named' | 'ready';
     pane?: string;
@@ -35,8 +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>;
 };
 export type State = {
     format: 1;
@@ -44,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

@@ -27,4 +27,17 @@ export type PassResult = {
 };
 export declare const SEAT_CHECKS: SeatCheck[];
 export declare const TEAM_CHECKS: TeamCheck[];
-export declare function pass(team: TeamFile, state: SessionState, live: Live, machine: Machine, now: number, memory: Memory, approval?: string[] | null, watch?: TeamFile['watch'], outcomes?: readonly CheckOutcome[], budgets?: TeamFile['budgets']): PassResult;
+export type PassInput = {
+    team: TeamFile;
+    state: SessionState;
+    live: Live;
+    machine: Machine;
+    now: number;
+    memory: Memory;
+    approval?: string[] | null;
+    watch: TeamFile['watch'];
+    outcomes?: readonly CheckOutcome[];
+    budgets?: TeamFile['budgets'];
+    readings?: readonly Seen[];
+};
+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";
@@ -23,7 +23,7 @@ import { swapFree } from "./checks/swap-free.js";
 import { swapGrowth } from "./checks/swap-growth.js";
 import { teamIdle } from "./checks/team-idle.js";
 import { unsent } from "./checks/unsent.js";
-import { readScreen } from "./screen.js";
+import { readScreen, statusRow } from "./screen.js";
 export function newMemory() {
     return { history: {}, slots: {}, active: new Set(), pending: [], pendingSince: null };
 }
@@ -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
@@ -50,13 +50,18 @@ function attentionOf(screen, status, quiet) {
         return 'unknown';
     return null;
 }
+// The figures off a seat's own pane: only a composer screen — idle, unsent or working — shows a
+// status row at all, and only that row's line is read. A dialog, a question, a trust screen or an
+// unknown one gives no figures, and neither does a line the seat printed or typed.
+function quotaOf(cli, screen, pane) {
+    if (pane === undefined)
+        return [];
+    if (screen.kind !== 'idle' && screen.kind !== 'unsent' && screen.kind !== 'working')
+        return [];
+    return figuresOf(quotaFor(cli), statusRow(cli, pane));
+}
 // One pass of the watch. Pure: it reads what it is handed and changes only `memory`.
-// `approval` is how the file differs from the approved one: [] when it doesn't, null when it was
-// never approved, undefined when that wasn't looked at. `watch` and `budgets` are the sections in
-// force — the approved ones, or the defaults while the file's own are not approved — and the
-// checks read those, never the file's. `outcomes` is what the accounts' check commands read
-// outside the pass, when the watch last ran them.
-export function pass(team, state, live, machine, now, memory, approval, watch = team.watch, outcomes = [], budgets = team.budgets) {
+export function pass({ team, state, live, machine, now, memory, approval, watch, outcomes = [], budgets = team.budgets, readings: stored = [], }) {
     const reports = [];
     const current = new Set();
     // Reported when it starts, and again only after it has cleared.
@@ -76,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,
@@ -83,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) {
@@ -99,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,
@@ -141,7 +156,8 @@ export function pass(team, state, live, machine, now, memory, approval, watch =
             screen,
             cli,
             vendor,
-            quota: pane === undefined ? [] : figuresOf(quotaFor(cli), pane),
+            account,
+            quota: quotaOf(cli, screen, pane),
             running: true,
             quiet,
             working,
@@ -154,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,
@@ -191,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,10 +1,16 @@
 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;
 };
+/**
+ * The one line a quota figure may be read from: the composer's own status row, or null when the
+ * window shows none. A dialog, a transcript line, the input box — anything the seat printed or
+ * typed — is never the row. The caller still has to know the screen is a composer screen.
+ */
+export declare function statusRowOf(data: ScreenData, lines: string[]): string | null;
 /** `lines` is already the window: the last 20 lines, each trimmed at the end. */
 export declare function classifyLines(data: ScreenData, lines: string[], clock?: ReadClock): Screen;
 /**