team 0.1.1 → 0.2.0

package/dist/commands/status.d.ts

@@ -9,6 +9,8 @@ export type StatusSources = {
     watchInForce(team: TeamFile, root: string): TeamFile['watch'];
     budgetsInForce(team: TeamFile, root: string): TeamFile['budgets'];
     now(): Date;
+    /** The home whose store holds the override file. Absent in a test that does not set one. */
+    home?: string;
 };
 export declare const realSources: StatusSources;
 export declare const status: Command;

package/dist/commands/status.js

@@ -1,6 +1,8 @@
 import { execFileSync } from 'node:child_process';
+import { homedir } from 'node:os';
 import { relative, resolve } from 'node:path';
 import { approvalDifferences, budgetsInForce, watchInForce } from "../approve/approval.js";
+import { overridesInForce } from "../profiles/overrides.js";
 import { readArgs } from "../args.js";
 import { budgetLine, budgetTable } from "../budgets/table.js";
 import { recall } from "../budgets/readings.js";
@@ -41,6 +43,7 @@ export const realSources = {
     watchInForce: (team, root) => watchInForce(team, root),
     budgetsInForce: (team, root) => budgetsInForce(team, root),
     now: () => new Date(),
+    home: homedir(),
 };
 export const status = (argv, io) => runStatus(argv, io, realSources);
 export default status;
@@ -62,17 +65,21 @@ export async function runStatus(argv, io, sources) {
     for (const warning of current.warnings)
         io.stderr(`team status: warning, line ${warning.line}: ${warning.message}\n`);
     const session = args.values.session ?? team.session;
+    const overrides = sources.home ? overridesInForce(team.project, root, sources.home) : emptyOverrides();
+    for (const problem of overrides.problems)
+        io.stderr(`team status: ${problem}\n`);
     const live = sources.live(session, team);
     if (!live) {
         io.stderr('team status: herdr doesn\'t answer; is it installed and running?\n');
         return 2;
     }
-    const state = readState(dir).sessions[session] ?? emptySession();
-    const budgets = budgetTable(sources.budgetsInForce(team, root), recall(state.budgets), sources.now().getTime());
+    const whole = readState(dir);
+    const state = whole.sessions[session] ?? emptySession();
+    const budgets = budgetTable(sources.budgetsInForce(team, root), recall(whole.budgets), sources.now().getTime());
     const comparison = compare(team, session, state, live, sources.now(), sources.watchInForce(team, root));
     if (!live.running)
         comparison.notes.unshift(`the herdr session "${session}" is not running`);
-    comparison.differences.push(...protectedCheckouts(team, root, sources), ...approvalDrift(sources.approval(team, root)));
+    comparison.differences.push(...protectedCheckouts(team, root, sources), ...approvalDrift(sources.approval(team, root)), ...overrideDrift(overrides));
     if (args.flags.has('json')) {
         const doc = {
             format: 1,
@@ -91,6 +98,18 @@ export async function runStatus(argv, io, sources) {
     }
     return comparison.differences.length ? 1 : 0;
 }
+function emptyOverrides() {
+    return { profiles: [], differences: [], problems: [] };
+}
+function overrideDrift(report) {
+    return [
+        ...report.differences.map((line) => ({
+            what: `the overrides differ from the approved copy: ${line}`,
+            repair: 'the owner runs team approve',
+        })),
+        ...report.problems.map((problem) => ({ what: problem, repair: 'fix the overrides file' })),
+    ];
+}
 // A file that was never approved, or was changed since, runs nothing until the owner approves it.
 export function approvalDrift(differences) {
     if (differences === null)

package/dist/commands/up.d.ts

@@ -35,6 +35,8 @@ export type Launch = {
     typeText?(session: string, pane: string, text: string): boolean;
     pressEnter?(session: string, pane: string): boolean;
     agentStatus?(session: string, pane: string): string | null;
+    /** Foreground argv0 names, or null when the pane can't be read. */
+    foreground(session: string, pane: string): string[] | null;
     sleep(ms: number): Promise<void>;
     now(): Date;
 };
@@ -44,6 +46,6 @@ export declare const realSources: UpSources;
 export declare const USAGE = "Usage: team up [--dry-run] [--session <name>] [--file <path>]\n";
 export declare const up: Command;
 export default up;
-/** The rules one seat gets at launch, with its own signature lines. */
+/** The rules one seat gets at launch, with its own signature lines, as its delivery carries them. */
 export declare function rulesOf(team: TeamFile, seat: Seat): string;
 export declare function runUp(argv: string[], io: Io, sources: UpSources): Promise<number>;

package/dist/commands/up.js

@@ -7,7 +7,7 @@ import { readArgs } from "../args.js";
 import { callerOf, describeCaller, isOwner } from "../caller.js";
 import { loadTeamFile } from "../file/load.js";
 import { renderSignature } from "../file/signature.js";
-import { agentList, agentStatus, agentRename, paneRead, paneRun, typeText, pressEnter, sessionRunning, sessionState, startServer, workspaceClose, workspaceCreate, workspaceList, } from "../herdr.js";
+import { agentList, agentStatus, agentRename, paneForeground, paneRead, paneRun, typeText, pressEnter, sessionRunning, sessionState, startServer, workspaceClose, workspaceCreate, workspaceList, } from "../herdr.js";
 import { executePlan } from "../launch/execute.js";
 import { formatPlan, upPlan } from "../launch/plan.js";
 import { rulesText } from "../launch/rules.js";
@@ -49,6 +49,7 @@ const realLaunch = {
     typeText: (session, pane, text) => typeText(pane, text, aim(session)),
     pressEnter: (session, pane) => pressEnter(pane, aim(session)),
     agentStatus: (session, pane) => agentStatus(pane, aim(session)),
+    foreground: (session, pane) => paneForeground(pane, aim(session)),
     sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     now: () => new Date(),
 };
@@ -77,9 +78,11 @@ export const realSources = {
 export const USAGE = 'Usage: team up [--dry-run] [--session <name>] [--file <path>]\n';
 export const up = (argv, io) => runUp(argv, io, realSources);
 export default up;
-/** The rules one seat gets at launch, with its own signature lines. */
+/** The rules one seat gets at launch, with its own signature lines, as its delivery carries them. */
 export function rulesOf(team, seat) {
     const { commits, pullRequests } = team.identity.signature;
+    const profile = profileFor(seat.cli);
+    const delivery = profile && profile.rulesOption !== null ? 'option' : 'message';
     return rulesText({
         coordinator: team.coordinator,
         rules: team.rules,
@@ -89,7 +92,7 @@ export function rulesOf(team, seat) {
             commitPosition: commits.position,
         },
         workspace: { mode: seat.mode, protected: team.workspace.protected, branch: team.workspace.branch },
-    });
+    }, delivery);
 }
 function resolveState(sources, session) {
     if (sources.sessionState)
@@ -208,8 +211,8 @@ export async function runUp(argv, io, sources) {
     }
     const recorded = readState(dir).sessions[session];
     const workspaces = sources.workspaces?.(session) ?? null;
-    const readings = loadReadings(dir, session);
-    const spend = loadSpendReadings(dir, session);
+    const readings = loadReadings(dir);
+    const spend = loadSpendReadings(dir);
     const seats = [];
     const refused = new Set();
     for (const seat of team.seats) {
@@ -305,6 +308,7 @@ export async function runUp(argv, io, sources) {
             status: () => launch.agentStatus?.(session, pane) ?? null,
             type: (value) => launch.typeText?.(session, pane, value) ?? false,
             enter: () => launch.pressEnter?.(session, pane) ?? false,
+            foreground: () => launch.foreground(session, pane),
             now: () => now().getTime(),
             sleep: sources.sleep ?? launch.sleep,
         }),
@@ -331,7 +335,9 @@ export async function runUp(argv, io, sources) {
             updateState(dir, (file) => {
                 const current = (file.sessions[session] ??= emptySession());
                 const prior = current.seats[name] ?? { stage: patch.stage };
-                current.seats[name] = { ...prior, ...patch };
+                // The CLI the seat was launched with: `down` needs it when the file no longer names the seat.
+                const cli = team.seats.find((seat) => seat.name === name)?.cli;
+                current.seats[name] = { ...prior, ...patch, ...(cli ? { cli } : {}) };
             });
         },
         running(name) {

package/dist/commands/watch.d.ts

@@ -14,6 +14,8 @@ export type WatchSources = {
     readChecks(team: TeamFile, root: string, now: number): CheckOutcome[];
     screen(pane: string, session: string): string | null;
     status(pane: string, session: string): string | null;
+    /** Foreground argv0 names, or null when the pane can't be read. */
+    foreground(pane: string, session: string): string[] | null;
     typeText(pane: string, text: string, session: string): boolean;
     pressEnter(pane: string, session: string): boolean;
     notify(text: string): void;
@@ -27,6 +29,8 @@ export type WatchSources = {
     stopSeat?(session: string, seat: DownSeat): Promise<boolean>;
     /** Removes one merged worktree. The real watch calls `worktree remove`. */
     removeWorktree?(task: string): number;
+    /** The home whose store holds the override file. Absent in a test that does not set one. */
+    home?: string;
 };
 export declare const realWatchSources: WatchSources;
 export declare const watch: Command;

package/dist/commands/watch.js

@@ -1,10 +1,11 @@
 import { readArgs } from "../args.js";
 import { budgetsInForce, watchInForce } from "../approve/approval.js";
-import { saveReadings, saveSpendReadings } from "../budgets/readings.js";
+import { callerOf, describeCaller, isOwner } from "../caller.js";
+import { loadReadings, saveSpendReadings, updateReadings } from "../budgets/readings.js";
 import { runChecks } from "../budgets/run.js";
 import { currentTeam } from "../file/current.js";
 import { homedir } from 'node:os';
-import { agentStatus, paneRead, pressEnter, typeText } from "../herdr.js";
+import { agentStatus, paneForeground, paneRead, pressEnter, typeText } from "../herdr.js";
 import { logLine } from "../log.js";
 import { emptySession, readState, updateState } from "../state.js";
 import { readMachine } from "../watch/machine.js";
@@ -13,9 +14,13 @@ import { newMemory, pass } from "../watch/pass.js";
 import { readScreen } from "../watch/screen.js";
 import { judgeTemporary, judgeWorktree } from "../watch/close.js";
 import { readEnd } from "../watch/end.js";
+import { reportedLiveAgent } from "../launch/agent.js";
+import { boxHoldsText } from "../launch/deliver.js";
 import { stopRunning, realSources as removeSources } from "./remove.js";
 import { removeWorktree } from "./worktree.js";
 import { stateOf } from "./down.js";
+import { profileFor } from "../profiles/index.js";
+import { classifyWith, overridesInForce, quotaWith } from "../profiles/overrides.js";
 import { realSources } from "./status.js";
 function waitOrStop(seconds) {
     return new Promise((done) => {
@@ -41,6 +46,7 @@ export const realWatchSources = {
     readChecks: (team, root, now) => runChecks(team, root, now),
     screen: (pane, session) => paneRead(pane, 14, session),
     status: agentStatus,
+    foreground: (pane, session) => paneForeground(pane, session),
     typeText,
     pressEnter,
     notify,
@@ -56,6 +62,7 @@ export const realWatchSources = {
         }
     },
     pid: process.pid,
+    home: homedir(),
 };
 export const watch = (argv, io) => runWatch(argv, io, realWatchSources);
 export default watch;
@@ -74,17 +81,30 @@ export async function runWatch(argv, io, sources) {
     }
     const session = args.values.session ?? first.team.session;
     const { dir } = first;
+    // A seat that starts the session's only watch must not be able to drop the operator's nudge
+    // or the operator's desktop notices. The owner's own `--no-notify` still cannot silence a
+    // report addressed to the owner: those are routed below.
+    if (args.flags.has('no-nudge') || args.flags.has('no-notify')) {
+        const caller = callerOf(io, session);
+        if (!isOwner(caller)) {
+            io.stderr(`team watch: --no-nudge and --no-notify are the owner's, from a terminal outside herdr; this call is ${describeCaller(caller)}\n`);
+            return 1;
+        }
+    }
     const other = readState(dir).sessions[session]?.watch;
     if (other && other.pid !== sources.pid && sources.alive(other.pid)) {
         io.stderr(`team watch: a watch already runs for the session "${session}" (pid ${other.pid})\n`);
         return 1;
     }
-    const say = (text, desktop) => {
+    // The log line is written for every report. `--no-notify` never removes it, and it never
+    // removes a desktop notice addressed to the owner. It does silence every other notice.
+    const tell = (text, notify) => {
         io.stdout(`${sources.now().toISOString()} ${text}\n`);
         logLine(dir, 'watch', 'watch', text, sources.now());
-        if (desktop && !args.flags.has('no-notify'))
+        if (notify)
             sources.notify(text);
     };
+    const say = (text, desktop) => tell(text, desktop && !args.flags.has('no-notify'));
     const beat = () => updateState(dir, (state) => {
         const record = (state.sessions[session] ??= emptySession());
         record.watch = { pid: sources.pid, heartbeat: sources.now().toISOString() };
@@ -102,11 +122,32 @@ export async function runWatch(argv, io, sources) {
             const current = currentTeam(io.cwd, args.values.file, sources.now());
             const team = current.ok ? current.team : first.team;
             const root = current.ok ? current.root : first.root;
+            const overrides = sources.home
+                ? overridesInForce(team.project, root, sources.home)
+                : { profiles: [], differences: [], problems: [] };
+            for (const line of [
+                ...overrides.problems,
+                ...overrides.differences.map((difference) => `the overrides differ from the approved copy: ${difference}`),
+            ]) {
+                if (told.has(line))
+                    continue;
+                told.add(line);
+                say(line, false);
+            }
             const problem = current.ok ? current.notice : `team.yaml can't be read (${current.errors[0]?.message ?? 'unknown'}); watching with the team as it was`;
             if (problem !== notice) {
                 notice = problem;
                 if (problem)
-                    say(problem, true);
+                    tell(problem, true);
+            }
+            // Only the watch of the file's own session saves readings. A watch on another session —
+            // anyone may run one, from any terminal — reads and reports, but the figures it sees are
+            // not the project's cache that `up` and `add` count (§ 4.4): it says so once and writes
+            // none, budget or spend.
+            const foreign = session !== team.session;
+            if (foreign && !told.has('foreign-session')) {
+                told.add('foreign-session');
+                say(`the session "${session}" is not this file's "${team.session}": its readings are not saved`, false);
             }
             // The values in force, read with the file: until the owner approves an edit to `watch`,
             // the watch keeps running with what was approved, or with the defaults.
@@ -117,7 +158,7 @@ export async function runWatch(argv, io, sources) {
             const live = sources.live(session, team);
             if (!live) {
                 if (!silent)
-                    say('herdr doesn\'t answer; the watch keeps trying', true);
+                    tell('herdr doesn\'t answer; the watch keeps trying', true);
                 silent = true;
             }
             else {
@@ -134,7 +175,8 @@ export async function runWatch(argv, io, sources) {
                     // The money a spend check counted is kept, like the pass's screen readings: the launch
                     // gate of `up` and `add` reads it later, and one that is stale by then reads unknown
                     // (§ 5). An account whose check did not run keeps its stored reading.
-                    saveSpendReadings(dir, session, spendOf(outcomes));
+                    if (!foreign)
+                        saveSpendReadings(dir, spendOf(outcomes));
                     for (const outcome of outcomes) {
                         const key = `check:${outcome.account}`;
                         if (outcome.state === 'read') {
@@ -149,21 +191,38 @@ export async function runWatch(argv, io, sources) {
                             : `the check for ${outcome.account} is unapproved; that account reads unknown`, false);
                     }
                 }
-                const result = pass({
+                // Herdr's process list per pane, read with the screen: a figure is only read off a pane
+                // where herdr reports the seat's CLI. A pane it can't read is null, and a null is not a
+                // CLI: no figure.
+                const foreground = {};
+                for (const agent of live.agents)
+                    foreground[agent.pane] = sources.foreground(agent.pane, session);
+                const run = (stored) => pass({
                     team, state, live, machine: sources.machine(root), now, memory,
                     approval: sources.approval(team, root), watch: inForce, outcomes, budgets: budget,
+                    quotaFor: (cli) => quotaWith(cli, overrides.profiles),
+                    readScreen: (cli, pane) => classifyWith(cli, pane, overrides.profiles),
+                    readings: stored, foreground,
                 });
+                // The pass folds its figures where the state is held: two watches of the project fold one
+                // after the other, not over each other. A watch on a foreign session still folds, for its
+                // reports, and saves nothing.
+                const result = foreign
+                    ? run(loadReadings(dir))
+                    : updateReadings(dir, now, (stored) => {
+                        const folded = run(stored);
+                        return { readings: folded.readings, value: folded };
+                    });
                 for (const report of result.reports)
-                    say(report.text, true);
-                saveReadings(dir, session, result.readings, now);
+                    tell(report.text, report.to === 'owner' || !args.flags.has('no-notify'));
                 if (result.nudge) {
                     if (args.flags.has('no-nudge'))
                         say(`nudge not typed (--no-nudge): ${result.nudge.text}`, false);
                     else
-                        deliver(result.nudge, team, session, sources, memory, say);
+                        deliver(result.nudge, team, session, sources, memory, say, tell, told);
                 }
                 if (result.fallback)
-                    say(result.fallback, true);
+                    tell(result.fallback, true);
                 await closeEnded({ team, root, dir, session, live, sources, say, io, told });
             }
             beat();
@@ -177,7 +236,7 @@ export async function runWatch(argv, io, sources) {
             if (record?.watch?.pid === sources.pid)
                 delete record.watch;
         });
-        say(`the watch of "${session}" stopped`, true);
+        tell(`the watch of "${session}" stopped`, true);
     }
     return 0;
 }
@@ -198,7 +257,7 @@ function spendOf(outcomes) {
 }
 // Types the nudge, after reading the operator's screen once more: the pass saw it free, and a
 // prompt may have appeared since. Anything but an empty idle prompt keeps the nudge pending.
-function deliver(nudge, team, session, sources, memory, say) {
+function deliver(nudge, team, session, sources, memory, say, tell, told) {
     const cli = team.seats.find((seat) => seat.name === team.operator)?.cli ?? '';
     const look = () => readScreen(cli, sources.screen(nudge.pane, session) ?? undefined).kind;
     const status = sources.status(nudge.pane, session);
@@ -208,15 +267,30 @@ function deliver(nudge, team, session, sources, memory, say) {
         memory.pending.push(...nudge.pending);
         memory.pendingSince ??= sources.now().getTime();
     };
+    const names = profileFor(cli)?.processNames ?? [];
+    const live = () => reportedLiveAgent(sources.foreground(nudge.pane, session), names);
+    const noAgent = 'nudge:no-agent';
+    if (!live()) {
+        tellOnce(told, noAgent, 'a nudge was not typed: no live agent in the operator\'s pane', tell);
+        keep();
+        return;
+    }
+    told.delete(noAgent);
     if ((status !== 'idle' && status !== 'done') || look() !== 'idle' || !sources.typeText(nudge.pane, nudge.text, session)) {
         keep();
         return;
     }
-    // The text is in the box. A dialog that opened meanwhile must not get the Enter: the text
-    // then stays unsent, which the next passes report, and the nudge is kept.
-    const after = look();
-    if (after !== 'idle' && after !== 'unsent') {
-        say('a nudge was typed and not sent: the operator\'s screen changed before the Enter', true);
+    // The text is in the box. The agent is read again before Enter: it may have exited
+    // since the text was typed, and an unframed line is not a box to send.
+    if (!live()) {
+        tellOnce(told, noAgent, 'a nudge was not typed: no live agent in the operator\'s pane', tell);
+        keep();
+        return;
+    }
+    // The box is read back before the Enter: it must hold exactly the nudge's own text. An idle
+    // or changed screen here is the text not rendered, and unsent text alone is not this nudge.
+    if (!boxHoldsText(cli, nudge.text, sources.screen(nudge.pane, session) ?? undefined)) {
+        tell('a nudge was typed and not sent: the operator\'s box does not hold it', true);
         keep();
         return;
     }
@@ -225,6 +299,12 @@ function deliver(nudge, team, session, sources, memory, say) {
     else
         keep();
 }
+function tellOnce(told, key, text, tell) {
+    if (told.has(key))
+        return;
+    told.add(key);
+    tell(text, true);
+}
 function noteWorked(dir, session, live) {
     const recorded = readState(dir).sessions[session];
     if (!recorded)

package/dist/conformance/adapter.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from '../io.ts';
+/** The answer for one request line. A line that is not a request is an error object. */
+export declare function respond(line: string): string;
+declare const adapter: Command;
+export default adapter;

package/dist/conformance/adapter.js

@@ -0,0 +1,44 @@
+import { createInterface } from 'node:readline';
+import { classify, classifyComposer } from "../watch/screen.js";
+import { parseYaml } from "../yaml.js";
+/** The answer for one request line. A line that is not a request is an error object. */
+export function respond(line) {
+    let request;
+    try {
+        request = JSON.parse(line);
+    }
+    catch {
+        return JSON.stringify({ error: 'the line is not JSON' });
+    }
+    if (request === null || typeof request !== 'object')
+        return JSON.stringify({ error: 'a request needs an op' });
+    if (request.op === 'classify' || request.op === 'composer') {
+        if (typeof request.cli !== 'string' || !Array.isArray(request.lines) || request.lines.some((item) => typeof item !== 'string')) {
+            return JSON.stringify({ error: 'classify needs a cli and lines of text' });
+        }
+        const screen = request.op === 'classify' ? classify(request.cli, request.lines) : classifyComposer(request.cli, request.lines);
+        return JSON.stringify({ kind: screen.kind });
+    }
+    if (request.op === 'yaml') {
+        if (typeof request.text !== 'string')
+            return JSON.stringify({ error: 'yaml needs text' });
+        try {
+            parseYaml(request.text);
+            return JSON.stringify({ ok: true });
+        }
+        catch {
+            return JSON.stringify({ ok: false });
+        }
+    }
+    return JSON.stringify({ error: 'unknown op' });
+}
+const adapter = async (_argv, io) => {
+    const lines = createInterface({ input: process.stdin });
+    for await (const line of lines) {
+        if (line.length === 0)
+            continue;
+        io.stdout(`${respond(line)}\n`);
+    }
+    return 0;
+};
+export default adapter;

package/dist/file/check.d.ts

@@ -0,0 +1,20 @@
+import type { YamlEntry, YamlNode } from '../yaml.ts';
+import type { Problem } from './types.ts';
+export type Fields = Map<string, YamlEntry>;
+export declare class Check {
+    problems: Problem[];
+    warnings: Problem[];
+    fail(line: number, message: string): void;
+    fields(node: YamlNode | undefined, where: string, known: string[]): Fields;
+    text(entry: YamlEntry | undefined, name: string): string | undefined;
+    required(entry: YamlEntry | undefined, name: string, line: number): string | undefined;
+    oneOf<T extends string>(entry: YamlEntry | undefined, name: string, values: T[]): T | undefined;
+    flag(entry: YamlEntry | undefined, name: string): boolean;
+    whole(entry: YamlEntry | undefined, name: string, least: number): number | undefined;
+    number(entry: YamlEntry | undefined, name: string): number | undefined;
+    measure(entry: YamlEntry | undefined, name: string, units: Record<string, number>, example: string): number | undefined;
+    list(entry: YamlEntry | undefined, name: string): {
+        value: string;
+        line: number;
+    }[];
+}

package/dist/file/check.js

@@ -0,0 +1,112 @@
+export class Check {
+    problems = [];
+    warnings = [];
+    fail(line, message) {
+        this.problems.push({ line, message });
+    }
+    // The fields of a map, with every field outside `known` reported.
+    fields(node, where, known) {
+        const fields = new Map();
+        if (!node)
+            return fields;
+        if (node.kind !== 'map') {
+            if (!(node.kind === 'scalar' && node.value === null))
+                this.fail(node.line, `${where} must be a map of fields`);
+            return fields;
+        }
+        for (const entry of node.entries) {
+            if (known.includes(entry.key))
+                fields.set(entry.key, entry);
+            else
+                this.fail(entry.line, `unknown field "${entry.key}" in ${where}`);
+        }
+        return fields;
+    }
+    text(entry, name) {
+        if (!entry)
+            return undefined;
+        const node = entry.value;
+        if (node.kind === 'scalar' && typeof node.value === 'string' && node.value !== '')
+            return node.value;
+        this.fail(node.line, `${name} must be text${node.kind === 'scalar' && node.value !== null && node.value !== '' ? ': quote it' : ''}`);
+        return undefined;
+    }
+    required(entry, name, line) {
+        if (!entry)
+            this.fail(line, `${name} is required`);
+        return this.text(entry, name);
+    }
+    oneOf(entry, name, values) {
+        if (!entry)
+            return undefined;
+        const node = entry.value;
+        if (node.kind === 'scalar' && typeof node.value === 'string' && values.includes(node.value)) {
+            return node.value;
+        }
+        this.fail(node.line, `${name} must be one of: ${values.join(', ')}`);
+        return undefined;
+    }
+    flag(entry, name) {
+        if (!entry)
+            return false;
+        const node = entry.value;
+        if (node.kind === 'scalar' && typeof node.value === 'boolean' && !node.quoted)
+            return node.value;
+        this.fail(node.line, `${name} must be true or false`);
+        return false;
+    }
+    whole(entry, name, least) {
+        if (!entry)
+            return undefined;
+        const node = entry.value;
+        if (node.kind === 'scalar' && typeof node.value === 'number' && Number.isInteger(node.value) && node.value >= least) {
+            return node.value;
+        }
+        this.fail(node.line, `${name} must be a whole number, ${least} or more`);
+        return undefined;
+    }
+    number(entry, name) {
+        if (!entry)
+            return undefined;
+        const node = entry.value;
+        if (node.kind === 'scalar' && typeof node.value === 'number' && Number.isFinite(node.value) && node.value > 0) {
+            return node.value;
+        }
+        this.fail(node.line, `${name} must be a number above 0`);
+        return undefined;
+    }
+    // A value with its unit, such as 120s, 25% or 10GB.
+    measure(entry, name, units, example) {
+        if (!entry)
+            return undefined;
+        const node = entry.value;
+        const raw = node.kind === 'scalar' ? node.raw : '';
+        const match = /^([0-9]+(?:\.[0-9]+)?)([A-Za-z%]+)$/.exec(raw);
+        const unit = match?.[2];
+        if (match && unit !== undefined && unit in units && node.kind === 'scalar' && !node.quoted) {
+            return Number(match[1]) * units[unit];
+        }
+        this.fail(node.line, `${name} needs a value with its unit (${Object.keys(units).join(', ')}), such as ${example}`);
+        return undefined;
+    }
+    list(entry, name) {
+        if (!entry)
+            return [];
+        const node = entry.value;
+        if (node.kind !== 'seq') {
+            if (!(node.kind === 'scalar' && node.value === null))
+                this.fail(node.line, `${name} must be a list`);
+            return [];
+        }
+        const out = [];
+        for (const item of node.items) {
+            if (item.kind === 'scalar' && typeof item.value === 'string' && item.value !== '') {
+                out.push({ value: item.value, line: item.line });
+            }
+            else {
+                this.fail(item.line, `each item of ${name} must be text${item.kind === 'map' ? ': quote a line that contains ": "' : ''}`);
+            }
+        }
+        return out;
+    }
+}

package/dist/file/lines.js

@@ -1,5 +1,6 @@
 // Edits the team file by the line. Comments, order and every other seat stay as written.
 // Nothing here re-serialises the file.
+import { defaultLabel } from "./validate.js";
 function indent(line) {
     let n = 0;
     while (line[n] === ' ')
@@ -100,6 +101,11 @@ export function rewriteCount(text, declared) {
         return null;
     const lines = body(text, block);
     const label = field(lines, 'label');
+    const model = field(lines, 'model');
+    const version = field(lines, 'version');
+    // A counted seat with no label is titled with the model. Later instances need that title
+    // written out, or they collide with the first on the same default.
+    const implied = label === null && model !== null && version !== null ? defaultLabel(model, version) : null;
     const copies = [];
     for (let instance = 1; instance <= block.count; instance++) {
         const suffix = instance === 1 ? '' : `-${instance}`;
@@ -108,8 +114,13 @@ export function rewriteCount(text, declared) {
                 return [];
             if (instance === 1)
                 return [line];
-            if (/^\s*(?:-\s+)?name:/.test(line))
-                return [setValue(line, `${declared}${suffix}`)];
+            if (/^\s*(?:-\s+)?name:/.test(line)) {
+                const renamed = [setValue(line, `${declared}${suffix}`)];
+                if (implied === null)
+                    return renamed;
+                const pad = /^(\s*)/.exec(line)?.[1] ?? '';
+                return [...renamed, `${pad}label: ${implied}${suffix}`];
+            }
             if (label !== null && /^\s*label:/.test(line))
                 return [setValue(line, `${label}${suffix}`)];
             return [line];

package/dist/file/sections/budgets.d.ts

@@ -0,0 +1,15 @@
+import type { TeamFile } from '../types.ts';
+import type { Section } from './section.ts';
+/** What the budgets section hands the rest of the file: its value, and the account names it declares. */
+export interface Budgeted {
+    budgets: TeamFile['budgets'];
+    /** Every name the accounts map writes, whether or not the account itself reads cleanly. */
+    declared: Set<string>;
+}
+export declare const budgets: Section;
+/**
+ * The budget values a file that sets none runs with — and, since the section is the owner's, the
+ * values a file runs with until the owner approves what it sets instead. No accounts: nothing is
+ * budgeted until the owner names one.
+ */
+export declare function defaultBudgets(): TeamFile['budgets'];