toolroll 0.9.103 → 0.9.105

package/dist/exec.d.ts

@@ -1,355 +0,0 @@
-/**
- * Running external commands.
- *
- * Two rules define this module. Arguments are passed as an array and never
- * through a shell, so a directory named `; rm -rf ~` is a string and not a
- * command. And nothing here rejects: a failed command is a value. Discovery
- * walks repos it has never seen, and one broken repo must not end the scan.
- */
-import { type FenceGrants } from "./agent-fence.js";
-import { type ProcessTreeObserver } from "./process-tree.js";
-import { type ContainmentBackendId } from "./containment.js";
-import type { Store } from "./store.js";
-import type { LiveInput } from "./live-input.js";
-export type ExecResult = {
-    /** Process exit code, or one of the synthetic codes below. */
-    code: number;
-    stdout: string;
-    stderr: string;
-    /** Killed for exceeding its timeout. */
-    timedOut: boolean;
-    /** Binary is not on PATH — distinct from "ran and failed", and worth saying so. */
-    notFound: boolean;
-    /**
-     * The OS containment this spawn had (OS containment plan). Absent under
-     * observed containment. `refused` = required containment could not be
-     * established and the target NEVER ran. Otherwise the backend, the exact
-     * OS object, and whether the OS proved it empty before this result was
-     * returned — a transport exit alone never proves that.
-     */
-    containment?: ContainmentOutcome;
-    /** The signal that ended the process, when one did (its `code` then reads 1, as it always has): kept apart so a
-     * killed command is never mistaken for one that exited 1 on its own (release check 3261). Only the buffered
-     * process-group transport says. */
-    signal?: NodeJS.Signals | null;
-    /** This process (the plane) ended it with its hard stop (terminateLiveProviders: a worker shutting down), not
-     * anything the command or another process did. */
-    stoppedByPlane?: boolean;
-};
-export type ContainmentOutcome = {
-    refused: string;
-} | {
-    backend: ContainmentBackendId;
-    id: string;
-    empty: boolean;
-};
-/** Shell convention for "could not be executed": the refusal before any target ran. */
-export declare const CONTAINMENT_REFUSED_CODE = 126;
-export type RunOptions = ProcessTreeObserver & {
-    cwd?: string;
-    /** The agent fence (agent-fence.ts): on macOS the spawned process tree runs
-     * inside a sandbox that denies these paths. Applied here, at the one spawn
-     * road, so an injected test runner still sees the provider's own argv. */
-    fence?: readonly string[];
-    /** What the fence gives back beside those paths (agent-fence.ts FenceGrants). */
-    fenceGrants?: FenceGrants;
-    /** `required`: this spawn runs code a build controls, so it runs inside the OS fence or not at all (never unwrapped
-     * because no backend applies here). The caller passes the fence it must run in. */
-    confinement?: "required";
-    /** UTF-8 input for JSONL or buffered process-group transports; closed after delivery. */
-    stdin?: string;
-    /** One ACP conversation (runAcpSession only): the brief, the sealed model, and the agent the attestation names. */
-    acp?: AcpRun;
-    /** The conformance check's own admission (the gateway only; set by the check job and nothing else): this run is the
-     * request's current step, admitted by the request instead of an attestation. */
-    acpCheck?: {
-        requestId: number;
-        step: 1 | 2;
-        /** Step 1: the plane's isolation probes — a canary file in the fenced state, and a canary value the launching
-         * environment carries under a key every ACP launch sheds. */
-        isolation?: {
-            file: string;
-            fileCanary: string;
-            envValue: string;
-        };
-    };
-    /**
-     * Absolute wall-clock ceiling. Keep this for bounded commands and repair
-     * turns. Long-running provider sessions use idleTimeoutMs instead: useful
-     * work should not be killed merely because it has been running a while.
-     */
-    timeoutMs?: number;
-    /**
-     * No-progress watchdog for streaming children. It is re-armed whenever
-     * stdout or stderr produces bytes. When this is supplied without
-     * timeoutMs there is deliberately no absolute wall-clock ceiling.
-     */
-    idleTimeoutMs?: number;
-    /** Ends a process-group run early, exactly as its timeout does: the whole group is killed and the result reads timed out. */
-    signal?: AbortSignal;
-    maxBuffer?: number;
-    /**
-     * Extra environment, merged over the process's own. A capability probe is a
-     * question about an environment, and a test has to be able to construct the
-     * environment the question is about.
-     */
-    env?: Record<string, string>;
-    /**
-     * Names removed from the child's environment after the merge. This exists
-     * for exactly one class of variable: a secret the parent holds that the
-     * child must never see — the Telegram bot token in an agent's process
-     * would let the agent read and answer the operator's own decisions.
-     */
-    omitEnv?: readonly string[];
-    /**
-     * When set, the child's environment is EXACTLY these names, taken from
-     * the parent where present, plus whatever `env` merges on top (audit
-     * IV-5): the approved worktree setup sees an allowlist, never a clone
-     * of the operator's shell with two names scrubbed.
-     */
-    envAllowlist?: readonly string[];
-    /**
-     * Run the child in its own process group and register it as a live
-     * provider (M6.12). Set by the invocation gateway and nowhere else: an
-     * agent harness spawns shells and tools of its own, and stopping "the
-     * provider" must mean the whole tree — a kill that orphans the
-     * grandchildren stops nothing. Timeout kills become group kills too.
-     */
-    processGroup?: boolean;
-    /**
-     * Who OWNS this child (v52, safe task stop): an opaque tag — the
-     * invocation gateway and the builder's check/setup legs pass
-     * `run:<id>` — under which the live child is registered, so an
-     * operator's stop on one exact attempt can end THAT attempt's process
-     * tree through the handle this process holds, and nothing else's. A
-     * kill by tag reaches only children this process spawned and still
-     * tracks: never a pid read back from durable state.
-     */
-    owner?: string;
-    /** Rechecked at each actual spawn, including transient spawn retries. */
-    beforeSpawn?: () => boolean;
-    /**
-     * Live stdout for a process-group run, chunk by chunk as it arrives (the
-     * full buffer is still returned). A listener error never affects the run.
-     */
-    onStdout?: (chunk: string) => void;
-    /** Live stderr for a process-group run, with the same observational rules. */
-    onStderr?: (chunk: string) => void;
-    /**
-     * Called the moment the stream announces its session (codex:
-     * thread.started), so a crash mid-turn cannot lose the id (M6.9 —
-     * currently only the streaming transport can deliver this early).
-     */
-    onSessionId?: (id: string) => void;
-    /**
-     * Live input (live-input.ts): a Claude transport that declares `streamInput`
-     * keeps stdin piped and open, hands it to this session, and shows it every
-     * stdout event. The session sends the brief first and decides when stdin
-     * closes; the run then ends with the process, and the LAST primary result
-     * is the accounting envelope (one result per turn), with every main
-     * result's usage and turns added up (cumulativeLiveResult).
-     */
-    liveInput?: LiveInput;
-    /** Fires once the child exists, with its pid (the process-group id when
-     * processGroup is set) — the slot ledger records it (v14 finding 26). */
-    onSpawn?: (pid: number) => void;
-    /** Fires instead of onSpawn when a spawn that beforeSpawn admitted made no
-     * process at all (the OS call threw — ENOENT, EAGAIN — returned no pid, or
-     * its OS object could not be made), so its reserved witness can be settled
-     * as never started in the same step. Never fires once a child exists. */
-    onSpawnFailed?: () => void;
-    /** Fires before any target spawn, so a crash cannot lose its OS object. */
-    onContainer?: (info: {
-        backend: ContainmentBackendId;
-        id: string;
-        identity?: string;
-    }) => void;
-    /** Fires once the OS proved this spawn's object empty (every member
-     * gone, including detached helpers). Never fires on a transport exit
-     * alone; a spawn whose object could not be proven empty reports
-     * onUnknown instead and its custody stays unproven. */
-    onContainerEmpty?: () => void;
-    /**
-     * Every parsed stream event, as it arrives (claude's streaming transport
-     * only). Purely observational: exceptions are caught and counted, and
-     * nothing about the run — retention, timeout, exit — changes because a
-     * listener misbehaved. The live window renders these; nothing else may.
-     */
-    onStreamEvent?: (event: Record<string, unknown>) => void;
-    /**
-     * Fires ONCE, the moment the stream proves the prompt reached the agent
-     * (arc 1 finding 11): the first top-level assistant event, or a
-     * successful primary result when no assistant event preceded it. Error
-     * results never fire it — a startup death is not a delivery. Latched
-     * before invocation, so a throwing listener cannot make it fire twice.
-     */
-    onReceipt?: () => void;
-};
-/** Thrown BEFORE any spawn when required containment cannot be had. */
-export declare class ContainmentRefusal extends Error {
-    readonly name = "ContainmentRefusal";
-}
-/**
- * The command as it runs inside the agent fence (Anthropic's sandbox-runtime wrapping it: agent-fence.ts
- * sandboxedSpawn), with the environment that needs beside the caller's, or as it is when it has no fence. A spawn whose
- * confinement is required and that no sandbox here can wrap is refused (ContainmentRefusal): nothing runs, and nothing
- * falls back to running it unwrapped.
- */
-export declare function confined(file: string, args: readonly string[], bag: {
-    fence?: readonly string[] | undefined;
-    fenceGrants?: FenceGrants | undefined;
-    confinement?: "required" | undefined;
-    cwd?: string | undefined;
-    temp?: string | undefined;
-}): {
-    file: string;
-    args: string[];
-    env: Record<string, string>;
-};
-/** A spawn's environment with what its sandbox needs added (nothing added: the caller's, as it was). */
-export declare function withSandboxEnv<T extends Record<string, string | undefined>>(env: T | undefined, added: Record<string, string>, fenced?: boolean): T | Record<string, string | undefined> | undefined;
-/** Run IDs are local to a database. Connections to the same file share
- * custody; separate files and separate in-memory databases never do. */
-export declare function runOwnerTag(store: Store, runId: number): string;
-/** How many live children this process still tracks under an owner tag. */
-export declare function ownedProcessCount(owner: string): number;
-/**
- * The exact-attempt stop (v52): SIGKILL the process group of every live
- * child registered under the owner tag — and only those. Returns how many
- * were signalled. Idempotent: a child already gone was dropped at close,
- * and a tag nobody registered kills nothing. This is the ONLY kill road a
- * task action may take; the global sweep below is the watch's shutdown.
- */
-export declare function terminateOwnedProcesses(owner: string): number;
-/**
- * The hard stop (M6.12): SIGKILL every live provider's process group.
- * Called by the watch when its stop grace expires — never on the first
- * signal, which stays graceful. Late output cannot commit or publish:
- * the killed process exits nonzero, the build finalizes as the failure
- * it is, and every commit sits behind fences the corpse cannot pass.
- */
-export declare function terminateLiveProviders(): number;
-/** Conventions from the shell and from coreutils `timeout(1)`. */
-export declare const NOT_FOUND_CODE = 127;
-export declare const TIMEOUT_CODE = 124;
-export declare const OVERFLOW_CODE = 125;
-export declare const DEFAULT_TIMEOUT_MS = 15000;
-export declare const DEFAULT_MAX_BUFFER: number;
-export declare const SPAWN_RETRY_DELAYS_MS: readonly number[];
-export declare function isTransientSpawnFailure(error: {
-    code?: number | string;
-} | null | undefined): boolean;
-/** One attempt's answer, with whether the process never started at all. */
-export type SpawnAttempt = {
-    result: ExecResult;
-    transient: boolean;
-};
-/**
- * Retry `attempt` while it reports a transient spawn failure, sleeping the
- * given delays between tries; the last answer stands when they run out.
- * A non-transient answer — success, a real exit code, not found, timeout —
- * is returned at once: only the never-started case is retried.
- */
-export declare function retryTransientSpawn(attempt: () => Promise<SpawnAttempt>, delays?: readonly number[], sleep?: (ms: number) => Promise<void>): Promise<ExecResult>;
-export declare function run(file: string, args: readonly string[], options?: RunOptions): Promise<ExecResult>;
-/** How long a timed-out plain command has to exit after SIGTERM before it is killed outright. */
-export declare const TERM_GRACE_MS = 2000;
-/**
- * Provider replies are nested inside their JSONL envelope. A 64 KiB reply
- * therefore needs appreciably more than 64 KiB on the wire once quotes,
- * backslashes, and control characters are escaped. 512 KiB carries that
- * worst useful case while remaining a hard, per-event memory boundary.
- */
-export declare const JSONL_EVENT_HARD_CAP: number;
-/** Marks a Claude result whose session cost could not be read: the gateway charges the run's dollar cap instead. */
-export declare const CLAUDE_COST_UNKNOWN = "standing_orders_cost_unknown";
-export declare function runStreamJsonl(file: string, args: readonly string[], options?: RunOptions): Promise<ExecResult>;
-/**
- * The streaming transport for gemini's stream-json dialect (Phase 3 D1/A7).
- *
- * Retention: a bounded `init` identity witness (the first init signal, first
- * usable session id, and first conflicting id), the FIRST
- * `severity:"error"` error event (diagnostics),
- * the LAST `result` event (tokens + structural status), and the assistant's
- * text — which gemini emits only as many `message` delta lines — ASSEMBLED
- * into one line of a dedicated internal schema the real CLI cannot emit:
- *
- *   {"type":"synthetic_message","content":"...","truncated":true?}
- *
- * Assembly rules (round-3 f9): only `role:"assistant"` events with
- * `delta === true` concatenate; a non-delta assistant message REPLACES the
- * buffer (full-message semantics); non-string content is dropped; the cap
- * is enforced on the SERIALIZED UTF-8 BYTES of the complete synthetic line
- * (marker included), so it can never violate the runner's own line
- * discipline. Everything else — user echoes, tool_use, tool_result,
- * warnings — is dropped. Timeout, process-group, kill, and spawn
- * semantics match `runStreamJsonl`.
- */
-export declare function runGeminiStreamJsonl(file: string, args: readonly string[], options?: RunOptions): Promise<ExecResult>;
-/** What runAcpSession needs beyond a process: the conversation's terms (acp-client.ts). */
-export type AcpRun = {
-    prompt: string;
-    model: string;
-    /** The agent's name and version as its attestation recorded them; the handshake must say the same. */
-    expect: {
-        name: string;
-        version: string;
-    } | null;
-    /** Handed the conversation's controls once it starts (the conformance probe cancels with it). */
-    onControl?: (control: AcpControl) => void;
-    /** Each handshake step's deadline (ACP_HANDSHAKE_MS unless a test shortens it). */
-    handshakeMs?: number;
-};
-/** What a caller (the conformance check) may do with a running ACP conversation. */
-export type AcpControl = {
-    /** Ask the agent to stop the prompt in flight; unanswered within `deadlineMs`, the agent is stopped and the
-     * conversation fails (a check's cancel must be answered in time). */
-    cancel: (deadlineMs?: number) => void;
-    /** A fresh, plane-side reading, now, of what the agent itself started and is still running: the live (never zombie)
-     * processes beneath the agent's own process — below any wrapper the fence put around it — with their process
-     * groups. Null when it can't be read here (Windows). */
-    liveDescendants: () => {
-        pid: number;
-        group: number;
-    }[] | null;
-};
-/**
- * Whether a listed process is the agent's launch (`names`): by its listed name, or on Linux by the program it runs,
- * since a listing there shows the main thread's name, which Node 24 sets to "MainThread".
- */
-export declare function agentNamed(row: {
-    pid: number;
-    name: string;
-}, names: readonly string[], programOf?: (pid: number) => string | null): boolean;
-/** How long each shutdown step waits: session/close's answer, then exit after stdin closes, then exit after SIGTERM. */
-export declare const ACP_SHUTDOWN_MS: {
-    readonly close: 2000;
-    readonly eof: 5000;
-    readonly term: 5000;
-};
-/** How long each handshake step (initialize, session/new, choosing the model) may take before the agent is stopped. */
-export declare const ACP_HANDSHAKE_MS = 30000;
-/**
- * One ACP build conversation over the agent's stdio (docs/plans/acp-adapter.md § Gateway, runner, custody). The
- * conversation itself is acp-client.ts; this owns the process: the same contained spawn, ownership, descendant
- * observation, container settlement and watchdog every other runner uses, with both clocks at once.
- *
- * After the prompt is answered it shuts the agent down in bounded steps — session/close (when offered), stdin EOF,
- * SIGTERM to the group, then the forced kill — and returns only when the process has settled, so the gateway's
- * witness records the real exit. A protocol failure kills at once. A stop, from the gateway's stop watch, kills at
- * any step. The result's stdout is the conversation's retained record, never the agent's stream; its code is 0 only
- * when the prompt was answered end_turn and the agent then exited cleanly or on our own signal.
- */
-export declare function runAcpSession(file: string, args: readonly string[], options?: RunOptions): Promise<ExecResult>;
-/**
- * A live session's account so far (one main result per turn, checked on Claude Code 2.1.290): the latest result's
- * session, ending, words and cost — `total_cost_usd` is already the session's running total — with the usage token
- * fields and `num_turns`, which count only their own message, added up across every main result. A field that is not
- * a non-negative number adds nothing.
- */
-export declare function cumulativeLiveResult(previous: Record<string, unknown>, latest: Record<string, unknown>): Record<string, unknown>;
-/** This transport can keep stdin open for a live session (RunOptions.liveInput). */
-export declare const STREAM_INPUT: unique symbol;
-/** Whether a runner declares it keeps stdin open for a live session; an injected runner opts in by carrying the mark. */
-export declare const streamsInput: (runner: unknown) => boolean;
-export declare function runClaudeStreamJsonl(file: string, args: readonly string[], options?: RunOptions): Promise<ExecResult>;

package/dist/exhaustion.d.ts

@@ -1,58 +0,0 @@
-/**
- * How a finished attempt ended, classified where the evidence still exists
- * (the provider adapter's structural terminal record), never in disposal.
- * The one class that changes what happens next is `auth-expired`: a sign-in
- * or API key that no longer works pauses dispatch for that provider until
- * someone signs in, instead of burning attempts. Everything else is the
- * ordinary failure road.
- *
- * `usage-exhausted` moves the work to the next agent a person approved
- * (fallback.ts), so it comes only from a recogniser below, and a recogniser
- * comes only from a real run (docs/plans/fallback-chains.md). A provider with
- * none never reads as exhausted. `credits-depleted` and `transient-throttle`
- * are only ever read from older runs' records.
- */
-export type TerminalClass = "usage-exhausted" | "credits-depleted" | "transient-throttle"
-/** The provider's sign-in or API key no longer works — no retry:
- * dispatch for that provider pauses until someone signs in. */
- | "auth-expired"
-/** A definite structural failure terminal (ordinary failure). */
- | "not-exhausted"
-/** No structural signal — the ordinary failure/strike road. */
- | "unknown";
-/**
- * The structural terminal a provider's parser retained. `failed` marks a
- * structural FAILURE terminal (codex turn.failed, a gemini error terminal):
- * its presence blocks success ingestion regardless of exit code. `text` is
- * the bounded terminal message; `code` its machine code if the harness
- * typed one.
- */
-export type StructuralTerminal = {
-    failed: boolean;
-    text: string | null;
-    code: string | null;
-};
-/** Classify a finished attempt: a sign-in that no longer works first, for
- * any provider or version; then a recognised plan limit, on the exact provider,
- * auth mode and CLI line it was seen on; then a structural failure terminal is
- * `not-exhausted`, and anything else `unknown`. */
-export declare function classifyTerminal(args: {
-    terminal: StructuralTerminal | null;
-    /** The run's own provider, its auth mode, and the version the installed CLI reports to the gateway: never the checkout's word. */
-    run?: {
-        provider: string;
-        authMode: string;
-        version: string | null;
-    };
-    /** What a run that failed within seconds, having produced nothing, said
-     * on its way out (stderr and unstructured stdout) — read ONLY for the
-     * sign-in signal: a CLI that is not logged in often exits before its
-     * structured stream begins. */
-    earlyExit?: string | null;
-}): TerminalClass;
-/** Whether a terminal reads as a limit for this provider and auth mode, before its CLI version is asked. */
-export declare function terminalMatchesLimit(provider: string, authMode: string, terminal: StructuralTerminal | null): boolean;
-/** Whether Toolroll can recognise this agent running out at all: the words every surface shows beside an entry. */
-export declare function limitRecognised(provider: string, authMode: string): boolean;
-/** Whether a provider's own words say its sign-in or key no longer works. */
-export declare function isAuthFailure(text: string): boolean;

package/dist/export-ui.d.ts

@@ -1,11 +0,0 @@
-/**
- * Settings → Data (v105): an instance operator downloads everything Toolroll
- * knows as one .zip: the password (when the rules ask for it) and a button.
- * Built from the revamp kit; the Settings frame adds the title.
- */
-import { type Html } from "./html.js";
-/** The page is kit pieces now; nothing of the old look is left. Kept as an export for the shared stylesheet. */
-export declare const EXPORT_CSS = "";
-export declare function dataExportHtml(said: {
-    problem?: string | null;
-}): Html;

package/dist/export.d.ts

@@ -1,48 +0,0 @@
-import type { Store } from "./store.js";
-export declare const EXPORT_FORMAT = "standing-orders/export/v1";
-export type ExportFile = {
-    path: string;
-    data: Buffer;
-};
-export type ManifestEntry = {
-    path: string;
-    sha256: string;
-    bytes: number;
-    rows?: number;
-};
-export type ExportManifest = {
-    format: typeof EXPORT_FORMAT;
-    generatedAt: string;
-    generatedBy: string;
-    schemaVersion: number;
-    files: ManifestEntry[];
-    /** What was left out on purpose, so a reader knows it wasn't lost. */
-    excluded: {
-        tables: string[];
-        columns: string[];
-    };
-};
-export type FullExport = {
-    root: string;
-    files: ExportFile[];
-    manifest: ExportManifest;
-    tables: number;
-    packs: number;
-};
-/** Where a table's file goes: by what it's about. Anything new lands in "other", never nowhere. */
-export declare function categoryOf(table: string): string;
-/** Every key- or token-shaped run in `text` replaced by "[redacted]". */
-export declare function redactKeyShapes(text: string): string;
-/** The whole export, in memory: the files, the manifest and README among them. */
-export declare function buildExport(store: Store, options: {
-    who: string;
-    now: Date;
-    evidenceRoot: string;
-    configDir: string | null;
-}): FullExport;
-/** Write the export as a new folder at `out` (its parent must exist; it must not). Files are readable by their owner only. */
-export declare function writeExportFolder(out: string, exported: FullExport): void;
-/** The same files as one .zip (deflated, inside a folder named for the export). */
-export declare function exportZip(exported: FullExport): Buffer;
-/** One line for the ledger and the person who asked. */
-export declare function exportSummary(exported: FullExport): string;

package/dist/failing-first.d.ts

@@ -1,31 +0,0 @@
-/** Failing test first (docs/plans/fleet-follow-through.md), on its own so the steering mailbox can read it. Evidence pairs
- * reach the builder through follow-up checks, and the mailbox loads with the provider table: importing them from there
- * is a cycle that fails at load in every built command. */
-import { z } from "zod";
-import type { Store } from "./store.js";
-export declare const FAILING_FIRST_OUTPUT_LIMIT = 2000;
-/** Where the agent writes its report, in the attempt's own mailbox folder. */
-export declare const FAILING_FIRST_FILE = "failing-first.json";
-export declare const failingFirstReportSchema: z.ZodObject<{
-    key: z.ZodString;
-    test: z.ZodString;
-    output: z.ZodString;
-}, z.core.$strict>;
-export type FailingFirst = {
-    askedBy: string;
-    askedAt: string;
-    reportRun: number | null;
-    test: string | null;
-    output: string | null;
-    reportedAt: string | null;
-};
-export declare function failingFirstOf(store: Store, taskId: string): FailingFirst | null;
-export declare function askFailingFirst(store: Store, taskId: string, by: string, now: Date): boolean;
-export declare function dropFailingFirst(store: Store, taskId: string): void;
-/** The agent's report, as data. Only a task that asked takes one. */
-export declare function saveFailingFirstReport(store: Store, taskRef: number, runId: number, report: {
-    test: string;
-    output: string;
-}, now: Date): boolean;
-/** How the step stands, or null when this task didn't ask for it. */
-export declare function failingFirstWords(step: FailingFirst | null): string | null;

package/dist/fallback-schema.d.ts

@@ -1,8 +0,0 @@
-/**
- * v156: fallback chains (docs/plans/fallback-chains.md). New tables only, so a saved row reads as it did. Their names
- * differ from the tables v115 dropped: nothing old comes back under an old name. Kept beside nothing else so the update
- * road can read the list without loading the store.
- */
-export declare const V156_SCHEMA = "\nCREATE TABLE IF NOT EXISTS fallback_setting (\n  repo            TEXT PRIMARY KEY,\n  entries_json    TEXT NOT NULL,\n  paid_granted_by TEXT,\n  paid_granted_at TEXT,\n  updated_by      TEXT NOT NULL,\n  updated_at      TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS fallback_walk (\n  id            INTEGER PRIMARY KEY AUTOINCREMENT,\n  task_ref      INTEGER NOT NULL,\n  scope_digest  TEXT NOT NULL,\n  chain_digest  TEXT NOT NULL,\n  cursor        INTEGER NOT NULL DEFAULT 0,\n  tail_run      INTEGER NOT NULL,\n  state         TEXT NOT NULL DEFAULT 'open' CHECK (state IN ('open','closed')),\n  closed_reason TEXT,\n  opened_at     TEXT NOT NULL,\n  closed_at     TEXT\n);\nCREATE UNIQUE INDEX IF NOT EXISTS fallback_walk_one_open ON fallback_walk (task_ref) WHERE state = 'open';\nCREATE TABLE IF NOT EXISTS fallback_move (\n  walk           INTEGER NOT NULL REFERENCES fallback_walk(id),\n  to_index       INTEGER NOT NULL,\n  from_run       INTEGER NOT NULL UNIQUE,\n  to_run         INTEGER UNIQUE,\n  terminal_class TEXT NOT NULL,\n  paid           INTEGER NOT NULL DEFAULT 0,\n  moved_at       TEXT NOT NULL,\n  PRIMARY KEY (walk, to_index)\n);\n";
-export declare const V156_TABLES: readonly ["fallback_setting", "fallback_walk", "fallback_move"];
-export declare const V156_STEPS: readonly ["fallback-tables"];

package/dist/fallback.d.ts

@@ -1,138 +0,0 @@
-import { type ChainEntry, type ExecutionProfile, type Scope } from "./scope.js";
-import type { Store } from "./store.js";
-export declare const MAX_FALLBACK_ENTRIES = 3;
-/** What a project's setting names: the rest of each entry's terms resolve at filing and seal with the approval. */
-export type FallbackEntry = {
-    provider: string;
-    model: string;
-    authMode: "subscription" | "api-key";
-};
-export type FallbackSetting = {
-    repo: string;
-    entries: FallbackEntry[];
-    paidGrant: {
-        by: string;
-        at: string;
-    } | null;
-    updatedBy: string;
-    updatedAt: string;
-};
-export declare function entryDigestOf(entry: ChainEntry): string;
-/** An entry in the words every surface uses. */
-export declare function entryWords(entry: FallbackEntry): string;
-/** Whether Toolroll can see this entry run out, in plain words: an entry it can't recognise ends the chain there. */
-export declare function entryMovesOnWords(entry: Pick<FallbackEntry, "provider" | "authMode">): string;
-/** Whether this entry spends money, by what it was pinned to: an API key, or a provider that only bills by use. A plan
- * entry is never paid: where its login can't be proved to be that plan, it doesn't run (invoke.ts), it is never
- * reinterpreted as a paid agent. */
-export declare function entryPaid(_store: Store, entry: Pick<FallbackEntry, "provider" | "authMode">): boolean;
-/** Parse `provider:model:plan|api-key`. The model is everything between the first and last colon, so ":free" ids work. */
-export declare function parseEntry(text: string): FallbackEntry | string;
-export declare function entriesProblem(entries: readonly FallbackEntry[]): string | null;
-export declare function fallbackSettingOf(store: Store, repo: string): FallbackSetting | null;
-export declare function setFallbackChain(store: Store, repo: string, entries: readonly FallbackEntry[], by: string, now: Date): {
-    ok: true;
-} | {
-    ok: false;
-    problem: string;
-};
-export declare function clearFallbackChain(store: Store, repo: string, by: string, now: Date): {
-    ok: true;
-} | {
-    ok: false;
-    problem: string;
-};
-/** The paid grant: the one explicit yes a paid entry spends under, read again at every money moment. */
-export declare function setPaidGrant(store: Store, repo: string, allowed: boolean, by: string, now: Date): {
-    ok: true;
-} | {
-    ok: false;
-    problem: string;
-};
-/**
- * The chain a new scope files with: its base agent, then the project's entries. Null means no chain. A setting that can't
- * resolve is a stated problem: the scope files unresolved in those words, and nothing runs on half a chain.
- */
-export declare function chainForFiling(store: Store, repo: string | null, base: ExecutionProfile, baseAuth: string, lower: (profile: ExecutionProfile) => ExecutionProfile): {
-    ok: true;
-    chain: ChainEntry[] | null;
-} | {
-    ok: false;
-    problem: string;
-};
-export declare const chainJsonOf: (chain: readonly ChainEntry[]) => string;
-/**
- * Why this chain can't seal on this yes, or null. A paid entry takes a person's own yes: the ceremony or their chat tap,
- * never a mode, grant, schedule, lead or automatic seal, and no machine's credential. A chat tap is bound to the scope's
- * digest, which covers the chain, and the card shows the chain in full (chainTermsLines).
- */
-export declare function chainSealProblem(store: Store, scope: Scope, basis: {
-    kind: string;
-} | undefined): string | null;
-/** Each tick, before any dispatch: settle every open walk. */
-export declare function reconcileWalks(store: Store, now: Date): void;
-export type FallbackDispatch = {
-    index: number;
-    entry: ChainEntry;
-    paid: boolean;
-} | {
-    problem: string;
-} | null;
-/**
- * Which entry the next build of this task runs as, read by the tick before anything is claimed: null is the ordinary
- * road (no chain, or the base agent). A move whose paid grant has since gone closes here and says so: nothing runs on it.
- */
-export declare function dispatchEntryOf(store: Store, taskRef: number, taskId: string, now: Date): FallbackDispatch;
-/** A route stamp for a fallback entry, checked against the sealed chain: the admission's proof of `fallback` provenance. */
-export declare function fallbackStampProblem(store: Store, taskRef: number, taskId: string, stamp: {
-    routeDigest: string;
-    phase: string;
-    provider: string;
-    model: string | null;
-}, parentRun: number | null): string | null;
-/**
- * Inside the run's admission transaction: bind it to its walk, or say why not (the caller rolls the row back). A base run
- * opens a walk; a pending entry consumes its edge exactly once, with the paid grant re-read; a parked tail hands custody to
- * its resumption; a repair inherits its parent's binding verbatim. Nothing else opens on a chain approval.
- */
-export declare function bindRunToWalk(store: Store, runId: number, now: Date): string | null;
-/** The pinned entry a bound run spends as, or null for a run with no binding. */
-export declare function pinnedEntryOf(store: Store, runId: number): {
-    index: number;
-    entry: ChainEntry;
-} | {
-    problem: string;
-} | null;
-/**
- * THE LAST LOOK AT THE SPAWN: one read of every authority a chain run spends under. A builder or repair on a chain
- * approval with no binding spends nothing; a bound run must hold the walk's current place, under the live approval, as its
- * exact entry; a paid entry must still hold the live grant. Null means go.
- */
-export declare function chainCustodyProblem(store: Store, runId: number): string | null;
-/** Whether this finished attempt is about to move on: it holds a walk's place and the gateway classed it exhausted. */
-export declare function ranOutOnChain(store: Store, runId: number): boolean;
-/** The gateway refused this bound run: its plan login isn't proved. The walk closes, a person is told, no strike. */
-export declare function closeWalkSignedOut(store: Store, runId: number, now: Date): void;
-/**
- * After the dispatch road finished a refused run: when it was a fallback agent refused for not being signed in to its
- * plan, the task stops and waits for a person (task state failed, the run's reason saying why), until they retry it.
- * Nothing expires it. True when it did.
- */
-export declare function blockAfterSignedOut(store: Store, runId: number, now: Date): boolean;
-export type MoveResult = {
-    moved: true;
-    to: FallbackEntry;
-    paid: boolean;
-} | null;
-/**
- * THE MOVE, inside sealFailure's transaction (the claim is already released, the run still open): only the walk's own tail,
- * started and classed exhausted by the gateway, on the exact entry it was pinned to. Null means the ordinary failure road
- * runs, with the walk closed in words when it can't go on. The caller finishes the run either way; a walk that moved leaves
- * no strike.
- */
-export declare function moveOnIfExhausted(store: Store, runId: number, taskId: string, now: Date): MoveResult;
-/**
- * What the next agent is told about the move, for its brief. The one place the handover note plugs in: once it merges, a
- * fallback run gets that note here. Null for any run that isn't continuing another agent's work.
- */
-export declare function fallbackBriefFor(store: Store, runId: number): string | null;