toolroll 0.9.103 → 0.9.105

package/dist/operate.d.ts

@@ -1,401 +0,0 @@
-import { type IntegrationIo } from "./integrations.js";
-import { type OnboardIo } from "./agent-onboard.js";
-import { type Sizer } from "./task-sizing.js";
-import { type TriggerIo } from "./flow-triggers.js";
-import { type GhRead } from "./nightly-github.js";
-import type { StepIo } from "./flow-steps.js";
-import type { FetchLike } from "./flow-share.js";
-import { type Store, type Publication } from "./store.js";
-import { type LaptopSeams } from "./laptop-background.js";
-import { type DispatchAdapter } from "./sync.js";
-import { type ParentToRole, type RolePort, type UpRoleStart, type UpStartAuthority } from "./up-processes.js";
-import { type DecisionServer } from "./serve.js";
-import { type TelegramTransport } from "./telegram.js";
-import { type ProjectIdentities } from "./project-identity.js";
-import { type FolderLookOptions } from "./folder-look.js";
-import { type LeadCliSeams } from "./lead-cli.js";
-import { type Principal, type RemoteRun, type RemoteSource } from "./operate-remote.js";
-import { type PublishExec } from "./publish.js";
-import { type ApplyResult, type ExtraWrite, type ModelChange, type Slot } from "./model-choices.js";
-import { type Runner as CommandRunner } from "./builder.js";
-import { type ReleaseIo } from "./releases.js";
-export type Write = (line: string) => void;
-/**
- * 0 done · 1 broke · 2 bad usage · 3 ran fine, the answer is no.
- *
- * 3 is the one that matters. `toolroll claim` losing a race and
- * `toolroll claim` failing to open the database must not look the same to a
- * caller deciding whether to try the next task or wake somebody up.
- */
-export declare const EXIT: {
-    readonly ok: 0;
-    readonly failed: 1;
-    readonly usage: 2;
-    readonly refused: 3;
-};
-export type OperateOptions = {
-    /** Native-shell proof key, passed in memory rather than command-line arguments. */
-    desktopIdentity?: string;
-    /** A desktop service directory is state, never an implicitly enrolled project. */
-    inferProjectFromCwd?: boolean;
-    /** Exact additions approved by the native project picker, independent of the enrollment registry. */
-    additionalProjectRepos?: () => readonly string[];
-    /** Overridden by tests and by an agent that wants its own queue. */
-    databaseFile?: string;
-    /** Injected by tests: how `status` and the console ask for the latest release. */
-    releaseIo?: ReleaseIo;
-    /** Injected by tests: the bin whose real path says how Toolroll was installed. */
-    installBin?: string;
-    /** Tests: what `serve check-public` fetches with instead of the network. */
-    publicProbe?: import("./public-check.js").Probe;
-    /** Injected by tests: where `storage` looks for leftover test temp folders (default: the temp folder and /tmp). */
-    tempRoots?: readonly string[];
-    openDatabase?: (file: string) => Store;
-    now?: Date;
-    /**
-     * Injected by tests: the processes `tick` and `build` run. The agent runner
-     * is what spends money, so a test that forgets to stub it fails loudly on a
-     * missing `claude` binary rather than quietly building something.
-     */
-    agentRunner?: CommandRunner;
-    gitRunner?: CommandRunner;
-    /** Injected by tests: the Telegram Bot API. Production dials the real one. */
-    telegramTransport?: TelegramTransport;
-    /** Injected by tests: the environment checked for a fenced network before Telegram is reached (default: this process's, with the real transport). */
-    telegramEnv?: Record<string, string | undefined>;
-    publishExec?: PublishExec;
-    /** Injected by tests: the stop fence a watch would set. */
-    shouldStop?: () => boolean;
-    /** Injected by tests: the external-dispatch gh surface. */
-    dispatchAdapter?: DispatchAdapter;
-    /** Injected by tests: how flow triggers reach GitHub (gh) and Linear (fetch), and where their secrets live. */
-    flowTriggerIo?: Partial<TriggerIo>;
-    /** Injected by tests: how flow check and update steps run commands and reach GitHub and Linear. */
-    flowStepIo?: Partial<StepIo>;
-    /** Injected by tests: how often a worker's flow passes run beside its builds (default FLOW_EVERY_MS). */
-    flowEveryMs?: number;
-    /** Injected by tests: the operating system this runs on (check access: no sign-ins on Linux yet). */
-    platform?: NodeJS.Platform;
-    /** Injected by tests: whether this machine has an OS fence for checks (macOS sandbox or bubblewrap). */
-    fenceAvailable?: () => boolean;
-    /** Injected by tests: how `flows import` fetches a flow file's address. */
-    flowFetch?: FetchLike;
-    /** Injected by tests: how `integrations` checks reach services (fetch, gh, sign-in checks, mail servers). */
-    integrationIo?: Partial<IntegrationIo>;
-    /** Injected by tests: the lead's provider fetch, key environment, and stdin lines. */
-    leadSeams?: LeadCliSeams;
-    /** Test seam for the short indexed wait loop. */
-    waitSleep?: (milliseconds: number) => Promise<void>;
-    /** Injected by tests: `onboard`'s home folder, terminal and probes. */
-    onboardSeams?: OnboardSeams;
-    /** Injected by tests: whether `up` has a person at a terminal, and how it opens a browser. */
-    upSeams?: {
-        terminal?: boolean;
-        env?: Record<string, string | undefined>;
-        openBrowser?: (url: string) => void;
-        home?: string;
-        fenceAvailable?: () => boolean;
-        laptopPorts?: readonly number[];
-    };
-    /** Injected by tests: the background service handoff's supervisor, HOME, processes and console proof (laptop-background.ts). */
-    laptopSeams?: LaptopSeams;
-    /** Injected by tests: `open`, `welcome` and `password set` — the terminal, the easy start's seams, the prompts. */
-    easySeams?: EasyCommandSeams;
-    /** Injected by tests: the classifier that sizes filed tasks (none by default under test). */
-    filingSizer?: Sizer;
-    /** Set only by up-role-child.ts: this process is one role of a `toolroll up` (the console or the worker). */
-    upRole?: UpRoleHost;
-    /** Injected by tests: how the console looks at project folders off its thread (folder-look.ts). */
-    folderLook?: FolderLookOptions;
-};
-export type OnboardSeams = Partial<Pick<OnboardIo, "home" | "env" | "cwd" | "interactive" | "confirm" | "findRepo" | "checkConnection" | "pullRequests" | "youiyoux">>;
-export declare const OPERATE_HELP: string;
-/** Parsed flags, with the positionals left over. */
-type Args = {
-    positional: string[];
-    flags: Map<string, string | true>;
-    /** EVERY --repo occurrence, in order (arc 2 finding 22): the Map keeps its
-     * last-wins behavior for every existing verb; only `up` reads this. */
-    repoList: string[];
-};
-/**
- * The subcommand inventories the dispatchers consult (arc 5): each verb's
- * runner refuses an action outside its list BEFORE its switch, so these
- * exports are behavior, not commentary — and the declared command guide
- * (surface.ts) is tested for exact equality against them.
- */
-export declare const TASK_ACTIONS: readonly ["add", "new", "keep", "list", "show", "wait", "state", "block", "unblock", "next", "steer", "pause", "continue", "assign", "reopen", "scope", "approve", "hold", "unhold", "require", "requeue", "regate", "plan", "review", "accept", "repair", "route", "stop", "resume", "complete", "revise", "merge", "ask", "checks", "add-tests", "archive", "restore", "tidy", "ship", "ready", "handover", "before-after", "failing-first"];
-export declare const PUBLISH_ACTIONS: readonly ["setup", "grant", "revoke", "status", "unblock", "rearm", "merge", "refire"];
-export declare const CONFIG_ACTIONS: readonly ["show", "set", "clear"];
-export declare const APPROVER_ACTIONS: readonly ["list", "add"];
-export declare const PEOPLE_ACTIONS: readonly ["list", "invite", "projects", "revoke"];
-export declare const KEYS_ACTIONS: readonly ["status", "set", "clear", "verify", "auth"];
-/**
- * The GLOBAL flag vocabulary (exported for the command guide's drift
- * tests): every value-taking flag any verb reads, and every boolean.
- * A --flag in neither set is a typo, refused by name.
- */
-/** Flags whose value is a secret someone types or pastes: taken as the next argument even when it starts with "--". */
-export declare const SECRET_VALUE_FLAGS: ReadonlySet<string>;
-export declare const OPERATE_VALUE_FLAGS: ReadonlySet<string>;
-export declare const OPERATE_BOOLEAN_FLAGS: ReadonlySet<string>;
-export declare function parseOperateArgs(argv: readonly string[], ownValues?: ReadonlySet<string>): Args | {
-    error: string;
-};
-/** Route a native command and return its exit code. Its password source cannot be selected by an HTTP request. */
-export declare function runOperate(command: string, argv: readonly string[], write: Write, options?: OperateOptions): Promise<number>;
-export type { Principal };
-/**
- * Run one command on this server for a person who signed in with their own API token (the transport and MCP
- * gateway prove the `so_` token and refuse browser origins; this is everything after). The command's row in the
- * machine contract decides first: "no" and "step-up" rows, and commands with no row, are refused before any
- * command code runs. The principal is re-proved against the store, a read token runs only reads, and the project
- * the command touches must be one the person may use, named by --repo where a local run would use the working
- * directory. The command then runs as that person: every credential check resolves to them, nothing prompts, and
- * this machine's saved login and lead token are never read. Files are only those sent in `files`, keyed by the
- * argument that names them. Every call is in the action history as the person, from source `api` (or `mcp`),
- * with the token's name. The store is the caller's and stays open.
- */
-export declare function runOperateAs(argv: string[], opts: {
-    principal: Principal;
-    store: Store;
-    write: (s: string) => void;
-    files?: Record<string, string>;
-    source?: RemoteSource;
-    tool?: string;
-    options?: OperateOptions;
-}): Promise<number>;
-type Context = {
-    /** Injected by tests: how the console looks at project folders off its thread. */
-    folderLook?: FolderLookOptions;
-    /** A remote run's person (runOperateAs): every credential check resolves to them. Absent for every local command. */
-    principal?: RemoteRun;
-    /** The lead token this command runs under: it signs in as its owner. */
-    leadToken?: string;
-    desktopIdentity?: string;
-    /** A desktop service directory is state, never an implicitly enrolled project. */
-    inferProjectFromCwd?: boolean;
-    /** Exact additions approved by the native project picker, independent of the enrollment registry. */
-    additionalProjectRepos?: () => readonly string[];
-    store: Store;
-    write: Write;
-    json: boolean;
-    /** Every --repo occurrence in order (arc 2) — only `up` reads it. */
-    repoList?: string[];
-    now: Date;
-    clock: () => Date;
-    evidenceRoot: string;
-    /** The directory holding the database — where credential files live. */
-    databaseFile: string;
-    /** Where `storage` looks for leftover test temp folders; default the temp folder and /tmp. */
-    tempRoots?: readonly string[];
-    /** The long-lived service's token: only a pass carrying it may start the automatic storage sweep. */
-    sweepOwner?: object;
-    telegramTokenFile: string;
-    agentRunner?: CommandRunner;
-    gitRunner?: CommandRunner;
-    telegramTransport?: TelegramTransport;
-    telegramEnv?: Record<string, string | undefined>;
-    /** Injected by tests: what `publish` runs for git and gh. */
-    publishExec?: PublishExec;
-    leadSeams?: LeadCliSeams;
-    /** Injected by tests: the external-dispatch gh surface. */
-    dispatchAdapter?: DispatchAdapter;
-    /** Injected by tests: how flow triggers reach GitHub (gh) and Linear (fetch), and where their secrets live. */
-    flowTriggerIo?: Partial<TriggerIo>;
-    /** Injected by tests: how flow check and update steps run commands and reach GitHub and Linear. */
-    flowStepIo?: Partial<StepIo>;
-    /** Injected by tests: how often a worker's flow passes run beside its builds (default FLOW_EVERY_MS). */
-    flowEveryMs?: number;
-    /** Injected by tests: the operating system this runs on (default process.platform). */
-    platform?: NodeJS.Platform;
-    /** Injected by tests: whether this machine has an OS fence for checks (default: probed). */
-    fenceAvailable?: () => boolean;
-    /** Injected by tests: how `flows import` fetches a flow file's address. */
-    flowFetch?: FetchLike;
-    integrationIo?: Partial<IntegrationIo>;
-    /**
-     * The stop fence (Codex M5-M8 audit, IV-1): set by the watch when a
-     * signal lands. A pass that sees true admits NOTHING more — no schedule
-     * fires, no claim, no run, no spawn. The in-flight build finishes under
-     * its own bounds (or the grace kill); admission is what stops.
-     */
-    shouldStop?: () => boolean;
-    /** A failed recovery pass pauses new admissions without stopping an owned build. */
-    shouldPauseAdmission?: () => boolean;
-    /** Test seam for task wait; production uses a timer. */
-    waitSleep?: (milliseconds: number) => Promise<void>;
-    releaseIo?: ReleaseIo;
-    installBin?: string;
-    onboardSeams?: OnboardSeams;
-    upSeams?: {
-        terminal?: boolean;
-        env?: Record<string, string | undefined>;
-        openBrowser?: (url: string) => void;
-        home?: string;
-        fenceAvailable?: () => boolean;
-        laptopPorts?: readonly number[];
-    };
-    /** Injected by tests: the background service handoff's supervisor, HOME, processes and console proof (laptop-background.ts). */
-    laptopSeams?: LaptopSeams;
-    easySeams?: EasyCommandSeams;
-    /** This process is one role of a `toolroll up`, started by it (never from the command line). */
-    upRole?: UpRoleHost;
-    /** In-memory seams a child process can't receive: `up` runs its console and worker in this one process. */
-    upOneProcess?: boolean;
-    /** Test seam: this computer's tailnet names (production asks `tailscale status`). */
-    tailnetNames?: () => Promise<readonly string[]>;
-};
-/** Durably create the login file BEFORE the bootstrap commits (arc 2
- * finding 27): exclusive, 0600, fsynced — file and directory both — so the
- * row only ever follows a durable secret. Throws on any failure. */
-export declare function writeLoginFileDurably(path: string, name: string, password: string): void;
-/** The platform browser opener — detached, silent, never load-bearing. */
-export declare function openBrowser(url: string): void;
-/**
- * The people allowed to agree to a scope.
- *
- * Kept apart from runners deliberately: a runner credential takes work, and an
- * approver credential agrees to it. One token that did both would collapse the
- * gate into a formality the moment an agent held it.
- */
-/**
- * Who is acting, from flags — or from a person at the terminal. Scripts and
- * agents pass --as/--token and never see a prompt; a human who left them off
- * is simply asked, with the password hidden. Under --json (or any non-TTY)
- * missing credentials stay a usage refusal, exactly as before.
- */
-export declare const PROPOSALS_ACTIONS: readonly ["list", "confirm", "dismiss"];
-/** The value flags a verb reads under a global switch's name, for parseOperateArgs. */
-export declare function ownValueFlags(command: string, argv: readonly string[]): ReadonlySet<string> | undefined;
-/** What up-role-child.ts hands runOperate: the role's start, and its channel to the `up` that started it. */
-export type UpRoleHost = {
-    start: UpRoleStart;
-    port: RolePort;
-};
-/** A role child's whole run (up-role-child.ts): the ordinary command prelude (containment, secrets, limits), then the
- * role itself. Only a process started by `up` gets here; no command line selects a role. */
-export declare function runUpRole(start: UpRoleStart, port: RolePort): Promise<number>;
-/** GitHub's nightly as release debt (docs/plans/evals-nightly.md, part A): the watch loop's background read of each
- * opted-in project's nightly runs, at most every 30 minutes, within a 60 s overall deadline, through the plane's own gh
- * (release-adapters.ts githubReads). Nothing is read for a project that never opted in. */
-export declare function refreshGithubNightlies(store: Store, now: () => Date, reads?: GhRead): Promise<number>;
-/**
- * `toolroll evals run | attempt | cases | recover` (docs/plans/evals-nightly.md, part C).
- *
- * - `run [--diagnostic] [--case a,b] [--k n] --as <you> --token <password>`: admit a campaign (a person's proof, the
- *   no release busy) and run it to its end from this installed plane. With no flags it is canonical,
- *   refused while any case is a draft. Each attempt is a child process: `evals attempt`.
- * - `attempt <campaign> <case> <n> --world <dir> --db <world db>`: one attempt's world (eval-world.ts). Only under its
- *   runner's dispatch gate, and only on the world's own database.
- * - `cases`: each installed case, its version, its pin, and whether a person has validated it yet.
- * - `recover [--abandon <campaign>]`: settle campaigns whose runner stopped; with --abandon, a person ends a stuck one.
- */
-export declare function evalsCommand(positional: readonly string[], flags: Map<string, string | true>, context: Context): Promise<number>;
-/**
- * The saved projects an `up` start couldn't reach (upCommand): each is proved again every `everyMs` while the worker
- * runs, by `prove` (upProveSaved), so a folder that answers again connects without a restart. Only what the start itself
- * read from the saved list is here, and the set only shrinks: a line connected, removed from the saved list
- * (`keepOnly`) or come back as some other checkout (`revoke`) is gone for good, so a line saved again later needs its
- * recorded admission like any other addition. `retry` answers the proof when one is due and answered, else null.
- */
-export declare function upDeferredRetry<T>(inputs: readonly string[], prove: (input: string) => Promise<T | null>, everyMs?: number, now?: () => number): {
-    has: (input: string) => boolean;
-    list: () => string[];
-    retry: (input: string) => Promise<T | null>;
-    revoke: (input: string) => void;
-    keepOnly: (saved: readonly string[]) => boolean;
-};
-/**
- * Whether a saved project's folder is a Git checkout now, read without blocking this thread: `git rev-parse
- * --show-toplevel` (bounded, its own process), then the real paths of the saved line and of the checkout, resolved off
- * the thread under a deadline (folder-look.ts). Null when it isn't one, or didn't answer.
- */
-export declare function upProveSaved(gitRun: (file: string, args: readonly string[], opts?: {
-    cwd?: string;
-}) => Promise<{
-    code: number | null;
-    stdout: string;
-}>, input: string, look?: FolderLookOptions): Promise<{
-    line: string;
-    root: string;
-} | null>;
-/** What `up` hands its next worker after the worker reports which saved projects it still holds start authority for:
- * only what both still hold. A worker's report can give up an authority, never add or give back one. */
-export declare function upNarrowDeferred(held: readonly string[], reported: readonly string[]): string[];
-/** Resolve the console's project identities after it is listening, never before: the deploy's health check and every
- * page answer at once, and each project shows up as its folder answers (project-identity.ts `refresh`, its looks a
- * few at a time under their deadline). Nothing waits on it; a pass that fails leaves those paths unresolved, which
- * fails closed, for the background pass to try again. */
-export declare function consoleIdentitiesInBackground(identities: ProjectIdentities, paths: readonly string[]): void;
-/** `config set` and `config clear` on the command line, through Settings → Models' one write path (model-choices.ts,
- * docs/plans/spend-dashboard.md slice 3), under the same target and resulting-configuration checks as the editor: the
- * person proved themselves with their own password or login at `proved.generation`; a machine credential (a remote
- * token, the lead's token) never changes which models run. The write re-proves them inside its transaction: still an
- * unrestricted instance operator, at that very generation, by a proof that still stands. */
-export declare function writeModelRow(store: Store, proved: {
-    actor: string;
-    generation: number;
-    method: string;
-}, scope: string, knownProject: (repo: string) => boolean, slot: Slot | null, to: ModelChange["to"], now: Date, extra?: readonly ExtraWrite[]): ApplyResult;
-/** The sign-in link `up` asks its console for, by this start's authority: none for "none". */
-export declare function upLinkRequest(authority: UpStartAuthority, account: string | null): {
-    kind: "full";
-    account: string;
-} | {
-    kind: "local";
-} | null;
-/**
- * The console's answer to a link request (plan C4): only the kind its own start was authorised for, whatever the
- * request says. A local start mints only a local owner's link (mintLocalLink names no account); a full start only the
- * named account's; "none", or a request of the other kind, mints nothing.
- */
-export declare function consoleSignInLink(server: Pick<DecisionServer, "mintSignInLink" | "mintLocalLink">, startAuthority: UpStartAuthority, message: Extract<ParentToRole, {
-    type: "sign-in-link";
-}>): string | null;
-/** Tests: a person at a terminal, the easy start's seams, the agents' sign-in check, and the prompts. */
-export type EasyCommandSeams = {
-    terminal?: boolean;
-    seams?: Partial<import("./easy-start.js").EasyStartSeams>;
-    check?: import("./provider-connection.js").ConnectionChecker;
-    ask?: (question: string) => Promise<string>;
-    askHidden?: (question: string) => Promise<string>;
-    confirm?: (question: string) => Promise<boolean>;
-    github?: import("./github-import.js").ImportDeps;
-};
-/**
- * Easy start: the ports `up --laptop` (no --port) tries, in order. The port this install saved, alone; else, for a NEW
- * laptop install (made by `up --laptop`, nothing saved yet), `up`'s default and the next nineteen, so a console that
- * isn't this database's (another Toolroll, the desktop app's) never stops a first start; else (an install made any other
- * way) `up`'s default alone, as before. `fromSeam` replaces the default range in tests.
- */
-export declare function upLaptopPortCandidates(store: Store, fromSeam?: readonly number[]): number[];
-/** The watch loop's background learning pass (docs/plans/learning-loops.md): advisory reads, each project at most every
- * 30 minutes through the plane's own gh. A failure here never reaches the loop: it is tried on the next pass. */
-export declare function refreshLearning(store: Store, now: () => Date, reads?: GhRead): Promise<void>;
-/** A project loop's share in its process's service beats. */
-export type ServiceBeatMember = {
-    context: Context;
-    progress: (line: string) => void;
-    /** This loop's reconciliation stands and it is not stopping: the fast CI pass runs only while every member's does. */
-    ciReady: () => boolean;
-};
-/** The delivery beat: web push and outgoing webhooks, off the build path. */
-export declare const DELIVERY_EVERY_MS = 5000;
-/** The fast CI beat: only while an opened pull request waits on its checks or its merge. */
-export declare const FAST_CI_EVERY_MS = 30000;
-/** The most pull requests one fast CI pass reads. */
-export declare const FAST_CI_LIMIT = 10;
-/**
- * The opened pull requests the fast CI pass reads, oldest read or tried (`attempted`) first, at most `limit`: checks not settled (never read,
- * running, or "none" shortly after an update), or green with its merge still waiting (a merge intent in flight, or a
- * followed pull request not yet marked ready on its accepted commit). Failing and settled ones stay on the 5 minute pass.
- */
-export declare function fastCiWaiting(store: Store, now: Date, limit?: number, attempted?: ReadonlyMap<number, string>): Publication[];
-/**
- * Join this process's service beats: one delivery beat (web push and outgoing webhooks every 5 s, and at once when
- * the wake moves with new notifications) and one fast CI beat (every 30 s, the existing `observeChecks` reader, only
- * for pull requests that wait). One set per store, however many project loops join; the last to leave stops them.
- * Opening a pull request stays on the tick path, and the 5 minute pass alone may set reconciliation ready.
- */
-export declare function joinServiceBeats(member: ServiceBeatMember): () => Promise<void>;

package/dist/orphan-sweep.d.ts

@@ -1,65 +0,0 @@
-import { type ProcessRow, type StopOptions } from "./run-closeout.js";
-import type { Store } from "./store.js";
-import { type TempOwner } from "./test-temp.js";
-import type { WorktreePool } from "./worktree.js";
-/** Where a process runs from: its working folder and executable, when the OS says. */
-export type Located = {
-    cwd?: string;
-    exe?: string;
-};
-/** Working folder and executable of each pid: /proc on Linux, lsof on macOS. Throws when the OS can't be asked. */
-export declare function locateProcesses(pids: readonly number[]): Map<number, Located>;
-/** A folder an orphan may be stopped from: a let-go checkout (only what was born before it was let go) or a temp root. */
-export type SweepRoot = {
-    path: string;
-    kind: "checkout" | "test temp";
-    bornBefore?: number;
-    repo?: string | null;
-    taskId?: string | null;
-};
-/** The root `located` runs from inside of, if any (its working folder first, then its executable). */
-export declare function rootOf(located: Located | undefined, roots: readonly SweepRoot[]): SweepRoot | null;
-export type OrphanTarget = {
-    row: ProcessRow;
-    root: SweepRoot;
-    orphan: number;
-};
-/**
- * Which processes go: each orphan (parent 1, no terminal, not protected) running from inside a root — for a checkout,
- * born before it was let go — and every process descending from one that goes (none at a terminal or protected).
- */
-export declare function orphanTargets(census: readonly ProcessRow[], located: ReadonlyMap<number, Located>, roots: readonly SweepRoot[], guard: {
-    pids: ReadonlySet<number>;
-    groups: ReadonlySet<number>;
-}): OrphanTarget[];
-/** Whether a temp root's owner (pid and start) is still the running process. */
-export declare function ownerRunning(census: readonly ProcessRow[]): (owner: TempOwner) => boolean;
-/**
- * The roots orphans may be stopped from now: every checkout let go with no live run on its task and not held, and
- * every test temp root whose owner is gone or that nothing touched for a day.
- */
-export declare function sweepRoots(store: Store, pool: WorktreePool | null, census: readonly ProcessRow[], tempRoots: readonly string[], now: Date): SweepRoot[];
-export type OrphanStop = {
-    pid: number;
-    name: string;
-    where: string;
-    kind: SweepRoot["kind"];
-    ranMs: number;
-    killed: boolean;
-};
-export type OrphanSweep = {
-    stopped: OrphanStop[];
-    failed: string[];
-};
-export type OrphanOptions = StopOptions & {
-    actor?: string;
-    pool?: WorktreePool | null;
-    tempRoots?: readonly string[];
-    locate?: (pids: readonly number[]) => Map<number, Located>;
-    self?: number;
-    /** A root live work uses (storage-sweep.ts): asked at both looks; true leaves everything in it running. */
-    spare?: (path: string) => boolean;
-};
-/** Stop the orphans Toolroll left (see the top of this file), each in the ledger. */
-export declare function sweepOrphans(store: Store, now: () => Date, options?: OrphanOptions): Promise<OrphanSweep>;
-export declare function durationWords(ms: number): string;

package/dist/page-work-contract.d.ts

@@ -1,21 +0,0 @@
-/**
- * One behaviour the app runs for the page on screen instead of a page script string (docs/plans/task-page-in-app.md).
- * `answer`: a question's inline answer (render-tasks.ts decisionAnswerScript). `region`: a server-drawn region kept
- * current from a build's own fragment (chrome.ts regionScript), `/r/<run>?fragment=check|peek`. `result`: reviewing the
- * result the page shows (result-review.ts RESULT_REVIEW_SCRIPT with render-results.ts reviewEvidenceScript). No code,
- * selector or address travels here: the app runs only the kinds it knows.
- */
-export type PageWork = {
-    kind: "answer";
-} | {
-    kind: "result";
-} | {
-    kind: "region";
-    region: "check-progress" | "run-peek";
-    run: number;
-};
-/** The work the app and the server agree on. A workspace read says it with `x-toolroll-work`; a reader that does not
- * say exactly this version (an older tab) gets the page as a document with its script string, as before. A hint, never
- * authority. It moves whenever a kind is added: 2 added `result`. */
-export declare const PAGE_WORK_VERSION = 2;
-export declare const PAGE_WORK_HEADER = "x-toolroll-work";

package/dist/password-bearer.d.ts

@@ -1,25 +0,0 @@
-/**
- * D7: a password on each request (`Authorization: Bearer <name>:<password>`) is deprecated. This release still
- * accepts it everywhere it was accepted, with the same per-address tries, locks and budgets, but every answer carries
- * a deprecation warning, and every refusal of such a request names the replacement: an API token. From
- * PASSWORD_BEARER_REFUSED_FROM on, the server refuses it before checking the password.
- */
-import type { ServerResponse } from "node:http";
-/** The one replacement every machine-credential refusal names. */
-export declare const TOKEN_REPLACEMENT = "Create an API token with `toolroll tokens create`";
-/** The first release that refuses a password on a request; 0.9.58 deprecated it with a warning. */
-export declare const PASSWORD_BEARER_REFUSED_FROM = "0.10.0";
-export declare const PASSWORD_BEARER_WARNING = "Signing in with a password on each request is deprecated and stops working in Toolroll 0.10.0. Create an API token with `toolroll tokens create` and send it as the bearer instead.";
-/** What the CLI says on stderr when a saved connection signs in with a password instead of an API token. */
-export declare const PASSWORD_PROFILE_WARNING = "Warning: this connection signs in with your password on each request, which is deprecated and stops working in Toolroll 0.10.0. Create an API token with `toolroll tokens create`, then connect again with --token-stdin.";
-export declare const PASSWORD_BEARER_REFUSED = "Toolroll no longer accepts a password on a request. Create an API token with `toolroll tokens create` and send it as the bearer instead.";
-/** Whether an Authorization header is a password bearer: a name and a secret, never an API token. */
-export declare function isPasswordBearer(authorization: string | undefined): boolean;
-/** Whether this build still accepts a password bearer: only a release before PASSWORD_BEARER_REFUSED_FROM does. */
-export declare function passwordBearerAccepted(version?: string): boolean;
-/**
- * The refusal boundary for one password-bearer request, whichever adapter answers it: the deprecation is announced in
- * headers (RFC 9745 Deprecation, and a Warning naming the replacement), and any refusal's words, plain text or a JSON
- * `message`, gain the replacement. Successful answers are left byte for byte.
- */
-export declare function announcePasswordBearer(response: ServerResponse): void;

package/dist/passwordless.d.ts

@@ -1,23 +0,0 @@
-/**
- * Passwordless (docs/plans/passwordless.md): one installation setting. When it is on, signing in is the only
- * password — a step-up is satisfied by the person's live browser session (scope.ts `proveAccountNow`, method
- * "session") or, at this computer's CLI, by its remembered login. Credential acts (the plan's closed list) still
- * take a typed password (`proveCredential`).
- *
- * Like the other policy settings it is an append-only ledger entry; the newest one wins; none means off.
- */
-import type { Store } from "./store.js";
-export declare const PASSWORDLESS_ACTION = "passwordless changed";
-export type PasswordlessSetting = {
-    on: boolean;
-    setBy: string | null;
-    at: string | null;
-};
-/** Read live at every act: a change takes effect on the next one. */
-export declare function passwordlessSetting(store: Store): PasswordlessSetting;
-export declare const passwordlessOn: (store: Store) => boolean;
-/** An operator's act (the caller proves it: on takes a typed password, off is one click). The ledger keeps before → after. */
-export declare function setPasswordless(store: Store, on: boolean, by: string, now: Date): {
-    changed: boolean;
-};
-export declare const PASSWORDLESS_TRADE = "Anyone holding a signed-in browser \u2014 an unlocked laptop, a phone, a stolen session \u2014 can then do everything you can without a second check. Signing in, session limits (12 hours idle, 7 days), signing out and ending sessions remain your protection. Creating or widening a way in (passwords, sign-in methods, API tokens, connected apps, people, workers, chat pairing, webhook secrets), or widening what a project's builds and checks reach (its network, where builds write, its home folder and its check access), still asks for your password.";

package/dist/peek-cli.d.ts

@@ -1,112 +0,0 @@
-/**
- * `toolroll peek` — the terminal multiplexer over live agents.
- *
- * One pane per open run: its task, worker, role, stage word, elapsed
- * clock, and the tail of its live transcript (the same per-run file the
- * console's run page follows: what the agent said and each step it took —
- * a command's text only where its project shows commands, never file
- * contents, credential shapes redacted at write and again at read). Digits focus one pane, `a` shows all, `q`
- * leaves. No dependency: the screen is the alternate buffer and a
- * handful of escape sequences. `--tmux` opens a real tmux session with one
- * window per run for people who live there. Outside a TTY (or with
- * `--json`) it prints one snapshot and exits — the same data, an envelope.
- *
- * Read-only by construction: nothing here writes to the store or the
- * files; a peek is a look.
- */
-import { type Store } from "./store.js";
-export declare const PEEK_TAIL_LINES = 400;
-export type PeekPane = {
-    runId: number;
-    taskId: string;
-    title: string;
-    repo: string | null;
-    runner: string;
-    role: string;
-    provider: string;
-    model: string | null;
-    phase: string;
-    startedAt: string;
-    /** Tail of the live transcript, newest last. */
-    lines: string[];
-    /** Why the transcript is absent, when it is. */
-    transcript: "live" | "not-yet" | "replaced" | "unreadable";
-};
-type Tail = {
-    offset: number;
-    lines: string[];
-    state: PeekPane["transcript"];
-    gen?: string;
-    inKey?: boolean;
-    keyTail?: string;
-    /** The "Show commands" answer the cached lines were made under; absent is unknown (treated as on: never trusted). */
-    commands?: boolean;
-};
-/**
- * Advance one run's tail from its offset; `replaced` resets visibly. The
- * offset always moves by the bytes read, even when nothing in them shows
- * (a finished step, a skipped line), and an offset is only ever used
- * against the file it came from. `commands` is the run's own captured
- * "Show commands" answer (store.ts runLiveCommands), read now: lines cached
- * under any other answer (off, on, or unknown) are dropped and the file is
- * read again from its start under this one, on every path — nothing
- * projected with command detail outlives the answer turning off, and a
- * recovered answer shows the detail again.
- */
-export declare function advanceTail(root: string, runId: number, previous: Tail, commands: boolean): Tail;
-/** The stage word for a pane: the machine's own phase, or what precedes it. */
-export declare function stageWord(run: {
-    phase: string | null;
-    model: string | null;
-    providerStartedAt: string | null;
-}): string;
-export declare function elapsedWords(startedAt: string, now: Date): string;
-/** One snapshot of every live run — the envelope's body, and the TUI's first frame. */
-export declare function snapshotLiveRuns(store: Store, root: string, now: Date, tails?: Map<number, Tail>): PeekPane[];
-/**
- * Compose one frame: panes stacked, each with a header and as many tail
- * lines as its share of the rows allows; the focused pane takes the whole
- * screen. Pure — the loop paints what this returns.
- */
-export declare function composeFrame(panes: PeekPane[], size: {
-    columns: number;
-    rows: number;
-}, focus: number | null, now: Date): string;
-export type PeekIo = {
-    stdout: NodeJS.WriteStream & {
-        columns?: number;
-        rows?: number;
-    };
-    stdin: NodeJS.ReadStream & {
-        setRawMode?: (raw: boolean) => void;
-        isRaw?: boolean;
-    };
-};
-/**
- * Follow live runs until `q` (or, watching one run, until it finishes).
- * Resolves with the exit code.
- */
-export declare function runPeek(store: Store, root: string, options: {
-    runId?: number;
-    io: PeekIo;
-    clock?: () => Date;
-    intervalMs?: number;
-}): Promise<number>;
-/**
- * A real tmux session, one window per live run, each running `peek <run>`
- * — for people who already live in tmux. The plane never becomes tmux's
- * dependant: liveness stays in the store's leases, and this is a view.
- */
-export declare function openInTmux(panes: readonly PeekPane[], command: readonly string[], run: (file: string, args: readonly string[]) => Promise<{
-    code: number;
-    stderr: string;
-}>, session?: string): Promise<{
-    ok: true;
-    windows: number;
-} | {
-    ok: false;
-    message: string;
-}>;
-/** Hand the terminal to tmux and wait for it to come back. */
-export declare function attachTmux(session?: string): Promise<number>;
-export {};