team 0.0.1 → 0.1.1

package/dist/commands/check.js

@@ -0,0 +1,103 @@
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { fromTeamFile } from "../check/config.js";
+import { GitError } from "../check/git.js";
+import { formatReport, runCheck } from "../check/run.js";
+import { loadTeamFile } from "../file/load.js";
+import { readLedger, storePath } from "../store/store.js";
+export const USAGE = `Usage: team check <ref> [--pr <file>] [--since <ref>] [--file <path>]
+
+  <ref>            a range when it holds "..", passed to git as given
+                   (origin/main..HEAD); otherwise that one commit
+  --pr <file>      also check a pull request's body ("-" reads standard input)
+  --since <ref>    skip this commit and everything reachable from it, for this
+                   run; overrides identity.since
+  --file <path>    the team file, instead of .agents/team.yaml
+
+Exits 0 when every commit passes, 1 when one is refused, 2 when the check
+can't run.
+`;
+const VALUE_OPTIONS = ['pr', 'since', 'file'];
+function parse(argv) {
+    const values = {};
+    const positional = [];
+    for (let index = 0; index < argv.length; index++) {
+        const argument = argv[index];
+        if (!argument.startsWith('--')) {
+            positional.push(argument);
+            continue;
+        }
+        const [name, inline] = argument.slice(2).split(/=(.*)/s, 2);
+        const option = VALUE_OPTIONS.find((known) => known === name);
+        if (!option)
+            return `unknown option ${argument}`;
+        const value = inline ?? argv[++index];
+        if (value === undefined || value === '')
+            return `--${option} needs a value`;
+        values[option] = value;
+    }
+    const [ref, ...rest] = positional;
+    if (ref === undefined)
+        return 'a <ref> is required';
+    if (rest.length > 0)
+        return 'one <ref> at most';
+    return { ref, ...values };
+}
+/** The file's rules, with the ledger of this machine's store when the owner has approved a file here. */
+export function loadConfig(cwd, file, home = homedir()) {
+    const loaded = loadTeamFile(cwd, { file });
+    if (!loaded.ok)
+        return loaded;
+    const store = storePath(loaded.team.project, loaded.root, home);
+    const ledgerFile = join(store, 'ledger.json');
+    try {
+        const ledger = readLedger(store);
+        return { ok: true, config: fromTeamFile(loaded.team, ledger), warnings: loaded.warnings };
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return { ok: false, errors: [{ line: 0, message: `can't read ${ledgerFile}: ${detail}` }] };
+    }
+}
+function place(problem, path) {
+    const where = [path, problem.line > 0 ? `line ${problem.line}` : ''].filter(Boolean).join(', ');
+    return `${where ? `${where}: ` : ''}${problem.message}`;
+}
+export async function check(argv, io, load = loadConfig) {
+    const args = parse(argv);
+    if (typeof args === 'string') {
+        io.stderr(`team check: ${args}\n\n${USAGE}`);
+        return 2;
+    }
+    const loaded = load(io.cwd, args.file);
+    if (!loaded.ok) {
+        for (const problem of loaded.errors)
+            io.stderr(`team check: ${place(problem, loaded.path)}\n`);
+        return 2;
+    }
+    for (const warning of loaded.warnings)
+        io.stderr(`team check: warning: ${place(warning)}\n`);
+    let pullRequestBody;
+    if (args.pr !== undefined) {
+        try {
+            pullRequestBody = readFileSync(args.pr === '-' ? 0 : resolve(io.cwd, args.pr), 'utf8');
+        }
+        catch (error) {
+            io.stderr(`team check: can't read the pull request body: ${error.message}\n`);
+            return 2;
+        }
+    }
+    try {
+        const report = runCheck(loaded.config, { cwd: io.cwd, ref: args.ref, since: args.since, pullRequestBody });
+        io.stdout(formatReport(report));
+        return report.ok ? 0 : 1;
+    }
+    catch (error) {
+        if (!(error instanceof GitError))
+            throw error;
+        io.stderr(`team check: ${error.message}\n`);
+        return 2;
+    }
+}
+export default check;

package/dist/commands/doctor.d.ts

@@ -0,0 +1,38 @@
+import type { TeamFile } from '../file/types.ts';
+import type { Command, Io } from '../io.ts';
+import { type Profile } from '../profiles/profile.ts';
+export type DoctorSources = {
+    version(binary: string): string | null;
+    onPath(binary: string): boolean;
+    loggedIn(profile: Profile): boolean | null;
+    herdrVersion(): string | null;
+    sessionRunning(session: string): boolean | null;
+    now(): Date;
+    home: string;
+};
+export type CommandRunner = (binary: string, args: string[]) => {
+    status: number | null;
+    stdout: string;
+} | null;
+export declare function run(binary: string, args: string[]): {
+    status: number | null;
+    stdout: string;
+} | null;
+export declare const realCommandRunner: typeof run;
+export declare function checkLogin(profile: Profile, runner?: CommandRunner): boolean | null;
+export declare const realSources: DoctorSources;
+export declare const USAGE = "Usage: team doctor [--session <name>] [--file <path>] [--login]\n";
+export type Level = 'ok' | 'warn' | 'miss' | 'note';
+export type Finding = {
+    level: Level;
+    text: string;
+};
+export declare function blocksLaunch(finding: Finding): boolean;
+export declare const doctor: Command;
+export default doctor;
+export declare function doctorFindings(team: TeamFile, root: string, dir: string, session: string, sources: DoctorSources, warnings: {
+    line: number;
+    message: string;
+}[]): 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

@@ -0,0 +1,232 @@
+import { spawnSync } from 'node:child_process';
+import { accessSync, constants } 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 { loadTeamFile } from "../file/load.js";
+import { HERDR_TESTED, herdrVersion, sessionRunning } from "../herdr.js";
+import { profileFor } from "../profiles/index.js";
+import { versionVerdict } from "../profiles/profile.js";
+import { readState } from "../state.js";
+import { readApproval, storePath } from "../store/store.js";
+export function run(binary, args) {
+    const result = spawnSync(binary, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 15_000 });
+    return result.error ? null : { status: result.status, stdout: result.stdout };
+}
+export const realCommandRunner = run;
+export function checkLogin(profile, runner = run) {
+    if (!profile.loginCheck)
+        return null;
+    // Only the exit code is read: the output names the account.
+    const result = runner(profile.binary, [...profile.loginCheck]);
+    return result ? result.status === 0 : null;
+}
+export const realSources = {
+    version(binary) {
+        const result = run(binary, ['--version']);
+        return result && result.status === 0 ? result.stdout.trim() : null;
+    },
+    onPath(binary) {
+        const folders = isAbsolute(binary) ? [''] : (process.env.PATH ?? '').split(delimiter).filter(Boolean);
+        return folders.some((folder) => {
+            try {
+                accessSync(folder ? join(folder, binary) : binary, constants.X_OK);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+    },
+    loggedIn(profile) {
+        return checkLogin(profile, run);
+    },
+    herdrVersion,
+    sessionRunning,
+    now: () => new Date(),
+    home: homedir(),
+};
+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.
+export function blocksLaunch(finding) {
+    if (finding.level !== 'miss')
+        return false;
+    return !finding.text.startsWith('no watch has run') && !finding.text.startsWith("the watch's heartbeat");
+}
+export const doctor = (argv, io) => runDoctor(argv, io, realSources);
+export default doctor;
+function range(tested) {
+    return tested.from === tested.to ? tested.from : `${tested.from} to ${tested.to}`;
+}
+function versionFinding(name, printed, tested) {
+    const verdict = versionVerdict(printed, tested);
+    if (verdict === 'tested')
+        return { level: 'ok', text: `${name} ${printed}` };
+    if (verdict === 'unread')
+        return { level: 'warn', text: `${name}: its version can't be read from "${printed}"` };
+    return { level: 'warn', text: `${name} ${printed} is ${verdict} than the tested ${range(tested)}` };
+}
+// The command a launch line starts: its first word that is not a variable assignment.
+function launchBinary(launch) {
+    return (launch
+        .trim()
+        .split(/\s+/)
+        .find((word) => !/^[A-Za-z_][A-Za-z0-9_]*=/.test(word)) ?? null);
+}
+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` }]
+        : []);
+}
+function approvalFindings(team, root, home) {
+    const differences = approvalDifferences(team, root, home);
+    if (differences === null) {
+        return [{ level: 'miss', text: 'run `team approve`: this file was never approved on this machine' }];
+    }
+    if (differences.length)
+        return [{ level: 'miss', text: `run \`team approve\`: ${differences.join('; ')}` }];
+    return [{ level: 'ok', text: 'the file is the one the owner approved' }];
+}
+function cliFindings(cli, seats, sources) {
+    const names = seats.map((seat) => seat.name).join(', ');
+    const profile = profileFor(cli);
+    if (!profile) {
+        return [{ level: 'warn', text: `${cli}: no launch profile in this version; \`up\` leaves out ${names}` }];
+    }
+    const printed = sources.version(profile.binary);
+    if (printed === null) {
+        return [{ level: 'miss', text: `install \`${profile.binary}\`: it is not on the PATH (${cli}: ${names})` }];
+    }
+    const findings = [versionFinding(profile.binary, printed, profile.tested)];
+    const loggedIn = sources.loggedIn(profile);
+    if (loggedIn === false)
+        findings.push({ level: 'miss', text: `log in to ${cli}: \`${profile.loginHint}\`` });
+    else if (loggedIn === null)
+        findings.push({ level: 'note', text: `${cli}: the login is not checked in this version` });
+    else
+        findings.push({ level: 'ok', text: `${cli}: logged in` });
+    for (const seat of seats) {
+        const binary = launchBinary(seat.launch);
+        if (binary !== null && binary !== profile.binary && !sources.onPath(binary)) {
+            findings.push({ level: 'miss', text: `${seat.name}: its launcher \`${binary}\` is not on the PATH` });
+        }
+        const named = profile.modelOf(seat.launch);
+        if (named === null) {
+            findings.push({
+                level: 'warn',
+                text: `${seat.name}: the launch names no model this version knows; the file says ${seat.model} ${seat.version}`,
+            });
+        }
+        else if (named.model !== seat.model || named.version !== seat.version) {
+            findings.push({
+                level: 'warn',
+                text: `${seat.name}: the launch starts ${named.model} ${named.version}, the file says ${seat.model} ${seat.version}`,
+            });
+        }
+    }
+    return findings;
+}
+// `watch` is the watch values in force — the approved ones — so an unapproved interval edit can't
+// move the verdict either way.
+function watchFindings(watch, dir, session, running, now) {
+    const recorded = readState(dir).sessions[session]?.watch;
+    if (!running)
+        return [];
+    if (!recorded)
+        return [{ level: 'miss', text: `no watch has run for session ${session}: start \`team watch\`` }];
+    const age = (now.getTime() - Date.parse(recorded.heartbeat)) / 1000;
+    if (!(age <= 2 * watch.interval)) {
+        return [
+            {
+                level: 'miss',
+                text: `the watch's heartbeat is ${Math.round(age / 60)} min old (two intervals are ${(2 * watch.interval) / 60} min): start \`team watch\``,
+            },
+        ];
+    }
+    return [{ level: 'ok', text: 'the watch is running' }];
+}
+export function doctorFindings(team, root, dir, session, sources, warnings) {
+    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));
+    const herdr = sources.herdrVersion();
+    const running = herdr === null ? null : sources.sessionRunning(session);
+    if (herdr === null)
+        findings.push({ level: 'miss', text: 'install herdr: it is not on the PATH' });
+    else {
+        findings.push(versionFinding('herdr', herdr, HERDR_TESTED));
+        if (running === null)
+            findings.push({ level: 'miss', text: "herdr doesn't answer" });
+        else
+            findings.push({ level: 'note', text: `session ${session} is ${running ? 'running' : 'not running'}` });
+    }
+    const launched = team.seats.filter((seat) => !seat.stopped);
+    for (const cli of new Set(launched.map((seat) => seat.cli))) {
+        findings.push(...cliFindings(cli, launched.filter((seat) => seat.cli === cli), sources));
+    }
+    findings.push(...watchFindings(watchInForce(team, root, sources.home), dir, session, running, sources.now()));
+    if (team.trust.length) {
+        findings.push({ level: 'note', text: 'trust: not applied or checked by this version; trust each folder by hand' });
+    }
+    return findings;
+}
+export function doctorLoginFindings(team, sources) {
+    const clis = [];
+    for (const seat of team.seats) {
+        if (!clis.includes(seat.cli))
+            clis.push(seat.cli);
+    }
+    const findings = [];
+    for (const cli of clis) {
+        const profile = profileFor(cli);
+        if (!profile) {
+            findings.push({ level: 'note', text: `${cli}: no launch profile in this version` });
+            continue;
+        }
+        const loggedIn = sources.loggedIn(profile);
+        if (loggedIn === false) {
+            findings.push({ level: 'miss', text: `log in to ${cli}: \`${profile.loginHint}\`` });
+        }
+        else if (loggedIn === null) {
+            findings.push({ level: 'note', text: `${cli}: the login is not checked in this version` });
+        }
+        else {
+            findings.push({ level: 'ok', text: `${cli}: logged in` });
+        }
+    }
+    return findings;
+}
+export async function runDoctor(argv, io, sources) {
+    const args = readArgs(argv, ['session', 'file'], ['login']);
+    if (args.error || args.rest.length) {
+        io.stderr(`team doctor: ${args.error ?? `unexpected "${args.rest[0]}"`}\n${USAGE}`);
+        return 2;
+    }
+    const loaded = loadTeamFile(io.cwd, args.values.file ? { file: args.values.file } : {});
+    if (!loaded.ok) {
+        for (const problem of loaded.errors) {
+            io.stderr(`team doctor: ${problem.line ? `line ${problem.line}: ` : ''}${problem.message}\n`);
+        }
+        return 2;
+    }
+    const { team, root } = loaded;
+    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);
+    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;
+    const warnings = findings.filter((finding) => finding.level === 'warn').length;
+    io.stdout(missing
+        ? `team doctor: ${missing} missing, ${warnings} warning${warnings === 1 ? '' : 's'}: \`up\` and \`add\` refuse until the missing ones are done\n`
+        : `team doctor: nothing missing, ${warnings} warning${warnings === 1 ? '' : 's'}\n`);
+    return missing ? 1 : 0;
+}

package/dist/commands/down.d.ts

@@ -0,0 +1,37 @@
+import { type HerdrAgent } from '../herdr.ts';
+import type { Command, Io } from '../io.ts';
+import { type DownSeat } from '../launch/plan.ts';
+import { type Screen } from '../watch/screen.ts';
+export type DownSources = {
+    sessionRunning(session: string): boolean | null;
+    agents(session: string): HerdrAgent[] | null;
+    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;
+    /** 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;
+    now(): Date;
+    sleep?(ms: number): Promise<void>;
+    launch?: DownLaunch;
+};
+export type DownLaunch = {
+    typeText(session: string, pane: string, text: string): boolean;
+    pressEnter(session: string, pane: string): boolean;
+    agentPanes(session: string): string[] | null;
+    closeWorkspace(session: string, workspace: string): boolean;
+    stopSession(session: string): boolean;
+    kill(pid: number): boolean;
+    sleep(ms: number): Promise<void>;
+    now(): Date;
+};
+export declare const realSources: DownSources;
+/** How long `--wait` gives a working seat, in seconds. */
+export declare const WAIT_SECONDS = 120;
+export declare const USAGE = "Usage: team down [--dry-run] [--wait] [--abandon] [--session <name>] [--file <path>]\n";
+export declare const down: Command;
+export default down;
+export declare function paneStillRunning(foreground: readonly string[] | null, processNames: readonly string[]): boolean;
+export declare function stateOf(status: string, screen: Screen): DownSeat['state'];
+export declare function runDown(argv: string[], io: Io, sources: DownSources): Promise<number>;

package/dist/commands/down.js

@@ -0,0 +1,258 @@
+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 { executePlan } from "../launch/execute.js";
+import { downPlan, formatPlan } from "../launch/plan.js";
+import { profileFor } from "../profiles/index.js";
+import { logLine } from "../log.js";
+import { emptySession, readState, updateState } from "../state.js";
+import { readScreen } from "../watch/screen.js";
+function aim(session) {
+    return session === 'default' ? undefined : session;
+}
+const realLaunch = {
+    typeText: (session, pane, text) => typeText(pane, text, aim(session)),
+    pressEnter: (session, pane) => pressEnter(pane, aim(session)),
+    agentPanes(session) {
+        const agents = agentList(aim(session));
+        return agents === null ? null : agents.map((agent) => agent.pane);
+    },
+    closeWorkspace: (session, workspace) => workspaceClose(workspace, aim(session)),
+    stopSession: sessionStop,
+    kill(pid) {
+        try {
+            process.kill(pid, 'SIGTERM');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    now: () => new Date(),
+};
+export const realSources = {
+    sessionRunning,
+    agents: (session) => agentList(aim(session)),
+    alive(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    screen(session, pane, cli) {
+        return readScreen(cli, paneRead(pane, 200, aim(session)) ?? undefined);
+    },
+    status: (session, pane) => agentStatus(pane, aim(session)),
+    foreground: (session, pane) => paneForeground(pane, aim(session)),
+    now: () => new Date(),
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    launch: realLaunch,
+};
+/** How long `--wait` gives a working seat, in seconds. */
+export const WAIT_SECONDS = 120;
+export const USAGE = 'Usage: team down [--dry-run] [--wait] [--abandon] [--session <name>] [--file <path>]\n';
+export const down = (argv, io) => runDown(argv, io, realSources);
+export default down;
+// Free only when herdr says idle or done and the screen is an empty idle prompt. A permission
+// prompt is idle to herdr, and typing `/exit` there would answer it.
+// Herdr keeps a pane after the CLI exits, so the pane id staying listed is not "still there".
+// The seat has left when no foreground process is its CLI. An unreadable list keeps the wait.
+export function paneStillRunning(foreground, processNames) {
+    if (!foreground)
+        return true;
+    return foreground.some((name) => processNames.includes(name));
+}
+export function stateOf(status, screen) {
+    if (screen.kind === 'unsent')
+        return 'unsent';
+    if (screen.kind === 'permission' || screen.kind === 'trust' || screen.kind === 'question')
+        return 'blocked';
+    // A screen showing a running turn is working even when herdr's status has not caught up:
+    // `--wait` waits for it, and it is never typed into.
+    if (screen.kind === 'working')
+        return 'working';
+    if (screen.kind === 'unknown')
+        return 'unknown';
+    if (status === 'idle' || status === 'done')
+        return 'free';
+    if (status === 'working' || status === 'blocked')
+        return status;
+    return 'unknown';
+}
+export async function runDown(argv, io, sources) {
+    const args = readArgs(argv, ['session', 'file'], ['dry-run', 'wait', 'abandon']);
+    if (args.error || args.rest.length) {
+        io.stderr(`team down: ${args.error ?? `unexpected "${args.rest[0]}"`}\n${USAGE}`);
+        return 2;
+    }
+    const dry = args.flags.has('dry-run');
+    const current = currentTeam(io.cwd, args.values.file, sources.now());
+    if (!current.ok) {
+        for (const problem of current.errors) {
+            io.stderr(`team down: ${problem.line ? `line ${problem.line}: ` : ''}${problem.message}\n`);
+        }
+        return 2;
+    }
+    if (current.notice)
+        io.stdout(`${current.notice}\n`);
+    const { team, dir } = current;
+    const session = args.values.session ?? team.session;
+    const running = sources.sessionRunning(session);
+    if (running === null) {
+        io.stderr("team down: herdr doesn't answer; is it installed and running?\n");
+        return 2;
+    }
+    if (!running) {
+        io.stdout(`session ${session} is not running: nothing to stop${dry ? '\ndry run: nothing was run' : ''}\n`);
+        return 0;
+    }
+    let agents = sources.agents(session);
+    if (agents === null) {
+        io.stderr(`team down: the agents of session ${session} can't be read\n`);
+        return 2;
+    }
+    const caller = callerOf(io, session === 'default' ? undefined : session);
+    const refusals = [];
+    if (!mayChangeTeam(caller, team)) {
+        refusals.push(`only the owner, the coordinator or the operator stops the team; this call is ${describeCaller(caller)}`);
+    }
+    const abandon = args.flags.has('abandon');
+    if (abandon && !callerOwns(caller)) {
+        refusals.push('only the owner abandons a team, from a terminal outside herdr');
+    }
+    if (!dry && args.flags.has('wait') && refusals.length === 0) {
+        const deadline = sources.now().getTime() + WAIT_SECONDS * 1000;
+        const sleep = sources.sleep ?? sources.launch?.sleep;
+        while (sleep && sources.now().getTime() < deadline) {
+            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';
+            });
+            if (!waiting)
+                break;
+            const before = sources.now().getTime();
+            await sleep(2000);
+            if (sources.now().getTime() <= before)
+                break;
+            const again = sources.agents(session);
+            if (again === null)
+                break;
+            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) {
+        if (!agent.name || !known.has(agent.name)) {
+            extra++;
+            continue;
+        }
+        const like = state?.seats[agent.name]?.temporary?.like;
+        const cli = cliOf.get(agent.name) ?? (like ? cliOf.get(like) : undefined) ?? 'unknown';
+        seats.push({
+            name: agent.name,
+            cli,
+            pane: agent.pane,
+            workspace: agent.workspace,
+            state: stateOf(agent.status, sources.screen(session, agent.pane, cli)),
+        });
+    }
+    const watch = state?.watch;
+    const plan = downPlan({
+        session,
+        seats,
+        extra,
+        watchPid: watch && sources.alive(watch.pid) ? watch.pid : null,
+        keep: caller.kind === 'seat' ? [team.coordinator, team.operator] : [],
+        abandon: abandon && callerOwns(caller),
+    });
+    if (dry) {
+        for (const refusal of refusals)
+            io.stdout(`! down would refuse: ${refusal}\n`);
+        io.stdout(formatPlan(plan));
+        return 0;
+    }
+    if (refusals.length) {
+        for (const refusal of refusals)
+            io.stderr(`team down: ${refusal}\n`);
+        return 1;
+    }
+    const launch = sources.launch;
+    if (!launch) {
+        io.stderr('team down: this call has no way to reach herdr\n');
+        return 1;
+    }
+    const now = () => sources.now();
+    const host = {
+        startServer: () => false,
+        sessionUp: () => true,
+        createWorkspace: () => null,
+        paneRun: () => false,
+        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.
+            const cli = seats.find((seat) => seat.pane === pane)?.cli ?? '';
+            const look = () => sources.screen(sessionName, pane, cli).kind;
+            const resting = () => {
+                const status = sources.status(sessionName, pane);
+                return status === 'idle' || status === 'done';
+            };
+            if (!resting() || look() !== 'idle')
+                return false;
+            if (!launch.typeText(sessionName, pane, text))
+                return false;
+            const after = look();
+            if (!resting() || (after !== 'idle' && after !== 'unsent'))
+                return false;
+            return launch.pressEnter(sessionName, pane);
+        },
+        renameAgent: () => false,
+        closeWorkspace: launch.closeWorkspace,
+        stopSession: launch.stopSession,
+        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.
+            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);
+            });
+        },
+        classify: () => 'unknown',
+        sleep: sources.sleep ?? launch.sleep,
+        now: () => now().getTime(),
+        allow: () => null,
+        record() { },
+        running() { },
+        drop(name) {
+            updateState(dir, (file) => {
+                const seatsOf = (file.sessions[session] ??= emptySession()).seats;
+                delete seatsOf[name];
+            });
+        },
+        say: (line) => io.stdout(line),
+        log: (who, what) => logLine(dir, 'down', describeCaller(caller), `${who}: ${what}`, now()),
+    };
+    const report = await executePlan(plan, session, host);
+    return report.held ? 1 : 0;
+}
+function callerOwns(caller) {
+    return caller.kind === 'owner';
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,9 @@
+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 exclude(root: string): string[];
+export declare const init: Command;
+export default init;
+export declare const USAGE = "Usage: team init [--restore]\n";
+export declare function runInit(argv: string[], io: Io, home?: string): Promise<number>;