toolroll 0.9.103 → 0.9.105

package/dist/spend.d.ts

@@ -1,142 +0,0 @@
-/**
- * Spend (v105): what agent work cost, priced for every provider, and who and
- * what it counts toward. Work on a subscription (a Claude or Codex login)
- * costs nothing extra and counts as $0 (its limits are what bind it; see
- * provider-limits.ts). Work billed to an API key costs what its provider
- * reported; otherwise its tokens at the model's catalogue price (Settings →
- * Models), or at the provider's highest listed price when the model isn't
- * listed; work with no tokens and no cost is "unpriced" and said so.
- *
- * Spend counts toward a project (a run's task, a subagent's, a project chat),
- * a person (who filed the task, or had the chat), a subagent (its turns, and
- * tasks it filed), and the whole installation. Budgets are per calendar
- * month (UTC).
- */
-import type { Database } from "./store.js";
-export type PriceSource = "reported" | "estimated" | "unpriced" | "subscription";
-export type Billing = "subscription" | "api-key";
-/** How a provider's work is billed right now: an API key when Toolroll is set to use one, or when the CLI
- * itself was last seen billing a key (a key helper, a Console login, Bedrock or Vertex, `codex login --with-api-key`);
- * otherwise its plan. `db` supplies what was seen (provider_account); without it, the setting alone. */
-export declare function billingOf(provider: string, db?: Database): Billing;
-/** How a provider's CLI was last seen billing (provider_account), or null. */
-export declare function seenBilling(db: Database, provider: string): Billing | null;
-/** How a Claude turn was really billed, from its own stream. Only a plan reports its usage windows (Claude Code 2.1
- * does on every turn), so that is the one sign of the plan; a named key source or a cloud model id (Bedrock, Vertex)
- * is a key, and so is "none" without windows (a gateway's bearer token or a cloud provider says "none" too). Null when
- * the stream said nothing. */
-export declare function claudeBillingFrom(seen: {
-    keySource: string | null;
-    model: string | null;
-    planWindows: boolean;
-}): Billing | null;
-/** How Claude bills on this computer when Toolroll gives it no key (subagent turns, drafts): as its keyless runs
- * were last seen, and its plan until one has been. */
-export declare function claudeMachineBilling(db: Database): Billing;
-/** Whether API work on this provider can be priced: it reports its cost, or the catalogue has its prices. */
-export declare function canPrice(db: Database, provider: string): boolean;
-export type Price = {
-    inputUsd: number;
-    outputUsd: number;
-    model: string;
-};
-/** A model's catalogue price (US dollars per million tokens), or null when the catalogue doesn't list one. A
- * Claude short name ("sonnet") is priced as the newest of its family, as the Claude CLI runs it. */
-export declare function priceFor(db: Database, provider: string, model: string | null): Price | null;
-/** The provider's highest listed price, for API work whose model the catalogue doesn't list (or that ran the CLI's
- * default): a budget that stops work must never see it as free. */
-export declare function ceilingPriceFor(db: Database, provider: string): Price | null;
-/** What a piece of work cost, in micro-dollars: nothing on a subscription; otherwise reported, or tokens at the
- * catalogue price (usd per million tokens times tokens is micro-dollars), or unpriced. */
-export declare function priceWork(db: Database, work: {
-    provider: string;
-    model: string | null;
-    costUsd: number | null;
-    tokensIn: number | null;
-    tokensOut: number | null;
-    billing: Billing;
-}): {
-    microusd: number | null;
-    source: PriceSource;
-    price: Price | null;
-};
-export declare const SPEND_SCHEMA = "\nCREATE TABLE IF NOT EXISTS run_spend (\n  run         INTEGER PRIMARY KEY,\n  microusd    INTEGER,\n  source      TEXT NOT NULL CHECK (source IN ('reported', 'estimated', 'unpriced', 'subscription')),\n  billing     TEXT NOT NULL CHECK (billing IN ('subscription', 'api-key')),\n  -- 1 once the run's own evidence set it (a key it was given, what its CLI said); a later turn can only make it a key.\n  billing_fixed INTEGER NOT NULL DEFAULT 0,\n  price_model TEXT,\n  input_usd   REAL,\n  output_usd  REAL,\n  priced_at   TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS budget (\n  id          INTEGER PRIMARY KEY AUTOINCREMENT,\n  scope_kind  TEXT NOT NULL CHECK (scope_kind IN ('installation', 'project', 'person', 'subagent')),\n  scope_key   TEXT NOT NULL,\n  limit_microusd INTEGER NOT NULL CHECK (limit_microusd > 0),\n  hard_stop   INTEGER NOT NULL DEFAULT 1,\n  created_by  TEXT NOT NULL,\n  created_at  TEXT NOT NULL,\n  updated_by  TEXT NOT NULL,\n  updated_at  TEXT NOT NULL,\n  removed_by  TEXT,\n  removed_at  TEXT\n);\nCREATE UNIQUE INDEX IF NOT EXISTS budget_live ON budget (scope_kind, scope_key) WHERE removed_at IS NULL;\nCREATE TABLE IF NOT EXISTS provider_limit (\n  provider       TEXT NOT NULL,\n  window         TEXT NOT NULL,\n  used_percent   REAL NOT NULL,\n  window_minutes INTEGER,\n  resets_at      TEXT,\n  reached        INTEGER NOT NULL DEFAULT 0,\n  plan           TEXT,\n  observed_at    TEXT NOT NULL,\n  PRIMARY KEY (provider, window)\n);\n-- Spend that isn't a run, a subagent turn or a chat: a flow's Claude draft.\nCREATE TABLE IF NOT EXISTS side_spend (\n  id        INTEGER PRIMARY KEY AUTOINCREMENT,\n  kind      TEXT NOT NULL CHECK (kind IN ('draft')),\n  repo      TEXT,\n  provider  TEXT NOT NULL,\n  model     TEXT,\n  cost_usd  REAL,\n  billing   TEXT NOT NULL CHECK (billing IN ('subscription', 'api-key')),\n  at        TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS side_spend_at ON side_spend (at);\nCREATE TABLE IF NOT EXISTS provider_account (\n  provider    TEXT PRIMARY KEY,\n  billing     TEXT NOT NULL CHECK (billing IN ('subscription', 'api-key')),\n  observed_at TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS chat_turn_created ON chat_turn (created_at);\nCREATE INDEX IF NOT EXISTS mate_turn_created ON mate_turn (created_at);\nCREATE INDEX IF NOT EXISTS subagent_turn_at ON subagent_turn (at);\n";
-export type BudgetScope = "installation" | "project" | "person" | "subagent";
-export type Budget = {
-    id: number;
-    scope: BudgetScope;
-    key: string;
-    limitMicrousd: number;
-    hardStop: boolean;
-    updatedBy: string;
-    updatedAt: string;
-};
-/** One piece of spend, whatever made it, with what it counts toward. */
-export type SpendItem = {
-    at: string;
-    kind: "run" | "subagent" | "chat" | "sort" | "draft";
-    microusd: number | null;
-    source: PriceSource;
-    project: string | null;
-    person: string | null;
-    subagent: number | null;
-    provider: string;
-    model: string | null;
-    tokensIn: number | null;
-    tokensOut: number | null;
-    taskId: string | null;
-    runId: number | null;
-    authMode: string | null;
-};
-/** The calendar month (UTC) `at` falls in: [start, end) as ISO strings, and its name (YYYY-MM). */
-export declare function monthOf(at: Date): {
-    from: string;
-    to: string;
-    name: string;
-};
-/** A month by its name (YYYY-MM), or null. */
-export declare function monthNamed(name: string | null): {
-    from: string;
-    to: string;
-    name: string;
-} | null;
-/** Every subagent's name by id (its handle when its soul file names none). */
-export declare function subagentNames(db: Database): Map<number, string>;
-export declare function subagentFilers(db: Database): (repo: string | null, filedBy: string | null, kind: string | null) => number | null;
-/** Who a task's work counts toward: its own filer, or, for a revision filed by automation (an automatic repair), the
- * filer of the task it revises, up its ancestry (bounded). */
-export declare function filersOf(db: Database): (taskRef: number) => {
-    repo: string | null;
-    filedBy: string | null;
-    kind: string | null;
-};
-/** Every piece of spend in [from, to): runs (by when they started), subagent turns and chat turns. `modeOf` says how
- * a provider bills when a record doesn't (older rows): its current login or key. */
-export declare function spendItems(db: Database, from: string, to: string, modeOf?: (provider: string) => Billing): SpendItem[];
-/** Whether a piece of spend counts toward a budget. */
-export declare function countsToward(item: SpendItem, budget: Pick<Budget, "scope" | "key">): boolean;
-export type BudgetState = Budget & {
-    spentMicrousd: number;
-    unpriced: number;
-    percent: number;
-};
-/** A piece of work's agents as a budget sees them: which provider, billed how. */
-export type BudgetAgent = {
-    provider: string;
-    billing: Billing;
-};
-/** What a budget gate says: nothing holds it, or the budget it's over (used up), or the budget that covers API work it
- * can't price (no reported cost, no catalogue prices yet: never counted as free). */
-export type BudgetHold = {
-    over: BudgetState | null;
-    why: "used-up" | "unpriced" | null;
-    unpricedProvider: string | null;
-    remainingMicrousd: number | null;
-};
-/** Why work waits on a budget, in words. */
-export declare function budgetHoldWords(hold: BudgetHold, month: string, subagentName?: string): string;
-/** Each budget's month so far: what counted toward it, and how many pieces of work had no price. */
-export declare function budgetStates(budgets: readonly Budget[], items: readonly SpendItem[]): BudgetState[];
-/** A budget in words: "The shop project's", "alex's", "Maya's (subagent)", "The whole installation's". */
-export declare function budgetLabel(budget: Pick<Budget, "scope" | "key">, subagentName?: string): string;
-export declare const usd: (microusd: number | null) => string;

package/dist/sqlite-runtime.d.ts

@@ -1,3 +0,0 @@
-/** Keep native SQLite out of import-only UI/module graphs. Load the real
- * driver only when a database operation needs it, as the main store does. */
-export declare function sqliteRuntime(): typeof import('node:sqlite');

package/dist/sqlite-telemetry.d.ts

@@ -1,9 +0,0 @@
-import type { Database } from './store.js';
-import type { ServerTelemetry } from './server-telemetry.js';
-/** One observation for the entire bounded BEGIN retry, including a failed acquisition. */
-export declare function measureWriteWait<T>(db: Database, body: () => T): T;
-/** Preserve SQLite calls, timeouts and transaction semantics. No SQL or parameters leave this wrapper.
- * Native SQLite does not expose busy-handler time for autocommit writes: report their whole duration separately.
- * Runtime explicit IMMEDIATE/EXCLUSIVE transactions report acquisition and hold; startup migrations are excluded.
- */
-export declare function instrumentDatabase(db: Database, telemetry: ServerTelemetry): Database;

package/dist/sso-settings.d.ts

@@ -1,33 +0,0 @@
-import type { OidcSettings } from "./oidc.js";
-export declare const SSO_CALLBACK = "/login/sso/callback";
-/** A name for the button from the issuer, when none is given. */
-export declare function providerLabel(issuer: string): string;
-export declare function readSsoSettings(dir: string | null | undefined): OidcSettings | null;
-/**
- * Save what the form sent. The client secret is kept when the field is left
- * blank; rules come as rows (group, role, projects), blank groups dropped.
- * `projects` for a row is "all" or the project paths chosen.
- */
-export declare function saveSsoSettings(dir: string, form: {
-    issuer: string;
-    clientId: string;
-    clientSecret: string;
-    label: string;
-    scopes: string;
-    groupsClaim: string;
-    passwords: string;
-    rules: {
-        group: string;
-        role: string;
-        projects: string[];
-    }[];
-}, previous: OidcSettings | null): {
-    ok: true;
-    settings: OidcSettings;
-} | {
-    ok: false;
-    said: string;
-};
-export declare function removeSsoSettings(dir: string): void;
-/** What changed, for the ledger: never the secret itself, only that it changed. */
-export declare function ssoChangeWords(before: OidcSettings | null, after: OidcSettings | null): string;

package/dist/sso-ui.d.ts

@@ -1,26 +0,0 @@
-/**
- * Settings → Sign-in (v100): the identity provider, the groups that may sign
- * in and what each may do, and who may still use a password. An instance
- * operator's page; changes take their password.
- */
-import type { OidcSettings } from "./oidc.js";
-import { type Html } from "./html.js";
-/** The old card look; the page is built from the kit now. Kept for chrome.ts, which still concatenates it. */
-export declare const SSO_CSS = "";
-export type SsoSettingsView = {
-    settings: OidcSettings | null;
-    /** The address to register with the provider as this app's sign-in redirect. */
-    redirect: string | null;
-    projects: {
-        path: string;
-        name: string;
-    }[];
-    /** Whether the person looking is linked to the provider already. */
-    linked: boolean;
-};
-/** Whether an address only this computer can open (localhost, 127.x, ::1): a provider can't send people back to it. */
-export declare function loopbackAddress(address: string): boolean;
-export declare function ssoSettingsHtml(view: SsoSettingsView, outcome: {
-    said?: string | null;
-    problem?: string | null;
-}): Html;

package/dist/staged-runtimes.d.ts

@@ -1,54 +0,0 @@
-import { type ProcessRow } from "./run-closeout.js";
-/** A deploy or update that never finished keeps its stage this long (it may be resumed). */
-export declare const UNFINISHED_KEEP_MS: number;
-export declare const STAGED_FOLDER = "staged-upgrades";
-export type Stage = {
-    path: string;
-    name: string;
-    at: number;
-    finished: boolean;
-    prior: string | null;
-    keptAside: boolean;
-};
-export type StageKeep = "current" | "previous" | "newest" | "under way" | "kept-aside database";
-export type StagePlan = {
-    keep: {
-        path: string;
-        why: StageKeep;
-    }[];
-    go: Stage[];
-    refused: string | null;
-};
-/** The `browser-*` and `release-*` stages: real folders directly in staged-upgrades, newest first. */
-export declare function stagedRuntimes(stateDir: string): Stage[];
-/**
- * Paths a runtime may be running from: the launchd services' definitions, every `toolroll` (or older
- * `standing-orders`) command on PATH, in the usual link folders or under nvm (a link counts by its target), this
- * process, and `extra`.
- */
-export declare function runtimesInUse(extra?: readonly string[], home?: string, path?: string, stateDir?: string): string[];
-/** Retain only recognized Toolroll entry scripts in candidate stages, never complete argv. ps is asked only
- * for Node/Toolroll processes; /proc supplies NUL-separated argv on Linux. Fail closed with a fixed message,
- * since an execFileSync exception can otherwise contain private argument text in stdout/stderr. */
-export declare function runtimeScriptPaths(stateDir: string, onlyPids?: readonly number[], observations?: {
-    census?: () => ProcessRow[];
-    argv?: (pids: readonly number[]) => string[];
-}): string[];
-/** What stays and what goes now, and why. */
-export declare function stagePlan(stateDir: string, inUse: readonly string[], now: Date): StagePlan;
-export type StagePrune = {
-    removed: string[];
-    failed: string[];
-    refused: string | null;
-};
-/**
- * Remove the stages that go. Right before each goes, the plan is made again (what's in use now), nothing live may use
- * it (`spare`, storage-sweep.ts) and the stage must still be a real folder directly in staged-upgrades.
- */
-export declare function pruneStagedRuntimes(stateDir: string, now: Date, options?: {
-    inUse?: () => string[];
-    remove?: (path: string) => void;
-    spare?: (path: string) => boolean;
-    /** Deterministic race seam, not supplied by production callers. */
-    quarantined?: (original: string, trash: string) => void;
-}): StagePrune;

package/dist/steer-capabilities.d.ts

@@ -1,32 +0,0 @@
-/**
- * What a running attempt can be told and done to, in one place (docs/plans/agents-cockpit.md §4, R10): every live
- * view of an attempt offers exactly these, and says plainly what is missing. Each answer is derived from the same facts
- * the store's own gates read (steeringLiveBuild / liveInputRun for notes and pauses, requestRunStop's rules for Stop),
- * so the view never offers what the store would refuse.
- *
- *   Builder with live input (Claude, on this computer's runner)  notes reach it at once · pause/resume · stop
- *   Any other builder (Codex, OpenRouter, Gemini, ACP; another computer's runner relays)  notes by mailbox while it is
- *     open, read at its next check; before it starts, in its brief · stop
- *   A builder past its mailbox (finishing, or repairing its handoff)  no notes for this attempt
- *   A protocol repair (a `repair` child of a builder), a planner's correction  no notes · Stop stops the owning attempt
- *   Planner, scout, reviewer  no notes (none reads a mailbox) · stop
- *
- * A repair *task* (a task filed to fix a result) runs as a builder, so it is the builder row.
- */
-import type { Store } from "./store.js";
-export type SteerSend = "live" | "mailbox";
-export type SteerCapability = {
-    /** How a note reaches this attempt; null: it takes none now. */
-    send: SteerSend | null;
-    /** Pause, resume, and pause-and-steer (live input only). */
-    pause: boolean;
-    /** The run a Stop names (the owning attempt for a child), and what the button says; null: the store would refuse. */
-    stop: {
-        run: number;
-        label: string;
-    } | null;
-    /** One plain sentence for the composer: how a note travels, or why there is none. */
-    words: string;
-};
-/** The capability of this exact run, now. Null when it is not running. */
-export declare function steerCapabilityOf(store: Store, runId: number, now: Date): SteerCapability | null;

package/dist/steer-controls.d.ts

@@ -1,14 +0,0 @@
-import type { BrowserAgentControls } from "./browser-workspace.js";
-import type { Store } from "./store.js";
-/** The attempt running for a task now: one under the task's live claim (any role; a child shows as its owner's own),
- * or a review, which runs under its own claim (requestRunStop exempts it from the task's). */
-export declare function liveAttemptOf(store: Store, taskRef: number, now: Date): number | null;
-/** One running attempt's composer: the note's target (null: it takes none now) and its controls. Null when it is not
- * running, or this person may not act on it (a viewer, the demo). */
-export declare function steerControlsFor(store: Store, taskId: string, runId: number, now: Date, canAct: boolean): {
-    steer: {
-        action: string;
-        run: number;
-    } | null;
-    controls: BrowserAgentControls;
-} | null;

package/dist/steer-live.d.ts

@@ -1,19 +0,0 @@
-import type { LiveInput } from "./live-input.js";
-import { type SteerMailbox } from "./steer-mailbox.js";
-import type { SteerNote, Store } from "./store.js";
-/** How often the dispatcher looks: a note reaches a running Claude build within about this long. */
-export declare const LIVE_TICK_MS = 500;
-/** How long an unread note waits before it is sent again. */
-export declare const LIVE_RESEND_MS = 90000;
-/** How many times an unread note is sent again before it reads Not picked up. */
-export declare const LIVE_RESENDS = 3;
-export type LiveSteer = {
-    box: SteerMailbox;
-    session: LiveInput | null;
-};
-/** The stdin copy of a note: the same fenced text and key as its file, and what to do with the file. */
-export declare function liveNoteText(box: SteerMailbox, number: number, note: SteerNote): string;
-/** A re-send: only the note's number and file, and what to do with it. The note itself was sent in full once. */
-export declare function liveReminderText(box: SteerMailbox, number: number): string;
-/** One tick. `agentRunning`: the agent process is up, so a note written now can be read. */
-export declare function tickLiveSteer(store: Store, steer: LiveSteer, now: Date, agentRunning: boolean): void;

package/dist/steer-mailbox.d.ts

@@ -1,46 +0,0 @@
-import type { Store } from "./store.js";
-export declare const STEER_HANDLED = "handled";
-/** Findings have their own folder: a finding is not operator steering, and must never read as it (findings.ts). */
-export declare const STEER_FINDINGS = "findings";
-/** What the agent writes back: one file per finding it answers. */
-export declare const STEER_ANSWERS = "answers";
-export declare const findingNoteName: (id: number) => string;
-export type SteerMailbox = {
-    runId: number;
-    taskRef: number;
-    /** Worktree-relative, as the brief names it. */
-    folder: string;
-    dir: string;
-    /** The folder's real path, resolved once when it was made inside the worktree. */
-    realDir: string;
-    /** This attempt's note key: in the brief and in every genuine note, nowhere else. */
-    key: string;
-    /** The highest number this pulse has written. */
-    last: number;
-    /** Mailed and not yet moved to handled/: number → note id. */
-    waiting: Map<number, number>;
-    /** Findings mailed to this run and not yet moved to handled/. */
-    findingsWaiting: Set<number>;
-};
-export declare const steerNoteName: (number: number) => string;
-/** Make the folder and its handled/ inside the worktree; null when it cannot be made. */
-export declare function openSteerMailbox(worktree: string, folder: string, runId: number, taskRef: number, key: string): SteerMailbox | null;
-/** One beat: record what the agent read and answered, then mail what is new while the agent runs. */
-export declare function pulseSteerMailbox(store: Store, box: SteerMailbox, now: Date, agentRunning: boolean): void;
-/** The attempt is over: one last read, then the folder goes. Unread notes stay pending for the next attempt. */
-export declare function closeSteerMailbox(store: Store, box: SteerMailbox, now: Date): void;
-/**
- * Claude's doorbell: a synchronous PostToolUse hook that lists the folder and,
- * while a note is unread, hands the agent one line of context between tool
- * calls. It only says notes are waiting — it never quotes one, and its firing
- * is never an acknowledgement. Rendered into the run's own --settings.
- */
-export declare function claudeSteerHooks(dir: string, folder: string): {
-    PostToolUse: {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }[];
-};

package/dist/steer-status.d.ts

@@ -1,25 +0,0 @@
-/**
- * Where a steering note stands, in the one set of words the task page, the
- * CLI and the lead all use (v120). A note is read only when the agent proves
- * it: the stream's receipt of a brief that quoted it, or the agent moving it
- * to handled/ in a running build's steering folder. Everything else is
- * either waiting for the agent that is running now, or for the next attempt.
- */
-import type { SteerNote } from "./store.js";
-export type SteerStanding = "read" | "waiting" | "not-picked-up" | "next-attempt" | "ended" | "unverified";
-/** `liveBuild`: the task has a build whose agent is running and reads its steering folder (Store.steeringLiveBuild). */
-export declare function steerStandingOf(note: SteerNote, liveBuild: boolean): SteerStanding;
-/** The words, and the moment the agent read it when it has: each surface renders that time its own way. */
-export declare function steerStandingParts(note: SteerNote, liveBuild: boolean): {
-    words: string;
-    readAt: string | null;
-};
-export declare function steerStandingWords(note: SteerNote, liveBuild: boolean, time: (iso: string) => string): string;
-/** Where a note filed now goes, said before or right after filing it. */
-export declare function steerDestinationWords(liveBuild: boolean, liveInput?: boolean): string;
-/** A paused live build's one sentence: until when it can wait before it ends, and how long that is (live-input.ts
- * idleLimit), or only that it is paused when it has no idle limit. `time` renders the moment its surface's way. */
-export declare function pausedWords(pause: {
-    until: string | null;
-    limitMs: number | null;
-}, time: (iso: string) => string): string;

package/dist/stop-proof.d.ts

@@ -1,67 +0,0 @@
-import { type StopOptions } from "./run-closeout.js";
-import { type Store } from "./store.js";
-/** How long after a run finished its processes have to go on their own before Toolroll looks. */
-export declare const STOP_PROOF_GRACE_MS = 60000;
-export type StopProofOutcome = 
-/** Proven stopped and settled, in the ledger with its evidence. */
-"settled"
-/** Not yet: inside the grace period, a live child is still tracked here, or a leftover was just stopped. */
- | "waiting"
-/** This computer can't prove it (can't look, another computer's process, or something it didn't start is in the
- * folder). Recorded once, in plain words. */
- | "blocked"
-/** Nothing for this proof to do: already stopped, still open, alive on its own record, or a native sandbox. */
- | "skipped";
-export type StopProofResult = {
-    run: number;
-    outcome: StopProofOutcome;
-    words: string;
-    stopped?: number;
-};
-export type StopProofOptions = StopOptions & {
-    /** How long after the run finished before Toolroll looks (STOP_PROOF_GRACE_MS). `graceMs` is the SIGTERM grace. */
-    afterFinishMs?: number;
-    /** Which processes have their working directory inside each path; must throw when it can't tell. */
-    cwds?: (paths: readonly string[]) => Map<string, number[]>;
-    /** Every process's command line, by pid; must throw when it can't tell. */
-    commandLines?: () => Map<number, string>;
-    /** The live service's own pid (its ancestors are never targets). */
-    self?: number;
-    /** The worktree note check (worktree.ts); throws when the note can't be read. */
-    occupancy?: (path: string) => {
-        held: true;
-        by: number;
-    } | {
-        held: false;
-    };
-    /** Called after processes were stopped: a cached look must be read again. */
-    refresh?: () => void;
-};
-/** One pass's shared look at this computer: the process table, folders and command lines are read once for every
- * run the pass checks, and again after anything was stopped. */
-export declare function sharedLook(options?: StopProofOptions): StopProofOptions;
-/** Which processes work inside each path, from the OS: /proc on Linux, lsof on macOS. Unlike a best-effort listing,
- * it throws when the listing can't be read: no answer is never "nobody". */
-export declare function processesInStrict(paths: readonly string[], listing?: readonly {
-    pid: number;
-    cwd: string;
-}[]): Map<string, number[]>;
-/** Every process's working directory, from the OS; throws when the listing can't be read. */
-export declare function processFolders(): {
-    pid: number;
-    cwd: string;
-}[];
-/** Every process's command line, by pid. Read to match a folder's path in memory only; never stored or shown. */
-export declare function processCommandLines(): Map<number, string>;
-/** Whether a command line names `path` or something inside it (a whole path, never a longer folder's prefix). */
-export declare function namesPath(line: string, path: string): boolean;
-/**
- * Prove one finished run stopped, on this computer, without asking anyone (see the file's comment). Walks the run's
- * owned runs one unproven stop at a time. Never signals a process that isn't proven the run's.
- */
-export declare function proveRunStopped(store: Store, runId: number, clock: () => Date, options?: StopProofOptions): Promise<StopProofResult>;
-/** The worker's pass (operate.ts reconcile): every finished run of this computer whose stop is unproven where
- * Toolroll's own look can prove it. A batch a pass, oldest first; a blocked run never holds newer ones back. */
-export declare function proveFinishedRunsStopped(store: Store, clock: () => Date, options?: StopProofOptions & {
-    batch?: number;
-}): Promise<StopProofResult[]>;

package/dist/storage-sweep-child.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/storage-sweep-process.d.ts

@@ -1,55 +0,0 @@
-/** The storage child's bounded IPC protocol. No paths or process arguments are written to logs. */
-import { type ChildProcess } from "node:child_process";
-import type { SweepRecord } from "./storage-sweep.js";
-export type SweepRequest = {
-    version: 1;
-    databaseFile: string;
-    poolRoot: string | null;
-    tempRoots: string[];
-    actor: string;
-    at: string;
-};
-export type SweepExecutor = (request: SweepRequest) => Promise<SweepRecord>;
-export declare function sweepRequest(value: unknown): value is SweepRequest;
-export declare function sweepResponse(value: unknown, request: SweepRequest): value is {
-    version: 1;
-    record: SweepRecord;
-};
-export type SweepCompletion = {
-    ok: true;
-    record: SweepRecord;
-} | {
-    ok: false;
-    reason: "failed" | "timeout" | "stopped";
-};
-export type SweepSupervisor = {
-    readonly running: boolean;
-    start: (request: SweepRequest, complete: (result: SweepCompletion) => void, owner?: object) => boolean;
-    stop: (owner?: object) => void;
-};
-export declare const SWEEP_TIMEOUT_MS: number;
-export declare const SWEEP_KILL_GRACE_MS = 5000;
-/** The sweep runs behind everything else: a positive nice and, on macOS, the background CPU and I/O policy. */
-export declare const SWEEP_NICE = 10;
-/**
- * How the child enters the background policy on macOS, or null elsewhere (or without taskpolicy): the child runs it on
- * its own pid once Node has started and loaded the sweep, before any sweep work. Everything it starts after that (rm,
- * du, git) inherits the policy. Starting Node itself under it let a busy machine hold the child's start for as long
- * as anything else wanted the CPU, before it had done any of the work the policy is for.
- */
-export declare function sweepBackground(pid: number, platform?: NodeJS.Platform, exists?: (path: string) => boolean): {
-    file: string;
-    args: string[];
-} | null;
-/** In the child: the background policy from now on. Without it the sweep still runs, at the nice its parent set. */
-export declare function enterSweepBackground(run?: (file: string, args: string[]) => void): boolean;
-/** Owns one child without lending its lifetime to a reconcile pass or its database connection. */
-export declare function createSweepSupervisor(options?: {
-    timeoutMs?: number;
-    killGraceMs?: number;
-    launch?: () => ChildProcess;
-    signal?: (child: ChildProcess, signal: NodeJS.Signals) => void;
-}): SweepSupervisor;
-export declare function storageSweepSupervisor(databaseFile: string): SweepSupervisor;
-/** Awaitable only for explicit callers/tests; automatic maintenance always uses start(). */
-export declare const runSweepChild: SweepExecutor;

package/dist/storage-sweep-schedule.d.ts

@@ -1,30 +0,0 @@
-import { type SweepDeps, type SweepRecord } from "./storage-sweep.js";
-import { type SweepSupervisor } from "./storage-sweep-process.js";
-import { type Store } from "./store.js";
-/** How often the service looks again at a due sweep. */
-export declare const SWEEP_CHECK_MS: number;
-/** After this long without an automatic sweep, it runs even while work is running or waiting. */
-export declare const SWEEP_FORCE_MS: number;
-export type SweepBusy = "run" | "claim" | "ready";
-/** What keeps a due sweep waiting now, or null when nothing is running or waiting. */
-export declare function sweepBusy(store: Store, now: Date): SweepBusy | null;
-/** Whether a long-lived Toolroll service holds a current lease. Rows from earlier services don't count. */
-export declare function sweepServiceRunning(store: Store, now: Date): boolean;
-export type SweepState = "off" | "sweeping" | "no-service" | "recent" | "retry" | "busy" | "forced" | "due";
-export type SweepSchedule = {
-    state: SweepState;
-    /** The latest automatic sweep's recorded time, or null when there has been none. */
-    lastAt: string | null;
-    /** When the next sweep is due, or null when it is off or due now. */
-    nextAt: string | null;
-    busy: SweepBusy | null;
-};
-/** The sweep's schedule from what is recorded now; reads only. */
-export declare function sweepSchedule(store: Store, now: Date, env?: NodeJS.ProcessEnv): SweepSchedule;
-/** Why the sweep is waiting or when it is next due, after "Automatic sweep: ". `when` formats a time for the reader. */
-export declare function sweepScheduleWords(schedule: SweepSchedule, when: (at: string) => string): string;
-/**
- * The service's claim and launch. A one-shot caller has no `owner` and never claims. A hung child never holds
- * reconciliation or the caller's store open; the result is saved by the flight's own connection.
- */
-export declare function idleStorageSweep(store: Store, deps: SweepDeps, now: () => Date, supervisor?: SweepSupervisor): SweepRecord | null;