team 0.1.1 → 0.2.0

package/dist/budgets/gate.js

@@ -1,13 +1,14 @@
-import { verdict } from "./readings.js";
+import { checkOf, countedFor, screenOf } from "./readings.js";
 const RANK = { session: 0, daily: 1, weekly: 2 };
 /**
- * The seat's account is its vendor. There is no separate account field on a seat. `budgets` is
- * the section in force: an unapproved edit to a reserve refuses no one until it is approved,
- * and an account only the unapproved edit names is not an account at all. `spend` holds the
- * stored spend check readings; a subscription account never looks at them.
+ * The seat's account is its own `account:` when the file names one — one vendor with two accounts
+ * is two buckets (§ 3b) — and its vendor otherwise. `budgets` is the section in force: an
+ * unapproved edit to a reserve refuses no one until it is approved, and an account only the
+ * unapproved edit names is not an account at all. `spend` holds the stored spend check readings;
+ * a subscription account never looks at them.
  */
 export function seatBudget(budgets, readings, seat, now, spend = []) {
-    const name = seat.vendor;
+    const name = seat.account ?? seat.vendor;
     const account = budgets.accounts[name];
     if (!account)
         return { kind: 'clear' };
@@ -35,7 +36,9 @@ export function seatBudget(budgets, readings, seat, now, spend = []) {
     let counted = false;
     let worst = null;
     for (const group of windowsOf(mine)) {
-        const result = verdict(group, now, staleAfterMs, account.reserve);
+        // The window's reading from the sources the account names, in order (§ 3, § 5): a check
+        // reading counts by its own freshness, ahead of a screen reading below it.
+        const result = countedFor(account.sources, screenOf(group), checkOf(group), now, staleAfterMs, account.reserve);
         if (result.kind === 'unknown') {
             unknown = true;
             continue;
@@ -46,8 +49,7 @@ export function seatBudget(budgets, readings, seat, now, spend = []) {
             continue;
         }
         counted = true;
-        const inside = account.reserve !== null && result.reading.left <= account.reserve;
-        if (!inside && result.kind !== 'refusing')
+        if (account.reserve === null || result.reading.left > account.reserve)
             continue;
         if (!worst
             || result.reading.left < worst.left
@@ -57,9 +59,11 @@ export function seatBudget(budgets, readings, seat, now, spend = []) {
     }
     if (worst && account.reserve !== null) {
         const room = accountsWithRoom(budgets, readings, now).filter((accountName) => accountName !== name);
+        // A check reading was measured, not changed on a screen: § 5's word for it.
+        const when = worst.source === 'check' ? 'read' : 'changed';
         return {
             kind: 'refuse',
-            why: `${name} ${worst.window} left ${worst.left}%, inside its ${account.reserve}% reserve, changed ${age(now - worst.changedAt)} ago; accounts with room: ${room.length ? room.join(', ') : 'none'}`,
+            why: `${name} ${worst.window} left ${worst.left}%, inside its ${account.reserve}% reserve, ${when} ${age(now - worst.changedAt)} ago; accounts with room: ${room.length ? room.join(', ') : 'none'}`,
         };
     }
     if (unknown)
@@ -90,11 +94,11 @@ export function accountsWithRoom(budgets, readings, now, spend = []) {
         let counted = 0;
         let inside = false;
         for (const group of groups) {
-            const result = verdict(group, now, staleAfterMs, account.reserve);
+            const result = countedFor(account.sources, screenOf(group), checkOf(group), now, staleAfterMs, account.reserve);
             if (result.kind === 'unknown' || result.kind === 'unconfirmed')
                 continue;
             counted += 1;
-            if (result.kind === 'refusing' || result.reading.left <= account.reserve)
+            if (result.reading.left <= account.reserve)
                 inside = true;
         }
         if (counted > 0 && !inside)
@@ -121,7 +125,12 @@ function age(ms) {
         return `${hours}h`;
     return `${minutes}m`;
 }
-/** A money figure in a refusal: the cents are shown even when the file wrote none. */
+/**
+ * A money figure in a refusal, as read: up to four decimals — the most a check or a floor may
+ * carry — with the trailing zeros beyond the cents dropped, and never fewer than two decimals.
+ * The figure the words judge is the figure the eyes see.
+ */
 function money(amount) {
-    return amount.toFixed(2);
+    const written = amount.toFixed(4).replace(/0+$/, '');
+    return written.padEnd(written.indexOf('.') + 3, '0');
 }

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,11 +21,13 @@ 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 = {
-    kind: 'fresh' | 'unconfirmed' | 'stale' | 'refusing';
+    kind: 'fresh' | 'unconfirmed' | 'stale' | 'refusing' | 'last-seen';
     reading: Seen;
 } | {
     kind: 'unknown';
@@ -41,26 +48,67 @@ export type StoredSpend = {
 };
 /** 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
  * only when no confirmed reading is still live. Staleness is measured from
  * `changedAt`. A stale reading inside the reserve refuses until its reset;
- * with no reset time it is unknown.
+ * with no reset time it is unknown when it could still matter — inside the
+ * reserve or within the reserve again outside it — and last seen when it sits
+ * further out, room the account may still hold. It never refuses.
  */
 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.
+ * A stale figure with no known reset counts as the room last seen only when it is well outside
+ * the reserve, and it sits below any inside-reserve figure: a last sight never clears a refusal.
+ */
+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, session: string, list: readonly SpendReading[]): void;
-export declare function loadSpendReadings(dir: string, session: string): SpendReading[];
+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;

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,12 +28,56 @@ 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 distance rule for a stale figure with no known reset (§ 5), in one place: more than the
+ * reserve again outside it, the figure is the room last seen rather than unknown. `verdict` and
+ * the check branch of `countedFor` both ask this, so the two cannot be edited apart.
+ */
+function pastTheReserveAgain(left, reserve) {
+    return left > reserve * 2;
+}
 /**
  * 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
  * only when no confirmed reading is still live. Staleness is measured from
  * `changedAt`. A stale reading inside the reserve refuses until its reset;
- * with no reset time it is unknown.
+ * with no reset time it is unknown when it could still matter — inside the
+ * reserve or within the reserve again outside it — and last seen when it sits
+ * further out, room the account may still hold. It never refuses.
  */
 export function verdict(list, now, staleAfterMs, reserve) {
     const live = list.filter((item) => item.resetsAt === null || item.resetsAt > now);
@@ -52,17 +97,77 @@ export function verdict(list, now, staleAfterMs, reserve) {
     const inside = reserve !== null && reading.left <= reserve;
     if (inside && reading.resetsAt !== null)
         return { kind: 'refusing', reading };
-    if (reading.resetsAt === null)
+    if (reading.resetsAt === null) {
+        if (reserve !== null && pastTheReserveAgain(reading.left, reserve))
+            return { kind: 'last-seen', reading };
         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.
+ * A stale figure with no known reset counts as the room last seen only when it is well outside
+ * the reserve, and it sits below any inside-reserve figure: a last sight never clears a refusal.
+ */
+export function countedFor(sources, screen, checks, now, staleAfterMs, reserve) {
+    let fallback = null;
+    let lastSeen = 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;
+            // A stale check figure with no reset, past the reserve again, is the room last seen.
+            const sight = checks.find((item) => item.resetsAt === null && reserve !== null && pastTheReserveAgain(item.left, reserve));
+            if (sight)
+                lastSeen ??= sight;
+            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 };
+        if (result.kind === 'last-seen') {
+            lastSeen ??= result.reading;
+            continue;
+        }
+        fallback ??= result.reading;
+    }
+    if (fallback)
+        return { kind: 'counted', reading: fallback };
+    if (lastSeen)
+        return { kind: 'counted', reading: lastSeen };
+    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,35 +176,44 @@ 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) => {
-        const current = state.sessions[session] ?? emptySession();
-        current.budgets = remember(list, now);
-        state.sessions[session] = current;
+        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, session) {
-    return recall(readState(dir).sessions[session]?.budgets);
+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, session, list) {
+export function saveSpendReadings(dir, list) {
     if (!list.length)
         return;
     updateState(dir, (state) => {
-        const current = state.sessions[session] ?? emptySession();
-        const spend = current.spend ?? {};
+        const spend = state.spend ?? {};
         for (const reading of list)
             spend[reading.account] = storeSpend(reading);
-        current.spend = spend;
-        state.sessions[session] = current;
+        state.spend = spend;
     });
 }
-export function loadSpendReadings(dir, session) {
-    return recallSpend(readState(dir).sessions[session]?.spend);
+export function loadSpendReadings(dir) {
+    return recallSpend(readState(dir).spend);
 }
 export function storeSpend(reading) {
     return {
@@ -128,6 +242,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,
     };
 }
@@ -140,6 +255,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/run.js

@@ -12,10 +12,16 @@ const SPEND = /^([0-9]+(?:\.[0-9]{1,4})?) ([A-Z]{3})$/;
 // § 5: one to three lines, each a window, each figure whole and at most 100. The
 // printed reset is a duration; the printed measurement time is unix seconds.
 const LINE = /^(session|daily|weekly) (100|[0-9]{1,2})% (used|left)(?: resets ([0-9]+h(?:[0-9]+m)?|[0-9]+m))?(?: at ([0-9]{10}))?$/;
-/** An output's lines: one trailing newline allowed, and nothing else. */
+/**
+ * An output's lines: one trailing newline allowed, and nothing else. A "\r\n" ending reads
+ * as its line — the CR goes with the newline — and a CR anywhere else stays a character of
+ * the line, off the contract.
+ */
 function linesOf(text) {
     const body = text.endsWith('\n') ? text.slice(0, -1) : text;
-    return body === '' ? null : body.split('\n');
+    if (body === '')
+        return null;
+    return body.split('\n').map((line) => (line.endsWith('\r') ? line.slice(0, -1) : line));
 }
 /**
  * A subscription output against § 5. Any line off the contract, a figure over

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,9 @@ export type BudgetRow = {
     resetsIn: string | null;
     seat: string | null;
     age: string | null;
-    source: 'status_line' | null;
+    source: ReadingSource | null;
+    /** True when the counted figure did not come from the first source the account names (§ 3). */
+    fallback: boolean;
     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,12 @@ 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 sources = sourcesOf(budgets, account);
+        const result = countedFor(sources, screenOf(group), checkOf(group), now, staleAfterMs, reserve);
+        rows.push(result.kind === 'unknown'
+            ? { ...blank(account, reserve), window }
+            : rowOf(result, now, staleAfterMs, reserve, result.reading.source !== sources[0]));
     }
     for (const account of Object.keys(budgets.accounts)) {
         if (!named.has(account))
@@ -35,25 +40,37 @@ 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 source = row.fallback ? `${from} (fallback)` : from;
+    // A stale row with no known reset is the room last seen, not a reading aged out.
+    const when = row.state === 'stale' && row.resetsIn === null ? 'last seen' : 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  ${source}  ${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, fallback) {
     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,
+        fallback,
+        state,
+        inside,
         reserve,
     };
 }
@@ -67,6 +84,7 @@ function blank(account, reserve) {
         seat: null,
         age: null,
         source: null,
+        fallback: false,
         state: 'unknown',
         inside: false,
         reserve,

package/dist/cli.d.ts

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 import type { Command, Io } from './io.ts';
+import { version } from './version.ts';
 export declare const commands: Record<string, () => Promise<{
     default: Command;
     USAGE: string;
 }>>;
-export declare function version(): string;
+export { version };
 export declare function main(argv: string[], io: Io): Promise<number>;
 export declare function processIo(): Io;

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
-import { readFileSync, realpathSync } from 'node:fs';
+import { realpathSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
+import { version } from "./version.js";
 // Each command is loaded only when it is called. A slice adds its line here. The table is exported
 // so a test can walk it: every command, `--help`, `-h` and a usage line.
 export const commands = {
@@ -29,10 +30,7 @@ Options:
 
 The team is declared in <project>/.agents/team.yaml.
 `;
-export function version() {
-    const text = readFileSync(new URL('../package.json', import.meta.url), 'utf8');
-    return JSON.parse(text).version;
-}
+export { version };
 export async function main(argv, io) {
     const [name, ...rest] = argv;
     const names = Object.keys(commands);
@@ -45,6 +43,11 @@ export async function main(argv, io) {
         io.stdout(`${version()}\n`);
         return 0;
     }
+    // Hidden: a port speaks this protocol. It is not a command in the help text.
+    if (name === 'conformance-adapter') {
+        const { default: run } = await import("./conformance/adapter.js");
+        return run(rest, io);
+    }
     const load = commands[name];
     if (!load) {
         io.stderr(`team: unknown command "${name}"\n\n${usage}`);

package/dist/commands/add.d.ts

@@ -9,7 +9,6 @@ export type AddSources = {
     agents(session: string): HerdrAgent[] | null;
     workspaces(session: string): {
         id: string;
-        label: string;
     }[] | null;
     doctor: DoctorSources;
     machine?: (root: string) => Machine;