team 0.1.1 → 0.2.0

package/dist/profiles/claude-code.yaml

@@ -1,6 +1,6 @@
-# Claude Code's screen. The questions are written out in both cases: the old
-# classifier ignored case on those two lines and not on the "1. Yes" choice, and
-# ignore_case would apply to the whole rule.
+# Claude Code's screen. The trust question carries ignore_case on its own pattern:
+# the old classifier ignored case on those lines and not on the "1. Yes" choice,
+# and a rule-wide or stage-wide flag would have reached the choice too.
 format: 1
 cli: claude-code
 binary: claude
@@ -39,8 +39,12 @@ status_model:
 screen:
   trust:
     - all:
-        - '(?:[Dd][Oo] [Yy][Oo][Uu] [Tt][Rr][Uu][Ss][Tt] (?:[Tt][Hh][Ii][Ss]|[Tt][Hh][Ee]) [Ff][Oo][Ll][Dd][Ee][Rr]\?|[Oo][Nn][Ee] [Yy][Oo][Uu] [Tt][Rr][Uu][Ss][Tt]\?)'
+        - match: '(?:Do you trust (?:this|the) folder\?|One you trust\?)'
+          ignore_case: true
         - '^\s*[❯›>]?\s*1\.\s+Yes\b'
+    - all:
+        - '^\s*[❯›>]?\s*Yes, I trust this folder\b'
+      footer: 'Enter to confirm · Esc to cancel'
   # A quoted question above the composer's rule is not a dialog. The footer is the
   # captured last line and needs the question. A Yes/No choice below the last rule
   # is the other shape; the mark is optional, as on an unmarked "2. No".
@@ -50,20 +54,61 @@ 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'
         - '^[^\S\n]*[✢✳✶✻✼✽][^\n]*…\s*\(\s*\d'
   composer:
     mode: box-to-rule
-    prompt: '^\s*[❯›>]'
-    rule: '^\s*[─━]{8,}'
+    # The prompt sits at the pane's first column, as unsent-typed-ansi.txt draws `❯ Fix the`;
+    # the pane draws continuation rows at the content column — two spaces — so a prompt glyph
+    # on one of those is content, never the input row. The reader takes the box's first row
+    # under its opening rule and anchors this pattern to the captured column: a row the box
+    # holds can never be mistaken for the input.
+    prompt: '^[❯›>]'
+    # The box's two rules, as unsent-typed-ansi.txt draws them: one unbroken run of ─ from the
+    # pane's first column, the closing rule the window's last rule row. A rule-looking row the
+    # box holds is drawn at the content column and is content, never the frame.
+    rule: '^[─━]{8,}$'
+    footers:
+      - '^\s{2,}.*·.*(?:Opus|Sonnet|Haiku|Fable)\s+[0-9]+.*$'
+      - '^\s{2,}(?:⏵⏵\s+)?bypass permissions\b.*$'
+    # 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/codex.yaml

@@ -44,6 +44,9 @@ status_model:
     model: 'GPT {2:title}'
     version: '{1}'
   # A later footer that is not one of those four names is unread, as the old id map was.
+  # The `{1}` names a group this pattern does not have, on purpose: a template that cannot
+  # fill reads the line as naming no model. There is no plainer spelling — an empty string
+  # is refused and a literal would read as a found model, not as unread.
   - match: '^\s+GPT-[0-9][\w.-]*\s[^·]*·'
     model: '{1}'
     version: '{1}'
@@ -71,7 +74,17 @@ screen:
   composer:
     mode: status-last
     status_line: '^\s+GPT-[0-9][\w.-]*\s+[^·]*·'
-    prompt: '^\s*›(?:\s|$)'
+    # The input row carries the prompt at the pane's first column — unsent.txt draws `› Rules.`
+    # there, content on the rows below at the second, and exit-typed.txt keeps the old
+    # transcript and menu rows above it — and a prompt glyph on a content row is never the
+    # input row. The read scans up from the status line and anchors this pattern to the
+    # captured column.
+    prompt: '^›(?:\s|$)'
     placeholders:
       - equals: ''
       - equals: Ask Codex to do anything
+    # unsent.txt and exit-typed.txt show one empty row under the text, between it and the
+    # status line: the drop the pane draws of its own, inside the box's frame. The box read
+    # strips up to one trailing empty row as that frame; a row beyond it is one the typed
+    # text does not have.
+    frame_rows: 1

package/dist/profiles/cursor.yaml

@@ -48,18 +48,61 @@ screen:
           - '^\s*→'
           - '^\s+Grok\s+[0-9]'
   working:
+    # The running turn is the braille spinner (whatever verb it paints), the
+    # prompt line ending in "ctrl+c to stop", or the follow-up queue: the box's
+    # `enter …` hint row with, below it, the composer's own row — empty, or its
+    # placeholder. The order is the frame's: what follows the hint row may be
+    # chrome or that unpainted composer row and nothing else, so a typed row
+    # under the box falls to the composer read and says unsent. A transcript
+    # that quotes the box paints its prose lines there, so the queue rule reads
+    # them as content and leaves the screen alone. Idle and rules-accepted
+    # captures paint none of these.
     - any:
-        - 'ctrl\+c to stop'
-        - '^\s*[⠀-⣿]+\s+(Working|Thinking)\b'
+        - '^\s*→.*\s{2,}ctrl\+c to stop\s*$'
+        - '^\s*[⠀-⣿]+\s+\S'
+    - all:
+        - '^\s*│\s*enter (?:steer|interrupt and send) · ↑ select/edit · esc cancel\s*│\s*$'
+        - '^\s*→\s*(?:Add a follow-up|Plan, search, build anything)?\s*$'
+      none_after:
+        anchor: '^\s*│\s*enter (?:steer|interrupt and send) · ↑ select/edit · esc cancel\s*│\s*$'
+        patterns:
+          - match: '^\s*\S'
+            except:
+              - '^\s*[│┌└─┐┘├┤]'
+              - '^\s*[⠀-⣿]'
+              - '^\s*Tip:'
+              - '^\s*→\s*(?:Add a follow-up|Plan, search, build anything)?\s*$'
+              - '^\s+Grok\s'
+              - '^\s*<workspace>'
+              - '^\s*~/'
+              - '^\s*❯'
   composer:
     mode: status-then-one
     status_line: '^\s+Grok\s+[0-9]'
-    prompt: '^\s*→'
+    # The input row carries the prompt at the pane's second column — unsent.txt and
+    # follow-up-queue-typed.txt draw `  → Plan, search, build anything` there, continuations at
+    # the fourth — and a prompt glyph on a content or popup row is never the input row. The
+    # read scans up from the status line and anchors this pattern to the captured column.
+    prompt: '^ {2}→'
     strip_suffix: '\s*ctrl\+c to stop\s*$'
     placeholders:
       - equals: ''
       - equals: Plan, search, build anything
       - equals: Add a follow-up
+    # A line wider than the pane's content column continues on the next row at the text
+    # column, broken at a space: unsent.txt is its sentence word-wrapped this way on a
+    # 51-column pane, and the box is compared with the typed text before any Enter. Only
+    # the whitespace the row break itself stands for is normalised — the run the break was
+    # made at, or a blank line the text itself has; inside a row, every character must
+    # match, runs of spaces included.
+    wrap:
+      continuation: text-column
+      kind: word
+    # unsent.txt and follow-up-queue-typed.txt show two empty rows under the text, between
+    # it and the status line: the drop the pane draws of its own, inside the box's frame.
+    # The box read strips up to two trailing empty rows as that frame; a row beyond them is
+    # one the typed text does not have.
+    frame_rows: 2
     fallback:
       - all:
           - match: '^\s*→\s+\S'

package/dist/profiles/overrides.d.ts

@@ -0,0 +1,67 @@
+import type { QuotaPattern } from './quota.ts';
+import type { ScreenData, Stage } from '../watch/screen-data.ts';
+import { type Screen } from '../watch/screen.ts';
+export declare const DIALOG_STAGES: readonly ["unknown", "trust", "permission", "question"];
+export type DialogStage = (typeof DIALOG_STAGES)[number];
+export type ProfileOverride = {
+    cli: string;
+    screen: Partial<Record<DialogStage, Stage>>;
+    quota: QuotaPattern[];
+};
+export type OverrideProblem = {
+    line: number;
+    message: string;
+};
+export type OverrideParse = {
+    ok: true;
+    profiles: ProfileOverride[];
+} | {
+    ok: false;
+    errors: OverrideProblem[];
+};
+/** `<store>/overrides.yaml`, the same folder as the approval for this root. */
+export declare function overridesPath(project: string, root: string, home: string): string;
+/** The file's added patterns, or the line that refuses it. One error, the first. */
+export declare function parseOverrides(text: string): OverrideParse;
+/**
+ * Shipped rules stay first, and the added ones follow. The composer and the
+ * chrome are the shipped profile's own objects, so an override cannot retune
+ * them by merging.
+ */
+export declare function mergeScreen(base: ScreenData, added: ProfileOverride): ScreenData;
+/**
+ * An added pattern may move a reading toward a dialog. It may not make a screen
+ * idle or unsent when the shipped profile does not, and it may not stop a
+ * shipped permission, trust or question pattern from matching.
+ */
+export declare function guardReading(shipped: Screen, merged: Screen): Screen;
+/** The shipped reading, then the same window with this profile's added patterns, guarded. */
+export declare function classifyWith(cli: string, screen: string | undefined, profiles: readonly ProfileOverride[]): Screen;
+/** Shipped quota patterns, then the override's. The shipped ones are never dropped. */
+export declare function quotaWith(cli: string, profiles: readonly ProfileOverride[]): readonly QuotaPattern[];
+/** What `approve` records when the override file itself is the change. */
+export declare const OVERRIDE_CHANGED = "`overrides` changed";
+/** A stored copy that does not parse. The shipped profiles stay in force. */
+export declare const OVERRIDE_UNREADABLE = "the approved overrides can't be read";
+export type OverrideForce = {
+    /** The approved patterns. Empty when none were approved, or the copy cannot be read. */
+    profiles: ProfileOverride[];
+    /** Drift from the approved copy. Empty when the file is the approved one, or there is none. */
+    differences: string[];
+    /** The live file, when it cannot be read or parsed. Already carrying the path and the line. */
+    problems: string[];
+};
+/** The override file's text, and why it was refused. A missing file is an empty text and no problem. */
+export declare function overrideFile(project: string, root: string, home: string): {
+    path: string;
+    text: string | null;
+    problems: string[];
+};
+/**
+ * The patterns in force for this project. Keyed on the project root, the same
+ * store as the team-file approval: another checkout of the same name has its
+ * own. No file, or a stored copy that cannot be read, leaves the shipped profiles.
+ * The live file is used only when it is the text `approve` recorded.
+ */
+export declare function overridesInForce(project: string, root: string, home: string): OverrideForce;
+export declare function overrideProblem(path: string, problem: OverrideProblem): string;

package/dist/profiles/overrides.js

@@ -0,0 +1,190 @@
+// The owner's override file. It sits beside the approval and may only add dialog
+// patterns and quota patterns to a profile this version ships. It cannot take a
+// shipped pattern out, and it cannot change a composer, a prompt, a footer, a
+// launch line or the order of the stages: anything else in the file is refused
+// with its line. An edit takes effect only once `approve` records the text: until
+// then the approved copy stays in force, and a copy that cannot be read leaves
+// the shipped profiles.
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { profileFor, quotaFor, quotaList } from "./profile.js";
+import { readApproval, storePath } from "../store/store.js";
+import { addedRules } from "../watch/screen-file.js";
+import { classifyData, screenData } from "../watch/screen.js";
+import { YamlError, parseYaml } from "../yaml.js";
+export const DIALOG_STAGES = ['unknown', 'trust', 'permission', 'question'];
+/** `<store>/overrides.yaml`, the same folder as the approval for this root. */
+export function overridesPath(project, root, home) {
+    return join(storePath(project, root, home), 'overrides.yaml');
+}
+/** The file's added patterns, or the line that refuses it. One error, the first. */
+export function parseOverrides(text) {
+    try {
+        return { ok: true, profiles: profilesOf(parseYaml(text)) };
+    }
+    catch (error) {
+        if (error instanceof YamlError)
+            return { ok: false, errors: [{ line: error.line, message: error.message }] };
+        throw error;
+    }
+}
+/**
+ * Shipped rules stay first, and the added ones follow. The composer and the
+ * chrome are the shipped profile's own objects, so an override cannot retune
+ * them by merging.
+ */
+export function mergeScreen(base, added) {
+    const next = { ...base };
+    for (const name of DIALOG_STAGES) {
+        const extra = added.screen[name];
+        if (!extra)
+            continue;
+        const existing = base[name];
+        next[name] = { rules: [...(existing?.rules ?? []), ...extra.rules] };
+    }
+    return next;
+}
+const KEPT = new Set(['permission', 'trust', 'question']);
+const DIALOG = new Set(['unknown', 'trust', 'permission', 'question']);
+/**
+ * An added pattern may move a reading toward a dialog. It may not make a screen
+ * idle or unsent when the shipped profile does not, and it may not stop a
+ * shipped permission, trust or question pattern from matching.
+ */
+export function guardReading(shipped, merged) {
+    if (KEPT.has(shipped.kind))
+        return shipped;
+    if ((merged.kind === 'idle' || merged.kind === 'unsent') && merged.kind !== shipped.kind)
+        return shipped;
+    if (!DIALOG.has(merged.kind))
+        return shipped;
+    return merged;
+}
+/** The shipped reading, then the same window with this profile's added patterns, guarded. */
+export function classifyWith(cli, screen, profiles) {
+    if (screen === undefined)
+        return { kind: 'unknown' };
+    const base = screenData(cli);
+    if (!base)
+        return { kind: 'unknown' };
+    const lines = screen.split('\n');
+    const shipped = classifyData(base, lines);
+    const added = profiles.find((profile) => profile.cli === cli);
+    if (!added || DIALOG_STAGES.every((stage) => added.screen[stage] === undefined))
+        return shipped;
+    return guardReading(shipped, classifyData(mergeScreen(base, added), lines));
+}
+/** Shipped quota patterns, then the override's. The shipped ones are never dropped. */
+export function quotaWith(cli, profiles) {
+    const added = profiles.find((profile) => profile.cli === cli)?.quota ?? [];
+    return [...quotaFor(cli), ...added];
+}
+/** What `approve` records when the override file itself is the change. */
+export const OVERRIDE_CHANGED = '`overrides` changed';
+/** A stored copy that does not parse. The shipped profiles stay in force. */
+export const OVERRIDE_UNREADABLE = "the approved overrides can't be read";
+/** The override file's text, and why it was refused. A missing file is an empty text and no problem. */
+export function overrideFile(project, root, home) {
+    const path = overridesPath(project, root, home);
+    try {
+        const text = readFileSync(path, 'utf8');
+        const parsed = parseOverrides(text);
+        return { path, text, problems: parsed.ok ? [] : parsed.errors.map((problem) => overrideProblem(path, problem)) };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { path, text: null, problems: [] };
+        return { path, text: null, problems: [overrideProblem(path, { line: 0, message: "can't be read" })] };
+    }
+}
+/**
+ * The patterns in force for this project. Keyed on the project root, the same
+ * store as the team-file approval: another checkout of the same name has its
+ * own. No file, or a stored copy that cannot be read, leaves the shipped profiles.
+ * The live file is used only when it is the text `approve` recorded.
+ */
+export function overridesInForce(project, root, home) {
+    const record = readApproval(storePath(project, root, home));
+    const recorded = record !== null && Object.hasOwn(record.approval, 'overrides');
+    const stored = recorded ? record?.approval.overrides : undefined;
+    const approvedText = typeof stored === 'string' ? stored : null;
+    const live = overrideFile(project, root, home);
+    const differences = [];
+    const profiles = [];
+    if (approvedText !== null) {
+        const parsed = parseOverrides(approvedText);
+        if (parsed.ok)
+            profiles.push(...parsed.profiles);
+        else
+            differences.push(OVERRIDE_UNREADABLE);
+    }
+    else if (recorded && stored !== null && stored !== undefined) {
+        differences.push(OVERRIDE_UNREADABLE);
+    }
+    if (live.text !== approvedText) {
+        if (record === null) {
+            if (live.text !== null)
+                differences.push('the overrides were never approved');
+        }
+        else
+            differences.push(OVERRIDE_CHANGED);
+    }
+    return { profiles, differences, problems: live.problems };
+}
+export function overrideProblem(path, problem) {
+    return problem.line ? `${path}: line ${problem.line}: ${problem.message}` : `${path}: ${problem.message}`;
+}
+function profilesOf(root) {
+    const entries = mapping(root, 'an override file');
+    const format = required(entries, 'format', root.line);
+    if (format.value.kind !== 'scalar' || format.value.value !== 1)
+        fail(format.line, '"format" must be 1');
+    only(entries, ['format', 'profiles']);
+    const profiles = required(entries, 'profiles', root.line);
+    const named = mapping(profiles.value, '"profiles"');
+    if (named.length === 0)
+        fail(profiles.line, '"profiles" must name a profile');
+    return named.map(profileOf);
+}
+function profileOf(entry) {
+    if (!profileFor(entry.key))
+        fail(entry.line, `unknown profile "${entry.key}"`);
+    const entries = mapping(entry.value, 'a profile override');
+    only(entries, ['screen', 'quota']);
+    const screen = optional(entries, 'screen');
+    const quota = optional(entries, 'quota');
+    if (!screen && !quota)
+        fail(entry.line, 'a profile override adds dialog patterns or quota patterns');
+    const stages = screen ? screenOf(screen.value) : {};
+    if (screen && Object.keys(stages).length === 0 && !quota) {
+        fail(screen.line, 'a profile override adds dialog patterns or quota patterns');
+    }
+    return { cli: entry.key, screen: stages, quota: quota ? quotaList(quota.value) : [] };
+}
+function screenOf(node) {
+    const entries = mapping(node, 'screen');
+    only(entries, DIALOG_STAGES);
+    const screen = {};
+    for (const entry of entries)
+        screen[entry.key] = { rules: addedRules(entry.value) };
+    return screen;
+}
+function mapping(node, what) {
+    if (node.kind !== 'map')
+        fail(node.line, `${what} must be a map`);
+    return node.entries;
+}
+function only(entries, allowed) {
+    for (const entry of entries)
+        if (!allowed.includes(entry.key))
+            fail(entry.line, `unknown key "${entry.key}"`);
+}
+function required(entries, key, line) {
+    return optional(entries, key) ?? fail(line, `missing "${key}"`);
+}
+function optional(entries, key) {
+    return entries.find((entry) => entry.key === key);
+}
+function fail(line, message) {
+    throw new YamlError(line, message);
+}

package/dist/profiles/profile.d.ts

@@ -1,4 +1,5 @@
 import { type QuotaPattern } from './quota.ts';
+import { type YamlNode } from '../yaml.ts';
 /**
  * A launch profile: what `team` knows about one CLI, so a seat can't start
  * blocked. Keyed by the seat's `cli`.
@@ -53,6 +54,8 @@ export declare function profileFor(cli: string): Profile | null;
 export declare function quotaFor(cli: string): readonly QuotaPattern[];
 /** Patterns from a YAML list, for a profile snippet. A bad pattern throws. */
 export declare function quotaPatterns(text: string): QuotaPattern[];
+/** Quota patterns from a list already parsed. A bad pattern throws. */
+export declare function quotaList(node: YamlNode): QuotaPattern[];
 /** The model a status line names. `unreadable` is a line the rules claim that does not name one. */
 export declare function statusOnLine(cli: string, line: string): {
     model: string;

package/dist/profiles/profile.js

@@ -61,6 +61,10 @@ export function quotaFor(cli) {
 export function quotaPatterns(text) {
     return quotaOf(parseYaml(text));
 }
+/** Quota patterns from a list already parsed. A bad pattern throws. */
+export function quotaList(node) {
+    return quotaOf(node);
+}
 /** The model a status line names. `unreadable` is a line the rules claim that does not name one. */
 export function statusOnLine(cli, line) {
     const rules = SHIPPED[cli]?.status;
@@ -84,7 +88,7 @@ function launchOf(root) {
     const format = required(entries, 'format', root.line);
     if (format.value.kind !== 'scalar' || format.value.value !== 1)
         fail(format.line, '"format" must be 1');
-    only(entries, ['format', 'cli', 'screen', 'quota', ...LAUNCH_KEYS]);
+    only(entries, ['format', 'cli', 'screen', 'screen_module', 'quota', ...LAUNCH_KEYS]);
     const cli = text(required(entries, 'cli', root.line), 'cli');
     required(entries, 'screen', root.line);
     const quotaEntry = optional(entries, 'quota');

package/dist/state.d.ts

@@ -1,6 +1,8 @@
 import type { StoredReading, StoredSpend } from './budgets/readings.ts';
 export type SeatState = {
     stage: 'launched' | 'named' | 'ready';
+    /** The CLI the seat was launched with: `down` stops it under it when the file renamed it. */
+    cli?: string;
     pane?: string;
     /** The herdr workspace, so a later command can close it without listing agents. */
     workspace?: string;
@@ -35,10 +37,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 +44,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/compare.js

@@ -35,14 +35,17 @@ export function compare(team, session, state, live, now = new Date(), watch = te
             rows.push({ name: seat.name, state: 'stopped', model: seat.display, pane: '-' });
             continue;
         }
-        // An agent sits in the seat's workspace under another name, or under none.
-        const stray = live.agents.find((candidate) => !claimed.has(candidate.pane) && labels.get(candidate.workspace) === seat.label
-            && !team.seats.some((other) => other.name === candidate.name));
+        // An agent sits in the workspace recorded for this name, under another name or under none.
+        // The display label is not a key: two seats may share it.
+        const stray = recorded?.workspace
+            ? live.agents.find((candidate) => !claimed.has(candidate.pane) && candidate.workspace === recorded.workspace
+                && !team.seats.some((other) => other.name === candidate.name))
+            : undefined;
         if (stray) {
             claimed.add(stray.pane);
             rows.push({ name: seat.name, state: 'wrong name', model: seat.display, pane: stray.pane });
             differences.push({
-                what: `${seat.name}: the agent in its workspace "${seat.label}" is ${stray.name ? `named "${stray.name}"` : 'unnamed'}`,
+                what: `${seat.name}: the agent in ${stray.pane} is ${stray.name ? `named "${stray.name}"` : 'unnamed'}`,
                 repair: herdrCommand(session, 'agent', 'rename', stray.pane, seat.name),
             });
             continue;

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/store/store.d.ts

@@ -23,6 +23,11 @@ export interface Approval {
         path: string;
         hash: string;
     }>;
+    /**
+     * The override file as approved, or null when the owner approved there being
+     * none. Absent on a record written before the file existed.
+     */
+    overrides?: string | null;
 }
 export interface LedgerEntry {
     display: string;

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare function version(): string;

package/dist/version.js

@@ -0,0 +1,7 @@
+import { readFileSync } from 'node:fs';
+// The one place the CLI's version is read. `--version` prints it and `team init` pins the
+// schema URL's tag to it, so the URL can never name a release the CLI doesn't report.
+export function version() {
+    const text = readFileSync(new URL('../package.json', import.meta.url), 'utf8');
+    return JSON.parse(text).version;
+}

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;