toolroll 0.9.104 → 0.9.105

package/dist/agent-pulse.d.ts

@@ -1,43 +0,0 @@
-import { type StatusIngest, type StatusLine } from "./agent-board.js";
-import { type BaseTreeEntry } from "./peek.js";
-import type { Store } from "./store.js";
-/** The whole file may grow this far; past it, nothing more is read. */
-export declare const STATUS_FILE_CAP: number;
-/** One status line, strictly: a known status and its fields, or null. */
-export declare function parseStatusLine(line: string): StatusLine | null;
-export type StatusRead = {
-    ok: true;
-    read: StatusIngest;
-} | {
-    ok: false;
-    reason: "missing" | "replaced" | "unreadable" | "full";
-};
-/** The complete lines after `from`, and where the next read starts. */
-export declare function readStatusFile(path: string, from: number): StatusRead;
-/** Create the attempt's empty status file (created here, never adopted); null when it cannot be. */
-export declare function openStatusFile(worktree: string, name: string): string | null;
-export declare function removeStatusFile(path: string | null): void;
-/** The brief's few lines: where to write, what each status means, and how a reply arrives. */
-export declare function statusBrief(name: string, steerFolder: string | null): string;
-type BaseEntries = readonly BaseTreeEntry[];
-/** The run's verified base snapshot, as the live peek reads it; null when it was not captured cleanly. */
-export declare function baseEntriesOf(store: Store, root: string, run: number): BaseEntries | null;
-/** What a look at the checkout found: changed, deleted and new files together; null when it could not look. */
-export declare function changedFileCount(worktree: string, base: BaseEntries): Promise<number | null>;
-export type AgentPulseState = {
-    run: number;
-    attemptKey: string;
-    root: string;
-    worktree: string;
-    /** The status file, or null when this attempt has none. */
-    status: string | null;
-    base: BaseEntries | null | undefined;
-    looking: boolean;
-};
-/**
- * One beat for the board. Each part is its own fail-soft step: a status file
- * that cannot be read, or a checkout that cannot be looked at, costs only
- * its own line on the board, never the build.
- */
-export declare function pulseAgentBoard(store: Store, state: AgentPulseState, now: Date): void;
-export {};

package/dist/agent-state-words.d.ts

@@ -1,19 +0,0 @@
-/**
- * The agent states' words, tones and counts (docs/plans/agents-cockpit.md §1), with nothing the browser can't load:
- * agent-state.ts derives the states; the console's pages and the sidebar say them with these.
- */
-/** The display states, strongest first: a roll-up takes the first one any member has. */
-export declare const DISPLAY_STATES: readonly ["needs-you", "failed", "stuck", "paused", "working", "waiting", "done", "idle"];
-export type DisplayState = (typeof DISPLAY_STATES)[number];
-export declare const STATE_WORDS: Record<DisplayState, string>;
-/** For someone who may not act on it: the obligation is still there, and still counts. */
-export declare const NEEDS_SOMEONE = "Needs someone";
-/** Each state's tone, for the console's one palette (attention, problem, live, ready, done, muted). */
-export declare const STATE_TONE: Record<DisplayState, "attention" | "problem" | "live" | "ready" | "done" | "muted">;
-export type StateCounts = Record<DisplayState, number>;
-export declare const NO_COUNTS: StateCounts;
-/** The strongest state among counts, and the counts themselves. Nothing counted is idle. */
-export declare function rollUp(counts: StateCounts): {
-    state: DisplayState;
-    counts: StateCounts;
-};

package/dist/agent-state.d.ts

@@ -1,65 +0,0 @@
-/**
- * One set of agent states (docs/plans/agents-cockpit.md §1): what a person sees at a glance for an attempt, a task, a
- * flow or a project. A display state is derived from four separate facts — what the agent is doing, how it ended, what
- * someone must do, and whether this person has seen it — and never stored as one. Looking clears only `done`: a failure,
- * an approval or a result to accept stays until it is dealt with. The words and colours of each state live here only.
- */
-import { type AgentFacts } from "./agents-board.js";
-import type { Store } from "./store.js";
-import type { WorkSummaryAccess } from "./work-summary.js";
-import { type DisplayState, type StateCounts } from "./agent-state-words.js";
-export { DISPLAY_STATES, NEEDS_SOMEONE, NO_COUNTS, rollUp, STATE_TONE, STATE_WORDS, type DisplayState, type StateCounts } from "./agent-state-words.js";
-/** What an attempt is doing. */
-export type Activity = "queued" | "waiting" | "running" | "stuck" | "pausing" | "paused" | "stopping" | "stopped" | "finished";
-/** How it ended (checks-failed: built, but the project's checks failed on its result). */
-export type Outcome = "none" | "built" | "no-change" | "failed" | "checks-failed";
-export type StateFacts = {
-    activity: Activity;
-    outcome: Outcome;
-    /** Someone must act: a question, a plan or scope to approve, a decision, a result to accept, a sign-in. */
-    obligation: boolean;
-    /** This person hasn't seen its finished version. */
-    unread: boolean;
-    /** A newer attempt of the same task is running: an older failure no longer leads. */
-    newerRunning?: boolean;
-};
-/** The one glance a set of facts gives. */
-export declare function displayStateOf(facts: StateFacts): DisplayState;
-/** The four facts of one build attempt, from what the Agents board reads (agents-board.ts): its own record only — a
- * stopped or cancelled attempt is not a failure, a parked one is a decision only while it is unanswered and its task is open, and one being
- * repaired is at work, not stuck. */
-export declare function factsOfAttempt(facts: AgentFacts, activityAt: string | null, paused: boolean, now: Date, decisionOpen?: boolean): StateFacts;
-/** One task family's strongest state in a project, and its one line when an agent is at work on it. */
-export type FamilyState = {
-    rootId: string;
-    state: DisplayState;
-    line: string | null;
-    /** What it needs a person for, as an identity (task, question, hold, result…), and the agent it is about. */
-    ask?: {
-        version: string;
-        run: number | null;
-        at: string;
-    };
-};
-export type ProjectState = {
-    repo: string | null;
-    state: DisplayState;
-    counts: StateCounts;
-    /** Each family that counted, strongest first (flow cards count without one). */
-    families: FamilyState[];
-    /** Flow cards waiting at a person's decision, by identity (newest first, at most FLOW_ASKS per flow). */
-    flowAsks: {
-        card: number;
-        stage: string;
-        entry: number;
-        at: string;
-    }[];
-};
-/**
- * A project's states for one person: complete counts over every task family they may see, with the Tasks list's own
- * admission (never a page or the board's rows). Each family counts once for what it needs or how it ended; each live
- * attempt counts once for what it is doing (working, stuck, paused); an attempt that itself needs a person (crashed,
- * asking) counts there unless its family already does. Flow cards at a person's decision count too. Every visible
- * project is present, idle when nothing counts. Its cost is the Tasks list's own read, plus open runs.
- */
-export declare function projectStates(store: Store, access: WorkSummaryAccess, account: string, now: Date, root?: string, flowRepos?: readonly string[]): ProjectState[];

package/dist/agent-turns.d.ts

@@ -1,52 +0,0 @@
-/**
- * Live turn states from the agent's own output stream (Agents board): no
- * hooks, no model. The builder already parses Claude stream-json and Codex
- * --json events for the live log; this reads the same events for three facts:
- *
- * - busy: a session, turn or tool call started (or the agent is mid-turn);
- * - idle: the turn's result arrived (success or not, it is a result);
- * - crashed: the process ended while a turn was still open — no result.
- *
- * Each change is recorded once, under the run's attempt key
- * (agent-board.ts decides whether it may move the current snapshot).
- * The same events say which tool calls are open — a Claude tool_use until its
- * tool_result, a Codex command or tool item until it completes — so a long,
- * silent command is not mistaken for a stuck agent. Only those known shapes
- * count, at most OPEN_TOOLS_CAP at once, and a turn result or the process
- * ending closes them all.
- * Fail-soft: a recording that throws never touches the build.
- */
-import type { AgentTurn, ToolKind } from "./agent-board.js";
-type Observer = {
-    observe(event: Record<string, unknown>): void;
-    close(): void;
-};
-/** What one stream event says about the turn; null when it says nothing. */
-export declare function turnSignalOf(event: Record<string, unknown>): Exclude<AgentTurn, "crashed"> | null;
-/** At most this many open calls are tracked; past it, a new one is not (the oldest still holds the long threshold). */
-export declare const OPEN_TOOLS_CAP = 64;
-/** The tool calls one stream event opens and closes, by id: only Claude's and Codex's known shapes. */
-export declare function toolCallsOf(event: Record<string, unknown>): {
-    opened: {
-        id: string;
-        kind: ToolKind;
-    }[];
-    closed: string[];
-};
-export type OpenTool = {
-    kind: ToolKind;
-    at: Date;
-} | null;
-export type TurnRecorder = Observer & {
-    /** The agent process is gone: a turn still open ended without its result. */
-    ended(): void;
-    /** The last state recorded (null: nothing yet). */
-    readonly state: AgentTurn | null;
-};
-/**
- * Watch a run's stream for turn changes, beside its live log (which may be
- * null), and for the oldest tool call still open (recordTool hears it move;
- * a turn that leaves busy closes them all, and its own record clears them).
- */
-export declare function withAgentTurns(inner: Observer | null, record: (state: AgentTurn, at: Date) => void, clock: () => Date, recordTool?: (open: OpenTool, at: Date) => void): TurnRecorder;
-export {};

package/dist/agentconfig.d.ts

@@ -1,191 +0,0 @@
-/**
- * Phase-agent resolution: which provider and model a phase runs on, layer
- * by layer, with the layers written down (Codex provider review, Q8).
- *
- *   pinned task agent  — stamped by a fire transaction; NOTHING overrides it
- *   explicit flags     — this pass's operator, per field
- *   project override   — phase_config row scoped to the canonical repo
- *   installation       — phase_config row scoped 'installation'
- *   review inheritance — when review is unset, the planner's complete pair
- *   default            — claude, harness default model
- *
- * Config rows are COMPLETE pairs (provider required, model optional), so a
- * partial override cannot marry a codex model to an inherited claude
- * provider. Flags are per-field with one stated rule: `--model` alone
- * rides whatever provider resolves; `--provider` alone runs that
- * provider's default model — a lower layer's model never crosses onto a
- * flag-chosen provider it was not written for.
- *
- * The resolved pair is validated before anything is claimed or spent, and
- * the caller snapshots it into the run row.
- */
-import { type AgentSpec, type Phase } from "./provider.js";
-import type { Store, TaskRef } from "./store.js";
-import { type ExecutionProfile, type UnattendedPermissionMode } from "./scope.js";
-import { type ExactSpec, type PhaseRoute, type RouteCandidates } from "./phase-routing.js";
-import type { AcceptanceCriterion } from "./scope.js";
-export declare const INSTALLATION_SCOPE = "installation";
-export type PhaseFlags = {
-    provider?: string | undefined;
-    model?: string | undefined;
-};
-export type Resolution = {
-    ok: true;
-    spec: AgentSpec;
-    source: "pinned" | "flag" | "project" | "installation" | "default";
-} | {
-    ok: false;
-    problem: string;
-};
-export declare function resolvePhaseAgent(store: Store, phase: Phase, repo: string | null, flags: PhaseFlags, 
-/** The task being dispatched, when one is — its pin is authoritative. */
-ref?: Pick<TaskRef, "agentProvider" | "agentModel">): Resolution;
-/**
- * The FILING resolver (foundations findings 13/15/19): the execution
- * profile a scope stores, resolved once, exactly, at filing. The model is
- * the exact string the argv will carry — the harness-default road refuses
- * here rather than floating (ruling 10). Repair precedence: the
- * --repair-model flag, else the repair phase-config row's MODEL (its
- * provider must equal the build provider — cross-provider repair does not
- * exist), else the literal "inherit". Callers that file scopes SAVE an
- * unresolved state on refusal (finding 19) — this function only says why.
- */
-export type ProfileResolution = {
-    ok: true;
-    profile: ExecutionProfile;
-    provenance: {
-        resolvedFrom: string;
-        repairFrom: string;
-    };
-} | {
-    ok: false;
-    reason: "unknown-provider" | "no-model" | "repair-provider-mismatch";
-    problem: string;
-};
-export declare function resolveScopeProfile(store: Store, repo: string | null, ref: Pick<TaskRef, "agentProvider" | "agentModel"> | undefined, flags: PhaseFlags & {
-    repairModel?: string | undefined;
-    permissionMode?: UnattendedPermissionMode | undefined;
-}, platform?: NodeJS.Platform): ProfileResolution;
-/**
- * The two candidate tiers the routing policy chooses between, per phase,
- * read from configuration ONLY — never inferred from a model's name:
- *
- *   routine — the ordinary resolution above (project > installation,
- *             review inheriting the planner's pair), i.e. exactly the
- *             agent every pre-v47 scope resolved to — but EXACT: a phase
- *             whose resolution has no model id cannot be a candidate,
- *             because an approval binds exact routing. Repair is the one
- *             phase with no routine candidate of its own when nothing is
- *             configured: it inherits the build leg (repairs resume the
- *             builder's session), and the policy says so.
- *   strong  — the operator's named strong row (`config set <phase> --tier
- *             strong …`), project over installation, review inheriting the
- *             plan's strong row when it has none of its own; null when
- *             nothing is configured, and the route then SAYS so.
- *
- * A misconfigured row — unknown provider, missing model, argv-unsafe
- * model — REFUSES with the words to fix it; the caller files the scope
- * unresolved with them. Nothing is skipped or guessed.
- */
-export type CandidatesResolution = {
-    ok: true;
-    candidates: RouteCandidates;
-} | {
-    ok: false;
-    phase: Phase;
-    problem: string;
-};
-export declare function resolveRouteCandidates(store: Store, repo: string | null, pins?: {
-    plan?: ExactSpec | null;
-    build?: ExactSpec | null;
-}): CandidatesResolution;
-/** A task's pinned pair as an EXACT spec, or the words for why it cannot
- * route: a pin with no model id binds nothing exact. */
-export declare function exactPinOf(provider: string | null, model: string | null, phase: "plan" | "build"): {
-    ok: true;
-    pin: ExactSpec | null;
-} | {
-    ok: false;
-    problem: string;
-};
-/**
- * THE ROUTE A TASK RUNS UNDER, for dispatch and every surface:
- *
- *   approved   — the sealed route when the approval stands (authoritative;
- *                mutable configuration never rewrites it);
- *   proposed   — the WORKING proposed route the next approval would seal;
- *   live       — no scope yet (a plan request): a live recommendation from
- *                the task's own risk, overrides, and pins over today's
- *                configuration;
- *   legacy     — a row PROVEN to predate v47 (no route era): its sealed
- *                profile alone governs the build; plan and review resolve
- *                from configuration at run time, and the surfaces say so;
- *   unreadable — a routed row whose route data is missing, malformed, or
- *                does not verify against its approval, or a task whose
- *                configuration cannot make an exact route: FAIL CLOSED,
- *                with the words. Nothing dispatches on it.
- *
- * `source` says which, so a surface never presents a live recommendation
- * as a sealed term and a runner never runs a legacy road on a routed row.
- */
-export type TaskRoute = {
-    kind: "route";
-    route: PhaseRoute;
-    source: "approved" | "proposed" | "live";
-} | {
-    kind: "legacy";
-    profile: ExecutionProfile;
-    approved: boolean;
-} | {
-    kind: "unreadable";
-    problem: string;
-};
-export declare function routeOfTask(store: Store, taskId: string, ref: TaskRef | null, now: Date): TaskRoute | null;
-/**
- * THE EXACT AUTHORITY a project's configuration names today: the four-role
- * route work would run under, and the execution profile that restates its
- * build and repair legs exactly. The rubric's evidence needs, the
- * installation's quality default, and the repository's publication
- * authority are the other inputs. A configuration that cannot make an
- * exact, runnable route answers with the words (the recipes preview shows
- * them before any work is created).
- */
-export type AgentAuthority = {
-    ok: true;
-    route: PhaseRoute;
-    profile: ExecutionProfile;
-} | {
-    ok: false;
-    problem: string;
-};
-export declare function resolveAgentAuthority(store: Store, repo: string, acceptance: readonly AcceptanceCriterion[], now: Date): AgentAuthority;
-/** One agent a surface shows for one role: an exact pair, where it comes
- * from, whether it is the role's current leg, and whether it can be
- * CHOSEN — only a pair the active configuration names for this role is
- * selectable; a current leg the configuration no longer names is shown
- * for what runs today and nothing more. */
-export type AgentChoice = ExactSpec & {
-    source: string;
-    current: boolean;
-    selectable: boolean;
-};
-/**
- * THE ROLE'S CONFIGURED CHOICES (v48), simple and role-specific: for each
- * role, exactly the exact pairs the active configuration names FOR THAT
- * ROLE — its everyday agent and its strong agent — and nothing borrowed
- * from another role. Repair runs only the build leg's provider (repairs
- * resume the builder's session): its choices are the configured repair
- * rows on that provider plus the build role's own configured agents on
- * it, so an operator can keep repairs on the builder without naming a
- * repair row. Gemini never reviews. Nothing is typed free-hand and
- * nothing unconfigured is selectable: an approval binds an exact agent
- * the operator named once, in configuration.
- *
- * The role's CURRENT leg rides along marked `current`; when the
- * configuration no longer names it (a stale override, a routine's pin)
- * it is display-only — `selectable: false` — so a surface can say what
- * runs today without offering to re-pick it. Empty when the
- * configuration cannot make exact candidates at all; the surface then
- * says so instead of guessing.
- */
-export declare function agentChoicesFor(store: Store, repo: string | null, route: PhaseRoute | null): Record<Phase, AgentChoice[]>;

package/dist/agents-board.d.ts

@@ -1,145 +0,0 @@
-/**
- * The Agents board's projection (one place to check on running agents): each
- * task's newest build attempt from the last day, in the viewer's admitted
- * projects, grouped Needs you, Working, Stuck, Done (not viewed yet), Idle.
- * A protocol repair never takes the row: while one runs, its parent's row says
- * "Fixing the handoff" and keeps the parent's transcript, changes and link.
- * Saved facts only (agent-board.ts, the run, its activity and its sealed diff
- * stats); nothing here verifies evidence or grants an action.
- */
-import { type AgentTurn, type ToolKind } from "./agent-board.js";
-import type { AgentGroupKey, AgentLaneWindow, BrowserAgentLanes, BrowserAgentRow } from "./browser-workspace.js";
-import type { Store } from "./store.js";
-export declare const AGENT_GROUPS: readonly {
-    key: AgentGroupKey;
-    label: string;
-}[];
-export type AgentFacts = {
-    runId: number;
-    taskRef: number;
-    taskId: string;
-    title: string;
-    repo: string | null;
-    provider: string;
-    runner: string;
-    outcome: string | null;
-    reason: string | null;
-    startedAt: string;
-    finishedAt: string | null;
-    legacy: boolean;
-    taskState: string;
-    turn: AgentTurn | null;
-    stateAt: string | null;
-    transcriptAt: string | null;
-    stuckAt: string | null;
-    said: string | null;
-    saidNote: string | null;
-    saidAt: string | null;
-    diffFiles: number | null;
-    toolKind: ToolKind | null;
-    toolAt: string | null;
-    phase: string | null;
-    /** The note the board shows once the agent asked past the questions cap. */
-    questionNote: string | null;
-    /** A protocol repair of this attempt is running now. */
-    repairing: boolean;
-    question: {
-        id: number;
-        key: string;
-        text: string;
-    } | null;
-    seen: boolean;
-};
-/**
- * The board's candidate builds, through the partial indexes (agent_board_open, agent_board_recent): open ones and
- * those finished since $kept, one per task (its newest), never a scan of every run. A candidate a newer build of the
- * same task has replaced is dropped by an indexed probe, so the row is still the task's newest build.
- */
-export declare const BOARD_CANDIDATES = "WITH candidate AS (\n    SELECT task_ref, id FROM run WHERE role = 'builder' AND outcome IS NULL\n    UNION ALL\n    SELECT task_ref, id FROM run WHERE role = 'builder' AND outcome IS NOT NULL AND finished_at >= $kept\n  ), newest AS (SELECT task_ref, MAX(id) AS id FROM candidate GROUP BY task_ref)";
-/** The board's candidate attempts: each task's newest build, open or recently finished, in the admitted projects. */
-export declare function agentFacts(store: Store, now: Date, access: {
-    repos: readonly string[] | null;
-}, account: string): AgentFacts[];
-/** The board's query, exported for its query-plan test. */
-export declare function agentFactsSql(): string;
-export declare function agentFactsFor(store: Store, run: number, access: {
-    repos: readonly string[] | null;
-}, account: string): AgentFacts | null;
-/** Where an attempt sits on the board, and its one state word. Stuck is worked out from the facts now, so fresh
- * transcript or activity clears it at once (the pulse's saved mark only tells open boards it crossed). */
-export declare function agentGroupOf(facts: AgentFacts, activityAt: string | null, now: Date): {
-    group: AgentGroupKey;
-    label: string;
-};
-type DiffSummary = {
-    fileCount: number;
-    additions: number;
-    deletions: number;
-    files: {
-        path: string;
-        additions: number | null;
-        deletions: number | null;
-    }[];
-};
-/** A finished attempt's sealed diff stats (cached by artifact: sealed bytes never change). */
-export declare function sealedDiffOf(store: Store, root: string | undefined, run: number): DiffSummary | null;
-/** A row's diff size: the sealed stats once finished, the pulse's count while it runs. */
-export declare function diffWords(facts: AgentFacts, diff: DiffSummary | null): string | null;
-/** One board row. */
-export declare function agentRowOf(store: Store, facts: AgentFacts, now: Date, root?: string): BrowserAgentRow;
-/** The whole board: groups in order, rows newest first within each; empty groups dropped. */
-export declare function agentsBoardOf(store: Store, now: Date, access: {
-    repos: readonly string[] | null;
-}, account: string, root?: string): {
-    key: AgentGroupKey;
-    label: string;
-    rows: BrowserAgentRow[];
-}[];
-/** A board fingerprint for one exact build: what its open view shows moved, its repairs included. */
-export declare function agentRunFingerprint(store: Store, run: number): string | null;
-/** The timeline's windows, all rolling (so no server time zone decides what "today" means); two hours by default. */
-export declare const LANE_WINDOWS: readonly {
-    key: AgentLaneWindow;
-    label: string;
-}[];
-/** Rows the timeline shows: twenty running tasks read as twelve rows and a count, not a wall. */
-export declare const LANE_ROWS = 12;
-export declare function laneWindowOf(value: string | null): AgentLaneWindow;
-export declare function laneSinceOf(window: AgentLaneWindow, now: Date): Date;
-/** The window's tasks, one row each with whether a run is live and when it was last active, newest activity first,
- * and the total and running counts over all of them. The candidates come from bounded index ranges (run_started;
- * work_unfinished and agent_board_recent, named so SQLite never walks every run) and drive the join (CROSS JOIN), so no
- * task's history is walked; the admitted projects only. */
-export declare function agentLanesSql(): string;
-/** Segments one row keeps: its newest runs, so a task retried all day stays one readable row. */
-export declare const LANE_SEGMENTS = 40;
-/** One chosen task's live runs: all of them, through work_unfinished, so no cap can hide one. */
-export declare function laneLiveRunsSql(): string;
-/** Rows one task's lookups read at most, newest first: a task with thousands of runs costs the same as one with a few. */
-export declare const LANE_TASK_READ = 2000;
-/** One chosen task's runs that finished in the window: a seek on its own runs from its first finished run in the
- * window (lead_status_task_run), reading at most LANE_TASK_READ of its newest runs; the newest LANE_SEGMENTS. */
-export declare function laneRunsSql(): string;
-/** A task's newest build, whenever it ran, among its newest 500 runs: the row's state comes from it even when it
- * finished before the window. A task with more runs than that since its last build reads as planning or idle. */
-export declare function laneNewestBuildSql(): string;
-/** The timeline: one row per task that ran in the window, running ones first, then the most recently active, the
- * first LANE_ROWS of them; the counts cover every task in the window. A row's state is worked out from its own
- * newest build as the board would (planning while only a planner runs, otherwise idle). With nothing in the window but something in the last day,
- * the timeline stays (empty) so its window choice does too; with nothing in a day it is null. */
-export declare function agentLanesOf(store: Store, now: Date, access: {
-    repos: readonly string[] | null;
-}, account: string, window: AgentLaneWindow, path?: string): BrowserAgentLanes | null;
-/**
- * The Agents list's every live agent, not only builds (UI revamp wave B): the build board's groups, with each running
- * planner, scout and reviewer in the admitted projects added under Working (or Needs you when it asks). Reads the
- * open leases only (store.liveRuns), then each run through the same admitted read the opened view uses.
- */
-export declare function agentsListOf(store: Store, now: Date, access: {
-    repos: readonly string[] | null;
-}, account: string, root?: string): {
-    key: AgentGroupKey;
-    label: string;
-    rows: BrowserAgentRow[];
-}[];
-export {};

package/dist/agents-live.d.ts

@@ -1,31 +0,0 @@
-import { type AgentsLiveRun, type Store } from "./store.js";
-/** An ended agent stays on the grid this long, then leaves (it remains on the List). */
-export declare const LIVE_ENDED_KEEP_MS: number;
-export type AgentLiveState = "working" | "needs-you" | "done" | "failed" | "stopped" | "parked";
-export type AgentLiveTile = {
-    runId: number;
-    role: AgentsLiveRun["role"];
-    taskId: string;
-    title: string;
-    project: string | null;
-    agent: string;
-    model: string | null;
-    startedAt: string;
-    endedAt: string | null;
-    state: AgentLiveState;
-    /** Why it needs you: it has been quiet (the board's Stuck rule) or it asked a question. */
-    why: "quiet" | "question" | null;
-    /** Since when it has been quiet, when that is why. */
-    quietSince: string | null;
-    /** Its output is on this computer (another runner's can't be read here). */
-    local: boolean;
-    /** A repair's build: the tile it nests under. */
-    parentRun: number | null;
-    /** The task's own page, for a task this console keeps (an outside tracker's task has none here). */
-    taskHref: string | null;
-};
-/** The grid's tiles for one viewer: `canSee` is the caller's proof (ceiling and account access) for each run. */
-export declare function agentsLiveOf(store: Store, now: Date, viewer: {
-    canSee: (run: AgentsLiveRun) => boolean;
-    localRunner: string | undefined;
-}): AgentLiveTile[];

package/dist/api-tokens.d.ts

@@ -1,80 +0,0 @@
-export type TokenAccess = "read" | "act";
-export type TokenPurpose = "api" | "mcp";
-/** Who a credential stands for: a person (their API token), a person's lead, or a coordinator. */
-export type CredentialKind = "person" | "lead" | "coordinator";
-export declare const MCP_ROTATION_REFUSAL = "Reconnect the MCP client to renew this token. You can still revoke it here.";
-/** Missing purpose is an old ordinary token; an unrecognised stored purpose is never treated as ordinary. */
-export declare const tokenPurpose: (value: unknown) => TokenPurpose;
-export declare const tokenRotationProblem: (token: {
-    purpose: TokenPurpose;
-}) => string | null;
-export declare const TOKEN_DAYS: readonly [30, 90, 365];
-/** What a presented secret says it is, before any check. A coordinator's secret has no prefix and is hashed whole. */
-export type PresentedCredential = {
-    kind: "person" | "lead";
-    id: string;
-    secret: string;
-} | {
-    kind: "coordinator";
-    secret: string;
-};
-/** A new credential of `kind`: its id, the secret shown once, and the only thing kept, its hash. */
-export declare function mintCredential(kind: CredentialKind): {
-    id: string;
-    secret: string;
-    token: string;
-    hash: string;
-};
-export declare const hashSecret: (secret: string) => string;
-/** Read a presented credential's kind and parts; null for nothing at all. A lead token may carry surrounding space. */
-export declare function parseCredential(presented: string): PresentedCredential | null;
-export declare const mintApiToken: () => {
-    id: string;
-    secret: string;
-    token: string;
-    hash: string;
-};
-export declare const mintLeadToken: () => {
-    id: string;
-    secret: string;
-    token: string;
-    hash: string;
-};
-/** The id and secret of something shaped like an API token, or null. */
-export declare function parseApiToken(presented: string): {
-    id: string;
-    secret: string;
-} | null;
-/** The id and secret of something shaped like a lead token, or null. */
-export declare function parseLeadToken(presented: string): {
-    id: string;
-    secret: string;
-} | null;
-/** Whether the secret is the one whose hash was kept, in constant time. */
-export declare function secretMatches(secret: string, keptHash: string): boolean;
-/** v111: how long a rotated token keeps working beside its replacement, by default and at most. */
-export declare const ROTATION_OVERLAP_MINUTES = 10;
-export declare const ROTATION_OVERLAP_MAX_MINUTES = 60;
-/** v111: the person is told this many days before a token expires, once each. */
-export declare const EXPIRY_NOTICE_DAYS: readonly [7, 1];
-type TokenState = {
-    revokedAt: string | null;
-    expiresAt: string;
-    overlapUntil: string | null;
-};
-/** Whether a token signs anyone in at `now`: unrevoked, unexpired, and (once replaced) inside its overlap. */
-export declare function tokenLive(token: TokenState, now: number): boolean;
-/**
- * The projects a token's person may use through it now: the person's current access, narrowed by the token's limit.
- * Null is every project. A limit never widens access, and a project the person has lost stays lost.
- */
-export declare function tokenProjects(account: readonly string[] | null, token: readonly string[] | null): string[] | null;
-/** Whether `projects` (a principal's) stays inside the token's limit. A limited token never stands for every project. */
-export declare function withinTokenLimit(projects: readonly string[] | null, limit: readonly string[] | null): boolean;
-/** Whole days until a token expires, rounded up (0 once it has). */
-export declare const daysLeft: (expiresAt: string, now: number) => number;
-/** The expiry notice a token is due at `now` (7 or 1 days), or null. Replaced and revoked tokens get none. */
-export declare function expiryNoticeDue(token: TokenState & {
-    replacedBy: string | null;
-}, now: number): (typeof EXPIRY_NOTICE_DAYS)[number] | null;
-export {};