team 0.1.0 → 0.1.2

package/dist/budgets/readings.d.ts

@@ -1,4 +1,7 @@
 import type { QuotaFigure, WindowName } from '../profiles/quota.ts';
+import type { CheckWindow } from './run.ts';
+/** Where a reading came from: a pane's own status line, or an approved check command (§ 3). */
+export type ReadingSource = 'status_line' | 'check';
 export type Seen = {
     account: string;
     window: WindowName;
@@ -6,7 +9,9 @@ export type Seen = {
     used: number;
     changedAt: number;
     resetsAt: number | null;
-    seat: string;
+    /** The seat whose screen showed it; null for a check reading, which belongs to no seat. */
+    seat: string | null;
+    source: ReadingSource;
     confirmed: boolean;
 };
 export type StoredReading = {
@@ -16,7 +21,9 @@ export type StoredReading = {
     used: number;
     changedAt: string;
     resetsAt: string | null;
-    seat: string;
+    seat: string | null;
+    /** Absent in state files written before sources were recorded: a screen reading then. */
+    source?: ReadingSource;
     confirmed: boolean;
 };
 export type Verdict = {
@@ -25,8 +32,31 @@ export type Verdict = {
 } | {
     kind: 'unknown';
 };
+/** A spend check reading (RFC 0003 § 5): the money the account still holds. */
+export type SpendReading = {
+    account: string;
+    amount: number;
+    currency: string;
+    /** When the check ran: a spend line carries no time of its own (§ 5). */
+    at: number;
+};
+export type StoredSpend = {
+    account: string;
+    amount: number;
+    currency: string;
+    at: string;
+};
 /** Fold one seat's figure into the readings kept for this pass. */
 export declare function observe(list: readonly Seen[], figure: QuotaFigure, seat: string, now: number): Seen[];
+/**
+ * Fold a check command's windows into the readings kept for this pass (§ 5). A check reading is
+ * confirmed at first sight and belongs to no seat; one is kept per account and window, so a new
+ * check replaces the last, and the screen readings of the same window are left alone.
+ */
+export declare function observeCheck(list: readonly Seen[], account: string, windows: readonly CheckWindow[]): Seen[];
+/** The screen readings in a list, and the check readings: the two slots of the same account. */
+export declare function screenOf(list: readonly Seen[]): Seen[];
+export declare function checkOf(list: readonly Seen[]): Seen[];
 /**
  * The reading that counts. A figure from before a known reset is dropped.
  * Among confirmed live readings, the newest change wins. A first sight counts
@@ -35,12 +65,48 @@ export declare function observe(list: readonly Seen[], figure: QuotaFigure, seat
  * with no reset time it is unknown.
  */
 export declare function verdict(list: readonly Seen[], now: number, staleAfterMs: number, reserve: number | null): Verdict;
+export type CountedReading = {
+    kind: 'counted';
+    reading: Seen;
+} | {
+    kind: 'unconfirmed';
+    reading: Seen;
+} | {
+    kind: 'unknown';
+};
+/**
+ * The reading that counts for one window, from the sources the account names in order (§ 3, § 5):
+ * a lower source is used only when every higher one is failed, unknown or stale. A check reading
+ * counts while it is fresh by § 5's own time and its reset has not passed; a screen reading falls
+ * through when it is unknown, and a bare first sight falls through too, so a fresh check below it
+ * still counts (§ 4.3 rule 5). A stale reading inside its reserve with its reset ahead is kept as
+ * the fallback, whichever source it came from, so rule 4 still refuses when nothing below counts.
+ */
+export declare function countedFor(sources: readonly ReadingSource[], screen: readonly Seen[], checks: readonly Seen[], now: number, staleAfterMs: number, reserve: number | null): CountedReading;
 /** Readings whose reset has passed are left out. One with no reset time is kept. */
 export declare function remember(list: readonly Seen[], now: number): Record<string, StoredReading>;
 export declare function recall(stored: Record<string, StoredReading> | undefined): Seen[];
-/** Write the readings that still count. The state file is the per-project cache. */
-export declare function saveReadings(dir: string, session: string, list: readonly Seen[], now?: number): void;
-export declare function loadReadings(dir: string, session: string): Seen[];
+/** Write the readings that still count. The state file is the per-project cache (§ 4.4). */
+export declare function saveReadings(dir: string, list: readonly Seen[], now?: number): void;
+/**
+ * One pass's fold, read and written under the state lock (§ 4.4): `fold` is handed the readings
+ * the state holds and returns the list to keep, so a watch folding while another watch writes
+ * folds onto what was written, never over a list it read before it. Whatever the fold returns as
+ * its `value` is handed back.
+ */
+export declare function updateReadings<T>(dir: string, now: number, fold: (stored: Seen[]) => {
+    readings: Seen[];
+    value: T;
+}): T;
+export declare function loadReadings(dir: string): Seen[];
+/**
+ * Write the spend readings a pass's checks read, merging by account: an account whose check did
+ * not run this pass keeps the reading the state already holds. Nothing read, nothing written.
+ */
+export declare function saveSpendReadings(dir: string, list: readonly SpendReading[]): void;
+export declare function loadSpendReadings(dir: string): SpendReading[];
+export declare function storeSpend(reading: SpendReading): StoredSpend;
+export declare function recallSpend(stored: Record<string, StoredSpend> | undefined): SpendReading[];
 export declare function store(reading: Seen): StoredReading;
 export declare function revive(stored: StoredReading): Seen;
 /** When a duration such as `114h4m` ends, counted from a time. Null for no or an odd duration. */

package/dist/budgets/readings.js

@@ -1,4 +1,4 @@
-import { emptySession, readState, updateState } from "../state.js";
+import { readState, updateState } from "../state.js";
 /** Fold one seat's figure into the readings kept for this pass. */
 export function observe(list, figure, seat, now) {
     const next = list.slice();
@@ -19,6 +19,7 @@ export function observe(list, figure, seat, now) {
         changedAt: same && previous ? previous.changedAt : now,
         resetsAt: same && previous && previous.resetsAt !== null ? previous.resetsAt : resetsFrom(figure.resets, now),
         seat,
+        source: 'status_line',
         confirmed: previous === null ? agreed : same ? previous.confirmed || agreed : true,
     };
     if (at < 0)
@@ -27,6 +28,40 @@ export function observe(list, figure, seat, now) {
         next[at] = reading;
     return next;
 }
+/**
+ * Fold a check command's windows into the readings kept for this pass (§ 5). A check reading is
+ * confirmed at first sight and belongs to no seat; one is kept per account and window, so a new
+ * check replaces the last, and the screen readings of the same window are left alone.
+ */
+export function observeCheck(list, account, windows) {
+    const next = list.slice();
+    for (const window of windows) {
+        const reading = {
+            account,
+            window: window.window,
+            left: window.left,
+            used: window.used,
+            changedAt: window.at,
+            resetsAt: window.resetsAt,
+            seat: null,
+            source: 'check',
+            confirmed: true,
+        };
+        const at = next.findIndex((item) => item.account === account && item.window === window.window && item.source === 'check');
+        if (at < 0)
+            next.push(reading);
+        else
+            next[at] = reading;
+    }
+    return next;
+}
+/** The screen readings in a list, and the check readings: the two slots of the same account. */
+export function screenOf(list) {
+    return list.filter((item) => item.source === 'status_line');
+}
+export function checkOf(list) {
+    return list.filter((item) => item.source === 'check');
+}
 /**
  * The reading that counts. A figure from before a known reset is dropped.
  * Among confirmed live readings, the newest change wins. A first sight counts
@@ -56,13 +91,57 @@ export function verdict(list, now, staleAfterMs, reserve) {
         return { kind: 'unknown' };
     return { kind: 'stale', reading };
 }
+/**
+ * The reading that counts for one window, from the sources the account names in order (§ 3, § 5):
+ * a lower source is used only when every higher one is failed, unknown or stale. A check reading
+ * counts while it is fresh by § 5's own time and its reset has not passed; a screen reading falls
+ * through when it is unknown, and a bare first sight falls through too, so a fresh check below it
+ * still counts (§ 4.3 rule 5). A stale reading inside its reserve with its reset ahead is kept as
+ * the fallback, whichever source it came from, so rule 4 still refuses when nothing below counts.
+ */
+export function countedFor(sources, screen, checks, now, staleAfterMs, reserve) {
+    let fallback = null;
+    let unconfirmed = null;
+    for (const source of sources) {
+        if (source === 'check') {
+            const reading = checks.find((item) => (item.resetsAt === null || item.resetsAt > now) && now - item.changedAt < staleAfterMs);
+            if (reading)
+                return { kind: 'counted', reading };
+            // Rule 4 is about the reserve, not the source: a stale check figure inside it keeps
+            // refusing until its known reset, and a fresh source below still wins over this fallback.
+            const inside = checks.find((item) => item.resetsAt !== null && item.resetsAt > now && reserve !== null && item.left <= reserve);
+            if (inside)
+                fallback ??= inside;
+            continue;
+        }
+        const result = verdict(screen, now, staleAfterMs, reserve);
+        if (result.kind === 'unknown')
+            continue;
+        if (result.kind === 'unconfirmed') {
+            unconfirmed ??= result.reading;
+            continue;
+        }
+        if (result.kind === 'fresh')
+            return { kind: 'counted', reading: result.reading };
+        fallback ??= result.reading;
+    }
+    if (fallback)
+        return { kind: 'counted', reading: fallback };
+    if (unconfirmed)
+        return { kind: 'unconfirmed', reading: unconfirmed };
+    return { kind: 'unknown' };
+}
 /** Readings whose reset has passed are left out. One with no reset time is kept. */
 export function remember(list, now) {
     const out = {};
     for (const reading of list) {
         if (reading.resetsAt !== null && reading.resetsAt <= now)
             continue;
-        out[`${reading.account}/${reading.window}/${reading.seat}`] = store(reading);
+        // A screen reading is kept per seat; a check reading belongs to no seat and is kept alone.
+        const key = reading.source === 'check'
+            ? `${reading.account}/${reading.window}`
+            : `${reading.account}/${reading.window}/${reading.seat}`;
+        out[key] = store(reading);
     }
     return out;
 }
@@ -71,16 +150,62 @@ export function recall(stored) {
         return [];
     return Object.values(stored).map(revive);
 }
-/** Write the readings that still count. The state file is the per-project cache. */
-export function saveReadings(dir, session, list, now = Date.now()) {
+/** Write the readings that still count. The state file is the per-project cache (§ 4.4). */
+export function saveReadings(dir, list, now = Date.now()) {
+    updateState(dir, (state) => {
+        state.budgets = remember(list, now);
+    });
+}
+/**
+ * One pass's fold, read and written under the state lock (§ 4.4): `fold` is handed the readings
+ * the state holds and returns the list to keep, so a watch folding while another watch writes
+ * folds onto what was written, never over a list it read before it. Whatever the fold returns as
+ * its `value` is handed back.
+ */
+export function updateReadings(dir, now, fold) {
+    return updateState(dir, (state) => {
+        const folded = fold(recall(state.budgets));
+        state.budgets = remember(folded.readings, now);
+        return folded.value;
+    });
+}
+export function loadReadings(dir) {
+    return recall(readState(dir).budgets);
+}
+/**
+ * Write the spend readings a pass's checks read, merging by account: an account whose check did
+ * not run this pass keeps the reading the state already holds. Nothing read, nothing written.
+ */
+export function saveSpendReadings(dir, list) {
+    if (!list.length)
+        return;
     updateState(dir, (state) => {
-        const current = state.sessions[session] ?? emptySession();
-        current.budgets = remember(list, now);
-        state.sessions[session] = current;
+        const spend = state.spend ?? {};
+        for (const reading of list)
+            spend[reading.account] = storeSpend(reading);
+        state.spend = spend;
     });
 }
-export function loadReadings(dir, session) {
-    return recall(readState(dir).sessions[session]?.budgets);
+export function loadSpendReadings(dir) {
+    return recallSpend(readState(dir).spend);
+}
+export function storeSpend(reading) {
+    return {
+        account: reading.account,
+        amount: reading.amount,
+        currency: reading.currency,
+        at: new Date(reading.at).toISOString(),
+    };
+}
+export function recallSpend(stored) {
+    if (!stored)
+        return [];
+    return Object.values(stored).map((one) => ({
+        account: one.account,
+        amount: one.amount,
+        currency: one.currency,
+        at: Date.parse(one.at),
+    }));
 }
 export function store(reading) {
     return {
@@ -91,6 +216,7 @@ export function store(reading) {
         changedAt: new Date(reading.changedAt).toISOString(),
         resetsAt: reading.resetsAt === null ? null : new Date(reading.resetsAt).toISOString(),
         seat: reading.seat,
+        source: reading.source,
         confirmed: reading.confirmed,
     };
 }
@@ -103,6 +229,7 @@ export function revive(stored) {
         changedAt: Date.parse(stored.changedAt),
         resetsAt: stored.resetsAt === null ? null : Date.parse(stored.resetsAt),
         seat: stored.seat,
+        source: stored.source ?? 'status_line',
         confirmed: stored.confirmed,
     };
 }

package/dist/budgets/table.d.ts

@@ -1,6 +1,6 @@
 import type { TeamFile } from '../file/types.ts';
 import type { WindowName } from '../profiles/quota.ts';
-import { type Seen } from './readings.ts';
+import { type ReadingSource, type Seen } from './readings.ts';
 export type BudgetState = 'fresh' | 'unconfirmed' | 'stale' | 'refusing' | 'unknown';
 export type BudgetRow = {
     account: string;
@@ -10,7 +10,7 @@ export type BudgetRow = {
     resetsIn: string | null;
     seat: string | null;
     age: string | null;
-    source: 'status_line' | null;
+    source: ReadingSource | null;
     state: BudgetState;
     /** True when a subscription's left figure is at or inside its reserve. */
     inside: boolean;

package/dist/budgets/table.js

@@ -1,4 +1,4 @@
-import { verdict } from "./readings.js";
+import { checkOf, countedFor, screenOf } from "./readings.js";
 const WINDOWS = ['session', 'daily', 'weekly'];
 /** Rows for the accounts the budgets in force name, and for any reading still in the state. */
 export function budgetTable(budgets, list, now) {
@@ -17,7 +17,11 @@ export function budgetTable(budgets, list, now) {
         const window = group[0]?.window ?? null;
         named.add(account);
         const reserve = reserveOf(budgets, account);
-        rows.push(rowOf(account, window, verdict(group, now, staleAfterMs, reserve), now, reserve));
+        // The window's reading from the sources the account names, in order (§ 3, § 5).
+        const result = countedFor(sourcesOf(budgets, account), screenOf(group), checkOf(group), now, staleAfterMs, reserve);
+        rows.push(result.kind === 'unknown'
+            ? { ...blank(account, reserve), window }
+            : rowOf(result, now, staleAfterMs, reserve));
     }
     for (const account of Object.keys(budgets.accounts)) {
         if (!named.has(account))
@@ -35,25 +39,34 @@ export function budgetLine(row) {
         return [row.account, row.window, 'unknown'].filter((part) => part).join('  ');
     }
     const reset = row.resetsIn === null ? 'resets unknown' : `resets in ${row.resetsIn}`;
-    const from = row.source === 'status_line' ? 'status line' : 'unknown source';
+    const from = row.source === 'status_line' ? 'status line' : row.source === 'check' ? 'check' : 'unknown source';
+    const when = row.source === 'check' ? 'read' : 'changed';
     const state = row.inside && row.reserve !== null ? `${row.state}, inside reserve ${row.reserve}%` : row.state;
-    return `${row.account}  ${row.window}  left ${row.left}%  used ${row.used}%  ${reset}  ${row.seat}  changed ${row.age} ago  ${from}  ${state}`;
+    return `${row.account}  ${row.window}  left ${row.left}%  used ${row.used}%  ${reset}  ${row.seat ?? '-'}  ${when} ${row.age} ago  ${from}  ${state}`;
 }
-function rowOf(account, window, result, now, reserve) {
-    if (result.kind === 'unknown')
-        return { ...blank(account, reserve), window };
+/** The sources the account's figures are read from, in order: a status line when the file is silent. */
+function sourcesOf(budgets, account) {
+    return budgets.accounts[account]?.sources ?? ['status_line'];
+}
+function rowOf(result, now, staleAfterMs, reserve) {
     const reading = result.reading;
+    const inside = reserve !== null && reading.left <= reserve;
+    const state = result.kind === 'unconfirmed'
+        ? 'unconfirmed'
+        : now - reading.changedAt < staleAfterMs
+            ? 'fresh'
+            : inside && reading.resetsAt !== null ? 'refusing' : 'stale';
     return {
-        account,
+        account: reading.account,
         window: reading.window,
         left: reading.left,
         used: reading.used,
         resetsIn: reading.resetsAt === null ? null : span(reading.resetsAt - now),
         seat: reading.seat,
         age: span(now - reading.changedAt),
-        source: 'status_line',
-        state: result.kind,
-        inside: reserve !== null && reading.left <= reserve,
+        source: reading.source,
+        state,
+        inside,
         reserve,
     };
 }

package/dist/commands/add.js

@@ -1,19 +1,19 @@
 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";
 import { seatBudget } from "../budgets/gate.js";
-import { loadReadings } from "../budgets/readings.js";
+import { loadReadings, loadSpendReadings } from "../budgets/readings.js";
 import { rulesOf } from "../commands/up.js";
 import { branchPresent, readMerge } from "../end/condition.js";
 import { clearStopped, hasSeat, restoreSeat, seatIsStopped } from "../file/lines.js";
 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(),
 };
@@ -168,7 +169,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,7 +202,7 @@ 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());
+    const decision = seatBudget(budgets, loadReadings(dir), built.seat, sources.now().getTime(), loadSpendReadings(dir));
     const stray = unnamedIn(built.seat.label, agents, workspaces);
     const starting = seatPlan(prepared.team, built.seat, start);
     const planned = stray
@@ -246,6 +250,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);

package/dist/commands/doctor.d.ts

@@ -33,6 +33,8 @@ export default doctor;
 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): 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

@@ -150,12 +150,14 @@ function watchFindings(watch, dir, session, running, now) {
     }
     return [{ level: 'ok', text: 'the watch is running' }];
 }
-export function doctorFindings(team, root, dir, session, sources, warnings) {
+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) {
     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(...approvalFindings(approved, root, sources.home), ...checkFindings(team, root, sources.home));
     const herdr = sources.herdrVersion();
     const running = herdr === null ? null : sources.sessionRunning(session);
     if (herdr === null)

package/dist/commands/down.d.ts

@@ -10,8 +10,8 @@ export type DownSources = {
     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;
+    /** 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;

package/dist/commands/down.js

@@ -3,6 +3,7 @@ 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 { reportedLiveAgent } from "../launch/agent.js";
 import { downPlan, formatPlan } from "../launch/plan.js";
 import { profileFor } from "../profiles/index.js";
 import { logLine } from "../log.js";
@@ -204,6 +205,10 @@ export async function runDown(argv, io, sources) {
             // 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 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,6 +218,8 @@ export async function runDown(argv, io, sources) {
                 return false;
             if (!launch.typeText(sessionName, pane, text))
                 return false;
+            if (!live())
+                return 'no-agent';
             const after = look();
             if (!resting() || (after !== 'idle' && after !== 'unsent'))
                 return false;
@@ -232,7 +239,7 @@ export async function runDown(argv, io, sources) {
                 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/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,6 +9,7 @@ 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";
@@ -60,7 +63,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 +136,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 +144,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 +157,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 +198,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,6 +211,8 @@ export async function stopRunning(input) {
                 return false;
             if (!launch.typeText(sessionName, pane, text))
                 return false;
+            if (!live())
+                return 'no-agent';
             const after = look();
             if (!resting() || (after !== 'idle' && after !== 'unsent'))
                 return false;

package/dist/commands/status.js

@@ -67,8 +67,9 @@ export async function runStatus(argv, io, sources) {
         io.stderr('team status: herdr doesn\'t answer; is it installed and running?\n');
         return 2;
     }
-    const state = readState(dir).sessions[session] ?? emptySession();
-    const budgets = budgetTable(sources.budgetsInForce(team, root), recall(state.budgets), sources.now().getTime());
+    const whole = readState(dir);
+    const state = whole.sessions[session] ?? emptySession();
+    const budgets = budgetTable(sources.budgetsInForce(team, root), recall(whole.budgets), sources.now().getTime());
     const comparison = compare(team, session, state, live, sources.now(), sources.watchInForce(team, root));
     if (!live.running)
         comparison.notes.unshift(`the herdr session "${session}" is not running`);

package/dist/commands/up.d.ts

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