team 0.0.1 → 0.1.0

package/dist/status/compare.js

@@ -0,0 +1,110 @@
+import { herdrCommand } from "../herdr.js";
+import { seatModel } from "./statusline.js";
+export const WATCH_LABEL = 'watchdog';
+// Compares the file and the state with the live session. Pure: every input is handed in.
+// `watch` is the watch values in force — the approved ones — so an unapproved edit can't move a verdict.
+export function compare(team, session, state, live, now = new Date(), watch = team.watch) {
+    const rows = [];
+    const differences = [];
+    const notes = [];
+    const claimed = new Set();
+    const labels = new Map(live.workspaces.map((workspace) => [workspace.id, workspace.label]));
+    const anyRunning = team.seats.some((seat) => live.agents.some((agent) => agent.name === seat.name));
+    for (const seat of team.seats) {
+        const agent = live.agents.find((candidate) => candidate.name === seat.name);
+        const recorded = state.seats[seat.name];
+        if (agent) {
+            claimed.add(agent.pane);
+            const model = modelOf(seat, agent, live, differences, notes);
+            rows.push({ name: seat.name, state: seat.parked ? `${agent.status}, parked` : agent.status, model, pane: agent.pane });
+            if (seat.stopped) {
+                differences.push({
+                    what: `${seat.name} is marked stopped in the file and is running`,
+                    repair: `team remove ${seat.name} --keep, or take "stopped: true" off the seat`,
+                });
+            }
+            if (recorded && recorded.stage !== 'ready') {
+                differences.push({ what: `${seat.name}: its launch stopped at "${recorded.stage}"`, repair: 'team up (it resumes the launch)' });
+            }
+            if (recorded?.rules === 'undelivered') {
+                differences.push({ what: `${seat.name}: its rules were not delivered`, repair: `team remove ${seat.name} --keep, then team add ${seat.name}` });
+            }
+            continue;
+        }
+        if (seat.stopped) {
+            rows.push({ name: seat.name, state: 'stopped', model: seat.display, pane: '-' });
+            continue;
+        }
+        // An agent sits in the seat's workspace under another name, or under none.
+        const stray = live.agents.find((candidate) => !claimed.has(candidate.pane) && labels.get(candidate.workspace) === seat.label
+            && !team.seats.some((other) => other.name === candidate.name));
+        if (stray) {
+            claimed.add(stray.pane);
+            rows.push({ name: seat.name, state: 'wrong name', model: seat.display, pane: stray.pane });
+            differences.push({
+                what: `${seat.name}: the agent in its workspace "${seat.label}" is ${stray.name ? `named "${stray.name}"` : 'unnamed'}`,
+                repair: herdrCommand(session, 'agent', 'rename', stray.pane, seat.name),
+            });
+            continue;
+        }
+        rows.push({ name: seat.name, state: 'missing', model: seat.display, pane: '-' });
+        differences.push({
+            what: `${seat.name} is in the file and is not running`,
+            repair: anyRunning ? `team add ${seat.name}` : 'team up',
+        });
+    }
+    for (const [name, recorded] of Object.entries(state.seats)) {
+        if (!recorded.temporary)
+            continue;
+        const agent = live.agents.find((candidate) => candidate.name === name);
+        if (agent) {
+            claimed.add(agent.pane);
+            rows.push({ name, state: `${agent.status}, temporary`, model: `like ${recorded.temporary.like}`, pane: agent.pane });
+            notes.push(`${name} is temporary, until ${recorded.temporary.until}`);
+        }
+        else {
+            differences.push({ what: `${name}: a temporary seat is recorded and is not running`, repair: `team remove ${name}` });
+        }
+    }
+    for (const agent of live.agents) {
+        if (claimed.has(agent.pane) || labels.get(agent.workspace) === WATCH_LABEL)
+            continue;
+        differences.push({
+            what: `${agent.name ?? `an unnamed ${agent.agent ?? 'agent'}`} (${agent.pane}) is running and is not in the file`,
+            repair: 'add the seat to the file and run team approve, or close it',
+        });
+    }
+    for (const [task, worktree] of Object.entries(state.worktrees)) {
+        if (worktree.setup === 'failed') {
+            differences.push({ what: `worktree ${task}: its setup failed`, repair: `team worktree remove ${task}` });
+        }
+    }
+    if (live.running && anyRunning) {
+        const beat = state.watch ? Date.parse(state.watch.heartbeat) : NaN;
+        if (!state.watch) {
+            differences.push({ what: 'no watch has run for this session', repair: `team watch --session ${session}` });
+        }
+        else if (!(now.getTime() - beat <= 2 * watch.interval * 1000)) {
+            const minutes = Number.isFinite(beat) ? Math.round((now.getTime() - beat) / 60_000) : null;
+            differences.push({
+                what: `the watch's last pass was ${minutes === null ? 'never recorded' : `${minutes} minute(s) ago`}`,
+                repair: `team watch --session ${session}`,
+            });
+        }
+    }
+    return { rows, differences, notes };
+}
+function modelOf(seat, agent, live, differences, notes) {
+    const running = seatModel(seat, live.screens[agent.pane]);
+    if (!running) {
+        notes.push(`${seat.name}: version unread (its screen doesn't show the model)`);
+        return `${seat.display} (unread)`;
+    }
+    if (running.model === seat.model && running.version === seat.version)
+        return seat.display;
+    differences.push({
+        what: `${seat.name} runs ${running.model} ${running.version}; the file says ${seat.model} ${seat.version}`,
+        repair: `restart the seat on the file's model (team remove ${seat.name} --keep, then team add ${seat.name}), or correct the file and run team approve`,
+    });
+    return `${running.model} ${running.version} (file: ${seat.display})`;
+}

package/dist/status/statusline.d.ts

@@ -0,0 +1,9 @@
+export type Running = {
+    model: string;
+    version: string;
+};
+export declare function runningModel(cli: string, screen: string): Running | null;
+export declare function seatModel(seat: {
+    cli: string;
+    model: string;
+}, screen: string | undefined): Running | null;

package/dist/status/statusline.js

@@ -0,0 +1,26 @@
+// Each CLI shows its model in its own words. The profile's status_model rules turn a pane's
+// visible text into the file's two fields, `model` and `version`, or null when the text doesn't
+// show them: "unread" is never a mismatch. The last six lines are the window. A line the rules
+// claim but cannot name clears an earlier match; that is how an unknown Codex footer stays unread.
+import { statusOnLine } from "../profiles/profile.js";
+export function runningModel(cli, screen) {
+    let found = null;
+    for (const line of screen.split('\n').slice(-6)) {
+        const hit = statusOnLine(cli, line);
+        if (hit === 'unreadable')
+            found = null;
+        else if (hit)
+            found = hit;
+    }
+    return found;
+}
+// The model a seat runs, as far as its screen can say. Claude Code names Claude's families only:
+// for a seat that runs another maker's model through it, the line says nothing to compare, so
+// the seat is unread rather than wrong.
+export function seatModel(seat, screen) {
+    if (screen === undefined)
+        return null;
+    if (seat.cli === 'claude-code' && !seat.model.startsWith('Claude '))
+        return null;
+    return runningModel(seat.cli, screen);
+}

package/dist/store/store.d.ts

@@ -0,0 +1,62 @@
+import type { Fingerprints } from '../approve/fingerprint.ts';
+/**
+ * The user-level store: what must survive the project folder and stay out of
+ * every seat's working folders. One folder per project root, so a project
+ * that is moved or renamed is approved again.
+ */
+export interface Ceilings {
+    seats: number;
+    temporary: number;
+    vendors: Record<string, number>;
+}
+export interface Approval {
+    format: 1;
+    approvedAt: string;
+    /** The project root the approval is for. */
+    root: string;
+    fingerprints: Fingerprints;
+    /** Fixed here, and never recomputed from the roster. */
+    ceilings: Ceilings;
+    /** Each account's check command, resolved and hashed. Absent on an older record. */
+    checks?: Record<string, {
+        command: string;
+        path: string;
+        hash: string;
+    }>;
+}
+export interface LedgerEntry {
+    display: string;
+    role: string;
+    model: string;
+    version: string;
+}
+/** The store's folder for a project: `<home>/.config/team/<project>-<hash of the root's path>`. */
+export declare function storePath(project: string, root: string, home?: string): string;
+/**
+ * The store of the project at this root, found without its file: the folder
+ * whose name ends with the root's hash. Null when the owner approved nothing
+ * for this root on this machine.
+ */
+export declare function findStore(root: string, home?: string): string | null;
+/** The text of the file as the owner last approved it for this root, or null. */
+export declare function approvedCopy(root: string, home?: string): string | null;
+export interface ApprovalRecord {
+    approval: Approval;
+    /** The text of the file as it was approved. */
+    file: string;
+}
+/** The approval for this project, or null when the owner has approved nothing here. */
+export declare function readApproval(store: string): ApprovalRecord | null;
+/** The ledger: every `display` and `role` the team has had. */
+export declare function readLedger(store: string): LedgerEntry[];
+/** The ledger with these seats added; entries are never removed. */
+export declare function mergeLedger(ledger: readonly LedgerEntry[], seats: readonly LedgerEntry[]): LedgerEntry[];
+/**
+ * Records an approval. The fingerprints that let a file run and the text they
+ * are of go in one file, in one atomic write, so a write that stops halfway
+ * leaves the earlier approval whole. `approved.yaml` is a copy for the owner
+ * to read, and is never read back.
+ */
+export declare function writeApproval(store: string, record: ApprovalRecord, seats: readonly LedgerEntry[]): void;
+/** Adds seats the team has had. The approval itself is left as it is. */
+export declare function recordLedger(store: string, seats: readonly LedgerEntry[]): void;

package/dist/store/store.js

@@ -0,0 +1,116 @@
+import { createHash } from 'node:crypto';
+import { mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const APPROVAL = 'approval.json';
+const APPROVED_FILE = 'approved.yaml';
+const LEDGER = 'ledger.json';
+function rootHash(root) {
+    let real = root;
+    try {
+        real = realpathSync(root);
+    }
+    catch {
+        // A root that doesn't exist yet keeps its path as given.
+    }
+    return createHash('sha256').update(real).digest('hex').slice(0, 12);
+}
+function storesFolder(home) {
+    return join(home, '.config', 'team');
+}
+/** The store's folder for a project: `<home>/.config/team/<project>-<hash of the root's path>`. */
+export function storePath(project, root, home = homedir()) {
+    const name = project.replace(/[^A-Za-z0-9._-]/g, '_');
+    return join(storesFolder(home), `${name}-${rootHash(root)}`);
+}
+/**
+ * The store of the project at this root, found without its file: the folder
+ * whose name ends with the root's hash. Null when the owner approved nothing
+ * for this root on this machine.
+ */
+export function findStore(root, home = homedir()) {
+    const suffix = `-${rootHash(root)}`;
+    let names;
+    try {
+        names = readdirSync(storesFolder(home));
+    }
+    catch {
+        return null;
+    }
+    const name = names.sort().find((candidate) => candidate.endsWith(suffix));
+    return name === undefined ? null : join(storesFolder(home), name);
+}
+/** The text of the file as the owner last approved it for this root, or null. */
+export function approvedCopy(root, home = homedir()) {
+    const store = findStore(root, home);
+    if (store === null)
+        return null;
+    try {
+        return readApproval(store)?.file ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function readJson(path) {
+    let text;
+    try {
+        text = readFileSync(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+    return JSON.parse(text);
+}
+/** Writes to a temporary file, then renames it: a reader never sees half a file. */
+function writeAtomic(path, text) {
+    const temporary = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporary, text, { mode: 0o600 });
+    renameSync(temporary, path);
+}
+/** The approval for this project, or null when the owner has approved nothing here. */
+export function readApproval(store) {
+    const stored = readJson(join(store, APPROVAL));
+    if (stored === null)
+        return null;
+    if (stored.format !== 1)
+        throw new Error(`${join(store, APPROVAL)}: unknown format ${String(stored.format)}`);
+    const { file, ...approval } = stored;
+    return typeof file === 'string' ? { approval, file } : null;
+}
+/** The ledger: every `display` and `role` the team has had. */
+export function readLedger(store) {
+    return readJson(join(store, LEDGER)) ?? [];
+}
+function sameEntry(a, b) {
+    return a.display === b.display && a.role === b.role && a.model === b.model && a.version === b.version;
+}
+/** The ledger with these seats added; entries are never removed. */
+export function mergeLedger(ledger, seats) {
+    const merged = [...ledger];
+    for (const seat of seats) {
+        const entry = { display: seat.display, role: seat.role, model: seat.model, version: seat.version };
+        if (!merged.some((known) => sameEntry(known, entry)))
+            merged.push(entry);
+    }
+    return merged;
+}
+/**
+ * Records an approval. The fingerprints that let a file run and the text they
+ * are of go in one file, in one atomic write, so a write that stops halfway
+ * leaves the earlier approval whole. `approved.yaml` is a copy for the owner
+ * to read, and is never read back.
+ */
+export function writeApproval(store, record, seats) {
+    mkdirSync(store, { recursive: true, mode: 0o700 });
+    writeAtomic(join(store, LEDGER), `${JSON.stringify(mergeLedger(readLedger(store), seats), null, 2)}\n`);
+    writeAtomic(join(store, APPROVAL), `${JSON.stringify({ ...record.approval, file: record.file }, null, 2)}\n`);
+    writeAtomic(join(store, APPROVED_FILE), record.file);
+}
+/** Adds seats the team has had. The approval itself is left as it is. */
+export function recordLedger(store, seats) {
+    mkdirSync(store, { recursive: true, mode: 0o700 });
+    writeAtomic(join(store, LEDGER), `${JSON.stringify(mergeLedger(readLedger(store), seats), null, 2)}\n`);
+}

package/dist/watch/check.d.ts

@@ -0,0 +1,82 @@
+import type { CheckOutcome } from '../budgets/run.ts';
+import type { Seen } from '../budgets/readings.ts';
+import type { TeamFile } from '../file/types.ts';
+import type { HerdrAgent } from '../herdr.ts';
+import type { QuotaFigure } from '../profiles/quota.ts';
+import type { Live } from '../status/compare.ts';
+import type { SessionState } from '../state.ts';
+import type { Machine } from './machine.ts';
+import type { Screen } from './screen.ts';
+export type Report = {
+    key: string;
+    text: string;
+    to: 'operator' | 'owner';
+};
+export type Attention = 'permission' | 'question' | 'blocked' | 'unknown' | null;
+export type SeatHistory = {
+    lastWorking: number | undefined;
+    idleSince: number | undefined;
+};
+export type SeatObservation = {
+    name: string;
+    seat: {
+        cli: string;
+        model: string;
+        version: string;
+    } | undefined;
+    agent: HerdrAgent | undefined;
+    herdr: boolean;
+    screen: Screen;
+    cli: string;
+    vendor: string;
+    quota: QuotaFigure[];
+    running: boolean;
+    quiet: boolean;
+    working: boolean;
+    prompt: boolean;
+    lead: boolean;
+    parked: boolean;
+    stopped: boolean;
+    attention: Attention;
+    model: {
+        model: string;
+        version: string;
+    } | null;
+    history: SeatHistory;
+};
+export type TeamObservation = {
+    team: TeamFile;
+    state: SessionState;
+    live: Live;
+    machine: Machine;
+    limits: TeamFile['machine'];
+    seats: SeatObservation[];
+    known: Set<string>;
+    workers: {
+        idle: boolean;
+    }[];
+    approval: string[] | null | undefined;
+    readings: Seen[];
+    outcomes: readonly CheckOutcome[];
+};
+export type CheckContext = {
+    now: number;
+    watch: TeamFile['watch'];
+    budgets: TeamFile['budgets'];
+    once(key: string, text: string, to?: Report['to']): Report | null;
+    memory<T>(kind: string, start: () => T): T;
+};
+export interface SeatCheck {
+    name: string;
+    run(seat: SeatObservation, ctx: CheckContext): Report[];
+}
+export interface TeamCheck {
+    name: string;
+    run(team: TeamObservation, ctx: CheckContext): Report[];
+}
+export declare const CHECK_NAMES: readonly ["missing", "model-drift", "attention", "unsent", "idle", "extra", "team-idle", "approval", "load", "memory", "disk", "swap-free", "swap-growth", "budget"];
+export declare const ALWAYS_ON: readonly string[];
+/** A duration in whole minutes, as the report texts write it. */
+export declare function minutes(ms: number): number;
+/** The report `ctx.once` may have made, as the list `run` returns. */
+export declare function reported(report: Report | null): Report[];

package/dist/watch/check.js

@@ -0,0 +1,29 @@
+// Every check there is, in the order the core runs them: the seat checks first, then the team
+// checks. The order decides the order of the lines in the log, nothing else.
+export const CHECK_NAMES = [
+    'missing',
+    'model-drift',
+    'attention',
+    'unsent',
+    'idle',
+    'extra',
+    'team-idle',
+    'approval',
+    'load',
+    'memory',
+    'disk',
+    'swap-free',
+    'swap-growth',
+    'budget',
+];
+// The checks the file cannot turn off (RFC 0002 § 4.2): the four whose condition is the one thing
+// the watch exists for. The schema refuses them in `watch.checks`, and so does `team approve`.
+export const ALWAYS_ON = ['attention', 'missing', 'model-drift', 'approval'];
+/** A duration in whole minutes, as the report texts write it. */
+export function minutes(ms) {
+    return Math.floor(ms / 60_000);
+}
+/** The report `ctx.once` may have made, as the list `run` returns. */
+export function reported(report) {
+    return report ? [report] : [];
+}

package/dist/watch/checks/approval.d.ts

@@ -0,0 +1,2 @@
+import { type TeamCheck } from '../check.ts';
+export declare const approval: TeamCheck;

package/dist/watch/checks/approval.js

@@ -0,0 +1,16 @@
+import { reported } from "../check.js";
+// The owner's seat: a file that was never approved on this machine, or one that differs from the
+// file that was. Reported once while the difference holds. The watch never applies the file
+// itself — the report tells the owner, and nothing runs the differing file as approved.
+export const approval = {
+    name: 'approval',
+    run(team, ctx) {
+        if (team.approval === null) {
+            return reported(ctx.once('approval', 'the file was never approved on this machine', 'owner'));
+        }
+        if (team.approval?.length) {
+            return reported(ctx.once('approval', `the file differs from the approved one: ${team.approval.join('; ')}`, 'owner'));
+        }
+        return [];
+    },
+};

package/dist/watch/checks/attention.d.ts

@@ -0,0 +1,2 @@
+import { type SeatCheck } from '../check.ts';
+export declare const attention: SeatCheck;

package/dist/watch/checks/attention.js

@@ -0,0 +1,23 @@
+import { reported } from "../check.js";
+// The one exclusive reading the core made of the seat's screen and status: a seat waits at a
+// permission prompt its owner has to answer, asks a question the operator has to act on, is
+// blocked on a screen the watch doesn't recognise, or reports a status the watch doesn't know.
+// A permission prompt and a trust question are the same seat state to the watch.
+export const attention = {
+    name: 'attention',
+    run(seat, ctx) {
+        if (seat.attention === 'permission') {
+            return reported(ctx.once(`blocked:${seat.name}`, `${seat.name} waits at a permission prompt: its owner's to answer`, 'owner'));
+        }
+        if (seat.attention === 'question') {
+            return reported(ctx.once(`question:${seat.name}`, `${seat.name} asked a question: the operator's to act on`));
+        }
+        if (seat.attention === 'blocked') {
+            return reported(ctx.once(`blocked:${seat.name}`, `${seat.name} is blocked, and its screen is not one the watch recognises`, 'owner'));
+        }
+        if (seat.attention === 'unknown' && seat.agent) {
+            return reported(ctx.once(`unknown:${seat.name}`, `${seat.name}: herdr reports the status "${seat.agent.status}"`));
+        }
+        return [];
+    },
+};

package/dist/watch/checks/budget.d.ts

@@ -0,0 +1,2 @@
+import { type TeamCheck } from '../check.ts';
+export declare const budget: TeamCheck;

package/dist/watch/checks/budget.js

@@ -0,0 +1,141 @@
+import { verdict } from "../../budgets/readings.js";
+import { WINDOWS } from "../../profiles/quota.js";
+import { reported } from "../check.js";
+export const budget = {
+    name: 'budget',
+    run(team, ctx) {
+        const reports = [];
+        const marks = ctx.memory('budget', () => ({}));
+        const staleMs = ctx.budgets.staleAfter * 1000;
+        for (const [name, account] of Object.entries(ctx.budgets.accounts)) {
+            const counted = countedOf(name, account, team, staleMs, ctx.now);
+            // A figure nobody has yet seen (a first sight, not yet counted) is not "unknown": the
+            // launch gate is the one that says so, and a watch restart would otherwise report every run.
+            if (counted === 'unseen')
+                continue;
+            if (counted === null) {
+                reports.push(...reported(unknown(name, team, ctx)));
+                continue;
+            }
+            if (counted.kind === 'spend') {
+                const floor = account.floor;
+                if (floor !== null && counted.amount <= floor.amount) {
+                    const text = `${name} ${counted.amount} ${counted.currency} left, at its ${floor.amount} ${floor.currency} floor`;
+                    reports.push(...reported(ctx.once(`budget:floor:${name}`, text, 'owner')));
+                }
+                continue;
+            }
+            reports.push(...crossings(marks, name, counted.windows, ctx.budgets.marks, ctx.now));
+            const reserve = account.reserve;
+            if (reserve === null)
+                continue;
+            const inside = counted.windows.filter((window) => window.left <= reserve);
+            const worst = inside.reduce((a, b) => (a === null ? b : tightest(a, b)), null);
+            if (worst) {
+                const text = `${name} ${worst.window} left ${worst.left}%, inside its ${reserve}% reserve`;
+                reports.push(...reported(ctx.once(`budget:reserve:${name}`, text, 'owner')));
+            }
+        }
+        return reports;
+    },
+};
+/**
+ * The account's figure this pass, from the first source that has one (§ 4.3, § 5). A check
+ * reading counts while it is fresh; a screen reading counts when the verdict keeps it — fresh,
+ * stale, or refusing — and a bare first sight is `unseen`. Null: nothing counts at all.
+ */
+function countedOf(name, account, team, staleMs, now) {
+    for (const source of account.sources) {
+        if (source === 'check') {
+            const outcome = team.outcomes.find((one) => one.account === name);
+            if (!outcome || outcome.state !== 'read')
+                continue;
+            if (outcome.reading.kind === 'spend') {
+                if (now - outcome.reading.at < staleMs) {
+                    return { kind: 'spend', amount: outcome.reading.amount, currency: outcome.reading.currency };
+                }
+                continue;
+            }
+            const windows = outcome.reading.windows
+                .filter((window) => now - window.at < staleMs)
+                .map(({ window, left, used, resetsAt }) => ({ window, left, used, resetsAt }));
+            if (windows.length)
+                return { kind: 'subscription', windows };
+            continue;
+        }
+        const groups = new Map();
+        for (const reading of team.readings) {
+            if (reading.account !== name)
+                continue;
+            const group = groups.get(reading.window) ?? [];
+            group.push(reading);
+            groups.set(reading.window, group);
+        }
+        const windows = [];
+        let seen = false;
+        for (const group of groups.values()) {
+            const result = verdict(group, now, staleMs, account.reserve);
+            if (result.kind === 'unknown')
+                continue;
+            if (result.kind === 'unconfirmed') {
+                seen = true;
+                continue;
+            }
+            windows.push({
+                window: result.reading.window,
+                left: result.reading.left,
+                used: result.reading.used,
+                resetsAt: result.reading.resetsAt,
+            });
+        }
+        if (windows.length)
+            return { kind: 'subscription', windows };
+        if (seen)
+            return 'unseen';
+        continue;
+    }
+    return null;
+}
+/** The account reads unknown while a seat that spends it is running: the operator can stop it. */
+function unknown(name, team, ctx) {
+    const on = team.seats.filter((seat) => seat.running && seat.vendor === name).map((seat) => seat.name);
+    if (!on.length)
+        return null;
+    const verb = on.length === 1 ? 'runs' : 'run';
+    return ctx.once(`budget:unknown:${name}`, `${name} is unknown while ${on.join(', ')} ${verb} on it`, 'operator');
+}
+/**
+ * The marks this pass's figures cross (§ 6): each once per window, re-armed at the window's
+ * known reset, or — with no reset time known — when the figure drops ten points, which is a
+ * new window's figure.
+ */
+function crossings(marks, name, windows, list, now) {
+    const reports = [];
+    for (const window of windows) {
+        const key = `${name}\0${window.window}`;
+        const previous = marks[key];
+        const already = previous && !rearmed(previous, window, now) ? previous.reported : [];
+        const crossed = list.filter((mark) => window.used >= mark && !already.includes(mark));
+        for (const mark of crossed) {
+            reports.push({
+                key: `budget:mark:${name}:${window.window}:${mark}`,
+                text: `${name} ${window.window} is ${window.used}% used, past the ${mark}% mark`,
+                to: 'operator',
+            });
+        }
+        marks[key] = { used: window.used, resetsAt: window.resetsAt, reported: [...already, ...crossed] };
+    }
+    return reports;
+}
+function rearmed(previous, window, now) {
+    if (previous.resetsAt !== null && now >= previous.resetsAt) {
+        // The window the marks were reported in has ended; the new figure names the next one.
+        return window.resetsAt === null || window.resetsAt > now;
+    }
+    return previous.resetsAt === null && window.used <= previous.used - 10;
+}
+function tightest(a, b) {
+    if (a.left !== b.left)
+        return b.left < a.left ? b : a;
+    return WINDOWS.indexOf(b.window) < WINDOWS.indexOf(a.window) ? b : a;
+}

package/dist/watch/checks/disk.d.ts

@@ -0,0 +1,2 @@
+import { type TeamCheck } from '../check.ts';
+export declare const disk: TeamCheck;

package/dist/watch/checks/disk.js

@@ -0,0 +1,13 @@
+import { gb } from "../machine.js";
+import { reported } from "../check.js";
+// Free disk below the file's minimum, on the project's volume. A figure that wasn't read is
+// never reported.
+export const disk = {
+    name: 'disk',
+    run(team, ctx) {
+        const value = team.machine.diskFree;
+        if (value === null || value >= team.limits.diskMin)
+            return [];
+        return reported(ctx.once('disk', `free disk is ${gb(value)}, below ${gb(team.limits.diskMin)}`, 'owner'));
+    },
+};

package/dist/watch/checks/extra.d.ts

@@ -0,0 +1,2 @@
+import { type TeamCheck } from '../check.ts';
+export declare const extra: TeamCheck;