toolroll 0.9.104 → 0.9.105

package/dist/chat-rooms.d.ts

@@ -1,123 +0,0 @@
-/**
- * Team conversations inside any chat transport: a group or channel follows
- * one team conversation, a private chat may select one, and messages a
- * paired teammate sends there are saved through the same team operation
- * the browser and CLI use. The transport supplies identity (who sent it),
- * where rooms are recorded, and how to reply; nothing here runs a model.
- */
-import type { Store } from "./store.js";
-import { TeamLeads } from "./team-leads.js";
-import { type PhoneLink } from "./chat-channel.js";
-export type RoomCommand = {
-    kind: "list";
-} | {
-    kind: "select";
-    index: number;
-} | {
-    kind: "off";
-};
-/** `/team` lists, `/team <n>` chooses, `/team off` (or `private`) leaves.
- * The bare word works too, because Slack and Discord keep unregistered
- * slash text for themselves. Any other text is not ours. */
-export declare function roomCommand(text: string): RoomCommand | null;
-export declare const PAIR_FIRST = "Pair your account first: open Settings in Toolroll, choose this chat service, and send the code here in a private chat.";
-/** A room is a grant from one exact pairing (`binding`): its delivery and its
- * sends are rechecked against that person's current membership. */
-export type Room = {
-    id: number;
-    chatId: string;
-    kind: "group" | "private";
-    conversation: string;
-    boundBy: string;
-    binding: number;
-    cursor: number;
-};
-/** Where a transport records which chat follows which conversation. */
-export type RoomBackend = {
-    room(chatId: string): Room | null;
-    bind(args: {
-        chatId: string;
-        kind: "group" | "private";
-        conversation: string;
-        by: string;
-        binding: number;
-    }): {
-        ok: true;
-    } | {
-        ok: false;
-        reason: "group-taken";
-    };
-    /** The pairing a room was granted from, if it is still live. */
-    grant(binding: number): {
-        approver: string;
-        generation: number;
-        chatId: string;
-    } | null;
-    unbind(chatId: string, by: string): boolean;
-};
-export type RoomCounts = {
-    ignored: number;
-    chatQueued?: number;
-    chatRefused?: number;
-    statusReplies?: number;
-};
-export type RoomInbound = {
-    store: Store;
-    /** The transport's request-id prefix, e.g. "telegram", "slack". */
-    channel: string;
-    backend: RoomBackend;
-    chatId: string;
-    isGroup: boolean;
-    /** The paired sender, already proved by the transport; null when unpaired. */
-    sender: {
-        approver: string;
-        generation: number;
-        binding: number;
-    } | null;
-    /** A transport-unique key for this inbound message (update id, event id). */
-    updateKey: string;
-    text: string;
-    /** The enrolled ceiling; null when unreadable. */
-    projects: readonly string[] | null;
-    origin: string | null;
-    now: Date;
-    report: RoomCounts;
-    /** Queue one reply into the chat the message came from. */
-    say: (text: string, link?: PhoneLink) => void;
-};
-export declare function teamRequestId(channel: string, chatId: string, updateKey: string): string;
-export declare function conversationRow(store: Store, id: string): {
-    conversation: string;
-    title: string;
-    thread: number;
-    lead: string;
-    leadName: string;
-    visibility: string;
-} | null;
-/**
- * Handle one inbound message that belongs to the team layer. Returns true
- * when it was consumed here (a `/team` command in any chat, any message in
- * a followed room, or a private message while a conversation is selected);
- * false hands the message to the transport's personal path untouched.
- */
-export declare function applyRoomInbound(input: RoomInbound): boolean;
-/** Whether the pairing a room was granted from still holds: live, the same
- * person, still a manager of a team conversation for a group (a viewer for a
- * private selection). */
-export declare function roomGrantAllowed(store: Store, domain: TeamLeads, backend: RoomBackend, room: Room): boolean;
-export declare function teamDomain(store: Store, projects: readonly string[] | null): TeamLeads;
-export type RoomMessage = {
-    id: number;
-    role: "assistant" | "operator";
-    text: string;
-    turn: number | null;
-    author: string | null;
-    requestId: string | null;
-    status: string | null;
-};
-/** The conversation messages a room has not received yet, oldest first. */
-export declare function roomMessagesAfter(store: Store, thread: number, cursor: number, limit?: number): RoomMessage[];
-/** What a room shows for one message: the lead's reply as is, a teammate's message with its author, this room's own messages and cancelled ones not at all. */
-export declare function roomMessageText(message: RoomMessage, channel: string, chatId: string): string | null;
-/** Whose binding a room card rides: the person the lead was answering, else any paired participant. */
-export declare function roomCardApprover(store: Store, conversation: string, turn: number, paired: readonly string[]): string | null;

package/dist/chat-settings-page.d.ts

@@ -1,43 +0,0 @@
-import type { Store } from "./store.js";
-import { type Html } from "./html.js";
-import { type ChatIdentity } from "./chat-delivery-state.js";
-export type ChatSettingsOptions = {
-    code?: string;
-    problem?: string;
-    now?: Date;
-    who?: string;
-};
-/** What differs between the Slack, Discord and Teams settings pages; everything else is one page. */
-export type ChatSettingsPage = {
-    provider: "slack" | "discord" | "teams";
-    label: string;
-    credentials: ChatIdentity | null;
-    /** One sentence on what connecting gives, shown before it is connected. */
-    intro: string;
-    /** How to create the app, as list items, shown before it is connected. */
-    steps: Html;
-    /** The connect form's own fields (the password is the kit's). */
-    fields: Html;
-    /** One line under the connect fields. */
-    fieldsNote: string;
-    /** Where the pairing message is sent ("in a direct message to your Toolroll Slack app"). */
-    pairWhere: string;
-    /** What to try once paired. */
-    tryLine: Html;
-    /** Lines shown with the connection (the Teams messaging endpoint). */
-    connection?: Html;
-    /** The status words while connected and while waiting. */
-    liveWords?: readonly [on: string, off: string];
-    /** The "Access and setup" paragraphs, if any. */
-    access?: Html;
-};
-/** A secret the connect form posts (an app or bot token, a client secret): masked, never given a value, kept out of
- * password managers. */
-export declare function chatSecretRow(options: {
-    id: string;
-    name: string;
-    label: string;
-    placeholder?: string;
-}): Html;
-/** Settings → Slack, Discord or Teams: connect the app once, then each teammate pairs their own account. */
-export declare function chatSettingsHtml(store: Store, dir: string, options: ChatSettingsOptions, page: ChatSettingsPage): Html;

package/dist/chat-task-actions.d.ts

@@ -1,59 +0,0 @@
-import { type Store } from "./store.js";
-import type { VerifiedApprover } from "./principal.js";
-import { type StopRequest } from "./task-control.js";
-export declare const CHAT_TASK_ACTIONS: {
-    readonly stop: {
-        readonly label: "Stop task";
-        readonly detail: "Pauses this task once the run acknowledges the stop. Saved work remains; other tasks continue.";
-    };
-    readonly resume: {
-        readonly label: "Resume task";
-        readonly detail: "Lifts this stop’s hold and continues from saved work. Other holds and approval requirements still apply.";
-    };
-    readonly retry: {
-        readonly label: "Try again";
-        readonly detail: "Queues another attempt. Existing approvals and holds still apply.";
-    };
-    readonly plan: {
-        readonly label: "Plan first";
-        readonly detail: "Requests a plan. Building still requires approval.";
-    };
-    readonly wait_for: {
-        readonly label: "Add dependency";
-        readonly detail: "Waits for the selected task to finish.";
-    };
-    readonly stop_waiting: {
-        readonly label: "Remove dependency";
-        readonly detail: "Stops waiting for the selected task. Other requirements still apply.";
-    };
-    readonly run_checks: {
-        readonly label: "Run checks";
-        readonly detail: "Runs the project's quick check on this result's exact commit. A pass upgrades its status; a failure stays visible.";
-    };
-    readonly run_full_checks: {
-        readonly label: "Run full checks";
-        readonly detail: "Runs the project's full check on this result's exact commit. A pass upgrades its status; a failure stays visible.";
-    };
-    readonly add_tests: {
-        readonly label: "Add tests";
-        readonly detail: "Files a small task to write tests for this change. Nothing runs until it is approved.";
-    };
-};
-export type ChatTaskAction = keyof typeof CHAT_TASK_ACTIONS;
-export declare function isChatTaskAction(value: unknown): value is keyof typeof CHAT_TASK_ACTIONS;
-/** Bind cards to a specific execution and its current state, not the family's moving pointer. */
-export declare function chatTaskStamp(store: Store, who: VerifiedApprover, task: string): string | null;
-/** Only current, eligible controls can become cards; retain the exact run the reader saw. */
-export declare function chatTaskRun(store: Store, task: string, operation: "stop" | "resume", now: Date): number | null;
-export declare function applyChatTaskAction(store: Store, who: VerifiedApprover, payload: Record<string, unknown>, now: Date, web: boolean, controls?: Pick<StopRequest, "deferSignal"> & {
-    via?: StopRequest["via"];
-    evidenceRoot?: string;
-    person?: boolean;
-}): {
-    ok: true;
-    taskId: string;
-    said: string;
-} | {
-    ok: false;
-    message: string;
-};

package/dist/chat-terms.d.ts

@@ -1,29 +0,0 @@
-import { type Scope } from "./scope.js";
-/** What a plan's yes allows an agent to do, in a few plain words (the approval sheet's "You're allowing"). */
-export declare function permissionPlainWords(profile: Scope["profile"] | null | undefined): string | null;
-export type ShownScope = Pick<Scope, "goal" | "outOfScope" | "touches" | "acceptance" | "profile" | "budgetMicrousd"> & Partial<Pick<Scope, "proposedChainJson">>;
-/** Every word of the terms a yes agrees to, as the card shows them: the goal, what's excluded, the files (or plainly any
- * file), each requirement with the evidence it needs, and what the agent may do and spend. Nothing is shortened. */
-export declare function scopeTermsText(scope: ShownScope): string;
-/** The digest of the terms shown, bound to the scope's own digest: a changed word, limit or route is another digest. */
-export declare function shownTermsDigest(scope: ShownScope & Pick<Scope, "digest">): string;
-/** The digest of the exact words a card showed, taken when the card was made and kept with it. */
-export declare function cardTermsDigest(terms: string): string;
-/** Whether these words show this scope as it is now: its whole terms text, word for word, and what only a person's own
- * yes may agree to (checks past the sandbox, extra services). Part of the terms, or an earlier version's, is not. */
-export declare function cardShowsScope(scope: ShownScope, terms: string): boolean;
-/** Whether a scope lets its agent do anything, nothing asking first. */
-export declare function scopeFullAccess(profile: Scope["profile"] | null | undefined): boolean;
-/** Why a person's own limits refuse this scope, or null. */
-export declare function chatLimitProblem(scope: Pick<Scope, "profile" | "budgetMicrousd">, limits: {
-    fullAccess: boolean;
-    capMicrousd: number | null;
-}, yours: string): string | null;
-/** The chat apps a card goes to. */
-export type CardChannel = "telegram" | "slack" | "discord" | "teams";
-/** Whether a chat app shows a card's words exactly as they are stored, so a tap there is a yes to those words. Teams
- * draws card text as Markdown, where a link's label hides its address, and Slack turns `:name:` into an emoji: there
- * the words go to the review page and no tap approves them. Telegram's card is plain text and Discord's escapes its
- * presentation syntax. Both approval roads read this one rule (chat-decide.ts shownWhole, chat-actions.ts
- * sharedActionAllowsChallenge), so neither can seal words the other would refuse. */
-export declare function shownAsWritten(text: string, channel: CardChannel): boolean;

package/dist/chat-voice.d.ts

@@ -1,69 +0,0 @@
-import type { TelegramTransport } from "./telegram.js";
-import type { Store } from "./store.js";
-/** The bot's display name in every chat app. */
-export declare const BOT_NAME = "Toolroll";
-/** Updates for one person landing within this window become one message, edited in place as it grows. */
-export declare const BATCH_MS: number;
-export declare const SHORT_TITLE_MAX = 60;
-/** A short human summary of a task's title, at most 60 characters: no "— revision", and no task ids. Only the
- * task's own id and tokens `isTaskId` names as real tasks are dropped; `node-20` and `utf-8` stay. */
-export declare function shortTitle(title: string | null | undefined, taskId?: string | null, isTaskId?: (token: string) => boolean): string;
-/** A task's title as every chat says it: short, with its own id and any other real task's id dropped. */
-export declare function chatTitle(store: Pick<Store, "getTask">, taskId: string): string;
-/** A title inside a sentence or list: "faster tests", but "API keys" and "iOS" keep their capitals. */
-export declare function inSentence(summary: string): string;
-/** The facts one line of a chat update is made of, read from the shared task status. */
-export type FinishedFact = {
-    summary: string;
-    headline: string;
-    checks: "passed" | "failed" | "not-run" | "off" | null;
-    report: boolean;
-    completedBy: string | null;
-    /** Toolroll marked it complete because its work landed: why ("its pull request merged"). */
-    landed?: string | null;
-    /** An open pull request carries this result: the ask is "Merge it?" rather than "Accept and finish it?". */
-    pullRequest?: boolean;
-    /** The lead did this (built it, or marked it complete), so the lead says "I". */
-    lead?: boolean;
-    /** Not a finished result but another update about the task: its own words when it stands alone, and a few
-     * words for a list ("has a plan to review"). */
-    update?: {
-        words: string;
-        phrase: string;
-    } | null;
-    /** The person's lead took it on (lead-voice.ts): "<name> is on it", never "It waits for you". */
-    leadOnIt?: boolean;
-    /** What the person calls their lead (Settings → Lead); "Lead" when unnamed. */
-    leadName?: string;
-};
-/** The two buttons under a result ready for a person: the real next step, then a look first. */
-export declare const READY_ACTIONS: {
-    readonly merge: "Merge";
-    readonly complete: "Accept";
-    readonly look: "Look first";
-};
-/** Whether this line asks for the result's next step, so it carries [Merge] or [Accept and finish] and [Look first]. */
-export declare function asksToFinish(fact: FinishedFact): boolean;
-/** One update, said plainly: what happened, then what happens next. The lead says "I" for what it did. */
-export declare function finishedLine(fact: FinishedFact): string;
-/** Several updates in one message: "4 tasks finished: faster tests, cleanup, …" (or "3 updates: …" when not all of
- * them are finished work), then what broke and what happens next. */
-export declare function batchLine(facts: readonly FinishedFact[]): string;
-/**
- * Name the Telegram bot Toolroll. On pairing it always becomes Toolroll; on upgrade only a bot still called
- * StandingOrders is renamed, so a name a person chose later is kept. Best effort: a refused or failed call
- * leaves the old name and never blocks pairing or delivery. Returns whether a rename was sent and accepted.
- */
-export declare function nameTelegramBot(transport: TelegramTransport, when: "pairing" | "upgrade", signal?: AbortSignal): Promise<boolean>;
-/** The last word on any pushed chat text: a task's own id (bare or in brackets), a "— revision" suffix and a
- * "Replaced by <id>" never reach a chat, whatever words the fact was recorded with. A bare id reads as the
- * task's short title when one is given, else "this task". */
-export declare function chatText(text: string, tasks?: readonly (string | null | undefined | {
-    id: string;
-    title?: string;
-})[]): string;
-/** The one button a plain fact may carry: its label names where its machine-minted console path goes; nothing in
- * it comes from the fact's text. */
-export declare function factLinkLabel(path: string): string;
-/** Whether the words already name this title as a whole phrase (so it need not be said twice). */
-export declare function mentions(text: string, title: string): boolean;

package/dist/chat-warmth.d.ts

@@ -1,21 +0,0 @@
-/** Small warm touches while the lead works on a chat app: once a turn will take more than a few seconds (its first tool
- * step starts), a 👍 on the owner's message and the app's typing indicator until the turn ends. Best effort only: an
- * app or permission that does not allow it is skipped silently, and nothing here can fail, delay or change the turn. */
-import type { LeadProgress } from "./lead-progress.js";
-export declare const WARM_EMOJI = "\uD83D\uDC4D";
-/** Telegram and Teams show typing for about five seconds, Discord for ten: refreshed inside the shorter window. */
-export declare const TYPING_REFRESH_MS = 4000;
-export type WarmHooks = {
-    /** React to the owner's own message. Absent: the app (or this bot's permission) has no reactions. */
-    react?: () => Promise<unknown>;
-    /** Show the app's typing indicator once. Absent: the app has none for bots. */
-    typing?: () => Promise<unknown>;
-};
-export type WarmTurn = {
-    onProgress: (event: LeadProgress) => void;
-    stop: () => void;
-};
-/** The turn's progress listener: on the first tool step, react once and keep typing shown until `stop`. */
-export declare function warmTurn(hooks: WarmHooks, options?: {
-    refreshMs?: number;
-}): WarmTurn;

package/dist/check-access.d.ts

@@ -1,54 +0,0 @@
-/**
- * Check access (v132, docs/plans/check-access.md): how far a project's setup and check commands reach beyond the
- * plane's check fence. `sandboxed` (the default) is the fence as it is; `sign-ins` also reads the exact sign-in files
- * of Claude, Codex and gh, under the project's network fence; `unsandboxed` runs them with no OS fence, trusted by the
- * whole instance, for a project whose checks must create sandboxes themselves (Toolroll's own). Widening is an instance
- * operator's act with a password typed now; any approver for the project may narrow it back.
- */
-import { type NetworkProfile, type ProjectNetwork } from "./egress.js";
-export declare const CHECK_ACCESS_LEVELS: readonly ["sandboxed", "sign-ins", "unsandboxed"];
-export type CheckAccess = typeof CHECK_ACCESS_LEVELS[number];
-export declare const CHECK_ACCESS_DEFAULT: CheckAccess;
-export declare const isCheckAccess: (value: unknown) => value is CheckAccess;
-/** A stored or sealed value as a level: anything missing or unreadable is the narrowest, never a wider one. */
-export declare const checkAccessOf: (value: unknown) => CheckAccess;
-export declare const widerThan: (a: CheckAccess, b: CheckAccess) => boolean;
-/** The narrowest of several levels (none given: the default). */
-export declare const narrowestAccess: (levels: readonly CheckAccess[]) => CheckAccess;
-/** The level as a person reads it, in a sentence's middle ("Checks: …"). */
-export declare function checkAccessWords(level: CheckAccess): string;
-/** What each wider level means, said before anyone chooses it. */
-export declare const CHECK_ACCESS_WARNINGS: Readonly<Record<Exclude<CheckAccess, "sandboxed">, string>>;
-/** The services whose sign-ins a `sign-ins` check reads: Claude's and Codex's own hosts (egress.ts), and GitHub's. */
-export declare const SIGN_IN_HOSTS: readonly string[];
-/** Which of those a project's network doesn't allow (an open network allows all). The check's network is never widened
- * for them: the operator adds them, as a network change of its own. */
-export declare function signInHostsMissing(network: ProjectNetwork): string[];
-/** The narrower of two networks: every host both allow (a wildcard allows what it covers), local services only if both
- * do, open only if both are. A check never reaches what either its sealed network or the project's current one refuses. */
-export declare function narrowestNetwork(a: NetworkProfile, b: NetworkProfile): NetworkProfile;
-/** A build's checks' own network: what its approval sealed, less its agent's provider hosts (those are the agent's, never
- * its checks'); narrower if a project host happens to be one of them. */
-export declare function checkNetworkOf(sealed: NetworkProfile, provider: string, project: ProjectNetwork): NetworkProfile;
-/** On (0.9.70, sandbox parity C10): a `sign-ins` check reads its sign-in files itself, through its sandbox, by name
- * (agent-fence.ts signInGrants). Nothing privileged reads or copies one, so the race that kept sign-ins off (a folder
- * swapped between a privileged check and its read) has nothing to race; a link planted at a sign-in name leads, inside
- * the sandbox's own view, to a denied path. Every platform with an OS fence. */
-export declare const SIGN_INS_READY = true;
-export declare const signInsAvailable: (_platform?: NodeJS.Platform) => boolean;
-/** Why sign-ins can't be chosen here, said plainly (null: they can). */
-export declare const signInsUnavailableWords: (platform?: NodeJS.Platform) => string | null;
-/** The level checks actually get on this platform: `sign-ins` where it isn't available is `sandboxed` (narrower, never
- * wider). Everything that seals, launches or stamps a check's level goes through this. */
-export declare const checkAccessHere: (level: CheckAccess, platform?: NodeJS.Platform) => CheckAccess;
-/** How a project's checks actually run here, as the settings page and `project check-access` say it: with no OS fence
- * on this machine and unconfined running allowed by an operator, without a sandbox whatever is saved (never said to be
- * sandboxed); otherwise the saved level as this platform can give it. */
-export declare function checkAccessRunsAs(level: CheckAccess, here: {
-    platform: NodeJS.Platform;
-    fenced: boolean;
-    unconfinedAllowed: boolean;
-    localMode?: boolean;
-}): CheckAccess;
-/** Easy-start C5: while local mode is on, a project's checks reach at most its sign-ins, never unsandboxed. */
-export declare const localModeCap: (level: CheckAccess) => CheckAccess;

package/dist/check-facts.d.ts

@@ -1,126 +0,0 @@
-import { type CheckReport } from "./contracts/release-check.js";
-import { type Store, type VerifyCommand } from "./store.js";
-/** The sources a result can come from, and the states it can have. */
-export declare const CHECK_RESULT_SOURCES: readonly ["receipt", "report", "log", "learn"];
-export type CheckResultSource = typeof CHECK_RESULT_SOURCES[number];
-export type CheckResultState = "failed" | "passed" | "skipped" | "passed-on-retry";
-/** The receipt's whole-check identity, and the one a failed check with nothing else named records. */
-export declare const WHOLE_CHECK = "check";
-export declare const UNEXPLAINED = "unexplained";
-/** How many result rows one check records at most (a report's own bounds are far above any real check). */
-export declare const MAX_RESULTS_PER_CHECK = 20000;
-/** How old a tracked observation may be and still be asked about (docs/plans/learning-loops.md, 90-day window). */
-export declare const OBSERVATION_WATCH_MS: number;
-/** What a check ran under, captured when its command started. `tree` null: its commit couldn't be read from verified
- * objects, and nothing about the check is comparable. */
-export type CheckConditions = {
-    head: string;
-    tree: string | null;
-    commandDigest: string;
-    access: string;
-    harnessDigest: string | null;
-    lockfile: string | null;
-    conditionsDigest: string | null;
-    conditionsClass: string | null;
-    problem: string | null;
-};
-/**
- * The conditions a check's command starts under: its commit's verified tree facts, the approved command's digest, its
- * access, and the values of `envNames` (the variables the check inherits, builder.ts SETUP_ENV_ALLOWLIST) as this
- * process holds them now — what the command is given. Hashed with checkContextOf's fields; the class reads
- * `<platform>-<arch>-node<major>`. Values are hashed, never stored.
- */
-export declare function captureCheckConditions(input: {
-    repo: string | null;
-    head: string;
-    command: VerifyCommand;
-    access: string;
-    envNames: readonly string[];
-    env?: NodeJS.ProcessEnv;
-}): CheckConditions;
-/** Why the task's check ran: a release's or the nightly's purpose, read from the plane's own records. */
-export declare function checkPurposeOf(store: Store, taskRef: number): "release" | "nightly" | "ordinary";
-/** The advisory learning line of a check's output, read strictly: exactly one line carrying this run's nonce, at most
- * 64 KiB, before the report, matching its contract, naming only requested exact cases, each once. Anything else is
- * not recorded, with why; that loses learning evidence only. */
-export declare function learningLinesOf(stdout: string, nonce: string, asked: readonly string[]): {
-    ok: true;
-    results: {
-        identity: string;
-        state: "passed" | "failed" | "skipped";
-    }[];
-} | {
-    ok: false;
-    why: string;
-};
-type Row = {
-    identity: string;
-    state: CheckResultState;
-    source: CheckResultSource;
-};
-/** The report's lines as results: every case it names; a file, group, version or part only when it didn't simply pass. */
-export declare function reportResults(report: CheckReport): Row[];
-export type CheckFactsInput = {
-    runId: number;
-    taskRef: number;
-    repo: string | null;
-    /** Captured when the command started; null when no command started (nothing comparable was run). */
-    conditions: CheckConditions | null;
-    /** What the plane recorded as the check's own outcome (run_check), unchanged. */
-    receipt: {
-        status: "passed" | "failed" | "not-run";
-    };
-    /** The sealed report, when the check gave a valid one. */
-    report: CheckReport | null;
-    /** The check's handshake facts, when it had one: its nonce and what it was asked about for learning. */
-    attempt: {
-        nonce: string;
-        learn: readonly string[];
-    } | null;
-    /** The check's final command output, for the learning line (the same bytes the report was read from). */
-    stdout: string | null;
-    now: Date;
-};
-/**
- * Record what a settled check ran under and reported, once (first write wins), in one transaction: its fact row and
- * every result row. Called at disposition by the builder right after it records the check's own outcome. Advisory:
- * nothing reads these for a verdict, a rerun or an approval.
- */
-export declare function recordCheckFacts(store: Store, root: string, input: CheckFactsInput): void;
-/** The storage sweep's own step: results older than the retention window go; their fact rows stay. */
-export declare function pruneCheckResults(store: Store, now: Date): number;
-/** A check's recorded facts, or null. */
-export type CheckFact = {
-    run: number;
-    repo: string | null;
-    taskRef: number;
-    head: string | null;
-    tree: string | null;
-    commandDigest: string | null;
-    access: string | null;
-    harnessDigest: string | null;
-    lockfile: string | null;
-    conditionsDigest: string | null;
-    conditionsClass: string | null;
-    purpose: "release" | "nightly" | "ordinary";
-    learnState: "recorded" | "not-recorded" | "not-asked";
-    learnWhy: string | null;
-    recordedAt: string;
-};
-export declare function checkFactOf(store: Store, runId: number): CheckFact | null;
-/** A check's recorded results, by source then identity. */
-export declare function checkResultsOf(store: Store, runId: number): {
-    identity: string;
-    state: CheckResultState;
-    source: CheckResultSource;
-}[];
-/**
- * What a project's Full checks are asked about for learning (`learn`): its tracked identities (learning_watch) — an
- * accepted note's until it ends, an observation's for 90 days — exact cases only, the most recently tracked first, at
- * most 200. Those left out are counted (`leftOut`): a coverage gap, said, never hidden.
- */
-export declare function learnRequestFor(store: Store, repo: string, now: Date, runId?: number): {
-    learn: string[];
-    leftOut: number;
-};
-export {};

package/dist/check-failure.d.ts

@@ -1,113 +0,0 @@
-import { type CheckReport } from "./contracts/release-check.js";
-import { type CheckLoadRecord } from "./check-load.js";
-import { INFRA_RERUNS_PER_CANDIDATE, INFRA_RERUNS_PER_INCIDENT, type FailureClassName } from "./release.js";
-import type { Store } from "./store.js";
-export type FailureClass = FailureClassName;
-export type ClassifiedFailure = {
-    class: FailureClass;
-    why: string;
-};
-/** The plane's limits for confirmed infrastructure failures (one rerun per incident, two per candidate). */
-export { INFRA_RERUNS_PER_CANDIDATE, INFRA_RERUNS_PER_INCIDENT };
-/** The ledger action that records each rerun the release asked for, and why. */
-export declare const RELEASE_RECHECK_ACTION = "release check rerun";
-/** What a sealed verification receipt says about the check (receipt.result, and its coverage). */
-export type CheckFacts = {
-    result: {
-        configured: boolean;
-        ran?: boolean;
-        exitCode?: number;
-        attemptFailed?: boolean;
-        failure?: string;
-    };
-    coverage?: string | undefined;
-    /** The approved limit of the command the receipt names (receipt.command.timeoutMs): a load record must be for it. */
-    grantMs?: number | undefined;
-};
-/**
- * One failed check, classified. `facts` come from the plane's sealed receipt and `load` from the plane's own sealed load
- * record (check-load.ts); `report` (the check's own report, sealed when valid) only ever picks among the classes that
- * block — a timeout is excused only when the report names nothing else that failed, and only by the plane's own facts:
- * its load readings cut the budget, and the check ran into its limit by the plane's own clock. Null when it passed.
- */
-export declare function classifyCheckFailure(facts: CheckFacts, report: CheckReport | null, load?: CheckLoadRecord | null): ClassifiedFailure | null;
-/** What passed only on a retry inside a passing check (a real-model journey group, a unit file): counted and reported,
- * never silently part of a pass. Null when there is no valid report to read it from: unknown, never "no retries". */
-export declare function retriedInside(report: CheckReport | null): string[] | null;
-/** A run's check, classified from its sealed receipt and sealed report; null when it passed, or can't be read (then
- * `unreadable` says why — an unreadable receipt is itself unknown). */
-export declare function classifyRunCheck(store: Store, root: string, runId: number): ClassifiedFailure | null;
-/**
- * What passed only on a retry inside a run's check (eval-harness review 1, finding 3): the summary sealed into its
- * protected receipt, which a damaged or lost report can't take away; for an older receipt without one, read from the
- * sealed report. Null — unknown — when neither can be read, or when a readable report disagrees with the receipt.
- */
-export declare function retriedOfRun(store: Store, root: string, runId: number): string[] | null;
-/** How a check rerun after the approved recovery setup reads among the retries. */
-export declare const SETUP_REPLAY_RETRY = "the whole check, rerun after the approved setup";
-/**
- * The rerun's words with its first attempt's own class (eval-harness review 2, finding 5): a launch failure names the
- * missing program; a receipt that doesn't classify it (an older one) says so, never that it was a launch failure.
- */
-export declare function setupReplayWords(first: unknown): string;
-/**
- * An attempt interrupted before its candidate was even loaded (run 3326: the worker stopped under it — "The attempt was
- * stopped before the prepared candidate was loaded."): it ran no check, so it is no check failure of the commit. Only
- * the plane's own records say so, all of them at once: the run ended failed/interrupted, recorded no commit, and has no
- * check attempt (sealed before any check command runs), no recorded check and no check log or receipt. Any attempt that
- * got as far as its check keeps every rule below.
- */
-export declare function ranNoCheck(store: Store, row: {
-    id: number;
-    outcome: unknown;
-    reason: unknown;
-    head: unknown;
-    checkRow: unknown;
-}): boolean;
-/** The ledger entry the build writes when it refuses a prepared candidate before any process (builder.ts). */
-export declare const NOTHING_STARTED_ACTION = "attempt refused before anything ran";
-/**
- * Whether a passing check of a release task stands, given every earlier attempt on the same candidate and signed scope:
- * each earlier failure must be confirmed infrastructure the release itself reran (at most two), and nothing in the
- * passing run may have passed only on a retry. A deterministic, unknown or agent failure before it isn't erased by a
- * later pass: a person decides. `retried` is reported even when it stands (a person's approval reads it; an automatic
- * one refuses on it).
- */
-export declare function releaseCheckStanding(store: Store, root: string, input: {
-    taskId: string;
-    run: number;
-}): {
-    ok: true;
-    earlier: {
-        run: number;
-        why: string;
-    }[];
-    retried: string[] | null;
-} | {
-    ok: false;
-    why: string;
-    retried: string[] | null;
-};
-export declare const classWords: (kind: FailureClass) => string;
-export type RecheckAnswer = {
-    action: "rerun";
-    class: "infrastructure";
-    why: string;
-    source: number;
-    run: number;
-} | {
-    action: "pending";
-    source: number;
-} | {
-    action: "stop";
-    class: FailureClass | null;
-    why: string;
-    source: number | null;
-};
-/**
- * After a failed release check: the plane classifies the task's newest attempt from its own records and, only for
- * confirmed infrastructure within its limits (one rerun per incident, two per candidate), runs the check again on the
- * same candidate under the same approval (dispose.ts regateTask keeps candidate, scope and approval). Every attempt
- * stays in the evidence; each rerun is in the ledger with its class. Anything else stops, saying which class and why.
- */
-export declare function recheckReleaseTask(store: Store, root: string, taskId: string, now: Date): RecheckAnswer;