team 0.1.2 → 0.2.0

package/dist/profiles/overrides.js

@@ -0,0 +1,190 @@
+// The owner's override file. It sits beside the approval and may only add dialog
+// patterns and quota patterns to a profile this version ships. It cannot take a
+// shipped pattern out, and it cannot change a composer, a prompt, a footer, a
+// launch line or the order of the stages: anything else in the file is refused
+// with its line. An edit takes effect only once `approve` records the text: until
+// then the approved copy stays in force, and a copy that cannot be read leaves
+// the shipped profiles.
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { profileFor, quotaFor, quotaList } from "./profile.js";
+import { readApproval, storePath } from "../store/store.js";
+import { addedRules } from "../watch/screen-file.js";
+import { classifyData, screenData } from "../watch/screen.js";
+import { YamlError, parseYaml } from "../yaml.js";
+export const DIALOG_STAGES = ['unknown', 'trust', 'permission', 'question'];
+/** `<store>/overrides.yaml`, the same folder as the approval for this root. */
+export function overridesPath(project, root, home) {
+    return join(storePath(project, root, home), 'overrides.yaml');
+}
+/** The file's added patterns, or the line that refuses it. One error, the first. */
+export function parseOverrides(text) {
+    try {
+        return { ok: true, profiles: profilesOf(parseYaml(text)) };
+    }
+    catch (error) {
+        if (error instanceof YamlError)
+            return { ok: false, errors: [{ line: error.line, message: error.message }] };
+        throw error;
+    }
+}
+/**
+ * Shipped rules stay first, and the added ones follow. The composer and the
+ * chrome are the shipped profile's own objects, so an override cannot retune
+ * them by merging.
+ */
+export function mergeScreen(base, added) {
+    const next = { ...base };
+    for (const name of DIALOG_STAGES) {
+        const extra = added.screen[name];
+        if (!extra)
+            continue;
+        const existing = base[name];
+        next[name] = { rules: [...(existing?.rules ?? []), ...extra.rules] };
+    }
+    return next;
+}
+const KEPT = new Set(['permission', 'trust', 'question']);
+const DIALOG = new Set(['unknown', 'trust', 'permission', 'question']);
+/**
+ * An added pattern may move a reading toward a dialog. It may not make a screen
+ * idle or unsent when the shipped profile does not, and it may not stop a
+ * shipped permission, trust or question pattern from matching.
+ */
+export function guardReading(shipped, merged) {
+    if (KEPT.has(shipped.kind))
+        return shipped;
+    if ((merged.kind === 'idle' || merged.kind === 'unsent') && merged.kind !== shipped.kind)
+        return shipped;
+    if (!DIALOG.has(merged.kind))
+        return shipped;
+    return merged;
+}
+/** The shipped reading, then the same window with this profile's added patterns, guarded. */
+export function classifyWith(cli, screen, profiles) {
+    if (screen === undefined)
+        return { kind: 'unknown' };
+    const base = screenData(cli);
+    if (!base)
+        return { kind: 'unknown' };
+    const lines = screen.split('\n');
+    const shipped = classifyData(base, lines);
+    const added = profiles.find((profile) => profile.cli === cli);
+    if (!added || DIALOG_STAGES.every((stage) => added.screen[stage] === undefined))
+        return shipped;
+    return guardReading(shipped, classifyData(mergeScreen(base, added), lines));
+}
+/** Shipped quota patterns, then the override's. The shipped ones are never dropped. */
+export function quotaWith(cli, profiles) {
+    const added = profiles.find((profile) => profile.cli === cli)?.quota ?? [];
+    return [...quotaFor(cli), ...added];
+}
+/** What `approve` records when the override file itself is the change. */
+export const OVERRIDE_CHANGED = '`overrides` changed';
+/** A stored copy that does not parse. The shipped profiles stay in force. */
+export const OVERRIDE_UNREADABLE = "the approved overrides can't be read";
+/** The override file's text, and why it was refused. A missing file is an empty text and no problem. */
+export function overrideFile(project, root, home) {
+    const path = overridesPath(project, root, home);
+    try {
+        const text = readFileSync(path, 'utf8');
+        const parsed = parseOverrides(text);
+        return { path, text, problems: parsed.ok ? [] : parsed.errors.map((problem) => overrideProblem(path, problem)) };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { path, text: null, problems: [] };
+        return { path, text: null, problems: [overrideProblem(path, { line: 0, message: "can't be read" })] };
+    }
+}
+/**
+ * The patterns in force for this project. Keyed on the project root, the same
+ * store as the team-file approval: another checkout of the same name has its
+ * own. No file, or a stored copy that cannot be read, leaves the shipped profiles.
+ * The live file is used only when it is the text `approve` recorded.
+ */
+export function overridesInForce(project, root, home) {
+    const record = readApproval(storePath(project, root, home));
+    const recorded = record !== null && Object.hasOwn(record.approval, 'overrides');
+    const stored = recorded ? record?.approval.overrides : undefined;
+    const approvedText = typeof stored === 'string' ? stored : null;
+    const live = overrideFile(project, root, home);
+    const differences = [];
+    const profiles = [];
+    if (approvedText !== null) {
+        const parsed = parseOverrides(approvedText);
+        if (parsed.ok)
+            profiles.push(...parsed.profiles);
+        else
+            differences.push(OVERRIDE_UNREADABLE);
+    }
+    else if (recorded && stored !== null && stored !== undefined) {
+        differences.push(OVERRIDE_UNREADABLE);
+    }
+    if (live.text !== approvedText) {
+        if (record === null) {
+            if (live.text !== null)
+                differences.push('the overrides were never approved');
+        }
+        else
+            differences.push(OVERRIDE_CHANGED);
+    }
+    return { profiles, differences, problems: live.problems };
+}
+export function overrideProblem(path, problem) {
+    return problem.line ? `${path}: line ${problem.line}: ${problem.message}` : `${path}: ${problem.message}`;
+}
+function profilesOf(root) {
+    const entries = mapping(root, 'an override file');
+    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', 'profiles']);
+    const profiles = required(entries, 'profiles', root.line);
+    const named = mapping(profiles.value, '"profiles"');
+    if (named.length === 0)
+        fail(profiles.line, '"profiles" must name a profile');
+    return named.map(profileOf);
+}
+function profileOf(entry) {
+    if (!profileFor(entry.key))
+        fail(entry.line, `unknown profile "${entry.key}"`);
+    const entries = mapping(entry.value, 'a profile override');
+    only(entries, ['screen', 'quota']);
+    const screen = optional(entries, 'screen');
+    const quota = optional(entries, 'quota');
+    if (!screen && !quota)
+        fail(entry.line, 'a profile override adds dialog patterns or quota patterns');
+    const stages = screen ? screenOf(screen.value) : {};
+    if (screen && Object.keys(stages).length === 0 && !quota) {
+        fail(screen.line, 'a profile override adds dialog patterns or quota patterns');
+    }
+    return { cli: entry.key, screen: stages, quota: quota ? quotaList(quota.value) : [] };
+}
+function screenOf(node) {
+    const entries = mapping(node, 'screen');
+    only(entries, DIALOG_STAGES);
+    const screen = {};
+    for (const entry of entries)
+        screen[entry.key] = { rules: addedRules(entry.value) };
+    return screen;
+}
+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/profile.d.ts

@@ -1,4 +1,5 @@
 import { type QuotaPattern } from './quota.ts';
+import { type YamlNode } from '../yaml.ts';
 /**
  * A launch profile: what `team` knows about one CLI, so a seat can't start
  * blocked. Keyed by the seat's `cli`.
@@ -53,6 +54,8 @@ export declare function profileFor(cli: string): Profile | null;
 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[];
+/** Quota patterns from a list already parsed. A bad pattern throws. */
+export declare function quotaList(node: YamlNode): 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;

package/dist/profiles/profile.js

@@ -61,6 +61,10 @@ export function quotaFor(cli) {
 export function quotaPatterns(text) {
     return quotaOf(parseYaml(text));
 }
+/** Quota patterns from a list already parsed. A bad pattern throws. */
+export function quotaList(node) {
+    return quotaOf(node);
+}
 /** 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;
@@ -84,7 +88,7 @@ function launchOf(root) {
     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]);
+    only(entries, ['format', 'cli', 'screen', 'screen_module', 'quota', ...LAUNCH_KEYS]);
     const cli = text(required(entries, 'cli', root.line), 'cli');
     required(entries, 'screen', root.line);
     const quotaEntry = optional(entries, 'quota');

package/dist/state.d.ts

@@ -1,6 +1,8 @@
 import type { StoredReading, StoredSpend } from './budgets/readings.ts';
 export type SeatState = {
     stage: 'launched' | 'named' | 'ready';
+    /** The CLI the seat was launched with: `down` stops it under it when the file renamed it. */
+    cli?: string;
     pane?: string;
     /** The herdr workspace, so a later command can close it without listing agents. */
     workspace?: string;

package/dist/status/compare.js

@@ -35,14 +35,17 @@ export function compare(team, session, state, live, now = new Date(), watch = te
             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));
+        // An agent sits in the workspace recorded for this name, under another name or under none.
+        // The display label is not a key: two seats may share it.
+        const stray = recorded?.workspace
+            ? live.agents.find((candidate) => !claimed.has(candidate.pane) && candidate.workspace === recorded.workspace
+                && !team.seats.some((other) => other.name === candidate.name))
+            : undefined;
         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'}`,
+                what: `${seat.name}: the agent in ${stray.pane} is ${stray.name ? `named "${stray.name}"` : 'unnamed'}`,
                 repair: herdrCommand(session, 'agent', 'rename', stray.pane, seat.name),
             });
             continue;

package/dist/store/store.d.ts

@@ -23,6 +23,11 @@ export interface Approval {
         path: string;
         hash: string;
     }>;
+    /**
+     * The override file as approved, or null when the owner approved there being
+     * none. Absent on a record written before the file existed.
+     */
+    overrides?: string | null;
 }
 export interface LedgerEntry {
     display: string;

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare function version(): string;

package/dist/version.js

@@ -0,0 +1,7 @@
+import { readFileSync } from 'node:fs';
+// The one place the CLI's version is read. `--version` prints it and `team init` pins the
+// schema URL's tag to it, so the URL can never name a release the CLI doesn't report.
+export function version() {
+    const text = readFileSync(new URL('../package.json', import.meta.url), 'utf8');
+    return JSON.parse(text).version;
+}

package/dist/watch/checks/budget.js

@@ -1,4 +1,4 @@
-import { verdict } from "../../budgets/readings.js";
+import { countedFor } from "../../budgets/readings.js";
 import { WINDOWS } from "../../profiles/quota.js";
 import { reported } from "../check.js";
 export const budget = {
@@ -40,63 +40,59 @@ export const budget = {
     },
 };
 /**
- * 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.
+ * The account's figures this pass, per window, from the first source that has one for it (§ 4.3,
+ * § 5) — the same rule `countedFor` applies for the launch gate and the table, so the three can't
+ * drift apart. 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. A spend check is one number and no window, fresh by § 5.
  */
 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 };
+    const outcome = team.outcomes.find((one) => one.account === name);
+    const read = outcome && outcome.state === 'read' ? outcome : null;
+    if (read && read.reading.kind === 'spend' && account.sources.includes('check') && now - read.reading.at < staleMs) {
+        return { kind: 'spend', amount: read.reading.amount, currency: read.reading.currency };
+    }
+    const windows = [];
+    let seen = false;
+    for (const window of WINDOWS) {
+        // The readings of one window, by source: the screen readings the core folded in, and the
+        // check's when this pass's outcome carries that window (§ 5).
+        const screen = team.readings.filter((reading) => reading.account === name && reading.window === window && reading.source === 'status_line');
+        const checks = read && read.reading.kind === 'subscription'
+            ? read.reading.windows
+                .filter((one) => one.window === window)
+                .map((one) => ({
+                account: name,
+                window: one.window,
+                left: one.left,
+                used: one.used,
+                changedAt: one.at,
+                resetsAt: one.resetsAt,
+                seat: null,
+                source: 'check',
+                confirmed: true,
+            }))
+            : [];
+        if (!screen.length && !checks.length)
+            continue;
+        const result = countedFor(account.sources, screen, checks, now, staleMs, account.reserve);
+        if (result.kind === 'unknown')
+            continue;
+        if (result.kind === 'unconfirmed') {
+            seen = true;
             continue;
         }
-        const groups = new Map();
-        for (const reading of team.readings) {
-            if (reading.account !== name)
-                continue;
-            // The check readings of the same account live in this slot too: this source reads screens.
-            if (reading.source !== 'status_line')
-                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;
+        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';
     return null;
 }
 /** The account reads unknown while a seat that spends it is running: the operator can stop it. */

package/dist/watch/dialect.d.ts

@@ -1,5 +1,10 @@
 export declare class DialectError extends Error {
     constructor(message: string);
 }
-/** Compile one pattern. `ignoreCase` is the stage's flag, never an inline `(?i)`. */
+/** Compile one pattern. `ignoreCase` is the stage's flag, never an inline `(?i)`. The
+ *  flag is an ASCII fold: each ASCII letter of the pattern becomes its two-letter class,
+ *  `[Aa]`, exactly what the hand-spelled patterns wrote out. Folding that lives in the
+ *  pattern's own text travels with it — the shared dialect's other engine compiles the
+ *  same source — and the engine's wider Unicode folding (a long s for s, the Kelvin
+ *  sign for k) never applies. */
 export declare function compilePattern(source: string, ignoreCase?: boolean): RegExp;

package/dist/watch/dialect.js

@@ -20,25 +20,31 @@ export class DialectError extends Error {
         this.name = 'DialectError';
     }
 }
-/** Compile one pattern. `ignoreCase` is the stage's flag, never an inline `(?i)`. */
+/** Compile one pattern. `ignoreCase` is the stage's flag, never an inline `(?i)`. The
+ *  flag is an ASCII fold: each ASCII letter of the pattern becomes its two-letter class,
+ *  `[Aa]`, exactly what the hand-spelled patterns wrote out. Folding that lives in the
+ *  pattern's own text travels with it — the shared dialect's other engine compiles the
+ *  same source — and the engine's wider Unicode folding (a long s for s, the Kelvin
+ *  sign for k) never applies. */
 export function compilePattern(source, ignoreCase = false) {
     if (source.length === 0)
         throw new DialectError('a pattern is empty');
     if (source.length > MAX_PATTERN)
         throw new DialectError(`a pattern is longer than ${MAX_PATTERN} characters`);
     refuseSpelling(source);
-    const parser = new Parser(source);
+    const parser = new Parser(source, ignoreCase);
     const body = parser.parseAlt();
     if (!parser.done())
         throw new DialectError('a pattern has an extra ")"');
-    const flags = ignoreCase ? 'iu' : 'u';
-    return new RegExp(body.source, flags);
+    return new RegExp(body.source, 'u');
 }
 class Parser {
     at = 0;
     source;
-    constructor(source) {
+    ignoreCase;
+    constructor(source, ignoreCase) {
         this.source = source;
+        this.ignoreCase = ignoreCase;
     }
     done() {
         return this.at >= this.source.length;
@@ -114,7 +120,15 @@ class Parser {
         if (ch === ')')
             throw new DialectError('a pattern has an extra ")"');
         const cp = this.readCodePoint();
-        return this.leaf(escapeLiteral(cp), true);
+        return this.leaf(this.fold(cp), true);
+    }
+    // A literal under ignore_case: an ASCII letter becomes its two-letter class, `[Aa]`,
+    // as the hand-spelled patterns wrote it; everything else stands as itself.
+    fold(cp) {
+        const other = asciiCaseSwapped(cp);
+        if (!this.ignoreCase || other === null)
+            return escapeLiteral(cp);
+        return emitClass(false, [cp, other]);
     }
     parseGroup() {
         this.expect('(');
@@ -213,7 +227,7 @@ class Parser {
                 parts.push({ kind: 'char', cp: this.readCodePoint() });
         }
         this.expect(']');
-        return classSource(negated, foldRanges(parts));
+        return classSource(negated, foldRanges(parts, this.ignoreCase));
     }
     parseClassEscape() {
         this.expect('\\');
@@ -318,7 +332,9 @@ function refuseSpelling(source) {
 }
 // A class is a finite set, except a complement shorthand (`\S`, `\D`, `\W`), whose
 // negation brings it back to a finite set. `[^\S\n]` is the whitespace set without
-// a newline, which is what the working-line pattern relies on.
+// a newline, which is what the working-line pattern relies on. A positive class that
+// mixed one with other members would compile to a class nobody wrote (`[\D0-9]` is
+// everything), so it is refused rather than rewritten.
 function classSource(negated, parts) {
     const positive = new Set();
     const complements = [];
@@ -333,13 +349,16 @@ function classSource(negated, parts) {
     }
     if (complements.length === 0)
         return emitClass(negated, [...positive]);
+    if (!negated && positive.size > 0) {
+        throw new DialectError('a class cannot mix a complement shorthand with other members: negate the class, or write the shorthand alone');
+    }
     let inter = new Set(complements[0]);
     for (const extra of complements.slice(1))
         inter = new Set([...inter].filter((cp) => extra.includes(cp)));
     const remaining = [...inter].filter((cp) => !positive.has(cp));
     return emitClass(!negated, remaining);
 }
-function foldRanges(parts) {
+function foldRanges(parts, ignoreCase = false) {
     const out = [];
     for (let i = 0; i < parts.length; i++) {
         const part = parts[i];
@@ -358,7 +377,38 @@ function foldRanges(parts) {
         else
             out.push(part);
     }
-    return out;
+    if (!ignoreCase)
+        return out;
+    // Under ignore_case every ASCII letter of the class carries its other case too, as the
+    // letter classes of the hand-spelled patterns did. A complement shorthand (`\S` and
+    // the like) is written as its own set: its members are not the pattern's letters.
+    return out.map((part) => {
+        if (part.kind === 'char') {
+            const other = asciiCaseSwapped(part.cp);
+            return other === null ? part : { kind: 'chars', cps: [part.cp, other] };
+        }
+        if (part.kind === 'chars') {
+            const cps = [...part.cps];
+            for (const cp of part.cps) {
+                const other = asciiCaseSwapped(cp);
+                if (other !== null)
+                    cps.push(other);
+            }
+            return { kind: 'chars', cps };
+        }
+        return part;
+    });
+}
+// The other case of an ASCII letter, or null for every other character: the whole of a
+// pattern's ignore_case fold. The engine's Unicode folding — a long s (U+017F) for s,
+// the Kelvin sign (U+212A) for k — is deliberately not applied; the hand-spelled
+// classes this flag replaced never applied it.
+function asciiCaseSwapped(cp) {
+    if (cp >= 0x41 && cp <= 0x5a)
+        return cp + 0x20;
+    if (cp >= 0x61 && cp <= 0x7a)
+        return cp - 0x20;
+    return null;
 }
 function emitClass(negated, cps) {
     const sorted = [...new Set(cps)].sort((a, b) => a - b);
@@ -395,7 +445,7 @@ function classChar(cp) {
     if (cp === 0x2d || cp === 0x5d || cp === 0x5e || cp === 0x5c)
         return `\\${String.fromCodePoint(cp)}`;
     if (cp < 0x20 || cp > 0x7e)
-        return `\\u${cp.toString(16).padStart(4, '0')}`;
+        return codePointEscape(cp);
     return String.fromCodePoint(cp);
 }
 function escapeLiteral(cp) {
@@ -403,9 +453,15 @@ function escapeLiteral(cp) {
     if ('\\.^$|?*+()[]{}'.includes(ch))
         return `\\${ch}`;
     if (cp < 0x20 || cp > 0x7e)
-        return `\\u${cp.toString(16).padStart(4, '0')}`;
+        return codePointEscape(cp);
     return ch;
 }
+// A code point above U+FFFF needs the "\u{…}" form, which every pattern can carry: the "u"
+// flag is always set (compilePattern). A four-digit escape cannot spell it — the digits
+// would spill into the following character.
+function codePointEscape(cp) {
+    return cp > 0xffff ? `\\u{${cp.toString(16)}}` : `\\u${cp.toString(16).padStart(4, '0')}`;
+}
 function seqSource(atoms) {
     return atoms.map((atom) => atom.source).join('');
 }

package/dist/watch/pass.d.ts

@@ -1,10 +1,12 @@
 import { type Seen } from '../budgets/readings.ts';
 import type { CheckOutcome } from '../budgets/run.ts';
 import type { TeamFile } from '../file/types.ts';
+import { type QuotaPattern } from '../profiles/quota.ts';
 import type { SessionState } from '../state.ts';
 import type { Live } from '../status/compare.ts';
 import { type Report, type SeatCheck, type SeatHistory, type TeamCheck } from './check.ts';
 import type { Machine } from './machine.ts';
+import { type Screen } from './screen.ts';
 export type Memory = {
     history: Record<string, SeatHistory>;
     slots: Record<string, unknown>;
@@ -39,5 +41,10 @@ export type PassInput = {
     outcomes?: readonly CheckOutcome[];
     budgets?: TeamFile['budgets'];
     readings?: readonly Seen[];
+    foreground?: Readonly<Record<string, readonly string[] | null>>;
+    /** Screen readings with the approved overrides applied. The shipped profiles, when omitted. */
+    readScreen?: (cli: string, screen: string | undefined) => Screen;
+    /** Quota patterns in force, shipped plus the approved override. The shipped list, when omitted. */
+    quotaFor?: (cli: string) => readonly QuotaPattern[];
 };
-export declare function pass({ team, state, live, machine, now, memory, approval, watch, outcomes, budgets, readings: stored, }: PassInput): PassResult;
+export declare function pass({ team, state, live, machine, now, memory, approval, watch, outcomes, budgets, readings: stored, foreground, readScreen: read, quotaFor: patternsOf, }: PassInput): PassResult;