team 0.1.2 → 0.2.0

package/dist/commands/doctor.js

@@ -1,13 +1,17 @@
 import { spawnSync } from 'node:child_process';
-import { accessSync, constants } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { accessSync, constants, readFileSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { delimiter, dirname, isAbsolute, join } from 'node:path';
 import { approvalDifferences, budgetsInForce, watchInForce } from "../approve/approval.js";
 import { readArgs } from "../args.js";
-import { checkReadings } from "../budgets/checks.js";
+import { callerOf, isOwner } from "../caller.js";
+import { checkCommands } from "../budgets/checks.js";
+import { parseOutput, runCommand } from "../budgets/run.js";
 import { loadTeamFile } from "../file/load.js";
 import { HERDR_TESTED, herdrVersion, sessionRunning } from "../herdr.js";
 import { profileFor } from "../profiles/index.js";
+import { overridesInForce, quotaWith } from "../profiles/overrides.js";
 import { versionVerdict } from "../profiles/profile.js";
 import { readState } from "../state.js";
 import { readApproval, storePath } from "../store/store.js";
@@ -47,6 +51,7 @@ export const realSources = {
     sessionRunning,
     now: () => new Date(),
     home: homedir(),
+    runCheck: (path) => runCommand(path),
 };
 export const USAGE = 'Usage: team doctor [--session <name>] [--file <path>] [--login]\n';
 // A missing or stale watch is not a reason for `up` to refuse: `up` starts the watch itself.
@@ -75,13 +80,100 @@ function launchBinary(launch) {
         .split(/\s+/)
         .find((word) => !/^[A-Za-z_][A-Za-z0-9_]*=/.test(word)) ?? null);
 }
+// The approved bytes rule, as the watch applies it (budgets/checks.ts): a check whose file no
+// longer hashes to the approval is not the approved check, and is not run.
+function changedSinceApproval(check) {
+    try {
+        if (!statSync(check.path).isFile())
+            return true;
+        return createHash('sha256').update(readFileSync(check.path)).digest('hex') !== check.hash;
+    }
+    catch {
+        return true;
+    }
+}
 function checkFindings(team, root, home) {
     const record = readApproval(storePath(team.project, root, home));
     if (!record)
         return [];
-    return checkReadings(budgetsInForce(team, root, home), record.approval.checks).flatMap((reading) => reading.state === 'unknown'
-        ? [{ level: 'warn', text: `the check for ${reading.account} is unapproved; that account reads unknown` }]
-        : []);
+    const approved = record.approval.checks;
+    return checkCommands(budgetsInForce(team, root, home)).flatMap(({ account }) => {
+        const known = approved?.[account];
+        if (!known) {
+            return [{ level: 'warn', text: `the check for ${account} is unapproved; that account reads unknown` }];
+        }
+        if (changedSinceApproval(known)) {
+            return [{ level: 'warn', text: `the check for ${account} changed after approval and was not run; that account reads unknown` }];
+        }
+        return [];
+    });
+}
+// The CLIs of the seats that spend an account: its own `account:` when the file names one, its
+// vendor otherwise — the gate's resolution.
+function clisOf(team, account) {
+    return team.seats.filter((seat) => (seat.account ?? seat.vendor) === account).map((seat) => seat.cli);
+}
+function figureOf(reading) {
+    if (reading.kind === 'spend')
+        return `${reading.amount.toFixed(2)} ${reading.currency}`;
+    return reading.windows.map((one) => `${one.window} ${one.used}% used`).join(', ');
+}
+/**
+ * The budget checks, one line per account, plus the accounts nothing can read. The checks run
+ * the way the watch runs them (RFC 0003 § 5): the approved command's file, hashed again before
+ * it runs, in a clean environment with the watch's timeout. The raw output is parsed and
+ * dropped — never printed, never logged, never written anywhere. Only the owner's `doctor` runs
+ * a check, for the same reason the watch is the owner's: a check reads a vendor home. Any other
+ * caller gets the same report without the readings, and the one line that says so.
+ */
+export function budgetCheckFindings(team, root, sources, caller) {
+    const budgets = budgetsInForce(team, root, sources.home);
+    const findings = [];
+    // An account nothing can read: its sources name the status line but no seat of its CLIs
+    // ships a quota pattern for it, or they name a check with no command. A file that names a
+    // `check` source without a command is refused on read; the guard is for the type, not the file.
+    for (const [name, account] of Object.entries(budgets.accounts)) {
+        const patterns = overridesInForce(team.project, root, sources.home).profiles;
+        const noPattern = account.sources.includes('status_line') && !clisOf(team, name).some((cli) => quotaWith(cli, patterns).some((one) => one.account === name));
+        const noCommand = account.sources.includes('check') && account.check === null;
+        if (noPattern || noCommand)
+            findings.push({ level: 'warn', text: `${name}: no pattern can read this account` });
+    }
+    const commands = checkCommands(budgets);
+    if (!isOwner(caller)) {
+        if (commands.length)
+            findings.push({ level: 'note', text: 'the budget checks were not run: only the owner runs them' });
+        return findings;
+    }
+    const record = readApproval(storePath(team.project, root, sources.home));
+    if (!record)
+        return findings;
+    const run = sources.runCheck ?? runCommand;
+    const now = sources.now().getTime();
+    for (const { account } of commands) {
+        const known = record.approval.checks?.[account];
+        const entry = budgets.accounts[account];
+        // Unapproved and changed checks are said above, and never run.
+        if (!known || !entry || changedSinceApproval(known))
+            continue;
+        const text = run(known.path);
+        if (text === null) {
+            findings.push({ level: 'warn', text: `the check for ${account} failed or timed out; that account reads unknown` });
+            continue;
+        }
+        const reading = parseOutput(entry, text, now);
+        findings.push(reading
+            ? { level: 'ok', text: `the check for ${account} reads ${figureOf(reading)}` }
+            : { level: 'warn', text: `the check for ${account} broke its output contract; that account reads unknown` });
+    }
+    return findings;
+}
+function overrideFindings(team, root, home) {
+    const report = overridesInForce(team.project, root, home);
+    return [
+        ...report.differences.map((line) => ({ level: 'miss', text: `run \`team approve\`: ${line}` })),
+        ...report.problems.map((line) => ({ level: 'miss', text: line })),
+    ];
 }
 function approvalFindings(team, root, home) {
     const differences = approvalDifferences(team, root, home);
@@ -150,14 +242,40 @@ function watchFindings(watch, dir, session, running, now) {
     }
     return [{ level: 'ok', text: 'the watch is running' }];
 }
+// The session already carries the project, so a seat whose name or label repeats either is a
+// warning, never a refusal. One line per seat, naming the field.
+export function seatNameFindings(team, session) {
+    const needles = [...new Set([team.project, session].filter((value) => value !== ''))];
+    const findings = [];
+    for (const seat of team.seats) {
+        const hits = ['name', 'label'].map((field) => ({
+            field,
+            found: needles.filter((needle) => seat[field].toLowerCase().includes(needle.toLowerCase())),
+        })).filter((hit) => hit.found.length > 0);
+        if (hits.length === 0)
+            continue;
+        const same = hits.length === 2 && hits[0]?.found.join('\0') === hits[1]?.found.join('\0');
+        const which = same
+            ? `its name and its label repeat ${quoted(hits[0]?.found ?? [])}`
+            : hits.map((hit) => `its ${hit.field} repeats ${quoted(hit.found)}`).join(' and ');
+        findings.push({ level: 'warn', text: `${seat.name}: ${which}; the session already carries it` });
+    }
+    return findings;
+}
+function quoted(values) {
+    return values.map((value) => `"${value}"`).join(' and ');
+}
 export function doctorFindings(team, root, dir, session, sources, warnings, 
 /** The file as approved. `add` hands the team about to run, whose `stopped` mark is already cleared. */
-approved = team) {
+approved = team, 
+/** The budget-check lines, which only the report runs: `up` and `add` scan, they never run a check. */
+budgetChecks = []) {
     const findings = warnings.map((warning) => ({
         level: 'warn',
         text: `the file, line ${warning.line}: ${warning.message}`,
     }));
-    findings.push(...approvalFindings(approved, root, sources.home), ...checkFindings(team, root, sources.home));
+    findings.push(...seatNameFindings(team, session));
+    findings.push(...approvalFindings(approved, root, sources.home), ...overrideFindings(team, root, sources.home), ...checkFindings(team, root, sources.home), ...budgetChecks);
     const herdr = sources.herdrVersion();
     const running = herdr === null ? null : sources.sessionRunning(session);
     if (herdr === null)
@@ -222,7 +340,7 @@ export async function runDoctor(argv, io, sources) {
     const session = args.values.session ?? team.session;
     const findings = args.flags.has('login')
         ? doctorLoginFindings(team, sources)
-        : doctorFindings(team, root, dirname(loaded.path), session, sources, loaded.warnings);
+        : doctorFindings(team, root, dirname(loaded.path), session, sources, loaded.warnings, undefined, budgetCheckFindings(team, root, sources, callerOf(io)));
     const label = { ok: 'ok  ', warn: 'warn', miss: 'MISS', note: '--  ' };
     io.stdout(findings.map((finding) => `${label[finding.level]}  ${finding.text}\n`).join(''));
     const missing = findings.filter((finding) => finding.level === 'miss').length;

package/dist/commands/down.d.ts

@@ -8,6 +8,8 @@ export type DownSources = {
     alive(pid: number): boolean;
     /** Herdr's status is not enough: a permission prompt is reported as idle. */
     screen(session: string, pane: string, cli: string): Screen;
+    /** The pane's raw text, for reading the input box back before any Enter. */
+    screenText(session: string, pane: string, cli: string): string | undefined;
     /** Herdr's own status for the pane. The Enter waits for idle or done. */
     status(session: string, pane: string): string | null;
     /** Foreground argv0 names, or null when the pane can't be read. */
@@ -22,6 +24,8 @@ export type DownLaunch = {
     agentPanes(session: string): string[] | null;
     closeWorkspace(session: string, workspace: string): boolean;
     stopSession(session: string): boolean;
+    /** Clears the session this run stopped, so a later `up` starts from the beginning. */
+    deleteSession(session: string): boolean;
     kill(pid: number): boolean;
     sleep(ms: number): Promise<void>;
     now(): Date;

package/dist/commands/down.js

@@ -1,10 +1,11 @@
 import { readArgs } from "../args.js";
 import { callerOf, describeCaller, mayChangeTeam } from "../caller.js";
 import { currentTeam } from "../file/current.js";
-import { agentList, agentStatus, paneForeground, paneRead, sessionRunning, pressEnter, sessionStop, typeText, workspaceClose, } from "../herdr.js";
+import { agentList, agentStatus, paneForeground, paneRead, sessionDelete, sessionRunning, pressEnter, sessionStop, typeText, workspaceClose, } from "../herdr.js";
 import { executePlan } from "../launch/execute.js";
 import { reportedLiveAgent } from "../launch/agent.js";
 import { downPlan, formatPlan } from "../launch/plan.js";
+import { boxHoldsText } from "../launch/deliver.js";
 import { profileFor } from "../profiles/index.js";
 import { logLine } from "../log.js";
 import { emptySession, readState, updateState } from "../state.js";
@@ -21,6 +22,7 @@ const realLaunch = {
     },
     closeWorkspace: (session, workspace) => workspaceClose(workspace, aim(session)),
     stopSession: sessionStop,
+    deleteSession: sessionDelete,
     kill(pid) {
         try {
             process.kill(pid, 'SIGTERM');
@@ -48,6 +50,7 @@ export const realSources = {
     screen(session, pane, cli) {
         return readScreen(cli, paneRead(pane, 200, aim(session)) ?? undefined);
     },
+    screenText: (session, pane) => paneRead(pane, 200, aim(session)) ?? undefined,
     status: (session, pane) => agentStatus(pane, aim(session)),
     foreground: (session, pane) => paneForeground(pane, aim(session)),
     now: () => new Date(),
@@ -126,6 +129,18 @@ export async function runDown(argv, io, sources) {
     if (abandon && !callerOwns(caller)) {
         refusals.push('only the owner abandons a team, from a terminal outside herdr');
     }
+    const state = readState(dir).sessions[session];
+    const known = new Set([...team.seats.map((seat) => seat.name), ...Object.keys(state?.seats ?? {})]);
+    const cliOf = new Map(team.seats.map((seat) => [seat.name, seat.cli]));
+    // The CLI a running seat was launched with: the file's for the seats it still names, the
+    // state's for the rest, so a seat the file renamed is still stopped. A temporary seat falls
+    // back to the seat it is like. A state too old to say leaves the seat to its owner, named
+    // in the plan.
+    const cliFor = (name) => {
+        const recorded = state?.seats[name];
+        const like = recorded?.temporary?.like;
+        return cliOf.get(name) ?? recorded?.cli ?? (like ? cliOf.get(like) ?? state?.seats[like]?.cli : undefined) ?? 'unknown';
+    };
     if (!dry && args.flags.has('wait') && refusals.length === 0) {
         const deadline = sources.now().getTime() + WAIT_SECONDS * 1000;
         const sleep = sources.sleep ?? sources.launch?.sleep;
@@ -133,8 +148,7 @@ export async function runDown(argv, io, sources) {
             const waiting = agents.some((agent) => {
                 if (!agent.name)
                     return false;
-                const cli = team.seats.find((seat) => seat.name === agent.name)?.cli ?? 'claude-code';
-                return stateOf(agent.status, sources.screen(session, agent.pane, cli)) === 'working';
+                return stateOf(agent.status, sources.screen(session, agent.pane, cliFor(agent.name))) === 'working';
             });
             if (!waiting)
                 break;
@@ -148,9 +162,6 @@ export async function runDown(argv, io, sources) {
             agents = again;
         }
     }
-    const state = readState(dir).sessions[session];
-    const known = new Set([...team.seats.map((seat) => seat.name), ...Object.keys(state?.seats ?? {})]);
-    const cliOf = new Map(team.seats.map((seat) => [seat.name, seat.cli]));
     const seats = [];
     let extra = 0;
     for (const agent of agents) {
@@ -158,8 +169,7 @@ export async function runDown(argv, io, sources) {
             extra++;
             continue;
         }
-        const like = state?.seats[agent.name]?.temporary?.like;
-        const cli = cliOf.get(agent.name) ?? (like ? cliOf.get(like) : undefined) ?? 'unknown';
+        const cli = cliFor(agent.name);
         seats.push({
             name: agent.name,
             cli,
@@ -202,8 +212,8 @@ export async function runDown(argv, io, sources) {
         typeLine(sessionName, pane, text) {
             // Free was decided when the plan was built. Look again, and once more between the text and
             // the Enter: a prompt that appeared would take the key, as the watch's nudge does. Herdr's
-            // status is asked both times; Enter waits until it is idle or done and the screen is idle
-            // or holding unsent text.
+            // status is asked both times; the Enter waits until it is idle or done and the box reads
+            // back as exactly the typed text.
             const cli = seats.find((seat) => seat.pane === pane)?.cli ?? '';
             const names = profileFor(cli)?.processNames ?? [];
             const live = () => reportedLiveAgent(sources.foreground(sessionName, pane), names);
@@ -220,20 +230,29 @@ export async function runDown(argv, io, sources) {
                 return false;
             if (!live())
                 return 'no-agent';
-            const after = look();
-            if (!resting() || (after !== 'idle' && after !== 'unsent'))
+            // An idle screen after the typing is the text not rendered, and unsent text alone is not
+            // this exit's: only a box that reads back as the typed text gets the Enter.
+            if (!resting() || !boxHoldsText(cli, text, sources.screenText(sessionName, pane, cli)))
                 return false;
             return launch.pressEnter(sessionName, pane);
         },
         renameAgent: () => false,
         closeWorkspace: launch.closeWorkspace,
         stopSession: launch.stopSession,
+        // Only the session this run has itself just stopped, and only once herdr agrees it is no
+        // longer running: anything else — still running, or herdr silent — is left to its owner, with
+        // the command the line in `executePlan` names. `up` never deletes a session at all.
+        deleteSession(name) {
+            return sources.sessionRunning(name) === false && launch.deleteSession(name);
+        },
         kill: launch.kill,
         agentPanes(sessionName) {
             const listed = launch.agentPanes(sessionName);
             if (!listed)
                 return null;
-            // A pane back at its shell is no longer the seat. `gone` then finishes and the workspace closes.
+            // A pane back at its shell is no longer the seat. `gone` then finishes and the workspace
+            // closes. The wait keeps an unreadable list (`paneStillRunning`); the watch's quota read
+            // asks the other way — `reportedLiveAgent`, a figure only where the CLI was seen.
             return listed.filter((pane) => {
                 const cli = seats.find((seat) => seat.pane === pane)?.cli;
                 const names = cli ? profileFor(cli)?.processNames : undefined;

package/dist/commands/init.d.ts

@@ -1,7 +1,7 @@
 import type { Command, Io } from '../io.ts';
 export declare const EXCLUDED: string[];
 export declare const PRIVACY = "The team file is private to this clone: it is listed in .git/info/exclude, never in .gitignore,\nso git doesn't see it and a fresh clone doesn't carry it. A collaborator writes their own, or\nreceives one and approves it themselves.";
-export declare function skeleton(project: string, head: string | null): string;
+export declare function skeleton(project: string, head: string | null, teamVersion?: string): string;
 export declare function exclude(root: string): string[];
 export declare const init: Command;
 export default init;

package/dist/commands/init.js

@@ -8,6 +8,7 @@ import { validateTeamFile } from "../file/validate.js";
 import { logLine } from "../log.js";
 import { LOCK_FILE, LOG_FILE, STATE_FILE, writeAtomic } from "../state.js";
 import { approvedCopy } from "../store/store.js";
+import { version } from "../version.js";
 // What git must never pick up: the file and the runtime files beside it.
 export const EXCLUDED = [TEAM_FILE, `.agents/${STATE_FILE}`, `.agents/${LOG_FILE}*`, `.agents/${LOCK_FILE}`];
 export const PRIVACY = `The team file is private to this clone: it is listed in .git/info/exclude, never in .gitignore,
@@ -21,8 +22,9 @@ function git(root, ...args) {
         return null;
     }
 }
-export function skeleton(project, head) {
-    return `# The team of ${project}. Private to this clone: see .git/info/exclude.
+export function skeleton(project, head, teamVersion = version()) {
+    return `# yaml-language-server: $schema=https://raw.githubusercontent.com/floor/team/v${teamVersion}/schema/team.schema.json
+# The team of ${project}. Private to this clone: see .git/info/exclude.
 # Nothing here runs until the owner has read it and run \`team approve\`.
 format: 1
 project: ${project}

package/dist/commands/remove.js

@@ -16,6 +16,7 @@ import { logLine } from "../log.js";
 import { profileFor } from "../profiles/index.js";
 import { emptySession, readState, updateState, withLock } from "../state.js";
 import { paneStillRunning, realSources as downSources, stateOf } from "./down.js";
+import { boxHoldsText } from "../launch/deliver.js";
 function aim(session) {
     return session === 'default' ? undefined : session;
 }
@@ -213,8 +214,8 @@ export async function stopRunning(input) {
                 return false;
             if (!live())
                 return 'no-agent';
-            const after = look();
-            if (!resting() || (after !== 'idle' && after !== 'unsent'))
+            // As in `down`: only a box that reads back as exactly the typed text gets the Enter.
+            if (!resting() || !boxHoldsText(seat.cli, text, sources.screenText(sessionName, pane, seat.cli)))
                 return false;
             return launch.pressEnter(sessionName, pane);
         },
@@ -226,6 +227,8 @@ export async function stopRunning(input) {
             const listed = launch.agentPanes(sessionName);
             if (!listed)
                 return null;
+            // A pane back at its shell is no longer the seat. The wait keeps an unreadable list
+            // (`paneStillRunning`); the watch's quota read asks the other way (`reportedLiveAgent`).
             const names = profileFor(seat.cli)?.processNames;
             if (!names)
                 return listed;

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,6 +65,9 @@ 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');
@@ -73,7 +79,7 @@ export async function runStatus(argv, io, sources) {
     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,
@@ -92,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.js

@@ -335,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

@@ -29,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

@@ -15,10 +15,12 @@ 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) => {
@@ -60,6 +62,7 @@ export const realWatchSources = {
         }
     },
     pid: process.pid,
+    home: homedir(),
 };
 export const watch = (argv, io) => runWatch(argv, io, realWatchSources);
 export default watch;
@@ -119,6 +122,18 @@ 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;
@@ -176,10 +191,18 @@ export async function runWatch(argv, io, sources) {
                             : `the check for ${outcome.account} is unapproved; that account reads unknown`, false);
                     }
                 }
+                // 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,
-                    readings: stored,
+                    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
@@ -264,9 +287,10 @@ function deliver(nudge, team, session, sources, memory, say, tell, told) {
         keep();
         return;
     }
-    const after = look();
-    if (after !== 'idle' && after !== 'unsent') {
-        tell('a nudge was typed and not sent: the operator\'s screen changed before the Enter', true);
+    // 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;
     }

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;
+    }[];
+}