team 0.0.1 → 0.1.0

package/dist/commands/init.js

@@ -0,0 +1,138 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { readArgs } from "../args.js";
+import { callerOf, describeCaller, isOwner } from "../caller.js";
+import { TEAM_FILE, findRoot } from "../file/load.js";
+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";
+// 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,
+so git doesn't see it and a fresh clone doesn't carry it. A collaborator writes their own, or
+receives one and approves it themselves.`;
+function git(root, ...args) {
+    try {
+        return execFileSync('git', ['-C', root, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+export function skeleton(project, head) {
+    return `# 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}
+# visibility: public          # public | private: whether forbidden_public applies
+# session: ${project}          # the herdr session; never "default"
+coordinator: coordinator      # the seat that dispatches work
+operator: coordinator         # the seat the watch reports to
+
+# identity:
+#   signature:
+#     template: "Agent: {display} · {role}"
+#     commits:
+#       position: trailer     # last-line | trailer | anywhere
+#       exempt: [merge]
+#     pull_requests:
+#       position: last-line
+#       template: "**Agent:** {display} · {role}"
+#   humans: []                # commit authors who don't sign
+${head ? `#   since: ${head}   # check reads no commit reachable from this one\n` : ''}#   forbidden: []            # added to the defaults
+#   forbidden_public: []
+
+# rules:                      # added to every seat's rules at launch
+#   - Run the tests your change touches.
+
+# trust:                      # applied only by the owner, with \`team trust\`
+#   - .
+#   - ../worktrees/${project}/*
+
+workspace:
+  mode: shared                # worktree | shared
+  # path: ../worktrees/{repo}/{task}
+  # base: main
+
+seats:
+  - role: coordinator
+    name: coordinator
+    cli: claude-code          # claude-code | codex | cursor | grok | antigravity
+    vendor: anthropic
+    model: Claude Opus        # the model's name without its version
+    version: "0"              # the release number alone, quoted
+    launch: claude            # the command and its model options; no approval flags
+`;
+}
+// Adds the lines git must exclude, once each, to the common directory's info/exclude.
+export function exclude(root) {
+    const common = git(root, 'rev-parse', '--path-format=absolute', '--git-common-dir');
+    if (!common)
+        throw new Error('git doesn\'t answer for this folder');
+    const path = join(common, 'info', 'exclude');
+    mkdirSync(dirname(path), { recursive: true });
+    const current = existsSync(path) ? readFileSync(path, 'utf8') : '';
+    const present = new Set(current.split('\n').map((line) => line.trim()));
+    const missing = EXCLUDED.filter((line) => !present.has(line));
+    if (missing.length) {
+        writeAtomic(path, `${current}${current && !current.endsWith('\n') ? '\n' : ''}${missing.join('\n')}\n`);
+    }
+    return missing;
+}
+export const init = (argv, io) => runInit(argv, io);
+export default init;
+export const USAGE = 'Usage: team init [--restore]\n';
+// `home` is where the user-level store is looked for; tests hand in a temporary one.
+export async function runInit(argv, io, home) {
+    const args = readArgs(argv, [], ['restore']);
+    if (args.error || args.rest.length) {
+        io.stderr(`team init: ${args.error ?? `unexpected "${args.rest[0]}"`}\n${USAGE}`);
+        return 2;
+    }
+    const caller = callerOf(io);
+    if (!isOwner(caller)) {
+        io.stderr(`team init: only the owner runs init, from a terminal outside herdr; this call is ${describeCaller(caller)}\n`);
+        return 1;
+    }
+    const root = findRoot(io.cwd);
+    if (!root) {
+        io.stderr('team init: not inside a git repository\n');
+        return 2;
+    }
+    const path = join(root, TEAM_FILE);
+    if (git(root, 'ls-files', '--error-unmatch', TEAM_FILE) !== null) {
+        io.stderr(`team init: ${TEAM_FILE} is tracked by git, and a team file is private. Untrack it, keeping the file:\n  git rm --cached ${TEAM_FILE}\nthen run team init again. History is not rewritten.\n`);
+        return 1;
+    }
+    if (existsSync(path)) {
+        exclude(root);
+        io.stderr(`team init: ${TEAM_FILE} exists already; it is left as it is. Its lines in .git/info/exclude were checked, and added where missing.\n`);
+        return 1;
+    }
+    let text;
+    if (args.flags.has('restore')) {
+        const copy = home === undefined ? approvedCopy(root) : approvedCopy(root, home);
+        if (copy === null) {
+            io.stderr('team init: nothing to restore: no team file was approved for this folder on this machine. Run team init for a skeleton.\n');
+            return 1;
+        }
+        text = copy;
+    }
+    else {
+        text = skeleton(basename(root), git(root, 'rev-parse', 'HEAD'));
+        const check = validateTeamFile(text);
+        if (!check.ok)
+            throw new Error(`the skeleton doesn't validate: ${check.errors[0]?.message}`);
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    const added = exclude(root);
+    writeFileSync(path, text, { flag: 'wx' });
+    const what = args.flags.has('restore') ? 'restored the approved copy' : 'wrote a skeleton';
+    logLine(dirname(path), 'init', describeCaller(caller), `${what} as ${TEAM_FILE}; excluded ${added.length} path(s)`);
+    io.stdout(args.flags.has('restore')
+        ? `Restored ${TEAM_FILE} from the copy you last approved on this machine.\n\n${PRIVACY}\n`
+        : `Wrote ${TEAM_FILE}: a skeleton with one seat. Edit it, then run team approve.\n\n${PRIVACY}\n`);
+    return 0;
+}

package/dist/commands/remove.d.ts

@@ -0,0 +1,23 @@
+import type { Command, Io } from '../io.ts';
+import { type DownSeat } from '../launch/plan.ts';
+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;
+};
+export declare const realSources: RemoveSources;
+export declare const USAGE = "Usage: team remove <name> [--keep] [--abandon] [--session <name>] [--file <path>]\n";
+export declare const remove: Command;
+export default remove;
+export declare function runRemove(argv: string[], io: Io, sources?: RemoveSources): Promise<number>;
+/** Types the exit, waits for the shell, and closes the workspace. False leaves the seat as it is. */
+export declare function stopRunning(input: {
+    io: Io;
+    dir: string;
+    session: string;
+    seat: DownSeat;
+    abandon: boolean;
+    sources: RemoveSources;
+    logCommand: string;
+    caller: string;
+}): Promise<boolean>;

package/dist/commands/remove.js

@@ -0,0 +1,235 @@
+import { readFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { readArgs } from "../args.js";
+import { callerOf, describeCaller, isOwner, mayChangeTeam } from "../caller.js";
+import { loadTeamFile } from "../file/load.js";
+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 { 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";
+function aim(session) {
+    return session === 'default' ? undefined : session;
+}
+export const realSources = {
+    ...downSources,
+    foreground: (session, pane) => paneForeground(pane, aim(session)),
+};
+export const USAGE = 'Usage: team remove <name> [--keep] [--abandon] [--session <name>] [--file <path>]\n';
+const LEFT = {
+    working: 'is working; left as it is',
+    blocked: 'is blocked at a prompt, which team never answers',
+    unknown: 'shows a screen the profile does not recognise; left as it is',
+    unsent: 'holds unsent text in its input box; left as it is',
+};
+export const remove = (argv, io) => runRemove(argv, io, realSources);
+export default remove;
+/** The file edit `remove` would write, or null when that edit is valid or changes nothing. */
+function editProblems(path, name, keep) {
+    const text = readFileSync(path, 'utf8');
+    const next = keep ? markStopped(text, name) : takeOut(text, name);
+    if (next === text)
+        return null;
+    const parsed = validateTeamFile(next);
+    return parsed.ok ? null : parsed.errors;
+}
+export async function runRemove(argv, io, sources = realSources) {
+    const args = readArgs(argv, ['session', 'file'], ['keep', 'abandon']);
+    if (args.error || args.rest.length !== 1) {
+        io.stderr(`team remove: ${args.error ?? (args.rest.length ? `unexpected "${args.rest[0]}"` : 'a seat name is required')}\n${USAGE}`);
+        return 2;
+    }
+    const name = args.rest[0] ?? '';
+    const loaded = loadTeamFile(io.cwd, args.values.file ? { file: args.values.file } : {});
+    if (!loaded.ok) {
+        for (const problem of loaded.errors)
+            io.stderr(`team remove: ${problem.line ? `line ${problem.line}: ` : ''}${problem.message}\n`);
+        return 2;
+    }
+    const caller = callerOf(io);
+    if (args.values.file && !isOwner(caller)) {
+        io.stderr(`team remove: --file is the owner's, from a terminal outside herdr; this call is ${describeCaller(caller)}\n`);
+        return 1;
+    }
+    if (!mayChangeTeam(caller, loaded.team)) {
+        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 session = args.values.session ?? team.session;
+    if (session === 'default') {
+        io.stderr('team remove: session can\'t be "default", herdr\'s own session\n');
+        return 1;
+    }
+    const abandon = args.flags.has('abandon');
+    if (abandon && caller.kind !== 'owner') {
+        io.stderr('team remove: only the owner abandons a seat, from a terminal outside herdr\n');
+        return 1;
+    }
+    if ((name === team.coordinator || name === team.operator) && caller.kind !== 'owner') {
+        io.stderr(`team remove: only the owner removes the coordinator's or the operator's seat; this call is ${describeCaller(caller)}\n`);
+        return 1;
+    }
+    const dir = dirname(path);
+    const recorded = readState(dir).sessions[session]?.seats[name];
+    const declared = team.seats.find((seat) => seat.name === name);
+    if (!declared && !recorded) {
+        io.stderr(`team remove: the team has no seat ${JSON.stringify(name)}\n`);
+        return 1;
+    }
+    const temporary = recorded?.temporary;
+    if (args.flags.has('keep') && temporary) {
+        io.stderr('team remove: a temporary seat is not in the file; there is nothing to keep\n');
+        return 1;
+    }
+    const live = sources.sessionRunning(session);
+    if (live === null) {
+        io.stderr('team remove: herdr doesn\'t answer; nothing was changed\n');
+        return 1;
+    }
+    const agents = live ? sources.agents(session) : [];
+    if (agents === null) {
+        io.stderr(`team remove: session ${session} runs, and its agents can't be read; nothing was changed\n`);
+        return 1;
+    }
+    const agent = agents.find((item) => item.name === name);
+    const cli = declared?.cli ?? team.seats.find((seat) => seat.name === temporary?.like)?.cli ?? '';
+    if (agent) {
+        const screen = sources.screen(session, agent.pane, cli);
+        const where = stateOf(agent.status, screen);
+        if (where !== 'free' && !abandon) {
+            io.stderr(`team remove: ${name} ${LEFT[where]}\n`);
+            return 1;
+        }
+        if (!profileFor(cli) && !abandon) {
+            io.stderr(`team remove: no launch profile for \`${cli}\`; left as it is\n`);
+            return 1;
+        }
+    }
+    // An edit that will not validate is refused before the seat is stopped. Stopping first would
+    // end the live session and then report that nothing was written.
+    if (!temporary) {
+        const ahead = editProblems(path, name, args.flags.has('keep'));
+        if (ahead) {
+            for (const problem of ahead) {
+                io.stderr(`team remove: ${problem.line ? `line ${problem.line}: ` : ''}${problem.message}\n`);
+            }
+            return 2;
+        }
+    }
+    if (agent) {
+        const screen = sources.screen(session, agent.pane, cli);
+        const where = stateOf(agent.status, screen);
+        const stopped = await stopRunning({
+            io, dir, session, sources, logCommand: 'remove', caller: describeCaller(caller),
+            seat: { name, cli, pane: agent.pane, workspace: agent.workspace, state: where === 'free' ? 'free' : where },
+            abandon: abandon && where !== 'free',
+        });
+        if (!stopped)
+            return 1;
+    }
+    if (!temporary) {
+        const refused = withLock(dir, () => {
+            const text = readFileSync(path, 'utf8');
+            const next = args.flags.has('keep') ? markStopped(text, name) : takeOut(text, name);
+            if (next === text)
+                return null;
+            const wrote = writeTeamFile(path, next);
+            return wrote.ok ? null : wrote.errors;
+        });
+        if (refused) {
+            for (const problem of refused) {
+                io.stderr(`team remove: ${problem.line ? `line ${problem.line}: ` : ''}${problem.message}\n`);
+            }
+            return 2;
+        }
+    }
+    if (!agent && recorded) {
+        updateState(dir, (file) => {
+            const seats = file.sessions[session]?.seats;
+            if (seats)
+                delete seats[name];
+        });
+    }
+    const who = describeCaller(caller);
+    const what = temporary ? `removed temporary ${name}` : args.flags.has('keep') ? `stopped ${name}` : `removed ${name}`;
+    logLine(dir, 'remove', who, what, sources.now());
+    io.stdout(`${what}\n`);
+    return 0;
+}
+/** Types the exit, waits for the shell, and closes the workspace. False leaves the seat as it is. */
+export async function stopRunning(input) {
+    const launch = input.sources.launch;
+    if (!launch) {
+        input.io.stderr('team remove: this call has no way to reach herdr\n');
+        return false;
+    }
+    const { seat, session, sources } = input;
+    let stopped = false;
+    const steps = downPlan({
+        session,
+        seats: [seat],
+        extra: 1,
+        watchPid: null,
+        keep: [],
+        abandon: input.abandon,
+    }).filter((step) => step.kind !== 'skip');
+    const host = {
+        startServer: () => false,
+        sessionUp: () => true,
+        createWorkspace: () => null,
+        paneRun: () => false,
+        typeLine(sessionName, pane, text) {
+            const look = () => sources.screen(sessionName, pane, seat.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: () => false,
+        kill: () => false,
+        agentPanes(sessionName) {
+            const listed = launch.agentPanes(sessionName);
+            if (!listed)
+                return null;
+            const names = profileFor(seat.cli)?.processNames;
+            if (!names)
+                return listed;
+            return listed.filter((pane) => paneStillRunning(sources.foreground(sessionName, pane), names));
+        },
+        classify: () => 'unknown',
+        sleep: sources.sleep ?? launch.sleep,
+        now: () => sources.now().getTime(),
+        allow: () => null,
+        record() { },
+        running() { },
+        drop(dropped) {
+            if (dropped !== seat.name)
+                return;
+            stopped = true;
+            updateState(input.dir, (file) => {
+                const seats = (file.sessions[session] ??= emptySession()).seats;
+                delete seats[dropped];
+            });
+        },
+        say: (line) => input.io.stdout(line),
+        log: (who, what) => logLine(input.dir, input.logCommand, input.caller, `${who}: ${what}`, sources.now()),
+    };
+    await executePlan(steps, session, host);
+    return stopped;
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,41 @@
+import { type BudgetRow } from '../budgets/table.ts';
+import type { TeamFile } from '../file/types.ts';
+import type { Command, Io } from '../io.ts';
+import type { Difference, Live } from '../status/compare.ts';
+export type StatusSources = {
+    live(session: string, team: TeamFile): Live | null;
+    branch(path: string): string | null;
+    approval(team: TeamFile, root: string): string[] | null;
+    watchInForce(team: TeamFile, root: string): TeamFile['watch'];
+    budgetsInForce(team: TeamFile, root: string): TeamFile['budgets'];
+    now(): Date;
+};
+export declare const realSources: StatusSources;
+export declare const status: Command;
+export default status;
+/**
+ * The JSON shape printed by `team status --json`.
+ * Format 1.
+ */
+export interface StatusJson {
+    format: 1;
+    project: string;
+    session: string;
+    rows: Array<{
+        name: string;
+        state: string;
+        model: string;
+        pane: string;
+    }>;
+    notes: string[];
+    differences: Array<{
+        what: string;
+        repair: string;
+    }>;
+    notice: string | null;
+    /** Present when the file names an account, or a reading is stored. */
+    budgets?: BudgetRow[];
+}
+export declare const USAGE = "Usage: team status [--session <name>] [--file <path>] [--json]\n";
+export declare function runStatus(argv: string[], io: Io, sources: StatusSources): Promise<number>;
+export declare function approvalDrift(differences: string[] | null): Difference[];

package/dist/commands/status.js

@@ -0,0 +1,147 @@
+import { execFileSync } from 'node:child_process';
+import { relative, resolve } from 'node:path';
+import { approvalDifferences, budgetsInForce, watchInForce } from "../approve/approval.js";
+import { readArgs } from "../args.js";
+import { budgetLine, budgetTable } from "../budgets/table.js";
+import { recall } from "../budgets/readings.js";
+import { currentTeam } from "../file/current.js";
+import { agentList, paneRead, sessionRunning, workspaceList } from "../herdr.js";
+import { emptySession, readState } from "../state.js";
+import { compare } from "../status/compare.js";
+export const realSources = {
+    live(session, team) {
+        const running = sessionRunning(session);
+        if (running === null)
+            return null;
+        if (!running)
+            return { running: false, agents: [], workspaces: [], screens: {} };
+        const agents = agentList(session);
+        const workspaces = workspaceList(session);
+        if (!agents || !workspaces)
+            return null;
+        const screens = {};
+        for (const agent of agents) {
+            if (!team.seats.some((seat) => seat.name === agent.name))
+                continue;
+            const screen = paneRead(agent.pane, 12, session);
+            if (screen !== null)
+                screens[agent.pane] = screen;
+        }
+        return { running: true, agents, workspaces, screens };
+    },
+    branch(path) {
+        try {
+            return execFileSync('git', ['-C', path, 'rev-parse', '--abbrev-ref', 'HEAD'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        }
+        catch {
+            return null;
+        }
+    },
+    approval: (team, root) => approvalDifferences(team, root),
+    watchInForce: (team, root) => watchInForce(team, root),
+    budgetsInForce: (team, root) => budgetsInForce(team, root),
+    now: () => new Date(),
+};
+export const status = (argv, io) => runStatus(argv, io, realSources);
+export default status;
+export const USAGE = 'Usage: team status [--session <name>] [--file <path>] [--json]\n';
+export async function runStatus(argv, io, sources) {
+    const args = readArgs(argv, ['session', 'file'], ['json']);
+    if (args.error || args.rest.length) {
+        io.stderr(`team status: ${args.error ?? `unexpected "${args.rest[0]}"`}\n${USAGE}`);
+        return 2;
+    }
+    const current = currentTeam(io.cwd, args.values.file, sources.now());
+    if (!current.ok) {
+        printProblems(io, current.errors);
+        return 2;
+    }
+    const { team, root, dir } = current;
+    if (!args.flags.has('json') && current.notice)
+        io.stdout(`${current.notice}\n`);
+    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 live = sources.live(session, team);
+    if (!live) {
+        io.stderr('team status: herdr doesn\'t answer; is it installed and running?\n');
+        return 2;
+    }
+    const state = readState(dir).sessions[session] ?? emptySession();
+    const budgets = budgetTable(sources.budgetsInForce(team, root), recall(state.budgets), sources.now().getTime());
+    const 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)));
+    if (args.flags.has('json')) {
+        const doc = {
+            format: 1,
+            project: team.project,
+            session,
+            rows: comparison.rows,
+            notes: comparison.notes,
+            differences: comparison.differences,
+            notice: current.notice ?? null,
+            ...(budgets.length ? { budgets } : {}),
+        };
+        io.stdout(`${JSON.stringify(doc, null, 2)}\n`);
+    }
+    else {
+        io.stdout(render(team, session, comparison, budgets));
+    }
+    return comparison.differences.length ? 1 : 0;
+}
+// A file that was never approved, or was changed since, runs nothing until the owner approves it.
+export function approvalDrift(differences) {
+    if (differences === null)
+        return [{ what: 'the file was never approved on this machine', repair: 'the owner runs team approve' }];
+    return differences.map((line) => ({ what: `the file differs from the approved one: ${line}`, repair: 'the owner runs team approve' }));
+}
+function protectedCheckouts(team, root, sources) {
+    const base = team.workspace.base;
+    if (!base)
+        return [];
+    const out = [];
+    for (const path of team.workspace.protected) {
+        const full = resolve(root, path);
+        const branch = sources.branch(full);
+        if (branch === null || branch === base)
+            continue;
+        const shown = relative(root, full) || '.';
+        out.push({
+            what: `the protected checkout "${shown}" is on ${branch === 'HEAD' ? 'a detached commit' : `"${branch}"`}, not on "${base}"`,
+            repair: `the owner switches it back: git -C ${shown} switch ${base}`,
+        });
+    }
+    return out;
+}
+function render(team, session, comparison, budgets) {
+    const lines = [`team ${team.project}, session "${session}"`];
+    const widths = [0, 0, 0];
+    for (const row of comparison.rows) {
+        widths[0] = Math.max(widths[0], row.name.length);
+        widths[1] = Math.max(widths[1], row.state.length);
+        widths[2] = Math.max(widths[2], row.model.length);
+    }
+    for (const row of comparison.rows) {
+        lines.push(`  ${row.name.padEnd(widths[0])}  ${row.state.padEnd(widths[1])}  ${row.model.padEnd(widths[2])}  ${row.pane}`.trimEnd());
+    }
+    if (budgets.length) {
+        lines.push('budgets:');
+        // The row carries its own reserve: the line and the JSON can't disagree (queue 79).
+        for (const row of budgets)
+            lines.push(`  ${budgetLine(row)}`);
+    }
+    for (const note of comparison.notes)
+        lines.push(`note: ${note}`);
+    for (const difference of comparison.differences) {
+        lines.push(`difference: ${difference.what}`, `  repair: ${difference.repair}`);
+    }
+    lines.push(`${comparison.differences.length} difference(s)`);
+    return `${lines.join('\n')}\n`;
+}
+function printProblems(io, problems) {
+    for (const problem of problems) {
+        io.stderr(`team status: ${problem.line ? `team.yaml line ${problem.line}: ` : ''}${problem.message}\n`);
+    }
+}

package/dist/commands/up.d.ts

@@ -0,0 +1,49 @@
+import type { Seat, TeamFile } from '../file/types.ts';
+import { type HerdrAgent, type SessionState } from '../herdr.ts';
+import type { Command, Io } from '../io.ts';
+import { type DoctorSources } from './doctor.ts';
+import { type Machine } from '../watch/machine.ts';
+export type UpSources = {
+    sessionRunning(session: string): boolean | null;
+    sessionState?(session: string): SessionState | null;
+    agents(session: string): HerdrAgent[] | null;
+    workspaces?(session: string): {
+        id: string;
+    }[] | null;
+    home: string;
+    doctor?: DoctorSources;
+    machine?(root: string): Machine;
+    now?(): Date;
+    sleep?(ms: number): Promise<void>;
+    alive?(pid: number): boolean;
+    watchCommand?(session: string): string;
+    launch?: Launch;
+};
+export type Launch = {
+    sessionState(session: string): SessionState | null;
+    startServer(session: string): boolean;
+    sessionUp(session: string): boolean | null;
+    createWorkspace(session: string, cwd: string, label: string): {
+        pane: string;
+        workspace: string;
+    } | null;
+    paneRun(session: string, pane: string, command: string): boolean;
+    renameAgent(session: string, pane: string, name: string): boolean;
+    closeWorkspace(session: string, workspace: string): boolean;
+    agentPanes(session: string): string[] | null;
+    paneText(session: string, pane: string): string | null;
+    typeText?(session: string, pane: string, text: string): boolean;
+    pressEnter?(session: string, pane: string): boolean;
+    agentStatus?(session: string, pane: string): string | null;
+    sleep(ms: number): Promise<void>;
+    now(): Date;
+};
+/** The watchdog command, from this process and this install: `team` may not be on the PATH. */
+export declare function watchCommand(session: string): string;
+export declare const realSources: UpSources;
+export declare const USAGE = "Usage: team up [--dry-run] [--session <name>] [--file <path>]\n";
+export declare const up: Command;
+export default up;
+/** The rules one seat gets at launch, with its own signature lines. */
+export declare function rulesOf(team: TeamFile, seat: Seat): string;
+export declare function runUp(argv: string[], io: Io, sources: UpSources): Promise<number>;