team 0.1.1 → 0.2.0

package/dist/commands/add.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, resolve } from 'node:path';
-import { approvalDifferences, budgetsInForce } from "../approve/approval.js";
+import { approvalDifferences, budgetsInForce, recordSeatDigest } from "../approve/approval.js";
 import { readArgs } from "../args.js";
 import { callerOf, describeCaller, isOwner, mayChangeTeam } from "../caller.js";
 import { blocksLaunch, doctorFindings, realSources as doctorSources } from "../commands/doctor.js";
@@ -13,7 +13,7 @@ import { clearStopped, hasSeat, restoreSeat, seatIsStopped } from "../file/lines
 import { loadTeamFile, placedProblems } from "../file/load.js";
 import { validateTeamFile } from "../file/validate.js";
 import { writeTeamFile } from "../file/write.js";
-import { agentList, agentRename, paneRead, paneRun, sessionRunning, sessionState, startServer, workspaceClose, workspaceCreate, workspaceList, } from "../herdr.js";
+import { agentList, agentRename, paneForeground, paneRead, paneRun, sessionRunning, sessionState, startServer, workspaceClose, workspaceCreate, workspaceList, } from "../herdr.js";
 import { executePlan } from "../launch/execute.js";
 import { formatPlan, upPlan } from "../launch/plan.js";
 import { logLine } from "../log.js";
@@ -36,6 +36,7 @@ const realLaunch = {
         return agents === null ? null : agents.map((agent) => agent.pane);
     },
     paneText: (session, pane) => paneRead(pane, 200, aim(session)),
+    foreground: (session, pane) => paneForeground(pane, aim(session)),
     sleep: (ms) => new Promise((done) => setTimeout(done, ms)),
     now: () => new Date(),
 };
@@ -48,7 +49,7 @@ export const realSources = {
     agents: (session) => agentList(aim(session)),
     workspaces(session) {
         const listed = workspaceList(aim(session));
-        return listed === null ? null : listed.map((workspace) => ({ id: workspace.id, label: workspace.label }));
+        return listed === null ? null : listed.map((workspace) => ({ id: workspace.id }));
     },
     doctor: doctorSources,
     machine: readMachine,
@@ -122,6 +123,7 @@ export async function runAdd(argv, io, sources = realSources) {
         return 1;
     }
     const agents = live === 'running' ? sources.agents(session) : [];
+    // Read so a session whose workspace list can't be read is refused. The title is not a key.
     const workspaces = live === 'running' ? sources.workspaces(session) : [];
     if (agents === null || workspaces === null) {
         io.stderr(`team add: session ${session} runs, and its agents can't be read\n`);
@@ -168,7 +170,10 @@ export async function runAdd(argv, io, sources = realSources) {
     const doctorTeam = built.temporary
         ? { ...prepared.team, seats: prepared.team.seats.map((item) => item.name === built.temporary?.like ? { ...item, stopped: false } : item) }
         : prepared.team;
-    for (const finding of doctorFindings(doctorTeam, root, dir, session, sources.doctor, prepared.warnings)) {
+    // `team` is the file on disk, already the approved one. `doctorTeam` is the
+    // seat about to run, so a stopped seat's CLI is still checked. The digest is
+    // recorded with the write, after a refusal has left the file alone.
+    for (const finding of doctorFindings(doctorTeam, root, dir, session, sources.doctor, prepared.warnings, team)) {
         if (blocksLaunch(finding)) {
             io.stderr(`team add: ${finding.text}\n`);
             return 1;
@@ -198,8 +203,8 @@ export async function runAdd(argv, io, sources = realSources) {
     // The gate reads the approved budgets, never the edited file's: the seat this `add` inserts
     // changes no section of its own, and no unapproved reserve may unblock a launch (#50).
     const budgets = budgetsInForce(prepared.team, root, sources.home);
-    const decision = seatBudget(budgets, loadReadings(dir, session), built.seat, sources.now().getTime(), loadSpendReadings(dir, session));
-    const stray = unnamedIn(built.seat.label, agents, workspaces);
+    const decision = seatBudget(budgets, loadReadings(dir), built.seat, sources.now().getTime(), loadSpendReadings(dir));
+    const stray = unnamedIn(recorded.seats[built.name]?.workspace, agents);
     const starting = seatPlan(prepared.team, built.seat, start);
     const planned = stray
         ? { ...starting, stage: 'launched', pane: stray.pane, workspace: stray.workspace, agentLive: true }
@@ -246,6 +251,9 @@ export async function runAdd(argv, io, sources = realSources) {
                 io.stderr(`team add: ${where(problem)}${problem.message}\n`);
             return 2;
         }
+        const parsed = validateTeamFile(built.edited);
+        if (parsed.ok)
+            recordSeatDigest(parsed.team, root, built.name, sources.home);
     }
     const plan = upPlan({ root, session, sessionRunning: live === 'running', seats: [seatForPlan], watchAlive: true });
     const who = describeCaller(caller);
@@ -347,9 +355,10 @@ function seatPlan(team, seat, start) {
         ...(start.lobby ? { lobby: true } : {}),
     };
 }
-function unnamedIn(label, agents, workspaces) {
-    const ids = new Set(workspaces.filter((workspace) => workspace.label === label).map((workspace) => workspace.id));
-    return agents.find((agent) => !agent.name && ids.has(agent.workspace));
+function unnamedIn(workspace, agents) {
+    if (!workspace)
+        return undefined;
+    return agents.find((agent) => !agent.name && agent.workspace === workspace);
 }
 function runningOf(agents, team, state) {
     const seats = new Map(team.seats.map((seat) => [seat.name, seat]));

package/dist/commands/approve.js

@@ -11,6 +11,7 @@ import { callerOf, describeCaller, isOwner } from "../caller.js";
 import { loadTeamFile, placedProblems } from "../file/load.js";
 import { validateTeamFile } from "../file/validate.js";
 import { logLine } from "../log.js";
+import { OVERRIDE_CHANGED, overrideFile } from "../profiles/overrides.js";
 import { readApproval, storePath, writeApproval } from "../store/store.js";
 export const realSources = {
     async ask(question) {
@@ -86,6 +87,12 @@ export async function runApprove(argv, io, sources) {
     for (const warning of checked.warnings)
         io.stderr(`team approve: warning, line ${warning.line}: ${warning.message}\n`);
     const store = storePath(team.project, root, sources.home);
+    const live = overrideFile(team.project, root, sources.home);
+    if (live.problems.length) {
+        for (const problem of live.problems)
+            io.stderr(`team approve: ${problem}\n`);
+        return 2;
+    }
     const problem = storeProblem(store, root, team);
     if (problem) {
         io.stderr(`team approve: ${problem}\n`);
@@ -119,6 +126,15 @@ export async function runApprove(argv, io, sources) {
             io.stdout(`${path}: against the copy approved on ${previous.approval.approvedAt}:\n\n`);
             io.stdout(`${lines.map((line) => `  ${line}`).join('\n')}\n\n`);
         }
+        const recorded = Object.hasOwn(previous.approval, 'overrides') ? previous.approval.overrides ?? null : null;
+        if (recorded !== live.text) {
+            changes.push(OVERRIDE_CHANGED);
+            const overrideLines = formatDiff(recorded ?? '', live.text ?? '');
+            if (overrideLines.length) {
+                io.stdout(`overrides.yaml: against the copy approved on ${previous.approval.approvedAt}:\n\n`);
+                io.stdout(`${overrideLines.map((line) => `  ${line}`).join('\n')}\n\n`);
+            }
+        }
         io.stdout(changes.length ? `Needs a new approval: ${changes.join('; ')}.\n` : 'Nothing in it needs a new approval.\n');
         if (ceilingsLine(previous.approval.ceilings) !== ceilingsLine(ceilings)) {
             io.stdout(`Ceilings approved: ${ceilingsLine(previous.approval.ceilings)}.\n`);
@@ -139,7 +155,7 @@ export async function runApprove(argv, io, sources) {
         return 1;
     }
     const now = sources.now();
-    writeApproval(store, { approval: approvalOf(team, root, now, resolved.checks), file: text }, team.seats);
+    writeApproval(store, { approval: { ...approvalOf(team, root, now, resolved.checks), overrides: live.text }, file: text }, team.seats);
     logLine(dirname(path), 'approve', describeCaller(caller), `approved ${seats} seats; ceilings: ${ceilingsLine(ceilings)}`, now);
     io.stdout(`Approved. The record is in ${store}; check the rest with \`team doctor\`.\n`);
     return 0;

package/dist/commands/doctor.d.ts

@@ -1,3 +1,4 @@
+import { type Caller } from '../caller.ts';
 import type { TeamFile } from '../file/types.ts';
 import type { Command, Io } from '../io.ts';
 import { type Profile } from '../profiles/profile.ts';
@@ -9,6 +10,7 @@ export type DoctorSources = {
     sessionRunning(session: string): boolean | null;
     now(): Date;
     home: string;
+    runCheck?(path: string): string | null;
 };
 export type CommandRunner = (binary: string, args: string[]) => {
     status: number | null;
@@ -30,9 +32,23 @@ export type Finding = {
 export declare function blocksLaunch(finding: Finding): boolean;
 export declare const doctor: Command;
 export default doctor;
+/**
+ * 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 declare function budgetCheckFindings(team: TeamFile, root: string, sources: DoctorSources, caller: Caller): Finding[];
+export declare function seatNameFindings(team: TeamFile, session: string): Finding[];
 export declare function doctorFindings(team: TeamFile, root: string, dir: string, session: string, sources: DoctorSources, warnings: {
     line: number;
     message: string;
-}[]): Finding[];
+}[], 
+/** The file as approved. `add` hands the team about to run, whose `stopped` mark is already cleared. */
+approved?: TeamFile, 
+/** The budget-check lines, which only the report runs: `up` and `add` scan, they never run a check. */
+budgetChecks?: Finding[]): Finding[];
 export declare function doctorLoginFindings(team: TeamFile, sources: DoctorSources): Finding[];
 export declare function runDoctor(argv: string[], io: Io, sources: DoctorSources): Promise<number>;

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,12 +242,40 @@ function watchFindings(watch, dir, session, running, now) {
     }
     return [{ level: 'ok', text: 'the watch is running' }];
 }
-export function doctorFindings(team, root, dir, session, sources, warnings) {
+// 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, 
+/** 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(team, 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)
@@ -220,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,10 +8,12 @@ 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 process names in the pane, or null when the pane can't be read. */
-    foreground?(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;
     now(): Date;
     sleep?(ms: number): Promise<void>;
     launch?: DownLaunch;
@@ -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,9 +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";
@@ -20,6 +22,7 @@ const realLaunch = {
     },
     closeWorkspace: (session, workspace) => workspaceClose(workspace, aim(session)),
     stopSession: sessionStop,
+    deleteSession: sessionDelete,
     kill(pid) {
         try {
             process.kill(pid, 'SIGTERM');
@@ -47,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(),
@@ -125,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;
@@ -132,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;
@@ -147,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) {
@@ -157,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,
@@ -201,9 +212,13 @@ 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);
+            if (!live())
+                return 'no-agent';
             const look = () => sources.screen(sessionName, pane, cli).kind;
             const resting = () => {
                 const status = sources.status(sessionName, pane);
@@ -213,26 +228,37 @@ export async function runDown(argv, io, sources) {
                 return false;
             if (!launch.typeText(sessionName, pane, text))
                 return false;
-            const after = look();
-            if (!resting() || (after !== 'idle' && after !== 'unsent'))
+            if (!live())
+                return 'no-agent';
+            // 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;
                 if (!names)
                     return true;
-                return paneStillRunning(sources.foreground?.(sessionName, pane) ?? paneForeground(pane, aim(sessionName)), names);
+                return paneStillRunning(sources.foreground(sessionName, pane), names);
             });
         },
         classify: () => 'unknown',

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

@@ -4,6 +4,8 @@ import { type DownSources } from './down.ts';
 export type RemoveSources = DownSources & {
     /** Foreground process names in the pane, or null when the pane can't be read. */
     foreground(session: string, pane: string): string[] | null;
+    /** Approval store home. The real command uses the owner's home. */
+    home?: string;
 };
 export declare const realSources: RemoveSources;
 export declare const USAGE = "Usage: team remove <name> [--keep] [--abandon] [--session <name>] [--file <path>]\n";

package/dist/commands/remove.js

@@ -1,5 +1,7 @@
 import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { dirname } from 'node:path';
+import { recordSeatDigest } from "../approve/approval.js";
 import { readArgs } from "../args.js";
 import { callerOf, describeCaller, isOwner, mayChangeTeam } from "../caller.js";
 import { loadTeamFile } from "../file/load.js";
@@ -7,12 +9,14 @@ import { markStopped, takeOut } from "../file/lines.js";
 import { validateTeamFile } from "../file/validate.js";
 import { writeTeamFile } from "../file/write.js";
 import { paneForeground } from "../herdr.js";
+import { reportedLiveAgent } from "../launch/agent.js";
 import { executePlan } from "../launch/execute.js";
 import { downPlan } from "../launch/plan.js";
 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;
 }
@@ -60,7 +64,7 @@ export async function runRemove(argv, io, sources = realSources) {
         io.stderr(`team remove: only the owner, the coordinator or the operator runs it; this call is ${describeCaller(caller)}\n`);
         return 1;
     }
-    const { team, path } = loaded;
+    const { team, path, root } = loaded;
     const session = args.values.session ?? team.session;
     if (session === 'default') {
         io.stderr('team remove: session can\'t be "default", herdr\'s own session\n');
@@ -133,6 +137,7 @@ export async function runRemove(argv, io, sources = realSources) {
         if (!stopped)
             return 1;
     }
+    let kept = null;
     if (!temporary) {
         const refused = withLock(dir, () => {
             const text = readFileSync(path, 'utf8');
@@ -140,7 +145,11 @@ export async function runRemove(argv, io, sources = realSources) {
             if (next === text)
                 return null;
             const wrote = writeTeamFile(path, next);
-            return wrote.ok ? null : wrote.errors;
+            if (!wrote.ok)
+                return wrote.errors;
+            if (args.flags.has('keep'))
+                kept = next;
+            return null;
         });
         if (refused) {
             for (const problem of refused) {
@@ -149,6 +158,11 @@ export async function runRemove(argv, io, sources = realSources) {
             return 2;
         }
     }
+    if (kept !== null) {
+        const parsed = validateTeamFile(kept);
+        if (parsed.ok)
+            recordSeatDigest(parsed.team, root, name, sources.home ?? homedir());
+    }
     if (!agent && recorded) {
         updateState(dir, (file) => {
             const seats = file.sessions[session]?.seats;
@@ -185,6 +199,10 @@ export async function stopRunning(input) {
         createWorkspace: () => null,
         paneRun: () => false,
         typeLine(sessionName, pane, text) {
+            const names = profileFor(seat.cli)?.processNames ?? [];
+            const live = () => reportedLiveAgent(sources.foreground(sessionName, pane), names);
+            if (!live())
+                return 'no-agent';
             const look = () => sources.screen(sessionName, pane, seat.cli).kind;
             const resting = () => {
                 const status = sources.status(sessionName, pane);
@@ -194,8 +212,10 @@ export async function stopRunning(input) {
                 return false;
             if (!launch.typeText(sessionName, pane, text))
                 return false;
-            const after = look();
-            if (!resting() || (after !== 'idle' && after !== 'unsent'))
+            if (!live())
+                return 'no-agent';
+            // 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);
         },
@@ -207,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;