toolroll 0.9.104 → 0.9.105

package/dist/lead-tools.d.ts

@@ -1,167 +0,0 @@
-import { type FeedbackImage } from "./result-review.js";
-import { type FastPreview } from "./fast-start.js";
-import { type CommitmentChannel } from "./lead-commitments.js";
-import { type Integration } from "./integrations.js";
-import type { AuthMode } from "./keys.js";
-import type { ProviderId } from "./provider.js";
-import { type ReviewSnapshot } from "./chat-review.js";
-import { type Store, type LeadProposalKind, type LeadTurnEvidence } from "./store.js";
-import type { VerifiedApprover } from "./principal.js";
-import type { LeadToolSchema } from "./converse.js";
-import { type AcceptanceCriterion } from "./scope.js";
-import { type ContractResult } from "./contracts/contract.js";
-export declare const LEAD_MAX_PROPOSALS_PER_TURN = 5;
-export type LeadToolContext = {
-    store: Store;
-    who: VerifiedApprover;
-    now: Date;
-    /** Records a proposal as `drafting` under the running turn; null when the turn may draft no more. */
-    draft: (kind: LeadProposalKind, payload: Record<string, unknown>) => number | null;
-    /** The step this call runs in, and which decisions were read (by get_decision) at which step —
-     * an answer may be proposed only for a decision read in an EARLIER step (v3 review, finding 6). */
-    step: number;
-    readDecisions: Map<number, number>;
-    readResults?: Map<number, {
-        step: number;
-        snapshot: ReviewSnapshot;
-    }>;
-    replyImage?: FeedbackImage;
-    /** Where evidence lives, when the surface knows — a scout's report reads from here. */
-    evidenceRoot?: string;
-    /** Records the screenshots this turn selected, under the turn, for a channel that delivers files; returns how many are recorded. Absent: nothing durable is kept. */
-    /** Return the exact artifact ids reserved under this running turn, including earlier calls. */
-    selectEvidence?: (rows: readonly Omit<LeadTurnEvidence, "turn" | "ordinal" | "createdAt">[]) => readonly number[];
-    /** How this surface delivers selected images: Telegram sends them as documents after the reply; every other surface shows identity only. */
-    mediaDelivery?: "documents";
-    /** The conversation and turn this call runs in: where a promise (commit_to) is reported. Absent: no promise can be kept. */
-    thread?: number;
-    turn?: number;
-    /** The chat this turn arrived on, where a promise is reported; absent: the console or terminal conversation. */
-    channel?: CommitmentChannel;
-    /** Where search_project_memory looked this turn (a project path, or "*" for every project) and at which step. A proposal
-     * on a project with recorded decisions needs a search over it in an EARLIER step. Absent: no search happened. */
-    searchedMemory?: Map<string, number>;
-    /** The integrations as Settings → Integrations shows them; absent: read from the files beside the database. */
-    integrations?: () => readonly Integration[];
-    /** How each provider signs in (its subscription or an API key); absent: read from the keys folder, as a run does. */
-    authMode?: (provider: ProviderId) => AuthMode;
-    /** Which projects get_capabilities read this turn (each project path it covered) and at which step. A proposal or
-     * promise whose work needs an agent, a worker or an integration needs a read covering it in an EARLIER step. The
-     * conversation loop always passes it; absent (a direct call outside a turn), nothing is checked. */
-    checkedCapabilities?: Map<string, number>;
-    /** Records this turn's one question to its owner; false when it already asked one. Absent: this surface cannot ask. */
-    ask?: (question: string, options: readonly string[]) => boolean;
-    /** This turn's tool discovery (find_tools): how many searches it made and which deferred tools it found, which the
-     * conversation loop advertises from its next request. Absent (a direct call outside a turn): nothing to add to. */
-    findTools?: {
-        searches: number;
-        found: Set<string>;
-    };
-    /** propose_start only (docs/plans/one-step-chat.md C3): the preview the conversation loop prepared for THIS call, in
-     * this turn, after the call's input was validated (startInputOf). Never read from the model's arguments; absent (a
-     * direct call outside a turn), nothing was prepared and the person gets an ordinary task card. */
-    startPrepared?: FastPreview;
-};
-export type LeadToolResult = {
-    ok: true;
-    body: unknown;
-} | {
-    ok: false;
-    message: string;
-};
-export { reportSummaryFor } from "./report-summary.js";
-export type LeadViewContext = {
-    repos: readonly string[];
-    names: readonly string[];
-};
-/** Scrub one string. Exact repo paths and their basenames go first (v13: no paths, no basenames), then shapes. */
-export declare function redactForLead(text: string, view: LeadViewContext): string;
-/** The choke point: every string inside a tool result, recursively, scrubbed. */
-export declare function leadView<T>(value: T, view: LeadViewContext): T;
-export declare function leadViewContextFor(store: Store, who: VerifiedApprover): LeadViewContext;
-/** Project names are deliberate display metadata, not a general basename
- * exemption. Invalid, sensitive or account-identifying labels stay opaque. */
-export declare function projectLabelForLead(path: string, index: number, names: readonly string[]): string;
-/** The same text rule, for the gateway's proposals. */
-export declare function honestText(value: unknown, maxChars: number): value is string;
-export declare function readOptionalText(value: unknown, maxChars: number): string | null | undefined;
-export declare function readTouches(value: unknown): string[] | null;
-/** v39: the rubric a mate or coordinator proposal drafts — mandatory,
- * parsed the same way every other authoring road parses one. `null` means
- * the argument did not even parse into a non-empty rubric. */
-export declare function readAcceptanceArg(value: unknown): AcceptanceCriterion[] | null;
-/** A lead tool as the model is shown it (its inputSchema derived from its contract) and as a call is read and run. */
-export type LeadTool = LeadToolSchema & {
-    read: (ctx: LeadToolContext, raw: Record<string, unknown>) => ContractResult<Record<string, unknown>>;
-    handle: (ctx: LeadToolContext, args: Record<string, unknown>) => LeadToolResult;
-};
-/** Replace every `repoIndex` with a `repo` label, recursively. */
-export declare function labelRepos<T>(value: T, label: (index: number) => string): T;
-export declare function recapOver(store: Store, repos: readonly string[], now: Date, since: string | null): Record<string, unknown>;
-export declare function decisionsOver(store: Store, repos: readonly string[], now: Date): Record<string, unknown>;
-/**
- * One decision as a proposer may read it (mate arc v3, rule change #3):
- * the question, each option's id, label, reversibility, and consequence —
- * never the recap or the builder's recommendation. `repoIndex` names the
- * task's repo for the view; a decision outside `repos` is null.
- */
-export declare function decisionOver(store: Store, repos: readonly string[], decisionId: number, now: Date): Record<string, unknown> | null;
-export declare function queueOver(store: Store, repo: string, now: Date): Record<string, unknown>;
-export declare const ISO_STAMP_RULE: RegExp;
-/**
- * THE AGENTS A TASK RUNS UNDER, as chat reads them (v48): the task's size,
- * the same one-line summary the task page and CLI
- * print, each role's exact agent with its reasons, the standing of those
- * agents (approved / awaiting approval / recommended), and — for a
- * proposal — only the configured, role-valid choices an operator could
- * pick. Nothing here is a term chat may bind on its own; every change goes
- * through a confirmed card into the one authenticated edit transaction.
- */
-export declare function agentsOver(store: Store, taskId: string, now: Date): Record<string, unknown> | null;
-/**
- * The tools every request advertises (docs/plans/lead-deferred-tools.md): the ones most replies use, and every tool a
- * guard requires read in an earlier step (search_project_memory before any proposal, get_capabilities before work that
- * needs an agent, get_result before propose_review, get_decision before propose_answer). The rest are found with
- * find_tools and advertised from the next request of the same reply.
- */
-export declare const LEAD_CORE_TOOLS: ReadonlySet<string>;
-/** At most this many find_tools searches per reply, results per search, and bytes of found tool schemas per reply. */
-export declare const FIND_TOOLS_PER_TURN = 3;
-export declare const FIND_TOOLS_MAX_RESULTS = 6;
-export declare const FIND_TOOLS_SCHEMA_BYTES = 48000;
-/** The deferred tools a query finds, best first: an exact name, then words in the name, keywords and description. */
-export declare function findLeadTools(query: string): {
-    name: string;
-    summary: string;
-}[];
-/** The lead's tools, in the order the model is shown them: each one's inputSchema is its contract, derived. */
-export declare const LEAD_TOOLS: LeadTool[];
-/** A unified diff, file by file, with each file's added and removed lines. */
-export declare function patchFiles(patch: string): {
-    path: string;
-    added: number;
-    removed: number;
-    text: string;
-}[];
-export declare const LEAD_TOOL_SCHEMAS: LeadToolSchema[];
-export declare function isLeadTool(name: string): boolean;
-/** Scrub every result. Only list_repos then adds validated display metadata
- * from the same admitted project list; no user-authored result gets an exemption. */
-export declare function executeLeadTool(ctx: LeadToolContext, name: string, args: Record<string, unknown>, view?: LeadViewContext): LeadToolResult;
-/** Bytes of a serialized tool result as it will sit inside the request body. */
-export declare function toolResultBytes(text: string): number;
-/** What propose_start may start with, checked before Toolroll asks the classifier (docs/plans/one-step-chat.md C3): the
- * call's contract, the same memory and capability checks every proposal makes, never a team chat, a project the person
- * can reach now, and the same text and secret checks as propose_task. The conversation loop runs this, and only then
- * prepares a preview; the handler runs it again. Invalid input never reaches the classifier. */
-export declare function startInputOf(ctx: LeadToolContext, args: Record<string, unknown>): {
-    ok: true;
-    input: {
-        repo: string;
-        repoId: string;
-        title: string;
-    };
-} | {
-    ok: false;
-    message: string;
-};

package/dist/lead-voice.d.ts

@@ -1,85 +0,0 @@
-/** The lead's voice: what the person's lead (an agent under their lead token) is doing, in their chat and on the
- * console. `lead say` posts one short message from the lead, by the name its person gave it (Settings → Lead); several within two minutes are one message, edited
- * in place as it grows. `assignment claim` marks a task the lead's: it reads "<name> is on it" and leaves Needs
- * you until the lead completes it, hands it to a person, or two hours pass with no lead act on it.
- *
- * Every fact is an append-only ledger row under "lead for <owner>"; no table of its own. The chat message is an
- * ordinary notification addressed to the owner, so every chat delivers it with the usual receipts. */
-import { type Actor } from "./actor.js";
-import { type Notification, type Store } from "./store.js";
-export declare const LEAD_SAY_KIND = "lead-say";
-/** Repaints the owner's task card when the lead takes a task on: it never makes a new message in quiet chat. */
-export declare const LEAD_ON_IT_KIND = "lead-on-it";
-/** Repaints the owner's task card when a claim lapses: the card reads its real state again, and says so. */
-export declare const LEAD_LAPSED_KIND = "lead-lapsed";
-export declare const LEAD_SAID = "lead said";
-export declare const LEAD_CLAIMED = "lead is on it";
-/** A claim lapses after this long without a lead act on the task. */
-export declare const LEAD_IDLE_MS: number;
-/** The lead's acts that hand the task back: done, handed to a person, or cancelled. */
-export declare const LEAD_ENDS: readonly ["task completed", "task handed to a person", "task cancelled"];
-export declare const LEAD_SAY_MAX = 300;
-/** The work index's reading of a claim, per row of its `classified` projection: 0 none, 1 on it, 2 lapsed. Only the
- * viewer's own lead counts (`$leadOf`, "lead for <viewer>"; null for nobody): another person's lead is not yours. */
-export declare const LEAD_CLAIM_SQL: string;
-export type LeadClaim = {
-    state: "on-it" | "lapsed";
-    owner: string;
-    since: string;
-    lastActedAt: string;
-};
-export type LeadActivity = {
-    owner: string;
-    doing: string;
-    at: string;
-    taskId: string | null; /** What the owner calls their lead. */
-    name: string;
-};
-type Failure = {
-    ok: false;
-    reason: "usage" | "unknown-task" | "refused";
-    message: string;
-};
-/** One line of the lead's words: plain, short, no control characters. */
-export declare function leadWordsProblem(text: string): string | null;
-/** `lead say`: record the words as the lead's act, and post them in the owner's chat. Within two minutes of the
- * first, a later say joins it: the new row carries every line, and the earlier one stops waiting to be sent (a
- * chat that already showed it edits that message in place). */
-export declare function leadSay(store: Store, actor: Actor, text: string, taskId: string | null, now: Date): {
-    ok: true;
-    joined: boolean;
-    notification: number | null;
-} | Failure;
-/** A lead row's subject in its owner's current name for their lead, read when it is shown, so a rename reaches
- * earlier cards too; any other row's own subject. `reader`: who the chat belongs to, for a row with no recipient
- * (only its owner ever receives a lead row). */
-export declare function leadSubjectOf(store: Store, row: Pick<Notification, "kind" | "subject" | "recipient">, reader?: string | null): string;
-/** The words a chat shows for a lead-say row: the lead's name, then each line, plain, with no task id. `reader`: whose
- * chat it is, for a row with no recipient (see leadSubjectOf). */
-export declare function leadSayText(store: Store, row: Pick<Notification, "kind" | "subject" | "body" | "recipient">, reader?: string | null): string;
-/** The earlier rows of a lead-say message (newest first): a chat that showed one edits it rather than sending again. */
-export declare function leadSayEarlier(store: Store, row: Pick<Notification, "id" | "kind" | "dedupeKey" | "recipient">): number[];
-/** `assignment claim` under the lead token: the task is the lead's until it completes it, hands it on, or goes
- * quiet on it for two hours. Repeating a claim is safe and counts as a lead act. */
-export declare function leadClaim(store: Store, actor: Actor, taskId: string, now: Date): {
-    ok: true;
-    root: string;
-    claim: LeadClaim;
-} | Failure;
-/** Whether `viewer`'s own lead has this task now: on it, lapsed after two quiet hours (it says so), or null (never
- * claimed by their lead, handed on by it since, or completed or cancelled by anyone). Another person's lead never counts. */
-export declare function leadClaimOf(store: Store, taskId: string, now: Date, viewer: string | null | undefined): LeadClaim | null;
-/** A claim that lapsed repaints its owner's card once per lapse: the card reads the task's real state again and
- * says it is back with them. Run beside the evening digests on every chat pass; claims are found through their
- * repaint rows (an indexed key range), so nothing scans the ledger. */
-export declare function enqueueLeadLapses(store: Store, now: Date): number;
-/** The lead's act on a task that a claim counts (a retry, a state change, a steer): one ledger row as the lead. */
-export declare function noteLeadWork(store: Store, actor: Actor, taskId: string, what: string, now: Date): void;
-/** What `owner`'s own lead is doing now and when it last acted, both from its one newest act: its words when that
- * was a say, else the act in words. Nobody (null) has no lead line: another person's lead is never theirs. */
-export declare function leadActivity(store: Store, owner: string | null | undefined): LeadActivity | null;
-/** "just now", "3 min ago", "2 h ago", "yesterday", "4 days ago". */
-export declare function agoWords(at: string, now: Date): string;
-/** The one line `toolroll status` and the console say: "Lead: fixing 0.9.12's release check · 3 min ago". */
-export declare function leadActivityLine(activity: LeadActivity, now: Date): string;
-export {};

package/dist/lead.d.ts

@@ -1,142 +0,0 @@
-import { type LeadProgress } from "./lead-progress.js";
-import type { ChatConfig, LeadSession, LeadThread, Store } from "./store.js";
-import type { LeadFailureDetail } from "./lead-latency-schema.js";
-import type { Integration } from "./integrations.js";
-import type { VerifiedApprover } from "./principal.js";
-import { type LeadHistoryMessage } from "./converse.js";
-import { type SubscriptionLeadRunner } from "./subscription-chat.js";
-import { type LeadChannel } from './lead-context.js';
-export declare const LEAD_MESSAGE_MAX_CHARS = 2000;
-/** The thread's recent history the model sees, most recent first until the cap. */
-export declare const LEAD_HISTORY_CAP_BYTES = 16384;
-export declare const LEAD_HISTORY_MAX_MESSAGES = 40;
-export type LeadTurnInput = {
-    store: Store;
-    who: VerifiedApprover;
-    session: LeadSession;
-    thread: LeadThread;
-    /** The installation's chat configuration: provider, model, pinned price, caps. */
-    config: ChatConfig;
-    /** Direct API key; subscription providers use their cached harness login. */
-    key: string | null;
-    message: string;
-    /** Stable browser send identity. A retry returns the original turn,
-     * including a failed one; it never dispatches the provider again. */
-    requestId?: string;
-    /** A central conversation saved this operator message before acknowledging
-     * delivery. Bind it to this turn instead of inserting a second copy. */
-    queuedMessageId?: number;
-    /** Called inside turn admission. A failed queue fence rolls admission back. */
-    onAdmitted?: (turn: number) => void;
-    /** A personal queue claim (lead-queue.ts) this turn runs: with `queuedMessageId`, the queued message of the person's
-     * own thread this turn binds; admission lets it through the person's backlog (store.openLeadTurn). */
-    queueClaim?: {
-        message: number;
-        runner: string;
-        generation: number;
-    };
-    /** Safe, server-authored context for this turn only. Kept out of the
-     * visible thread so a task-scoped composer still reads like a normal
-     * conversation. */
-    context?: string;
-    /** Exact image from the transport record of the message being answered. */
-    replyImage?: import("./result-review.js").FeedbackImage;
-    fetcher?: typeof fetch;
-    /** Injected by tests; production invokes the isolated local harness. */
-    subscriptionRunner?: SubscriptionLeadRunner;
-    /** Live progress for someone watching (chat streaming): the steps, the
-     * tools in plain words, and the reply as it is written. Display only;
-     * never called with text that looks like a secret. */
-    onProgress?: (event: LeadProgress) => void;
-    clock?: () => Date;
-    /** Where evidence lives — get_task reads a scout's report from here. */
-    evidenceRoot?: string;
-    /** Where this conversation happens, so the lead fits its replies to it. */
-    channel?: LeadChannel;
-    /** A shared team conversation's own lead name, in place of this person's (Settings → Lead). */
-    leadName?: string;
-    /** How this surface delivers the images a turn selects: Telegram sends them as documents after the reply; absent means identity only. */
-    mediaDelivery?: "documents";
-    /** The integrations as Settings → Integrations shows them (get_integrations); absent: read from the files beside the database. */
-    integrations?: () => readonly Integration[];
-    /**
-     * A channel's own standing, re-proved where the approver's is: before
-     * admission, before every provider dispatch, after every provider wait,
-     * and before any tool runs. The
-     * paired Telegram chat uses it to prove the binding, its generation and
-     * the enrolled ceiling are still what the turn opened under — account
-     * generation alone cannot see an unpairing or a project removed from
-     * enrollment. A refusal ends the turn with nothing kept.
-     */
-    revalidate?: () => Promise<{
-        ok: true;
-    } | {
-        ok: false;
-        reason: LeadChannelProblem;
-    }>;
-};
-/** Why a chat's standing changed under a turn: each has its own plain words (LEAD_CHANNEL_COPY). */
-export type LeadChannelProblem = "unpaired" | "not-approver" | "projects-changed" | "projects-unreadable" | "member-changed" | "access-changed";
-export type LeadRefusal = "empty-message" | "secret-in-message" | "secret-in-context" | "standing" | "unpriced" | "ceiling-changed" | "not-yours" | "thread-closed" | "latched" | "concurrent" | "backlog" | "daily-cap" | "session-exhausted" | "session-ended" | "over-budget" | "monthly-budget" | "policy" | "invalid-request" | "request-changed" | "channel";
-export type LeadFailure = "provider-error" | "timeout" | "malformed-reply" | "secret-refused" | "latched" | "revoked" | "superseded" | "over-reservation";
-export type LeadTurnOutcome = {
-    ok: true;
-    replayed?: false;
-    turn: number;
-    reply: string;
-    activity: string;
-    proposals: number;
-    steps: number;
-    stoppedAtCap: boolean;
-    settledMicrousd: number;
-} | {
-    ok: true;
-    replayed: true;
-    turn: number;
-} | {
-    ok: false;
-    refused: LeadRefusal;
-    message: string;
-} | {
-    ok: false;
-    turn: number;
-    failed: LeadFailure;
-    message: string;
-    unknownSpend: boolean;
-    saved?: boolean;
-};
-/** What happened, what it means, and one next step: plain words a person can act on, never internal terms. */
-export declare const LEAD_REFUSAL_COPY: Record<LeadRefusal, string>;
-/** A turn stopped because its chat's standing changed: what happened, what it means, one next step. */
-export declare const LEAD_CHANNEL_COPY: Record<LeadChannelProblem, string>;
-/** Why a reply did not finish, in the same three parts: what happened, what it means, one next step. */
-export declare const LEAD_FAILURE_COPY: {
-    readonly stopped: "This reply was stopped before it finished, from another window or by a newer message. Nothing it proposed was kept. Send your message again if you still need an answer.";
-    readonly ended: "Your sign-in or this conversation ended while the lead was answering. Nothing it proposed was kept. Sign in again or start a new chat, then send your message again.";
-    readonly tooLong: string;
-    readonly secretRead: "Something the lead read looked like a password or key, so it stopped before sending it anywhere. Nothing was kept. Remove the password or key from that task or note, then ask again.";
-    readonly secretReply: "The lead's reply contained something that looked like a password or key, so it was thrown away. Nothing was kept. Ask again, without asking for a password or key.";
-    readonly paused: "An earlier reply stopped before its cost was known, so chat is paused. This message wasn't answered. Confirm that earlier reply on the Chat page, then send again.";
-    readonly notStarted: "The reply couldn't be started. Nothing was kept or charged. Send your message again.";
-    readonly notInstalled: "The chat app the lead uses isn't installed on this computer, so it couldn't answer. Nothing was kept. Install it, or choose another provider in Settings → Lead.";
-    readonly unreadable: "The chat provider sent back an answer that couldn't be read, so it was thrown away. Nothing was kept. Send your message again.";
-    readonly signIn: "The chat provider couldn't answer; its sign-in may have expired. Nothing was kept. Sign in to it again on this computer, then send your message again.";
-    readonly refused: "The chat provider turned the request down. Nothing was kept or charged. Try again in a minute; if it keeps happening, check the provider in Settings → Lead.";
-    readonly tooLongUnknownCost: string;
-    readonly lostUnknownCost: "The chat provider stopped responding partway through, and the cost isn't known, so chat is paused. Nothing it proposed was kept. Confirm the cost on the Chat page to turn chat back on.";
-    readonly unreadableUnknownCost: "The chat provider sent back an answer that couldn't be read, and its cost isn't known, so chat is paused. Nothing it proposed was kept. Confirm the cost on the Chat page to turn chat back on.";
-    readonly overReserved: "This reply reported more use than was set aside for it, so its cost is counted as unknown and chat is paused. Nothing it proposed was kept. Confirm the cost on the Chat page to turn chat back on.";
-    readonly empty: "The lead sent back an empty answer. Nothing was kept. Send your message again.";
-    readonly unusable: "The lead's answer couldn't be used, so it was thrown away. Nothing was kept. Send your message again.";
-};
-/** A failed turn's saved reason as plain words, for a surface that reads the turn back later (a restart, a delivery retry).
- * Its saved detail (v158), when known, names the exact cause the person saw live ("not installed", "sign-in expired"). */
-export declare function leadFailureText(reason: string | null, unknownSpend?: boolean, detail?: LeadFailureDetail | null): string;
-/** How long a provider that ignored its abort at the turn's deadline is waited for before the turn ends without it.
- * Its process group was already killed at the deadline; this only bounds the wait for the transport to say so. */
-export declare const LEAD_ABORT_GRACE_MS = 5000;
-/** The last messages of the thread as provider-neutral history, newest kept first until the byte cap. */
-export declare function historyFor(store: Store, thread: number, queuedMessageId?: number, named?: boolean): LeadHistoryMessage[];
-/** "read 3 · proposed 1 · 2 steps" — counts only, never results (ruling 11). */
-export declare function activitySummary(reads: number, proposals: number, steps: number, cacheShare?: number | null): string;
-export declare function runLeadTurn(input: LeadTurnInput): Promise<LeadTurnOutcome>;

package/dist/learning-child.d.ts

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

package/dist/learning-look.d.ts

@@ -1,25 +0,0 @@
-import { type FirstTaskSuggestion } from "./first-run.js";
-/** How long one project's recovery may take before it is stopped (the next pass tries again). */
-export declare const LEARNING_LOOK_MS = 60000;
-/** How long reading one project's first-task suggestions may take. */
-export declare const FIRST_TASKS_LOOK_MS = 20000;
-export type LearningOutcome = "done" | "failed" | "no-answer";
-export type LearningRunner = (input: {
-    databaseFile: string;
-    evidenceRoot: string;
-    repo: string;
-}, deadlineMs: number) => Promise<LearningOutcome>;
-/** The production learning runner: learning-child in its own process. */
-export declare const learningChild: LearningRunner;
-/** Recover learning for each project in turn, each in its own bounded process. */
-export declare function recoverLearningOffThread(input: {
-    databaseFile: string;
-    evidenceRoot: string;
-    repos: readonly string[];
-}, options?: {
-    runner?: LearningRunner;
-    deadlineMs?: number;
-}): Promise<Map<string, LearningOutcome>>;
-/** One project's first-task suggestions (first-run.ts findFirstTasks: its issues through gh, its TODOs through the
- * hardened git) read in a process of its own. Rejects when it failed or didn't answer: the caller keeps the generic ones. */
-export declare function firstTasksOffThread(repo: string, deadlineMs?: number): Promise<FirstTaskSuggestion[]>;

package/dist/ledger-chain.d.ts

@@ -1,46 +0,0 @@
-import type { Database } from "./store.js";
-export declare const LEDGER_CHAIN_SCHEMA = "\nCREATE TABLE IF NOT EXISTS ledger_seal (\n  id   INTEGER PRIMARY KEY,\n  prev TEXT NOT NULL,\n  hash TEXT NOT NULL\n);\nCREATE TRIGGER IF NOT EXISTS ledger_seal_no_update BEFORE UPDATE ON ledger_seal\nBEGIN SELECT RAISE(ABORT, 'the ledger chain is append-only'); END;\nCREATE TRIGGER IF NOT EXISTS ledger_seal_no_delete BEFORE DELETE ON ledger_seal\nBEGIN SELECT RAISE(ABORT, 'the ledger chain is append-only'); END;\nCREATE TABLE IF NOT EXISTS ledger_checkpoint (\n  id      INTEGER PRIMARY KEY AUTOINCREMENT,\n  through INTEGER NOT NULL,\n  hash    TEXT NOT NULL,\n  at      TEXT NOT NULL,\n  by      TEXT NOT NULL\n);\nCREATE TRIGGER IF NOT EXISTS ledger_checkpoint_no_update BEFORE UPDATE ON ledger_checkpoint\nBEGIN SELECT RAISE(ABORT, 'ledger checkpoints are append-only'); END;\nCREATE TRIGGER IF NOT EXISTS ledger_checkpoint_no_delete BEFORE DELETE ON ledger_checkpoint\nBEGIN SELECT RAISE(ABORT, 'ledger checkpoints are append-only'); END;\n";
-/** Where the chain starts: the previous fingerprint of the first entry. */
-export declare const LEDGER_GENESIS: string;
-/** A whole number column as JavaScript can hold it: one past 2^53 (only a hand edit puts one there) reads as its text,
- * which `rowProblem` names, instead of failing the read. */
-export declare const safeWhole: (column: string, as?: string) => string;
-/** An entry's fingerprint: the previous one and the entry's own fields, in a fixed order. */
-export declare function entryHash(prev: string, row: Record<string, unknown>): string;
-export declare const IN_RANGE: string;
-/** Why a row can't be an entry the ledger wrote: each field is exactly the kind of value its writers store. */
-export declare function rowProblem(row: Record<string, unknown>): string | null;
-/** Seal every entry written since the last seal, in id order. Returns how many were sealed. Call inside a write transaction. */
-export declare function sealLedger(db: Database): number;
-export type LedgerChainReport = {
-    ok: boolean;
-    /** Entries checked, and the last sealed entry's id and fingerprint (the head). */
-    entries: number;
-    through: number | null;
-    head: string;
-    /** Entries written after the last seal (sealed on the next pass; not yet part of the proof). */
-    unsealed: number;
-    checkpoints: number;
-    /** The first place the chain breaks, in words. */
-    problem: {
-        id: number | null;
-        what: string;
-    } | null;
-    /** When the whole chain was last walked from its first entry (later entries were checked as they were added). */
-    checkedAt: string | null;
-};
-/** Where a walk may start instead of the first entry: a head this process walked to before. */
-export type VerifiedHead = {
-    through: number;
-    head: string;
-    entries: number;
-};
-/** Walk the chain: every entry sealed, every seal an entry, each fingerprint right and linked to the one before,
- * and every checkpoint still matching. With `from`, the walk starts at a head verified earlier, after checking that
- * the head is still there (a chain rebuilt since doesn't match it). Reads only; call inside one read transaction. */
-export declare function verifyLedgerChain(db: Database, from?: VerifiedHead, checkedAt?: string | null): LedgerChainReport;
-/** Whether the chain still ends at a head someone copied off the machine (`<through>:<hash>`). */
-export declare function matchesOutsideCheckpoint(db: Database, checkpoint: string): {
-    ok: boolean;
-    what: string;
-};

package/dist/ledger-csv.d.ts

@@ -1,4 +0,0 @@
-import type { LedgerEntry } from "./action-ledger.js";
-export declare function csvCell(value: string | number | null): string;
-export declare const LEDGER_CSV_HEADER: string;
-export declare function ledgerCsvRows(rows: readonly LedgerEntry[]): string;

package/dist/ledger-view.d.ts

@@ -1,27 +0,0 @@
-import type { LedgerEntry } from "./action-ledger.js";
-import { type Html } from "./html.js";
-/** v103: the chain's state in one line, and (for an instance operator) a checkpoint to copy off the machine. */
-export type LedgerChainView = {
-    ok: boolean;
-    entries: number;
-    through: number | null;
-    head: string;
-    unsealed: number;
-    problem: {
-        id: number | null;
-        what: string;
-    } | null;
-    /** When the whole chain was last walked. */
-    checkedAt: string | null;
-    latest: {
-        through: number;
-        hash: string;
-        at: string;
-    } | null;
-    csrf: string | null;
-    /** Today (UTC, YYYY-MM-DD): the audit export's default range ends here. */
-    today: string;
-};
-/** The audit log (`/ledger`): what people and tokens did, newest first, as quiet timed rows, with the filters, the CSV
- * and the sealed export. A kit list page: the top bar, then rows between hairlines. */
-export declare function ledgerBody(rows: LedgerEntry[], projects: readonly string[], params: URLSearchParams, chain?: LedgerChainView): Html;

package/dist/lesson-notes.d.ts

@@ -1,81 +0,0 @@
-import type { Store } from "./store.js";
-export declare const NOTE_SURFACE = "lesson-note";
-/** The note behind a proposal, or null: the only thing that marks a `decision-add` as a lesson note. */
-export type LessonNote = {
-    proposal: number;
-    repo: string;
-    failedRun: number;
-    passingRun: number;
-    repairChain: number | null;
-    revisionOrigin: string | null;
-    identities: string[];
-    changedPaths: string[];
-    testFilesChanged: string[];
-    factsDigest: string;
-    createdAt: string;
-};
-export declare function lessonNoteOf(store: Store, proposal: number): LessonNote | null;
-/**
- * What this run's check should also ask about for learning: the failed cases of the check it revises (rule 4). Advisory:
- * a separate handshake field, never the gate's `watch`. Called before the run's check starts, so its own facts don't
- * exist yet.
- */
-export declare function revisedFailures(store: Store, runId: number): string[];
-/** Test and harness files, as a reader would call them. Every one R changed is listed, never hidden. */
-export declare function testOrHarnessPath(path: string): boolean;
-export type NoteOutcome = {
-    proposal: number;
-} | {
-    none: string;
-};
-/**
- * Consider a note for run R, once its check is recorded. Returns what happened; a note that can't be proposed for a
- * reason a person should see says so on R (rule 7). Any unreadable fact means no note.
- */
-export declare function considerLessonNote(store: Store, root: string, runId: number, now: Date): NoteOutcome;
-declare const sourceRefOf: (proposal: number) => string;
-/** Track an accepted note's cases in every later Full check, whether or not a run received it. */
-export declare function watchNote(store: Store, input: {
-    repo: string;
-    proposal: number;
-    identities: readonly string[];
-    decisionRevision?: number;
-    now: Date;
-}): void;
-/** A note's tracking ends when its decision stops being active. */
-export declare function endNoteWatch(store: Store, decisionSourceRef: string | null, now: Date): void;
-export declare const lessonNoteSourceRef: typeof sourceRefOf;
-/**
- * Count one check for every accepted note, in the transaction that records its results: distinct `(run, identity)`
- * pairs with explicit results, split by whether the run received the decision. A check with no line for the note's
- * tests counts as unreported. `observations`: what this check just added, so a failure elsewhere that turned out to
- * have mixed outcomes is counted as such.
- */
-export declare function tallyCheck(store: Store, runId: number, repo: string, observations: readonly number[], now: Date): void;
-/** A month whose check couldn't be recorded is partial, and says so. */
-export declare function markTalliesPartial(store: Store, repo: string, now: Date): void;
-export type NoteAfterwards = {
-    since: string;
-    executions: number;
-    failures: number;
-    mixed: number;
-    receivedExecutions: number;
-    receivedFailures: number;
-    unreported: number;
-    partial: boolean;
-    sources: string[];
-};
-/** What a note's tallies say since it was accepted: sums of durable rows, unchanged by retention. */
-export declare function noteAfterwards(store: Store, decision: {
-    id: number;
-    decidedAt: string;
-    sourceRef: string | null;
-}): NoteAfterwards | null;
-/** "Since Nov 5: failed 1 of 31 runs of this test (0 of 18 that received this note; 1 of 13 that didn't). …". No "helped". */
-export declare function afterwardsWords(after: NoteAfterwards): string;
-/** What waits for a person, for pages and chat. */
-export declare function memoryWaiting(store: Store, repo: string): {
-    notes: number;
-    cleanups: number;
-};
-export {};

package/dist/limits-ui.d.ts

@@ -1,34 +0,0 @@
-/**
- * Limits on the Tasks page (v105): each subscription's usage windows, as the
- * provider last said, and each monthly budget, one tile each. A subscription
- * costs nothing per run, so its windows are what bind it; budgets bind work
- * billed to an API key. An instance operator's view.
- */
-import type { BrowserLimits, BrowserUsageChip } from "./browser-workspace.js";
-import { type BudgetState } from "./spend.js";
-import { type Html } from "./html.js";
-/** "in 25 min", "in 2 h 10 min", or a day and hour ("Fri 11 PM") beyond a day. */
-export declare function resetWords(resetsAt: string, now: Date): string;
-export declare function limitsView(windows: readonly {
-    provider: string;
-    window: string;
-    usedPercent: number;
-    windowMinutes: number | null;
-    resetsAt: string | null;
-    reached: boolean;
-    plan: string | null;
-    observedAt: string;
-}[], budgets: readonly BudgetState[], names: {
-    project: (repo: string) => string;
-    subagent: (id: number) => string;
-}, now: Date): BrowserLimits | null;
-/**
- * The usage chip (cockpit §3, R16): the subscription window with the highest use the providers last reported, as
- * "Claude 5-hour · 82% · resets 3h". A reading older than 30 minutes stays visibly stale ("as of 2h ago"), judged by
- * the reading's age as the Limits view judges it; a window with no known reset says "resets: unknown". API-key budgets
- * are not compared here (they stay in the details). An operator's view, as the Limits view is. Null: nothing reported.
- */
-export declare function usageChipOf(windows: Parameters<typeof limitsView>[0], now: Date): BrowserUsageChip | null;
-/** The same tiles for the page without scripts. */
-export declare function limitsHtml(limits: BrowserLimits | null): Html;
-export declare const LIMITS_CSS: string;