team 0.0.1 → 0.1.0

package/dist/profiles/profile.d.ts

@@ -0,0 +1,60 @@
+import { type QuotaPattern } from './quota.ts';
+/**
+ * A launch profile: what `team` knows about one CLI, so a seat can't start
+ * blocked. Keyed by the seat's `cli`.
+ */
+export interface Profile {
+    cli: string;
+    /** The CLI's process names, for the caller check. */
+    processNames: readonly string[];
+    /** The binary whose version `doctor` reads, with `--version`. */
+    binary: string;
+    /** The range this profile was tested with, both ends included. */
+    tested: {
+        from: string;
+        to: string;
+    };
+    /** Options that make the CLI run without approvals, added to the launch. */
+    unattended: readonly string[];
+    /** The option that carries the rules, or null when they go as a first message. */
+    rulesOption: string | null;
+    /** Arguments that exit 0 only when the owner is logged in, or null when the CLI has none. */
+    loginCheck: readonly string[] | null;
+    /** The command the owner runs to log in. */
+    loginHint: string;
+    /** What is typed into an idle prompt to make the CLI exit. */
+    exit: string;
+    /** Seconds to wait for the idle prompt after a launch. */
+    idleTimeout: number;
+    /** Seconds to wait for the pane's shell after the exit command. */
+    exitTimeout: number;
+    /** The model and version a launch line's model id means, or null when unknown. */
+    modelOf(launch: string): {
+        model: string;
+        version: string;
+    } | null;
+}
+/** A version as numbers: `2.1.288 (Claude Code)` is [2, 1, 288]. Null when the text holds none. */
+export declare function parseVersion(text: string): number[] | null;
+export type VersionVerdict = 'tested' | 'older' | 'newer' | 'unread';
+/** Where a CLI's version sits against the range a profile was tested with. */
+export declare function versionVerdict(text: string, tested: Profile['tested']): VersionVerdict;
+/** A word quoted for a POSIX shell. */
+export declare function shellQuote(word: string): string;
+/**
+ * The command a seat's pane runs: the unattended flag in its environment, the
+ * file's launch line, then the profile's options and, where the CLI takes
+ * them at launch, the rules.
+ */
+export declare function launchCommand(profile: Profile, launch: string, rules: string): string;
+/** The profiles this version launches. A `cli` without one is reported and left out. */
+export declare function profileFor(cli: string): Profile | null;
+/** The quota patterns shipped with a CLI. An unknown CLI, or one with none, has an empty list. */
+export declare function quotaFor(cli: string): readonly QuotaPattern[];
+/** Patterns from a YAML list, for a profile snippet. A bad pattern throws. */
+export declare function quotaPatterns(text: string): QuotaPattern[];
+/** The model a status line names. `unreadable` is a line the rules claim that does not name one. */
+export declare function statusOnLine(cli: string, line: string): {
+    model: string;
+    version: string;
+} | 'unreadable' | null;

package/dist/profiles/profile.js

@@ -0,0 +1,313 @@
+// A launch profile, read from the CLI's YAML file. The screen is loaded separately.
+import { readFileSync } from 'node:fs';
+import { DialectError, compilePattern } from "../watch/dialect.js";
+import { WINDOWS } from "./quota.js";
+import { YamlError, parseYaml } from "../yaml.js";
+/** A version as numbers: `2.1.288 (Claude Code)` is [2, 1, 288]. Null when the text holds none. */
+export function parseVersion(text) {
+    const match = /\d+(?:\.\d+)*/.exec(text);
+    return match ? match[0].split('.').map(Number) : null;
+}
+function order(a, b) {
+    for (let index = 0; index < Math.max(a.length, b.length); index++) {
+        const difference = (a[index] ?? 0) - (b[index] ?? 0);
+        if (difference !== 0)
+            return Math.sign(difference);
+    }
+    return 0;
+}
+/** Where a CLI's version sits against the range a profile was tested with. */
+export function versionVerdict(text, tested) {
+    const version = parseVersion(text);
+    const from = parseVersion(tested.from);
+    const to = parseVersion(tested.to);
+    if (!version || !from || !to)
+        return 'unread';
+    if (order(version, from) < 0)
+        return 'older';
+    if (order(version, to) > 0)
+        return 'newer';
+    return 'tested';
+}
+/** A word quoted for a POSIX shell. */
+export function shellQuote(word) {
+    if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(word))
+        return word;
+    return `'${word.replaceAll("'", `'\\''`)}'`;
+}
+/**
+ * The command a seat's pane runs: the unattended flag in its environment, the
+ * file's launch line, then the profile's options and, where the CLI takes
+ * them at launch, the rules.
+ */
+export function launchCommand(profile, launch, rules) {
+    const options = [...profile.unattended];
+    if (profile.rulesOption !== null)
+        options.push(profile.rulesOption, rules);
+    return ['AGENT_UNATTENDED=1', launch.trim(), ...options.map(shellQuote)].join(' ');
+}
+const NAMES = ['claude-code', 'codex', 'cursor', 'antigravity'];
+const LAUNCH_KEYS = ['binary', 'process_names', 'tested', 'unattended', 'rules', 'login', 'exit', 'timeouts', 'models', 'status_model'];
+const SHIPPED = loadShipped();
+/** The profiles this version launches. A `cli` without one is reported and left out. */
+export function profileFor(cli) {
+    return Object.hasOwn(SHIPPED, cli) ? (SHIPPED[cli]?.profile ?? null) : null;
+}
+/** The quota patterns shipped with a CLI. An unknown CLI, or one with none, has an empty list. */
+export function quotaFor(cli) {
+    return SHIPPED[cli]?.quota ?? [];
+}
+/** Patterns from a YAML list, for a profile snippet. A bad pattern throws. */
+export function quotaPatterns(text) {
+    return quotaOf(parseYaml(text));
+}
+/** The model a status line names. `unreadable` is a line the rules claim that does not name one. */
+export function statusOnLine(cli, line) {
+    const rules = SHIPPED[cli]?.status;
+    if (!rules)
+        return null;
+    return apply(rules, line);
+}
+function loadShipped() {
+    const out = {};
+    for (const name of NAMES) {
+        const text = readFileSync(new URL(`./${name}.yaml`, import.meta.url), 'utf8');
+        const shipped = launchOf(parseYaml(text));
+        if (out[shipped.profile.cli])
+            fail(1, `two profiles are named "${shipped.profile.cli}"`);
+        out[shipped.profile.cli] = shipped;
+    }
+    return out;
+}
+function launchOf(root) {
+    const entries = mapping(root, 'a profile');
+    const format = required(entries, 'format', root.line);
+    if (format.value.kind !== 'scalar' || format.value.value !== 1)
+        fail(format.line, '"format" must be 1');
+    only(entries, ['format', 'cli', 'screen', 'quota', ...LAUNCH_KEYS]);
+    const cli = text(required(entries, 'cli', root.line), 'cli');
+    required(entries, 'screen', root.line);
+    const quotaEntry = optional(entries, 'quota');
+    for (const key of LAUNCH_KEYS)
+        required(entries, key, root.line);
+    const login = loginOf(required(entries, 'login', root.line).value);
+    const timeouts = required(entries, 'timeouts', root.line).value;
+    const models = modelsOf(required(entries, 'models', root.line).value);
+    return {
+        profile: {
+            cli,
+            binary: text(required(entries, 'binary', root.line), 'binary'),
+            processNames: strings(required(entries, 'process_names', root.line).value, 'process_names'),
+            tested: testedOf(required(entries, 'tested', root.line).value),
+            unattended: strings(required(entries, 'unattended', root.line).value, 'unattended'),
+            rulesOption: rulesOf(required(entries, 'rules', root.line).value),
+            loginCheck: login.check,
+            loginHint: login.hint,
+            exit: text(required(entries, 'exit', root.line), 'exit'),
+            idleTimeout: seconds(timeouts, 'idle'),
+            exitTimeout: seconds(timeouts, 'exit'),
+            modelOf: (launch) => modelOf(models, launch),
+        },
+        status: modelRules(required(entries, 'status_model', root.line).value, 'status_model'),
+        quota: quotaEntry ? quotaOf(quotaEntry.value) : [],
+    };
+}
+function quotaOf(node) {
+    if (node.kind !== 'seq' || node.items.length === 0)
+        fail(node.line, '"quota" must be a non-empty list');
+    return node.items.map((item) => {
+        const entries = mapping(item, 'a quota pattern');
+        only(entries, ['account', 'match', 'left', 'used', 'resets', 'window']);
+        const left = optional(entries, 'left');
+        const used = optional(entries, 'used');
+        if (left && used)
+            fail(left.line, 'a quota pattern has left or used, not both');
+        if (!left && !used)
+            fail(item.line, 'a quota pattern needs left or used');
+        const side = left ? 'left' : 'used';
+        const figure = text((left ?? used), side);
+        template(figure, (left ?? used)?.line ?? item.line);
+        const resetsEntry = optional(entries, 'resets');
+        const resets = resetsEntry ? text(resetsEntry, 'resets') : null;
+        if (resets !== null)
+            template(resets, resetsEntry?.line ?? item.line);
+        const window = text(required(entries, 'window', item.line), 'window');
+        if (!WINDOWS.includes(window))
+            fail(item.line, '"window" must be session, daily or weekly');
+        const match = required(entries, 'match', item.line);
+        return {
+            account: text(required(entries, 'account', item.line), 'account'),
+            window: window,
+            match: pattern(text(match, 'match'), false, match.line),
+            side,
+            figure,
+            resets,
+        };
+    });
+}
+// The flag's value is the next token, after "=" or any whitespace. The last flag in the line wins.
+function modelOf(models, launch) {
+    let bestAt = -1;
+    let id = null;
+    for (const option of models.option) {
+        const found = flagValue(launch, option);
+        if (found && found.at > bestAt) {
+            bestAt = found.at;
+            id = found.id;
+        }
+    }
+    if (id === null)
+        return null;
+    const hit = apply(models.ids, id);
+    return hit === 'unreadable' ? null : hit;
+}
+function flagValue(launch, option) {
+    const escaped = option.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const pattern = new RegExp(`(?:^|\\s)${escaped}(?:=|\\s+)(\\S+)`, 'gu');
+    let found = null;
+    for (const match of launch.matchAll(pattern)) {
+        if (match[1] === undefined || match.index === undefined)
+            continue;
+        found = { at: match.index, id: match[1] };
+    }
+    return found;
+}
+function apply(rules, text) {
+    for (const rule of rules) {
+        const match = rule.match.exec(text);
+        if (!match)
+            continue;
+        const model = fill(rule.model, match);
+        const version = fill(rule.version, match);
+        // A match that cannot fill its template is a line of this shape that names no model.
+        if (model === null || version === null)
+            return 'unreadable';
+        return { model, version };
+    }
+    return null;
+}
+function fill(template, match) {
+    let missing = false;
+    const out = template.replace(/\{(\d+)(?::(title))?\}/g, (_whole, number, mode) => {
+        const value = match[Number(number)];
+        if (value === undefined) {
+            missing = true;
+            return '';
+        }
+        return mode === 'title' ? `${value.slice(0, 1).toUpperCase()}${value.slice(1).toLowerCase()}` : value;
+    });
+    return missing ? null : out;
+}
+function modelsOf(node) {
+    const entries = mapping(node, 'models');
+    only(entries, ['option', 'ids']);
+    return {
+        option: strings(required(entries, 'option', node.line).value, 'option'),
+        ids: modelRules(required(entries, 'ids', node.line).value, 'ids'),
+    };
+}
+function modelRules(node, key) {
+    if (node.kind !== 'seq' || node.items.length === 0)
+        fail(node.line, `"${key}" must be a non-empty list`);
+    return node.items.map((item) => {
+        const entries = mapping(item, 'a model rule');
+        only(entries, ['match', 'ignore_case', 'model', 'version']);
+        const flag = optional(entries, 'ignore_case');
+        const ignoreCase = flag ? boolOf(flag.value, 'ignore_case') : false;
+        const match = required(entries, 'match', item.line);
+        const model = text(required(entries, 'model', item.line), 'model');
+        const version = text(required(entries, 'version', item.line), 'version');
+        template(model, match.line);
+        template(version, match.line);
+        return { match: pattern(text(match, 'match'), ignoreCase, match.line), model, version };
+    });
+}
+function template(text, line) {
+    const rest = text.replace(/\{(\d+)(?::title)?\}/g, '');
+    if (rest.includes('{') || rest.includes('}'))
+        fail(line, 'a template is "{n}" or "{n:title}"');
+}
+function rulesOf(node) {
+    if (node.kind === 'scalar' && node.value === 'first-message')
+        return null;
+    const entries = mapping(node, 'rules');
+    only(entries, ['option']);
+    return text(required(entries, 'option', node.line), 'option');
+}
+function loginOf(node) {
+    const entries = mapping(node, 'login');
+    only(entries, ['check', 'hint']);
+    return {
+        check: strings(required(entries, 'check', node.line).value, 'check'),
+        hint: text(required(entries, 'hint', node.line), 'hint'),
+    };
+}
+function testedOf(node) {
+    const entries = mapping(node, 'tested');
+    only(entries, ['from', 'to']);
+    return { from: text(required(entries, 'from', node.line), 'from'), to: text(required(entries, 'to', node.line), 'to') };
+}
+function seconds(node, key) {
+    const entries = mapping(node, 'timeouts');
+    only(entries, ['idle', 'exit']);
+    const value = text(required(entries, key, node.line), key);
+    const match = /^([0-9]+)s$/.exec(value);
+    if (!match || match[1] === undefined)
+        fail(node.line, `"${key}" is a number of seconds, written "90s"`);
+    return Number(match[1]);
+}
+function pattern(source, ignoreCase, line) {
+    try {
+        return compilePattern(source, ignoreCase);
+    }
+    catch (error) {
+        if (error instanceof DialectError)
+            fail(line, error.message);
+        throw error;
+    }
+}
+function strings(node, key) {
+    if (node.kind !== 'seq' || node.items.length === 0)
+        fail(node.line, `"${key}" must be a non-empty list`);
+    return node.items.map((item) => {
+        const value = stringOf(item);
+        if (!value)
+            fail(item.line, `"${key}" entries must be non-empty strings`);
+        return value;
+    });
+}
+function text(entry, key) {
+    const value = stringOf(entry.value);
+    if (!value)
+        fail(entry.line, `"${key}" must be a non-empty string`);
+    return value;
+}
+function boolOf(node, key) {
+    if (node.kind !== 'scalar' || typeof node.value !== 'boolean')
+        fail(node.line, `"${key}" must be true or false`);
+    return node.value;
+}
+function stringOf(node) {
+    if (node.kind !== 'scalar' || typeof node.value !== 'string' || node.value === '')
+        return null;
+    return node.value;
+}
+function mapping(node, what) {
+    if (node.kind !== 'map')
+        fail(node.line, `${what} must be a map`);
+    return node.entries;
+}
+function only(entries, allowed) {
+    for (const entry of entries)
+        if (!allowed.includes(entry.key))
+            fail(entry.line, `unknown key "${entry.key}"`);
+}
+function required(entries, key, line) {
+    return optional(entries, key) ?? fail(line, `missing "${key}"`);
+}
+function optional(entries, key) {
+    return entries.find((entry) => entry.key === key);
+}
+function fail(line, message) {
+    throw new YamlError(line, message);
+}

package/dist/profiles/quota.d.ts

@@ -0,0 +1,22 @@
+export declare const WINDOWS: readonly ["session", "daily", "weekly"];
+export type WindowName = (typeof WINDOWS)[number];
+export type QuotaPattern = {
+    account: string;
+    window: WindowName;
+    match: RegExp;
+    side: 'left' | 'used';
+    /** A template such as `{1}%`. */
+    figure: string;
+    /** A template for a duration such as `114h4m`, or null when the line has none. */
+    resets: string | null;
+};
+export type QuotaFigure = {
+    account: string;
+    window: WindowName;
+    /** 0 to 100. `left` and `used` add to 100. */
+    left: number;
+    used: number;
+    resets: string | null;
+};
+/** Figures from the last six lines. A cut line, or a figure over 100, is absent. */
+export declare function figuresOf(patterns: readonly QuotaPattern[], screen: string): QuotaFigure[];

package/dist/profiles/quota.js

@@ -0,0 +1,56 @@
+// A profile's quota patterns. They are read after a screen is classified, and they
+// only produce figures: they never change what the screen is.
+export const WINDOWS = ['session', 'daily', 'weekly'];
+const RESET = /^(?:[0-9]+h(?:[0-9]+m)?|[0-9]+m)$/;
+const PERCENT = /^([0-9]+)%$/;
+/** Figures from the last six lines. A cut line, or a figure over 100, is absent. */
+export function figuresOf(patterns, screen) {
+    const lines = screen.split('\n').map((line) => line.trimEnd()).slice(-6);
+    const found = [];
+    for (const pattern of patterns) {
+        let hit = null;
+        for (const line of lines) {
+            const match = pattern.match.exec(line);
+            if (!match)
+                continue;
+            const next = figureOf(pattern, match);
+            if (next)
+                hit = next;
+        }
+        if (hit)
+            found.push(hit);
+    }
+    return found;
+}
+function figureOf(pattern, match) {
+    const filled = fill(pattern.figure, match);
+    const percent = filled === null ? null : PERCENT.exec(filled);
+    const value = percent?.[1] === undefined ? null : Number(percent[1]);
+    if (value === null || value > 100)
+        return null;
+    let resets = null;
+    if (pattern.resets !== null) {
+        resets = fill(pattern.resets, match);
+        if (resets === null || !RESET.test(resets))
+            return null;
+    }
+    return {
+        account: pattern.account,
+        window: pattern.window,
+        left: pattern.side === 'left' ? value : 100 - value,
+        used: pattern.side === 'used' ? value : 100 - value,
+        resets,
+    };
+}
+function fill(template, match) {
+    let missing = false;
+    const out = template.replace(/\{(\d+)\}/g, (_whole, number) => {
+        const value = match[Number(number)];
+        if (value === undefined) {
+            missing = true;
+            return '';
+        }
+        return value;
+    });
+    return missing ? null : out;
+}

package/dist/state.d.ts

@@ -0,0 +1,59 @@
+import type { StoredReading } from './budgets/readings.ts';
+export type SeatState = {
+    stage: 'launched' | 'named' | 'ready';
+    pane?: string;
+    /** The herdr workspace, so a later command can close it without listing agents. */
+    workspace?: string;
+    cli_version?: string;
+    rules?: 'option' | 'message' | 'undelivered';
+    worked?: boolean;
+    temporary?: {
+        like: string;
+        until: string;
+        task?: string;
+        own_commits?: boolean;
+    };
+};
+export type WorktreeState = {
+    path: string;
+    branch: string;
+    own_commits?: boolean;
+    seat?: string;
+    setup: 'ok' | 'failed';
+};
+export type SessionState = {
+    started?: {
+        at: string;
+        by: string;
+    };
+    seats: Record<string, SeatState>;
+    worktrees: Record<string, WorktreeState>;
+    watch?: {
+        pid: number;
+        heartbeat: string;
+    };
+    nudge?: {
+        pending_since: string | null;
+    };
+    /** The last screen readings for this project, keyed by account, window and seat. */
+    budgets?: Record<string, StoredReading>;
+};
+export type State = {
+    format: 1;
+    last_valid?: {
+        read_at: string;
+        file: string;
+    };
+    sessions: Record<string, SessionState>;
+};
+export declare const STATE_FILE = "team.state.json";
+export declare const LOCK_FILE = "team.lock";
+export declare const LOG_FILE = "team.log";
+export declare function emptySession(): SessionState;
+export declare function readState(dir: string): State;
+export declare function updateState<T>(dir: string, change: (state: State) => T): T;
+export declare function writeAtomic(path: string, text: string): void;
+export declare function withLock<T>(dir: string, work: () => T, options?: {
+    waitMs?: number;
+    onStale?: (pid: number) => void;
+}): T;

package/dist/state.js

@@ -0,0 +1,127 @@
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const STATE_FILE = 'team.state.json';
+export const LOCK_FILE = 'team.lock';
+export const LOG_FILE = 'team.log';
+export function emptySession() {
+    return { seats: {}, worktrees: {} };
+}
+// The state in `dir` (the folder of the team file). A missing file is an empty state; a file
+// that can't be read as a state is an error, never silently replaced.
+export function readState(dir) {
+    const path = join(dir, STATE_FILE);
+    if (!existsSync(path))
+        return { format: 1, sessions: {} };
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        throw new Error(`${path} is not valid JSON; move it aside and run the command again`);
+    }
+    const state = parsed;
+    if (!state || typeof state !== 'object' || state.format !== 1 || typeof state.sessions !== 'object' || !state.sessions) {
+        throw new Error(`${path} is not a team state of format 1; move it aside and run the command again`);
+    }
+    for (const session of Object.values(state.sessions)) {
+        session.seats ??= {};
+        session.worktrees ??= {};
+    }
+    return state;
+}
+// Reads the state, lets `change` edit it, and writes it back, all under the lock.
+export function updateState(dir, change) {
+    return withLock(dir, () => {
+        const state = readState(dir);
+        const result = change(state);
+        writeAtomic(join(dir, STATE_FILE), `${JSON.stringify(state, null, 2)}\n`);
+        return result;
+    });
+}
+export function writeAtomic(path, text) {
+    const temporary = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporary, text);
+    renameSync(temporary, path);
+}
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+function pause(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+// Removes a lock whose holder is dead. Two commands may see the same dead holder: the lock is
+// moved aside first, which only one of them can do, and put back if it turns out to be a fresh
+// one that another command took in between.
+function takeOver(path, holder) {
+    const aside = `${path}.${process.pid}.stale`;
+    try {
+        renameSync(path, aside);
+    }
+    catch {
+        return false;
+    }
+    const found = Number(readFileSync(aside, 'utf8').trim());
+    if (found !== holder && Number.isInteger(found) && found > 0 && alive(found)) {
+        try {
+            renameSync(aside, path);
+        }
+        catch { }
+        return false;
+    }
+    unlinkSync(aside);
+    return true;
+}
+// One writer at a time. The lock file holds its holder's pid; a lock whose holder is dead is
+// taken over, and `onStale` is told.
+export function withLock(dir, work, options = {}) {
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, LOCK_FILE);
+    const deadline = Date.now() + (options.waitMs ?? 5000);
+    for (;;) {
+        try {
+            const fd = openSync(path, 'wx');
+            writeFileSync(fd, `${process.pid}\n`);
+            closeSync(fd);
+            break;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            let holder = NaN;
+            try {
+                holder = Number(readFileSync(path, 'utf8').trim());
+            }
+            catch {
+                continue; // released between the two calls
+            }
+            if (Number.isInteger(holder) && holder > 0 && alive(holder)) {
+                if (Date.now() > deadline)
+                    throw new Error(`another team command (pid ${holder}) holds ${path}; try again when it is done`);
+                pause(50);
+                continue;
+            }
+            // A dead holder, or a lock file too young to hold its pid yet.
+            if (!Number.isInteger(holder) && Date.now() - statSync(path).mtimeMs < 1000) {
+                pause(20);
+                continue;
+            }
+            if (takeOver(path, holder))
+                options.onStale?.(holder);
+        }
+    }
+    try {
+        return work();
+    }
+    finally {
+        try {
+            unlinkSync(path);
+        }
+        catch { }
+    }
+}

package/dist/status/compare.d.ts

@@ -0,0 +1,26 @@
+import type { TeamFile } from '../file/types.ts';
+import type { HerdrAgent, HerdrWorkspace } from '../herdr.ts';
+import type { SessionState } from '../state.ts';
+export type Live = {
+    running: boolean;
+    agents: HerdrAgent[];
+    workspaces: HerdrWorkspace[];
+    screens: Record<string, string>;
+};
+export type Row = {
+    name: string;
+    state: string;
+    model: string;
+    pane: string;
+};
+export type Difference = {
+    what: string;
+    repair: string;
+};
+export type Comparison = {
+    rows: Row[];
+    differences: Difference[];
+    notes: string[];
+};
+export declare const WATCH_LABEL = "watchdog";
+export declare function compare(team: TeamFile, session: string, state: SessionState, live: Live, now?: Date, watch?: TeamFile['watch']): Comparison;