toolroll 0.9.104 → 0.9.105

package/dist/lead-identity.d.ts

@@ -1,23 +0,0 @@
-/** Who the lead is (Settings → Lead): the name a person gives their lead and the short persona it speaks with. The
- * name is what every chat, pushed update and status line calls the lead; the persona opens each turn's DATA. */
-import type { Store } from "./store.js";
-export declare const DEFAULT_LEAD_NAME = "Lead";
-export declare const DEFAULT_LEAD_PERSONA = "Be genuinely helpful, not performative. Have opinions and say which you'd pick. Check before you claim. Be resourceful before asking. Keep it short.";
-export declare const LEAD_NAME_MAX = 40;
-export declare const LEAD_PERSONA_MAX = 600;
-export type LeadIdentity = {
-    name: string;
-    persona: string;
-};
-/** This person's lead: their saved name and persona, else the defaults. An older store reads as the defaults. */
-export declare function leadIdentityOf(store: Store, account: string | null | undefined): LeadIdentity;
-/** The name alone, for the places the lead speaks. */
-export declare function leadNameOf(store: Store, account: string | null | undefined): string;
-/** The saved form of a name and persona, or the problem with them. An empty name or persona means the default. */
-export declare function checkLeadIdentity(name: string, persona: string): {
-    ok: true;
-    identity: LeadIdentity;
-} | {
-    ok: false;
-    message: string;
-};

package/dist/lead-latency-schema.d.ts

@@ -1,24 +0,0 @@
-/**
- * v158: the lead's latency records and its quick-answer switch (docs/plans/responsive-chat.md, slice 5). Adds only:
- * a saved row reads as it did. Kept beside nothing else so the update road can read the lists without the store.
- *
- * - `chat_turn.tools`: the tool names one lead step asked for, as a JSON array of names (never arguments); saved rows
- *   read NULL (not recorded). So the next latency decision (a prefetched brief, §7.2) is made from data.
- * - `chat_turn.failure_detail` and `mate_turn.failure_detail`: why a step or reply failed, more exactly than
- *   failure_reason (LEAD_FAILURE_DETAILS); saved rows read NULL (unknown), and read the plain reason's words as before.
- * - `mate_turn.route`: which model answered (§8): `default`, `fast` (the quick model answered) or `escalated` (a quick
- *   step asked for more than reading, so the main model took the reply over); saved rows read NULL (before routing).
- * - `lead_quick_setting`: Settings → Lead's "Quick answers use a faster model", one row; absent reads off.
- */
-export declare const LEAD_FAILURE_DETAILS: readonly ["not-installed", "sign-in", "refused", "lost", "timeout-silent", "timeout-output"];
-export type LeadFailureDetail = typeof LEAD_FAILURE_DETAILS[number];
-export declare const LEAD_ROUTES: readonly ["default", "fast", "escalated"];
-export type LeadRoute = typeof LEAD_ROUTES[number];
-export declare const V158_SCHEMA = "\nCREATE TABLE IF NOT EXISTS lead_quick_setting (\n  id         INTEGER PRIMARY KEY CHECK (id = 1),\n  enabled    INTEGER NOT NULL CHECK (enabled IN (0, 1)),\n  updated_by TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n);\n";
-export declare const V158_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record<string, {
-    definition: string;
-    saved: string;
-}>>>>;
-export declare const V158_TABLES: readonly ["lead_quick_setting"];
-/** The v158 migration's steps, in order (a test seam may stop after each). */
-export declare const V158_STEPS: readonly ["lead-quick-setting", "lead-latency-columns"];

package/dist/lead-people.d.ts

@@ -1,55 +0,0 @@
-import type { Store, SubagentRow } from "./store.js";
-export type PersonEntry = {
-    id: string;
-    account: string;
-    name: string;
-    role: string;
-    projects: string[];
-    profile: string | null;
-};
-export type SubagentEntry = {
-    id: string;
-    mate: SubagentRow;
-    name: string;
-    role: string;
-    project: string;
-};
-export type TeamEntry = {
-    id: string;
-    conversation: string;
-    name: string;
-    members: string[];
-    purpose: string;
-    projects: string[];
-};
-export type PeopleIndex = {
-    people: PersonEntry[];
-    subagents: SubagentEntry[];
-    teams: TeamEntry[];
-};
-/** get_person's id shapes. */
-export declare const PERSON_ID: RegExp;
-/** The team chat this conversation is, or null when it is the person's own chat with their lead. */
-export declare function teamRoomOf(store: Store, thread: number | undefined): string | null;
-/** Everyone the owner's lead works with, in order; in a team chat (`room`), only that room and its members. */
-export declare function peopleIndexOf(store: Store, owner: string, repos: readonly string[], room?: string | null): PeopleIndex;
-/** One line each, as the bundle carries them. Free text goes through `redact`; names and project ids do not. */
-export declare function peopleLines(index: PeopleIndex, redact: (text: string) => string): {
-    people: string[];
-    subagents: string[];
-    teams: string[];
-};
-/** One entry in full by its id (p3fa91c2e, t5, c07b1d9a4) or by name; the candidates when a name fits several, null when
- * none. In a team chat (`room`), only that room and its members. */
-export declare function personEntry(store: Store, owner: string, repos: readonly string[], ask: {
-    id?: string;
-    name?: string;
-}, room?: string | null): {
-    found: Record<string, unknown>;
-} | {
-    several: {
-        id: string;
-        name: string;
-        kind: string;
-    }[];
-} | null;

package/dist/lead-progress.d.ts

@@ -1,67 +0,0 @@
-/** Live progress of one lead turn (chat streaming): what the lead is doing
- * and the reply as it is written. Nothing here is durable or authoritative —
- * the finished turn's saved message and cards remain the record. */
-export type LeadProgress = {
-    kind: "started";
-    turn: number;
-}
-/** `reason`: the step re-asks the model about its own reply (a repair of a claim it can't back, or a shorten). */
- | {
-    kind: "step";
-    turn: number;
-    step: number;
-    reason?: "repair" | "shorten";
-} | {
-    kind: "tool";
-    turn: number;
-    step: number;
-    id: string;
-    label: string;
-} | {
-    kind: "tool-result";
-    turn: number;
-    step: number;
-    id: string;
-    outcome: LeadToolOutcome;
-}
-/** `final`: the provider's finished answer for this step, sent once and secret-checked whole. */
- | {
-    kind: "text";
-    turn: number;
-    step: number;
-    text: string;
-    final?: true;
-}
-/** Text was held back because it looked like a password or key (mid-stream, or the finished reply refused): every
- * live preview of this turn closes and clears at once (docs/plans/responsive-chat.md §2.1). */
- | {
-    kind: "blocked";
-    turn: number;
-};
-export type LeadToolOutcome = {
-    state: "succeeded";
-} | {
-    state: "failed";
-    reason: string;
-};
-export type LeadLiveTool = {
-    id: string;
-    label: string;
-} & ({
-    state: "running";
-} | LeadToolOutcome);
-/** Keep tools as labels for older clients; toolCalls adds per-call outcomes. */
-export type LeadLiveStep = {
-    tools: string[];
-    toolCalls: LeadLiveTool[];
-    text: string;
-};
-export declare function leadToolLabel(name: string): string;
-export declare function leadToolFailureReason(name: string, message: string): string;
-/** The `text` of a structured answer still being written, when the answer
- * opens with it (`{"text": "…`); null until then. Escapes are decoded, and
- * an escape cut off at the end is left for the next chunk. */
-export declare function partialAnswerText(partial: string): string | null;
-/** A reader for `claude -p --output-format stream-json --include-partial-messages`:
- * follows the structured-output block and reports its text as it grows. */
-export declare function claudeStreamReader(onText: (text: string) => void, capBytes?: number): (chunk: string) => void;

package/dist/lead-queue-runtime.d.ts

@@ -1,46 +0,0 @@
-import { type LeadTurnInput } from "./lead.js";
-import { PersonalQueue, type LeadQueueContext } from "./lead-queue.js";
-import type { LeadProgress } from "./lead-progress.js";
-import type { ChatConfig, Store } from "./store.js";
-/** The words a task composer's mode adds to a turn (render-chat.ts TASK_COMPOSER_MODES), by mode. */
-export type ComposerModes = Readonly<Record<string, string>>;
-/** The context a lead turn is given for what the person was looking at: the same words for a message sent now and one
- * that waited. Null when the message was sent from the lead's own chat. */
-export declare function leadTurnContext(store: Store, context: LeadQueueContext | null, names: {
-    project: (path: string) => string;
-    modes: ComposerModes;
-}): string | undefined;
-export type PersonalQueueRuntimeOptions = {
-    store: Store;
-    evidenceRoot: string;
-    /** The chat provider now (null when chat is off: messages wait). */
-    provider: () => {
-        config: ChatConfig;
-        key: string | null;
-    } | null;
-    /** The projects the console admits for this person, computed as that person (never from a live request). */
-    admittedReposFor: (account: string) => string[];
-    /** Whether the task (or result run) a message was sent about is still there for this person. */
-    contextStands: (account: string, context: LeadQueueContext) => boolean;
-    names: {
-        project: (path: string) => string;
-        modes: ComposerModes;
-    };
-    /** The console's live reply display: started per turn, ended with the progress handle it returned. */
-    live?: {
-        begin: (thread: number, asked: string) => (event: LeadProgress) => void;
-        end: (thread: number, ok: boolean, progress: (event: LeadProgress) => void) => void;
-    };
-    subscriptionRunner?: LeadTurnInput["subscriptionRunner"];
-    fetcher?: typeof fetch;
-    clock?: () => Date;
-    everyMs?: number;
-};
-export declare function createPersonalQueueRuntime(options: PersonalQueueRuntimeOptions): {
-    queue: PersonalQueue;
-    /** Look now (a turn just ended, a message was just queued): the next message of each person may start. Safe to call
-     * from a request: the pass runs in the server's own context, never the caller's. Before start, the timer will look. */
-    kick(): void;
-    start(): void;
-    close(): Promise<void>;
-};

package/dist/lead-queue.d.ts

@@ -1,104 +0,0 @@
-import type { Store } from "./store.js";
-/** At most this many messages wait per person, and this many characters in all; a waiting message expires after 7 days. */
-export declare const LEAD_QUEUE_MAX_MESSAGES = 10;
-export declare const LEAD_QUEUE_MAX_CHARS = 20000;
-export declare const LEAD_QUEUE_EXPIRY_MS: number;
-/** What a queued message was sent with: resolved and validated at send, re-validated before its turn. */
-export type LeadQueueContext = {
-    task?: string;
-    result?: number;
-    mode?: string;
-    project?: string;
-};
-export type LeadQueueStatus = "queued" | "running" | "answered" | "failed" | "cancelled" | "uncertain";
-export type LeadQueueRow = {
-    message: number;
-    thread: number;
-    approver: string;
-    approverGeneration: number;
-    session: number;
-    ceilingDigest: string;
-    requestId: string;
-    payloadHash: string;
-    context: LeadQueueContext | null;
-    status: LeadQueueStatus;
-    revision: number;
-    generation: number;
-    runner: string | null;
-    turnId: number | null;
-    error: string | null;
-    createdAt: string;
-    text: string;
-};
-/** A claimed row: the fence every later step re-proves (status running, this runner, this generation and revision). */
-export type LeadQueueClaim = LeadQueueRow & {
-    runner: string;
-    status: "running";
-};
-/** The identity of a send: the same request with the same words and context is the same message. */
-export declare function leadQueuePayloadHash(thread: number, text: string, context: LeadQueueContext | null): string;
-export type SendDecision = {
-    kind: "run";
-} | {
-    kind: "queued";
-    row: LeadQueueRow;
-    already: boolean;
-} | {
-    kind: "conflict";
-} | {
-    kind: "full";
-    message: string;
-};
-export declare class PersonalQueue {
-    private readonly store;
-    constructor(store: Store);
-    private get db();
-    /** The approver's backlog: rows waiting or claimed but not yet bound to a turn, oldest first. */
-    backlog(approver: string): LeadQueueRow[];
-    /** Every queue row of a thread (what the thread shows next to its messages). */
-    forThread(thread: number): LeadQueueRow[];
-    get(message: number): LeadQueueRow | null;
-    /**
-     * Send: run now, or wait — in ONE transaction, so a turn ending between the check and the insert can't strand a
-     * message. A request already saved with the same words and context is that message (never a second send, never a
-     * removed one resurrected); with different ones it conflicts. Busy means a personal lead turn of this person is
-     * queued or running, or something of theirs already waits.
-     */
-    sendOrQueue(input: {
-        approver: string;
-        approverGeneration: number;
-        session: number;
-        ceilingDigest: string;
-        thread: number;
-        text: string;
-        requestId: string;
-        context: LeadQueueContext | null;
-    }, now: Date): SendDecision;
-    /**
-     * The next message to run: per person, only the oldest of their backlog, only while none of theirs runs, and only when
-     * `eligible` agrees (the runtime's admission stamp). Claiming keeps it in the backlog until its turn binds it.
-     */
-    claimNext(runner: string, now: Date, eligible?: (row: LeadQueueRow) => boolean): LeadQueueClaim | null;
-    /** The claim still stands: running, this runner, this generation and revision, unbound or bound to `turn`. */
-    current(claim: LeadQueueClaim): boolean;
-    /** Inside the engine's admission transaction (onAdmitted): the claim binds to the turn that took it, exactly once. */
-    bindTurn(claim: LeadQueueClaim, turnId: number): boolean;
-    /** The claim ends: answered (its turn's reply is in the thread), failed or cancelled (words kept as the error), or
-     * uncertain (an outcome that can't be confirmed — never sent again). A message that never got a turn loses its words. */
-    finish(claim: LeadQueueClaim, result: {
-        status: "answered" | "failed" | "cancelled" | "uncertain";
-        error?: string;
-        turnId?: number;
-    }, now: Date): boolean;
-    /** A refusal before admission (a cap, a budget, a latch, another turn): back to waiting with the words to show. */
-    defer(claim: LeadQueueClaim, error: string): boolean;
-    /** Remove a waiting message (its author only, while it still waits): its words are forgotten, its request kept. */
-    remove(approver: string, message: number, now: Date): "removed" | "started" | "not-found";
-    /** Settle rows whose bound turn ended (by its recorded state), expire week-old waiting rows, and mark a claim that
-     * never bound by its turn deadline uncertain (the binding is the proof; elapsed time never resends). */
-    reconcile(now: Date, turnDeadlineMs: number): number;
-    /** End every waiting message sent under a session (it ended, or its person's chat was revoked). */
-    cancelForSession(session: number, why: string, now: Date): number;
-    /** A message that never ran keeps no words, context or search copy (it stays pending, so never history). */
-    private forgetWords;
-}

package/dist/lead-route.d.ts

@@ -1,56 +0,0 @@
-import type { LeadRoute } from "./lead-latency-schema.js";
-import type { Store } from "./store.js";
-/** Words that ask for something to be done (§8's fixed list, plus a few plain synonyms). Any of them keeps a message on
- * the main model. Matched as whole words in their plain form, the form a request takes ("fix it", "can you merge",
- * "file a task"): "what's running?" or "is it merged?" ask about a state and stay quick. A quick step that asks to act
- * anyway is escalated (quickStepEscalates), so this list is the first line, not the only one. */
-export declare const QUICK_ACT_WORDS: readonly string[];
-/** The longest message the quick model takes: longer ones are rarely a plain status question. */
-export declare const QUICK_MESSAGE_MAX_CHARS = 240;
-/** Whether a message reads as a status or read question with no act word (§8's message rule). */
-export declare function quickQuestion(message: string): boolean;
-/**
- * The tools a quick reply's requests advertise: reads only. Every one is a read of saved state as this person sees it;
- * none drafts, records a question, a promise, a memory or a card, or opens a page. `find_tools` is advertised beside them
- * but is not one of them: it is how a quick step says it needs something else ("search before saying something can't
- * be done"), so calling it hands the reply to the main model, unrun (more conservative than §8's "find_tools for
- * something to change": any search escalates).
- */
-export declare const QUICK_READ_TOOLS: ReadonlySet<string>;
-/** Whether a quick step's request advertises this tool: the reads, and find_tools as the way to ask for more. */
-export declare function quickAdvertises(name: string): boolean;
-/** The faster model, as the model catalog names it: the newest Sonnet this computer's Claude has been seen to run, else
- * the compiled current one. Always an exact id, never an alias that could move under a recorded route. */
-export declare function quickLeadModel(store: Store): string;
-export type QuickRouteInput = {
-    /** Settings → Lead's switch. */
-    enabled: boolean;
-    provider: string;
-    /** The configured model, which a quick reply would otherwise run on. */
-    mainModel: string;
-    message: string;
-    /** Server-authored context for this turn (a task page, a crew update): present keeps the main model. */
-    hasContext: boolean;
-    /** The message replies to an image (a result's screenshot). */
-    hasReplyImage: boolean;
-    /** The thread's newest reply asked the owner a question. */
-    askOpen: boolean;
-    /** The faster model, and whether the organisation policy allows it. */
-    quickModel: string;
-    quickAllowed: boolean;
-};
-/** Which model answers: the faster one only when every condition holds. */
-export declare function quickRoute(input: QuickRouteInput): {
-    route: Extract<LeadRoute, "fast">;
-    model: string;
-} | {
-    route: Extract<LeadRoute, "default">;
-};
-/** Whether a quick step asked for anything beyond the quick reads: its calls are then discarded unrun (§8). */
-export declare function quickStepEscalates(calls: readonly {
-    name: string;
-}[]): boolean;
-/** "Sonnet 5.5" for claude-sonnet-5-5; the id itself for anything else. */
-export declare function modelName(model: string): string;
-/** The activity line's words for a routed reply: "answered by Sonnet 5.5", "moved to Opus"; nothing for the default. */
-export declare function routeWords(route: LeadRoute, quickModel: string, mainModel: string): string | null;

package/dist/lead-status.d.ts

@@ -1,116 +0,0 @@
-import { type LimitWindow } from "./provider-limits.js";
-import { type RunCheckSuite, type Store } from "./store.js";
-import { type HomeFigures } from "./home-groups.js";
-export type CheckSummary = {
-    status: "passed" | "failed" | "not-run" | "unknown";
-    exitCode: number | null;
-    suites: RunCheckSuite[];
-};
-export type TaskWaitSnapshot = {
-    task: string;
-    outcome: "Running" | "Queued" | "Ready" | "Complete" | "Failed" | "Needs a person";
-    run: number | null;
-    /** The attempt `wait` started watching, when a later retry replaced it. */
-    replacedRun: number | null;
-    phase: string | null;
-    check: CheckSummary;
-    next: string;
-    terminal: boolean;
-    exitCode: 0 | 1 | null;
-    reason: "ready" | "complete" | "failed" | "needs-person" | null;
-};
-export type InstallationStatus = {
-    generatedAt: string;
-    running: {
-        count: number;
-        phases: {
-            phase: string;
-            count: number;
-        }[];
-        tasks: {
-            task: string;
-            run: number;
-            phase: string;
-        }[];
-    };
-    queued: {
-        count: number;
-        reasons: {
-            reason: string;
-            count: number;
-        }[];
-        tasks: {
-            task: string;
-            reason: string;
-        }[];
-    };
-    waitingForReview: {
-        count: number;
-        results: {
-            task: string;
-            run: number | null;
-            check: CheckSummary;
-        }[];
-    };
-    releaseCheck: {
-        task: string;
-        run: number;
-        finishedAt: string | null;
-        check: CheckSummary;
-    } | null;
-    planWindows: (LimitWindow & {
-        provider: string;
-        plan: string | null;
-        observedAt: string;
-    })[];
-    /** Providers whose sign-in stopped working: their dispatch is paused. */
-    signIn: {
-        provider: string;
-        reason: string;
-        command: string;
-        since: string;
-    }[];
-    /** The most urgent tasks with the shared headline and sentence (task-status.ts), as every other surface words them. */
-    tasks: {
-        task: string;
-        title: string;
-        headline: string;
-        sentence: string;
-    }[];
-    /** What the person's lead is doing now and when it last acted (lead-voice.ts), as one line. */
-    lead: {
-        owner: string;
-        doing: string;
-        at: string;
-        task: string | null;
-        line: string;
-    } | null;
-    /** Home's figures from the same work index totals (home-groups.ts): each the count of the Tasks list it names. */
-    figures: HomeFigures;
-};
-/** One indexed observation for `task wait`. `watchedRun` is the attempt the
- * caller first saw. Each poll follows the task's newest attempt from there, so
- * a retry that lands between polls is reported with its own run and outcome,
- * and `replacedRun` says which attempt it replaced. Undefined means no attempt
- * has been observed yet. */
-export declare function taskWaitSnapshot(store: Store, taskId: string, now: Date, watchedRun?: number): TaskWaitSnapshot | null;
-/** Whole-installation status, deliberately aggregated and bounded. */
-/** The one-off repair on start. An older build left finished runs' process
- * exits unrecorded and counted completed families as waiting; nothing about
- * a status is stored, so recording every exit that can now be proven and
- * re-deriving each open task's headline from the shared projection clears
- * them. What can't be proven stays as it was. */
-export declare function repairStaleStatuses(store: Store, now: Date): {
-    exitsRecorded: number;
-    readyForReview: number;
-};
-/** `viewer`: the person asking (the lead asks as its person); null when nobody is known, which shows no lead.
- * `repos`: the only projects to report (a remote person limited to some projects); null is the whole installation.
- * A limited report counts only those projects' tasks and leaves out what belongs to the installation as a whole:
- * the release check, plan windows and the lead line are empty, never another project's. */
-export declare function installationStatus(store: Store, now: Date, viewer?: string | null, repos?: readonly string[] | null, root?: string): InstallationStatus;
-/** `limited`: a report over some projects (installationStatus's `repos`), which has no release check or plan windows to state. */
-export declare function renderInstallationStatus(status: InstallationStatus, limited?: boolean): string[];
-export declare function renderTaskWait(snapshot: TaskWaitSnapshot, outcome?: string): string;
-/** A queue reason as people read it (the JSON keeps its own words). */
-export declare function queueReasonWords(reason: string): string;

package/dist/lead-sweep.d.ts

@@ -1,67 +0,0 @@
-import { type AssignmentSnapshot } from "./assignment.js";
-import { type Store } from "./store.js";
-import { type StopRequest } from "./task-control.js";
-export declare const SWEEP_VERDICTS: readonly ["fixed", "not reproducible", "blocked", "done"];
-export type SweepVerdict = typeof SWEEP_VERDICTS[number];
-/** The line every sweep child's brief asks for, appended to the shared rules. */
-export declare const VERDICT_RULE = "Start your handoff's conclusion with one line: `Verdict: fixed`, `Verdict: not reproducible`, `Verdict: blocked` or `Verdict: done`, then ` \u2014 ` and one sentence why (the root cause, what you tried, or what blocks it).";
-/** A conclusion's verdict line, read strictly. */
-export declare function verdictOf(conclusion: string | null | undefined): {
-    verdict: SweepVerdict;
-    why: string;
-} | null;
-export type SweepRow = {
-    ordinal: number;
-    label: string;
-    /** The child's family root: its identity in the sweep. */
-    task: string;
-    /** The task the family is on now (a revision of the child, after one): what an act on this row acts on. */
-    active: string;
-    state: AssignmentSnapshot["state"] | "missing";
-    detail: string;
-    verdict: {
-        verdict: SweepVerdict;
-        why: string;
-    } | null;
-    /** The child's result, when it has one. */
-    result: {
-        taskId: string;
-        runId: number;
-    } | null;
-};
-export type SweepTable = {
-    id: number;
-    title: string;
-    repo: string;
-    maxParallel: number;
-    rows: SweepRow[];
-    counts: {
-        settled: number;
-        working: number;
-        total: number;
-        byVerdict: Partial<Record<SweepVerdict, number>>;
-    };
-};
-/** A sweep as its table shows it; null when there is no such sweep or this reader may not see its project. */
-export declare function sweepTable(store: Store, id: number, now: Date, repos: readonly string[], root?: string): SweepTable | null;
-/** "8 of 11 settled — 5 fixed, 2 not reproducible, 1 blocked": the sweep in one line. */
-export declare function sweepLine(table: SweepTable): string;
-/** Not ready yet: working, being checked, or waiting on a decision — what "cancel the rest" acts on. */
-export declare const SWEEP_OPEN: ReadonlySet<SweepRow["state"]>;
-/** One open item exactly as it stands now: its active task, state, attempt (a running build to stop) and last change. */
-export type SweepOpenItem = {
-    label: string;
-    task: string;
-    state: string;
-    run: number | null;
-    at: string | null;
-    scope: string | null;
-};
-/** Exactly what "cancel the rest" would act on now; any change makes a card or a form for it stale. */
-export declare function sweepOpen(store: Store, table: SweepTable, now: Date): SweepOpenItem[];
-export declare const sweepOpenDigest: (open: readonly SweepOpenItem[]) => string;
-/**
- * Cancel the rest: a running build is stopped through the ordinary stop (process-exit safeguards and all); anything
- * else is cancelled. Every refusal is said, never swallowed. The caller has proved `open` is what stands now.
- */
-export declare function cancelSweepRest(store: Store, actor: string, open: readonly SweepOpenItem[], now: Date, via: StopRequest["via"]): string;