toolroll 0.9.104 → 0.9.105

package/dist/task-control.d.ts

@@ -1,159 +0,0 @@
-/**
- * Safe task stop and resume (v52): the ONE domain API every surface — the
- * CLI, the authenticated console, the focused chat — speaks, and the fences
- * every execution road consults.
- *
- * The contract, in the operator's words: a stop names one exact active
- * attempt. The first answer is "stop requested", never "stopped" — the
- * request is durable before any process is signalled, and the attempt is
- * SETTLED only once all owned runs ended and retained process witnesses
- * establish exit. A dead worker can leave live subprocesses; recovery
- * keeps that stop pending. Other tasks keep running. The task stays
- * paused across restarts under a hold this stop owns, beside — never over —
- * any hold that already stood. Resume names the same exact attempt, refuses
- * until it is quiescent, lifts only that hold, approves nothing, and lets
- * the next pass re-prove the signed scope, take a fresh claim, and inherit
- * the preserved draft with fresh proof.
- *
- * Nothing here is a second engine: the stop rides the existing run, claim,
- * hold, recovery, and invocation-gateway machinery. This
- * module only names the door and the fence.
- */
-import type { StopVia } from "./store.js";
-import { type DispatchDiagnosis } from "./dispatch.js";
-import type { Run, RunStop, Store } from "./store.js";
-/** How often a running attempt re-reads its stop row while a child runs.
- * A stop is observed within this bound even when the console that filed
- * it lives in another process on the same database. */
-export declare const STOP_WATCH_MS = 1500;
-/**
- * The stop fence, as a predicate: an operator stop applies to the run (its
- * own, or an owning ancestor's), or the caller's own watch-level stop says
- * so. Every road that used to ask `shouldStop?.()` asks this instead.
- */
-export declare function stopRequestedFor(store: Store, runId: number, also?: () => boolean): boolean;
-/** The words a road records when a stop wins: who asked, and where the
- * work stays. */
-export declare function stopWords(store: Store, runId: number, worktree: string | null, fallback: string): string;
-/**
- * End every live child THIS process holds for one attempt and its owned
- * descendants — the exact-attempt handle, never a pid read from durable
- * state. Returns how many process groups were signalled.
- */
-export declare function terminateStoppedAttempt(store: Store, runId: number): number;
-/** Whether this process still tracks a live child for the attempt or any
- * run it owns — the in-process half of "quiescent". */
-export declare function attemptHasLiveChildren(store: Store, runId: number): boolean;
-/**
- * Run a child-bearing step under the stop watch: while `body` runs, the
- * run's stop row is re-read every `intervalMs`; the moment a stop applies
- * the run's owned children are killed through their handles and the
- * caller's `onStop` fires once. The body's own settlement then observes
- * the stop through `stopRequestedFor` and seals the attempt as
- * interrupted — this watch never writes an outcome itself.
- */
-export declare function underStopWatch<T>(store: Store, runId: number, body: () => Promise<T>, options?: {
-    intervalMs?: number;
-    onStop?: () => void;
-}): Promise<T>;
-export type StopRequest = {
-    taskId: string;
-    runId: number;
-    by: string;
-    via: "cli" | "web" | "telegram" | "slack" | "discord" | "teams";
-    /** A composing confirmation transaction runs this effect only after it commits. */
-    deferSignal?: ((signal: () => void) => void) | undefined;
-};
-export type StopOutcome = {
-    ok: true;
-    stop: RunStop;
-    repeated: boolean;
-    terminated: number;
-    taskId: string;
-} | {
-    ok: false;
-    reason: "no-task" | "no-run" | "wrong-task" | "finished" | "not-live" | "publication";
-    detail: string;
-};
-/**
- * The shared stop door. Records the durable request first (one fenced
- * transaction: exact run, still open, this task's current claim, no
- * admitted publication), THEN signals every child this
- * process holds for the attempt. A worker in another process observes the
- * same row through its stop watch within STOP_WATCH_MS.
- */
-export declare function requestTaskStop(store: Store, request: StopRequest, now: Date): StopOutcome;
-export type ResumeRequest = {
-    taskId: string;
-    runId: number;
-    by: string;
-    via: StopVia;
-    /** The workspace occupancy probe (the worktree pool's `inUse`): a
-     * checkout some process still holds is not quiescent, whatever the
-     * rows say — the concrete gate names the pid. */
-    occupied?: (worktree: string) => {
-        held: boolean;
-        by?: number | string | undefined;
-    };
-};
-export type ResumeOutcome = {
-    ok: true;
-    stop: RunStop;
-    taskId: string;
-    gate: DispatchDiagnosis | null;
-} | {
-    ok: false;
-    reason: "no-task" | "no-stop" | "wrong-task" | "stopping" | "already-resumed" | "superseded" | "busy" | "review" | "occupied" | "archived";
-    detail: string;
-};
-/**
- * The shared resume door. Refuses in words until the exact stopped attempt
- * is quiescent — settled, every owned run ended, no live claim, its
- * workspace not held by any process this machine can still see — then
- * lifts exactly this stop's hold. `gate` reports what still keeps the
- * next pass from starting work (an approval that must be signed again, a
- * worker that is offline), so a resume that cannot yet start is never
- * mistaken for one that did. A stopped review is refused here and pointed
- * at the explicit bounded review-retry door.
- */
-export declare function resumeTaskStop(store: Store, request: ResumeRequest, now: Date): ResumeOutcome;
-/**
- * What a surface shows for one task (v52) — the SAME projection on the
- * task page, the focused chat, `task show`, and the status fragment, so no
- * two surfaces can disagree about which exact run a control names:
- *
- *   stop      — an attempt is live; the control names its run.
- *   stopping  — a stop is recorded and not yet settled.
- *   paused    — a settled stop stands on the task's newest attempt.
- *   review-stopped — a review attempt was stopped; "Review again" is the
- *               explicit bounded retry door.
- *   none      — nothing to control.
- */
-export type TaskControlView = {
-    kind: "none";
-} | {
-    kind: "stop";
-    run: number;
-    role: Run["role"];
-} | {
-    kind: "stopping";
-    run: number;
-    role: Run["role"];
-    stop: RunStop;
-    unsettledRun: boolean;
-    detail?: string | null;
-} | {
-    kind: "paused";
-    run: number;
-    role: Run["role"];
-    stop: RunStop;
-    outcome: Run["outcome"];
-    committed: boolean;
-    worktree: string | null;
-} | {
-    kind: "review-stopped";
-    run: number;
-    sourceRun: number | null;
-    stop: RunStop;
-};
-export declare function taskControlOf(store: Store, taskRef: number, now: Date): TaskControlView;

package/dist/task-live.d.ts

@@ -1,8 +0,0 @@
-import { type LiveRoomOptions, type LiveRooms, type LiveViewer } from "./live-bus.js";
-import { type Store } from "./store.js";
-export type TaskViewer = LiveViewer;
-/** What changes when anything on the task page changes: one read over the family, kept short and opaque. */
-export declare function taskFingerprint(store: Store, root: string, now: Date, livenessMs?: number): string | null;
-export type TaskRooms = LiveRooms<string, TaskViewer>;
-/** Rooms keyed by the task family's root. With a bus, a write reaches every open page at once; without one, only the safety net. */
-export declare function createTaskRooms(fingerprint: (root: string) => string | null, options?: LiveRoomOptions): TaskRooms;

package/dist/task-moves.d.ts

@@ -1,90 +0,0 @@
-/**
- * The one door for writing a task's state (docs/plans/task-state-moves.md).
- *
- * A task is in one of five states: queued, running, done, failed, cancelled. TASK_MOVES lists every way code moves
- * a task between them today: the state it writes and the states it may move from. moveTask writes one move as ONE
- * statement, so the from-check and the write happen together inside whatever transaction the caller is in.
- *
- * Each from-list is copied from the statement it replaced, so this table records current behaviour exactly, except
- * where docs/plans/closed-task-claims.md changed it (exhaust narrowed, claim added). The two moves marked
- * `from: "any"` (complete, set) have no from-check and callers rely on that; making them narrower is a behaviour
- * change with its own plan.
- *
- * Cancellation is not a move here: it has its own door, Store.applyCancellation, which also records why and who.
- * Task creation (INSERT ... 'queued') is not a move either.
- *
- * This file imports nothing from store.ts at runtime (store.ts calls it), only types.
- */
-import type { TaskState } from "./store.js";
-export declare const TASK_MOVES: {
-    /** Back to the queue from a running attempt that ended without finishing (stop, service stop, sign-in expired,
-     * vanished builder, move to a fallback agent). */
-    readonly requeue: {
-        readonly to: "queued";
-        readonly from: readonly ["running"];
-    };
-    /** An unfinished task that cannot go on (retries stopped, fallback agent signed out). */
-    readonly giveUp: {
-        readonly to: "failed";
-        readonly from: readonly ["queued", "running"];
-    };
-    /** A person's Retry. */
-    readonly retry: {
-        readonly to: "queued";
-        readonly from: readonly ["failed", "queued", "done"];
-    };
-    /** The tracker item was opened again. */
-    readonly reopen: {
-        readonly to: "queued";
-        readonly from: readonly ["cancelled", "failed", "queued"];
-    };
-    /** The fenced completion of an attempt. Wide today: a late result still writes over a closed task. */
-    readonly complete: {
-        readonly to: readonly ["done", "failed"];
-        readonly from: "any";
-    };
-    /** Strikes used up (build and scouting). Only an open task: one a person already closed keeps its state
-     * (docs/plans/closed-task-claims.md, decision B). */
-    readonly exhaust: {
-        readonly to: "failed";
-        readonly from: readonly ["queued", "running"];
-    };
-    /** The CLI `claim`: taking a task makes it running, in the grant's own transaction. `running` is listed because
-     * taking over an expired claim on a task a CLI runner left running keeps it running. */
-    readonly claim: {
-        readonly to: "running";
-        readonly from: readonly ["queued", "running"];
-    };
-    /** Store.setTaskState (the state verb, backend.setState, release and others). Wide by design: it is the
-     * general-purpose write; cancelled goes through applyCancellation instead. */
-    readonly set: {
-        readonly to: readonly ["queued", "running", "done", "failed"];
-        readonly from: "any";
-    };
-};
-export type TaskMoveName = keyof typeof TASK_MOVES;
-/** The smallest database handle moveTask needs (Store.handle fits). */
-export type MoveDatabase = {
-    prepare(sql: string): {
-        run(...params: unknown[]): {
-            changes: number | bigint;
-        };
-    };
-};
-/**
- * Move one task. One statement: the from-check and the write together. True when the row changed (false when the
- * task does not exist or is not in one of the move's from-states). `to` is required for complete and set, and
- * refused for every other move.
- */
-export declare function moveTask(db: MoveDatabase, id: string, move: TaskMoveName, now: Date, to?: TaskState): boolean;
-/**
- * SQL condition, true while a runner holds a live claim on the task: the claim is not released, has not expired, and
- * is the newest generation for its task. It needs the `claim` table in scope under that name, and binds one
- * parameter: the current time as an ISO string. This is ownership, not proof that a process is alive.
- */
-export declare const claimedNowSql = "claim.released_at IS NULL AND claim.expires_at > ? AND claim.lease_generation = (SELECT MAX(newest.lease_generation) FROM claim AS newest WHERE newest.task_ref = claim.task_ref)";
-/**
- * SQL condition, true when the task's stored state is running (the `task` table in scope under that name). A task
- * can be marked running with no live claim (see claimedNowSql), so the two can count differently.
- */
-export declare const markedRunningSql = "task.state = 'running'";

package/dist/task-outcome-cli.d.ts

@@ -1,48 +0,0 @@
-import { type VerifiedApprover } from './principal.js';
-import { type PullRequestView } from './pull-request-flow.js';
-import type { PublishExec } from './publish.js';
-import type { Store } from './store.js';
-export declare function runTaskOutcomeCommand(action: 'complete' | 'revise', positional: readonly string[], flags: Map<string, string | true>, context: {
-    store: Store;
-    evidenceRoot: string;
-    json: boolean;
-    write: (line: string) => void;
-    now: Date;
-    operator: () => Promise<VerifiedApprover | null>;
-    /** The command it answers as: `task accept --finish` is this same completion under its own name. */
-    command?: string;
-}): Promise<number>;
-/** `task merge <task>`: the console's Merge — the newest pull request any version of the task opened through
- * Complete, merged behind the approver's password once a fresh read shows its checks passing. */
-export declare function runTaskMergeCommand(positional: readonly string[], flags: Map<string, string | true>, context: {
-    store: Store;
-    json: boolean;
-    write: (line: string) => void;
-    clock: () => Date;
-    exec?: PublishExec;
-    demo: boolean;
-    credentials: () => Promise<{
-        name: string;
-        token: string;
-    } | null>;
-}): Promise<number>;
-/** The lines `task show` prints for a task's pull request. */
-export declare function pullRequestLines(view: PullRequestView | null): string[];
-/** Toolroll's own stop proof for every finished build of a task's family whose stop it can prove here. Best effort: a
- * failure leaves the completion's own refusal to say what is still unproven. */
-export declare function proveTaskBuildsStopped(store: Store, task: string, clock: () => Date): Promise<void>;
-/**
- * `task complete` for the laptop's local owner (local-owner slice 1; the terminal UI's Accept): the exact result the
- * screen read, accepted and completed with no password. Its own road: it never reaches a password check (so it never
- * moves the sign-in guard), and is chosen only inside the local owner's chain; there, an owner who no longer stands is
- * refused, never handed to another road. Everything is pinned: `--run` and `--digest` are required (never defaulted
- * to the current result), `--checked` is the person's explicit yes to a check they made, and `--reason` (trimmed, not
- * empty) is an exception's why. No pull request: that needs a password.
- */
-export declare function runLocalCompletion(positional: readonly string[], flags: Map<string, string | true>, context: {
-    store: Store;
-    evidenceRoot: string;
-    json: boolean;
-    write: (line: string) => void;
-    now: Date;
-}): Promise<number>;

package/dist/task-review-brief.d.ts

@@ -1,69 +0,0 @@
-/** A read-only packet of saved result facts. Never opens a worktree or emits logs, patches or saved shell commands. */
-import type { Store } from './store.js';
-import { type AssignmentAccess } from './assignment.js';
-import { type BuildFinding as Finding, type FindingSeverity } from './contracts/review-findings.js';
-declare const MISSING: 'not recorded';
-type Missing = typeof MISSING;
-export type ReviewBrief = {
-    header: {
-        task: string;
-        run: number | Missing;
-        provider: string;
-        model: string;
-        minutes: number | Missing;
-        outcome: string;
-        base: string;
-        head: string;
-        state: string;
-    };
-    conclusion: string;
-    changedFiles: {
-        files: {
-            path: string;
-            additions: number | Missing;
-            deletions: number | Missing;
-        }[];
-        total: number;
-        omitted: number;
-    } | Missing;
-    check: {
-        status: string;
-        exit: number | Missing;
-        failed: string[] | Missing;
-    };
-    review: {
-        state: string;
-        reason: string;
-        findings: Finding[];
-        counts: Record<FindingSeverity, number>;
-        omitted: Record<FindingSeverity, number>;
-    } | Missing;
-    screenshots: {
-        files: {
-            path: string;
-            bytes: number | Missing;
-        }[];
-        omitted: number;
-    } | Missing;
-    plan: {
-        titles: string[];
-        omitted: number;
-    } | Missing;
-    nextActions: string[];
-};
-/** Select only finished build/report attempts in the admitted family. An explicit run never crosses that boundary. */
-export declare function taskReviewBrief(store: Store, task: string, root: string, now: Date, access: AssignmentAccess, options?: {
-    run?: number;
-    all?: boolean;
-    secrets?: readonly string[];
-}): {
-    ok: true;
-    brief: ReviewBrief;
-} | {
-    ok: false;
-    reason: string;
-    message: string;
-};
-/** Text and JSON share this bounded projection; --all includes LOW details within the same line budget. */
-export declare function renderReviewBrief(brief: ReviewBrief): string[];
-export {};

package/dist/task-sizing.d.ts

@@ -1,58 +0,0 @@
-import { type SizeAnswer } from "./contracts/task-sizing.js";
-import { type CommandRunner } from "./claude-print.js";
-import { type TaskSize, type TaskSizing } from "./phase-routing.js";
-import type { Store } from "./store.js";
-/** The classifier's whole budget, from asking to answer. */
-export declare const SIZING_BUDGET_MS = 5000;
-/** The model `claude -p` sizes with: small and fast, by its exact id (an alias would float to whatever is newest). */
-export declare const SIZING_CLAUDE_MODEL = "claude-haiku-5-5";
-export type SizingInput = {
-    title: string;
-    goal?: string | undefined;
-    outOfScope?: string | null | undefined;
-    touches?: readonly string[] | undefined;
-};
-export type { SizeAnswer } from "./contracts/task-sizing.js";
-/** One classifier: null (or a throw) is "no answer"; the signal ends at the budget. */
-export type Sizer = (input: SizingInput, signal: AbortSignal) => Promise<SizeAnswer | null>;
-/** Structural or broad work — the description signal planning has always read. */
-export declare const SUBSTANTIAL_WORK: RegExp;
-/** The description's own signals: several paths, a long description, or
- * structural work means planning first (medium); otherwise small. */
-export declare function planningSignals(input: SizingInput): boolean;
-/** The size the description alone gives — today's planning signals, never risky. */
-export declare function heuristicSizing(input: SizingInput, why?: string | null): TaskSizing;
-export declare const SIZE_MEANS: Record<TaskSize, string>;
-export declare const RISKY_MEANS = "Could a mistake here lose data, break security, sign-in, payments or permissions, change a database schema or migration, or be hard to undo?";
-/** What the classifier reads: the task as data, bounded, keys blanked. */
-export declare function sizingText(input: SizingInput): string;
-/** A small Claude model on this computer's sign-in: no tools, no MCP servers, no repository, credential keys stripped.
- * The abort ends it: a late answer never keeps a command (or its process) waiting. */
-export declare function claudeSizer(runner?: CommandRunner, model?: string, budgetMs?: number): Sizer;
-/** Jev, through OpenRouter with the operator's own key: one choice over the three sizes and one yes/no. */
-export declare function jevSizer(fetcher: typeof fetch, key: string): Sizer;
-/** The owner's own classifier: Jev when an OpenRouter key is set up, otherwise Claude on this computer's sign-in. */
-export declare function ownerSizer(fetcher?: typeof fetch, keyOf?: () => string | null): Sizer;
-/**
- * Size one task within the budget: the classifier's answer, or — when it
- * has none, fails, or runs out of time — the description's size, saying
- * why. Always resolves, never throws, never later than the budget.
- */
-export declare function classifyTask(input: SizingInput, sizer: Sizer | null, budgetMs?: number): Promise<TaskSizing>;
-/** Install the process's classifier for filings (the CLI, the console, the worker); returns how to remove it. Unset,
- * filings keep the description's size — tests never spend a turn. */
-export declare function installFilingSizer(sizer: Sizer, budgetMs?: number): () => void;
-/** The classifier this process filed with, and its budget (fast-start.ts waits for it; null: no answer will come). */
-export declare const filingSizer: () => {
-    sizer: Sizer | null;
-    budget: number;
-};
-/**
- * After a filing: ask the classifier (within the budget) and apply its size
- * to the still-unapproved task. Runs in the background; the filing already
- * stands. `followPlanning` lets planning follow the size unless the filer
- * chose planning explicitly.
- */
-export declare function refineFiledSizing(store: Store, taskId: string, input: SizingInput, followPlanning: boolean, clock?: () => Date): Promise<void> | null;
-/** Wait for every classification still in flight (each is bounded by the budget). */
-export declare function settleSizings(): Promise<void>;

package/dist/task-source.d.ts

@@ -1,77 +0,0 @@
-/**
- * Where a task came from (docs/plans/webhook-tasks.md §5): an outside event's delivery, kept with the task. A card's
- * source is written once at receipt (who proved it, the outside thing's identity and link); the task filed from that
- * card keeps a snapshot of it (task_source), which its revisions copy, so the reference outlives the card's own
- * task link and zone. Every word shown comes from that snapshot — never from today's trigger settings.
- */
-import type { FlowCardSource, Store } from "./store.js";
-/** A task filed from a GitHub issue or pull request (github-import.ts): its filed-via, and its snapshot's proof. Its
- * provenance is outside text however it reaches a seal, and a revision keeps it (markRevision copies the snapshot). */
-export declare const ISSUE_IMPORT_FILED_VIA = "issue-import";
-export declare const ISSUE_IMPORT_VERIFIED = "github-import";
-/** What a task keeps of the card it was filed from. */
-export type TaskSourceSnapshot = {
-    label: string;
-    verified: string;
-    external: {
-        id: string | null;
-        url: string | null;
-    };
-    receipt: string | null;
-};
-/** As much of a card's source as a reference reads. */
-export type SourceLike = Pick<FlowCardSource, "label"> & Partial<Pick<FlowCardSource, "verified" | "external" | "receipt">>;
-/** The snapshot an outside event's card gives its task, or null when the card didn't come from one (a person's, a poll's). */
-export declare function snapshotOf(source: SourceLike | null): TaskSourceSnapshot | null;
-/** A snapshot as saved, read back strictly: anything else is no snapshot at all. */
-export declare function readSnapshot(json: string): TaskSourceSnapshot | null;
-/** The host a link names, for words that always show where it goes. */
-export declare function hostOf(url: string | null): string | null;
-/** Where a link goes, as it is shown: its host and path (no scheme), the middle elided when long, so the destination is
- * always visible beside the label. */
-export declare function linkWords(url: string, max?: number): string;
-/** How a snapshot's delivery was proved, in words: "signed by Sentry", or "unsigned". */
-export declare function provedWords(snapshot: TaskSourceSnapshot): string;
-/**
- * The reference a task's brief carries: what the outside thing is, from where, and that it is data, not instructions.
- * Bounded (an identity is at most 120 characters and a link 2,000), and said plainly when it was unsigned.
- */
-/** A reference's words, at most: every reader of them (the planner's source, the scout's brief) accepts exactly this. The
- * largest there can be (a 253-character host, 120-character label and identity, a 2,000-character link) fits. */
-export declare const REFERENCE_LIMIT = 3000;
-export declare function referenceWords(snapshot: TaskSourceSnapshot): string;
-/** The same reference for a card that hasn't filed its task yet ({{card.source}}), or "" for a card from no outside event. */
-export declare function cardReference(source: SourceLike | null | undefined): string;
-/** Where a task came from, in the words a page shows: the flow (named and linked only for a viewer who can see it) and
- * the outside event (its label, how it was proved, its link and that link's host), all from what was kept. */
-export type TaskOrigin = {
-    flow: {
-        name: string;
-        href: string;
-    } | "hidden" | "removed" | null;
-    source: {
-        label: string;
-        proved: string;
-        url: string | null;
-        host: string | null;
-    } | null;
-    /** A youiyoux change or options request (youiyoux-intake.ts): its id, its kind, and where the person pointed. */
-    request?: {
-        id: string;
-        kind: "change" | "options";
-        route: string | null;
-        component: string | null;
-        at: string | null;
-    } | null;
-};
-/** A task's origin, or null when it came from neither a flow, an outside event nor a youiyoux request. */
-export declare function originOf(store: Store, taskId: string, canSee: (repo: string) => boolean): TaskOrigin | null;
-/** A youiyoux request by its kind: "youiyoux change request r-…" or "youiyoux options request r-…". */
-export declare function requestName(request: NonNullable<TaskOrigin["request"]>): string;
-/** Where a youiyoux request pointed, in words: "Button on /flows (src/button.tsx:12)". */
-export declare function requestWords(request: NonNullable<TaskOrigin["request"]>): string;
-/** The one line an approval shows about an outside event that started its work: context, never a term agreed to. */
-export declare function originNote(origin: TaskOrigin | null | undefined): string | null;
-/** Whether this task, or the task it revises, came from a GitHub import. Unreadable provenance on a row counts: it was
- * written by the import road, and nothing here widens on a doubt. */
-export declare function issueImported(store: Pick<Store, "filedViaOf" | "taskSourceOf">, taskId: string): boolean;