toolroll 0.9.104 → 0.9.105

package/dist/claim.d.ts

@@ -1,627 +0,0 @@
-/**
- * The claim, and the fence around it.
- *
- * This is the record §4 calls the one that matters, and the reason is a
- * specific 3am failure. A runner takes a task, starts work, and then stops
- * being reachable — the machine sleeps, the process is OOM-killed, the network
- * partitions. The scheduler cannot tell "dead" from "slow", so it waits for the
- * lease to expire and gives the task to someone else. Then the first runner
- * wakes up, finishes the work it was doing, and reports success for a task that
- * another runner is now halfway through.
- *
- * Both runners are behaving correctly. Without a fence, the control plane
- * believes the last one to speak.
- *
- * So a lease carries two things. `lease_id` is immutable and identifies one
- * grant of one task to one runner. `lease_generation` counts how many times
- * that task has been granted at all, and it only ever goes up. Acquiring is a
- * compare-and-swap on the generation; every later call carries the lease it
- * thinks it holds, and anything whose generation has been superseded is
- * refused. The late completion above is refused not because we detected the
- * crash — we never did — but because the world moved on without it.
- *
- * Losing a race here is ordinary, not an error. Several runners asking for the
- * same task at the same moment is the system working; exactly one wins.
- *
- * Time is a parameter everywhere. Expiry decided by an implicit clock is
- * untestable, and a lease is exactly the kind of thing that has to be provable
- * rather than probable.
- */
-import { type Store, type Mutation, type TaskState, type ClosedState } from "./store.js";
-import type { ParsedDecision, Problem } from "./decision.js";
-import type { ParsedPlan } from "./plan.js";
-import { type PlannerSource } from "./planner-source.js";
-import type { AuthorityChangeField } from "./plan.js";
-import type { ParsedReport } from "./scout-report.js";
-export type Claim = {
-    taskRef: number;
-    /** Immutable. Identifies this grant, and no other. */
-    leaseId: string;
-    /** Monotonic per task. The fencing token. */
-    generation: number;
-    runner: string;
-    acquiredAt: string;
-    expiresAt: string;
-    heartbeatAt: string;
-};
-export type AcquireResult = {
-    ok: true;
-    claim: Claim;
-    reclaimed: boolean;
-    replayed?: boolean;
-} | {
-    ok: false;
-    reason: "held";
-    by: string;
-    until: string;
-} | {
-    ok: false;
-    reason: "reserved";
-    reservedFor: string;
-} | {
-    ok: false;
-    reason: "external";
-    detail: "stale-mirror" | "external-closed" | "dispatch-revoked" | "plane-blocked";
-}
-/** A mode-sealed approval whose signature no longer stands (v29): the
- * approval falls back to a person; nothing dispatches on a dead mode. */
- | {
-    ok: false;
-    reason: "mode-ended";
-    message: string;
-}
-/** A lead sweep's limit (docs/plans/lead-fan-out.md): `limit` of its families already hold a live claim. */
- | {
-    ok: false;
-    reason: "sweep-limit";
-    sweep: number;
-    limit: number;
-}
-/** The credential presented with this acquisition did not verify against
- * the runner row AT CLAIM TIME (MCP spec v6): stale incarnations never
- * ride a successor's rotation. */
- | {
-    ok: false;
-    reason: "unauthenticated";
-    detail: "unknown" | "bad-token" | "retired" | "expired";
-}
-/** The task is placed nowhere — a repo-scoped runner cannot be
- * authorized for null. Place it, then dispatch. */
- | {
-    ok: false;
-    reason: "unplaced";
-}
-/** The runner's bound repo list does not contain the task's repo.
- * The refusal names the binding road. */
- | {
-    ok: false;
-    reason: "unauthorized-repo";
-    repo: string;
-}
-/** A coordinator filed this and no password ceremony has sealed its
- * scope yet — nothing claims, plans, or runs it until one does. */
- | {
-    ok: false;
-    reason: "coordinator-filed";
-} | {
-    ok: false;
-    reason: "archived";
-} | {
-    ok: false;
-    reason: "watch-custody";
-}
-/** The runner reported draining (v137 lifecycle): its stop has begun, so it takes no new work. */
- | {
-    ok: false;
-    reason: "draining";
-    until: string;
-}
-/** The task is done, failed or cancelled (docs/plans/closed-task-claims.md): nothing claims a closed task, except
- * check cleanup's own door (acquireForCheckCleanup). */
- | {
-    ok: false;
-    reason: "closed";
-    state: ClosedState;
-}
-/** A built-in reference with no task row behind it: nothing to claim. */
- | {
-    ok: false;
-    reason: "no-task";
-};
-/** `fenced` means the lease was superseded; `unknown` means it never existed. */
-export type FenceResult = {
-    ok: true;
-    claim: Claim;
-    duplicate?: boolean;
-} | {
-    ok: false;
-    reason: "fenced" | "unknown" | "stopped";
-};
-/** A heartbeat's answer: the fence, or `closed` when an expired claim's task was closed meanwhile (it is not renewed). */
-export type HeartbeatResult = FenceResult | {
-    ok: false;
-    reason: "closed";
-    state: ClosedState;
-};
-/**
- * Completion's OWN result (external dispatch, finding 33): `completed` is
- * today's world — the task is done/failed as asked; `disowned` means the
- * tracker closed this mirror while it was being built — the task is
- * cancelled, the branch is kept as evidence, and the caller must never
- * publish. The arm is DURABLE (claim.released_by), so a retried completion
- * returns its original answer forever.
- */
-export type CompleteResult = {
-    ok: true;
-    arm: "completed" | "disowned";
-    claim: Claim;
-    duplicate?: boolean;
-} | {
-    ok: false;
-    reason: "fenced" | "unknown" | "stopped";
-};
-/** How stale a mirror's last complete sync may be before admission refuses. */
-export declare const SYNC_MAX_AGE_MS: number;
-export type AcquireOptions = {
-    now: Date;
-    /** The runner's minted credential, re-verified INSIDE the claim
-     * transaction (MCP gateway spec v6, Codex round-5 finding 1): a
-     * takeover that rotates the credential between the caller's own auth
-     * and this CAS must not let the stale process ride its successor's
-     * authority. */
-    token: string;
-    ttlMs?: number;
-    /** Injected in tests so a lease id can be asserted on. */
-    newLeaseId?: () => string;
-    /** The watch incarnation dispatching this claim, for crash recovery keyed to it. */
-    incarnation?: string;
-    mutation?: Mutation;
-    /** External-mirror freshness bound; defaults to SYNC_MAX_AGE_MS. */
-    syncMaxAgeMs?: number;
-};
-/**
- * Long enough that an ordinary build does not lose its lease mid-thought,
- * short enough that a dead runner's work is picked up the same night rather
- * than at breakfast.
- */
-export declare const DEFAULT_LEASE_MS: number;
-/**
- * Take the task, if it is free.
- *
- * Free means no claim, or a claim whose lease expired, or one already released.
- * A live lease belonging to somebody else is refused with who holds it and
- * until when, because "no" without a reason is indistinguishable from a bug.
- */
-export declare function acquire(store: Store, taskRef: number, runner: string, options: AcquireOptions): AcquireResult;
-/**
- * Why `acquireIfReady` said no before the race was even run. `not-ready` is
- * about the task's own state; `capability` is about the machine's — a gap a
- * person can fill, named so the caller can say which.
- */
-export type NotReady = {
-    ok: false;
-    reason: "not-ready" | "capability" | "attention-budget" | "capacity" | "quota" | "provider-unavailable";
-    message: string;
-};
-/** DESIGN §8 gate 6: above this many open decisions, stop dispatching the parkers.
- * `missingCapability` remains re-exported for callers of the old claim seam. */
-export { DEFAULT_MAX_OPEN_DECISIONS, missingCapability } from "./dispatch.js";
-/**
- * Take the task, if it is free *and still worth taking*.
- *
- * `listReady` then `acquire` is two reads of a world that moves between them:
- * a hold placed, a blocker reopened, the task cancelled — and the CAS admits
- * the claim anyway, because the CAS only defends against other claimants. An
- * unattended pass has nobody watching who would notice the stale dispatch, so
- * the readiness conditions are re-proved inside the same transaction as the
- * acquire, against rows the write lock has already pinned.
- *
- * "Not ready" is a different answer from "held": held means somebody else got
- * it, which is a race being won; not-ready means nobody should have it, and
- * says why.
- */
-/**
- * A conformance check's claim (acp-check.ts): its task has no scope to approve, so readiness is not asked — but a
- * check runs real agents, so the runner's capacity is counted where the claim lands, as for dispatch.
- */
-export declare function acquireForCheck(store: Store, taskRef: number, runner: string, options: AcquireOptions): AcquireResult | NotReady;
-export declare function acquireIfReady(store: Store, taskRef: number, runner: string, options: AcquireOptions & {
-    repo?: string;
-    maxOpenDecisions?: number;
-    /** The provider this dispatch resolved to — the quota key. */
-    provider?: string;
-    /** The model this dispatch would run — the quota scope. */
-    model?: string;
-    /** A fallback entry's pinned auth mode: its quota is that credential's, never the base's. */
-    authMode?: "subscription" | "api-key";
-    /** What this dispatch is FOR. Re-proved inside the transaction — the
-     * caller's survey is not trusted (Codex planning review, finding 2). */
-    dispatchRole?: "builder" | "planner" | "scout";
-}): AcquireResult | NotReady;
-/**
- * "I am still here." Extends the lease, and tells a superseded runner that it
- * has been superseded — which is the cheapest moment for it to find out, well
- * before it has finished work nobody will accept.
- */
-export declare function heartbeat(store: Store, leaseId: string, now: Date, ttlMs?: number): HeartbeatResult;
-/**
- * Hand the task back.
- *
- * Accepted only from the lease that currently holds it. A completion arriving
- * on a superseded lease is the failure this whole module exists for, and it is
- * rejected without touching anything — the work is not lost, it is simply not
- * this runner's to report, and the record says so rather than overwriting a
- * live claim with a dead runner's opinion.
- */
-export declare function release(store: Store, leaseId: string, now: Date): FenceResult;
-/**
- * How an attempt ended, one kind per ending, each with the facts its seal needs. `finalize` seals every one.
- */
-export type Outcome = 
-/** The task's terminal state, written with the release (no run: the lease's own completion). */
-({
-    kind: "complete";
-} & CompleteSeal) | ({
-    kind: "park";
-} & ParkSeal) | ({
-    kind: "malformed";
-} & MalformedSeal) | ({
-    kind: "interrupted";
-} & InterruptedSeal) | ({
-    kind: "hand-back";
-} & HandBackSeal) | ({
-    kind: "failure";
-} & FailureSeal) | ({
-    kind: "plan";
-} & PlanSeal) | ({
-    kind: "revision";
-} & RevisionSeal) | ({
-    kind: "plan-failure";
-} & PlanFailureSeal) | ({
-    kind: "scout";
-} & ScoutSeal) | ({
-    kind: "scout-failure";
-} & ScoutFailureSeal);
-/** What sealing each kind answers. */
-export type Finalized = {
-    complete: CompleteResult;
-    park: ParkFinalize;
-    malformed: MalformedFinalize;
-    interrupted: InterruptSeal;
-    "hand-back": HandBackFinalize;
-    failure: FailureDisposition;
-    plan: PlanFinalize;
-    revision: RevisionFinalize;
-    "plan-failure": PlanFailureDisposition;
-    scout: ScoutFinalize;
-    "scout-failure": ScoutFailureDisposition;
-};
-/**
- * THE ONE WAY AN ATTEMPT ENDS: seal `outcome` for `leaseId` in one fenced transaction.
- *
- * Every ending passes the same fence, in the same order: the run is this lease's open attempt of the right role (a
- * caller defect otherwise, thrown); a stop that applies to it wins — the attempt is sealed as interrupted instead
- * (except the endings that ARE a stop or a service hand-back); then the claim is released by a compare-and-swap only the
- * live, unsuperseded lease wins. A lease the world moved past writes nothing but its own run's fenced refusal (the
- * stop and hand-back endings still end their run, touching no task state), and a retry of an ending the same lease
- * already made answers as a duplicate where that ending allows it. Only then does the ending's own effect run —
- * decision and hold, incident, strike and backoff, scope, report, revision, task state, the disowned mirror — inside
- * the same transaction, so nothing of it exists without the release, and a crash rolls all of it back together.
- */
-export declare function finalize<O extends Outcome>(store: Store, leaseId: string, outcome: O): Finalized[O["kind"]];
-/** The task's terminal state, written with the release (no run: the lease's own completion). */
-export type CompleteSeal = {
-    state: Extract<TaskState, "done" | "failed">;
-    now: Date;
-    mutation?: Mutation;
-};
-export type ParkSeal = {
-    runId: number;
-    taskId: string;
-    decision: ParsedDecision;
-    artifactIds: readonly number[];
-    /** Open planner correction that authored the accepted payload. It is
-     * settled in this same fence, never earlier. */
-    repairRunId?: number | null;
-    now: Date;
-};
-export type ParkFinalize = {
-    ok: true;
-    decisionId: number;
-} | {
-    ok: false;
-    reason: "fenced" | "unknown" | "stopped";
-};
-export type MalformedSeal = {
-    runId: number;
-    taskId: string;
-    problems: readonly Problem[];
-    now: Date;
-};
-export type MalformedFinalize = {
-    ok: true;
-    incidentId: number;
-} | {
-    ok: false;
-    reason: "fenced" | "unknown" | "stopped";
-};
-/** How a failed attempt is classified, per gnhf. Decides retry, backoff, or stall. */
-export type FailureClass = "agent-reported" | "retryable-infra" | "no-op"
-/** Run 2085: stopped before its handoff; the work was kept and the retry resumes it. Strikes like no-op. */
- | "no-handoff" | "commit-failure" | "unknown";
-export declare const MAX_STRIKES = 3;
-export type FailureDisposition = {
-    ok: true;
-    disposition: "backoff";
-    strikes: number;
-    until: string;
-} | {
-    ok: true;
-    disposition: "stalled";
-    strikes: number;
-    incidentId: number;
-} | {
-    ok: true;
-    disposition: "commit-incident";
-    incidentId: number;
-} | {
-    ok: true;
-    disposition: "auth-expired";
-    provider: string;
-} | {
-    ok: true;
-    disposition: "fallback";
-    provider: string;
-}
-/** Strikes used up on a task a person had already closed: its state is kept, and no incident, hold or page. */
- | {
-    ok: true;
-    disposition: "closed";
-    strikes: number;
-    state: ClosedState;
-} | {
-    ok: false;
-    reason: "fenced" | "unknown" | "stopped";
-};
-export type InterruptSeal = {
-    ok: true;
-    stopRun: number;
-    requeued: boolean;
-    fenced: false;
-} | {
-    ok: true;
-    stopRun: number;
-    requeued: false;
-    fenced: true;
-};
-export type InterruptedSeal = {
-    runId: number;
-    taskId: string;
-    stopRun: number;
-    message?: string;
-    committed?: boolean;
-    now: Date;
-};
-export type HandBackSeal = {
-    runId: number;
-    taskId: string;
-    message: string;
-    now: Date;
-};
-export type HandBackFinalize = {
-    ok: true;
-    requeued: boolean;
-    fenced: boolean;
-};
-/**
- * THE STOP FENCE at settlement (v52): when a stop applies to the run —
- * its own or an owning ancestor's — seal the attempt as interrupted and
- * answer with the seal; otherwise null, and the caller's own ending
- * proceeds. Every fenced finalizer asks this first, inside its own
- * transaction, so a stop that commits before terminal settlement wins
- * whatever the attempt was about to say.
- */
-export declare function interruptIfStopped(store: Store, args: {
-    leaseId: string;
-    runId: number;
-    taskId: string;
-    message?: string;
-    committed?: boolean;
-    now: Date;
-}): InterruptSeal | null;
-export type FailureSeal = {
-    runId: number;
-    taskId: string;
-    failureClass: FailureClass;
-    message: string;
-    worktree: string;
-    now: Date;
-};
-/** The live claim on a task, if there is one. */
-export declare const MAX_PLAN_STRIKES = 3;
-export type PlanFinalize = {
-    ok: true;
-    changes: number;
-    amendment: string | null;
-} | {
-    ok: false;
-    reason: "fenced" | "unknown" | "stopped";
-}
-/** The filed request moved while the planner ran (contract handoff,
- * task 1): the draft was planned against terms that no longer exist,
- * so nothing of it is ingested — the newer source stands, the claim
- * releases, and the task stays requested for a fresh attempt. */
- | {
-    ok: false;
-    reason: "stale-source" | "source-invalid";
-    detail: string;
-};
-export type PlanSeal = {
-    runId: number;
-    taskId: string;
-    plan: ParsedPlan;
-    /** The already-captured plan document file, described; null when the
-     * capture itself failed (the plan still lands as scope + handoff). */
-    artifact: {
-        key: string;
-        bytesOriginal: number;
-        bytesStored: number;
-        truncated: boolean;
-        sha256: string;
-        capture: string;
-    } | null;
-    /** Open planner correction that authored the accepted payload. */
-    repairRunId?: number | null;
-    /** The filed request this attempt planned for, and the recorded
-     * evidence of it (contract handoff, task 1). The source identity is
-     * re-derived from the store INSIDE this transaction and compared:
-     * a concurrent scope, authority, or term change refuses the draft
-     * atomically rather than letting an old plan overwrite the newer
-     * source. Optional only for the pre-source road (tests that seal a
-     * hand-built plan); every dispatch presents one. */
-    source?: PlannerSource;
-    sourceArtifact?: number | null;
-    /** Where the plan-contract ingestion record is written. */
-    evidenceRoot?: string;
-    now: Date;
-};
-export type RevisionFinalize = {
-    ok: true;
-    revisionId: number;
-    authorityKind: "plan-only" | "authority-change";
-} | {
-    ok: false;
-    reason: "fenced" | "unknown" | "stopped";
-};
-export type RevisionSeal = {
-    runId: number;
-    taskId: string;
-    taskRef: number;
-    /** Every content column of the row about to be appended. `status` is
-     * NOT the caller's to set: it follows from `authorityKind`, decided in
-     * exactly one place — here — so a caller can never file an
-     * authority-changing revision as already applied. */
-    revision: {
-        revision: number;
-        artifact: number;
-        parentHash: string | null;
-        reason: string;
-        evidenceLink: string | null;
-        author: string;
-        originRun: number | null;
-        authorityKind: "plan-only" | "authority-change";
-        authorityDigest: string;
-        changedFields: readonly AuthorityChangeField[];
-    };
-    now: Date;
-};
-export type PlanFailureDisposition = {
-    ok: true;
-    disposition: "malformed-incident";
-    incidentId: number;
-} | {
-    ok: true;
-    disposition: "backoff";
-    strikes: number;
-} | {
-    ok: true;
-    disposition: "exhausted";
-    incidentId: number;
-    strikes: number;
-} | {
-    ok: true;
-    disposition: "auth-expired";
-    provider: string;
-} | {
-    ok: false;
-    reason: "fenced" | "unknown" | "stopped";
-};
-export type PlanFailureSeal = {
-    runId: number;
-    taskId: string;
-    failure: "malformed" | "failure";
-    /** Which payload was malformed (v4 review, finding 12): the mailbox is a `malformed-decision`. */
-    malformed?: "decision" | "plan";
-    message: string;
-    now: Date;
-};
-export type ScoutFinalize = {
-    ok: true;
-} | {
-    ok: false;
-    reason: "fenced" | "unknown" | "stopped";
-};
-export type ScoutSeal = {
-    runId: number;
-    taskId: string;
-    report: ParsedReport;
-    /** The already-captured report file, described. Required: a report
-     * that was not captured is a FAILED attempt, never a finished task
-     * (v4 review, finding 1). */
-    artifact: {
-        key: string;
-        bytesOriginal: number;
-        bytesStored: number;
-        truncated: boolean;
-        sha256: string;
-        capture: string;
-        redacted: boolean;
-    };
-    now: Date;
-};
-export type ScoutFailureDisposition = {
-    ok: true;
-    disposition: "malformed-incident";
-    incidentId: number;
-} | {
-    ok: true;
-    disposition: "backoff";
-    strikes: number;
-} | {
-    ok: true;
-    disposition: "stalled";
-    incidentId: number;
-    strikes: number;
-} | {
-    ok: true;
-    disposition: "closed";
-    strikes: number;
-    state: ClosedState;
-} | {
-    ok: true;
-    disposition: "auth-expired";
-    provider: string;
-} | {
-    ok: false;
-    reason: "fenced" | "unknown" | "stopped";
-};
-export type ScoutFailureSeal = {
-    runId: number;
-    taskId: string;
-    failure: "malformed" | "failure";
-    /** Which payload was malformed (v4 review, finding 12): the park
-     * mailbox is a `malformed-decision` incident, the handoff a
-     * `malformed-report` one — the taxonomy says what actually broke. */
-    malformed?: "decision" | "report";
-    message: string;
-    now: Date;
-};
-export declare function currentClaim(store: Store, taskRef: number, now: Date): Claim | null;
-/**
- * Release every lease that has run out.
- *
- * Expiry alone already frees a task for acquisition, so this is not what makes
- * reclaim work — it is what makes it *visible*. A daemon reaping on a tick
- * turns "this lease is being ignored because its timestamp is in the past" into
- * a released row somebody can read, which is the difference between a system
- * that recovers and a system that appears to have lost the work.
- */
-export declare function reap(store: Store, now: Date): Claim[];
-/**
- * Check cleanup's claim (acp-check.ts settleChecks): the one road that may claim a closed task. Only the task bound to
- * check `checkId`, when that check is this runner's, finished and unsettled, held right now by this cleanup `attempt`,
- * and its task is the built-in one named from the check row's own id (store.ts checkCleanupTaskOf) — proved here, in
- * the same transaction as the grant. Every other gate of the claim still applies. When the proof fails, the claim
- * answers exactly as an ordinary one would: never wider.
- */
-export declare function acquireForCheckCleanup(store: Store, checkId: number, attempt: string, runner: string, options: AcquireOptions): AcquireResult;

package/dist/claude-print.d.ts

@@ -1,12 +0,0 @@
-import type { ExecResult, run } from "./exec.js";
-export type CommandRunner = (file: string, args: readonly string[], options: Parameters<typeof run>[2]) => Promise<ExecResult>;
-/** No tools, no permission prompts, no MCP servers, nothing kept: a `claude -p` call that can only answer. */
-export declare const CLAUDE_NO_TOOLS_ARGS: readonly string[];
-/** `--model <model>`, or nothing for the CLI's own default. */
-export declare const claudeModelArgs: (model: string) => string[];
-/** What a failed call's output says when this computer's Claude isn't signed in. */
-export declare const CLAUDE_SIGNED_OUT: RegExp;
-/** `claude -p --output-format json` stdout as its one object, or null. */
-export declare function claudeJsonBody(stdout: string, cap: number): Record<string, unknown> | null;
-/** Runs `work` in a fresh temporary folder named `<prefix>…`, removed afterwards whatever happens. */
-export declare function inScratchDir<T>(prefix: string, work: (dir: string) => Promise<T>): Promise<T>;

package/dist/cli-fast.d.ts

@@ -1,8 +0,0 @@
-/**
- * The answers that need nothing but this file: `--version` and the top-level
- * usage. The bin asks here before importing the CLI, so neither loads the
- * store, the contracts or a single command family. main() asks here too, so
- * both roads print the same bytes.
- */
-/** The line to print and exit 0 with, or null when the CLI has to run. */
-export declare function quickAnswer(argv: readonly string[]): string | null;

package/dist/cli-help.d.ts

@@ -1,8 +0,0 @@
-/**
- * The top-level usage text, on its own so `toolroll --help` can print it
- * without loading every command family (see cli-fast.ts).
- */
-export declare const HELP = "toolroll \u2014 hand coding work to agents, walk away, come back to pull requests\n\nUsage\n  toolroll                  at your terminal: start Toolroll here (or attach) and open it in the terminal\n                                   (--web: the browser; --project-root <dir>: where projects live)\n                                   in a repository without a terminal, under an agent or with --json: only says what it would do\n  toolroll open [--web]     open this computer's Toolroll again, signed in\n  toolroll welcome          the three steps to a first result (--json: the model)\n  toolroll password set     add a password (typed twice, at your terminal)\n  toolroll scan [path...]   report what is in flight (also bare `toolroll` outside a repository)\n  toolroll [path...]        the same report for the paths given\n  toolroll pulls            report what is waiting on a person\n  toolroll graph            report which work graph is already here\n  toolroll repos            list connected repositories, and how to adjust\n  toolroll repos add <path> add a project; it is in the console at once (no path: the repo you are in)\n  toolroll repos remove <path>\n                                   take it out of the console; its tasks and results stay\n  toolroll repos add-from-github <owner/name> --root <dir>\n                                   preview, then clone and connect (--yes)\n  toolroll link             put `toolroll` on your PATH\n  toolroll unlink           take it off again\n  toolroll update           update to the latest release: verified, drained, undoable\n                                   (preview first; --yes, --now, --at HH:MM, --rollback)\n  toolroll release <branch> release Toolroll itself: checks, your approval, deploy, merge, tag, publish\n                                   (rerun the same command to continue; --help)\n  toolroll skills install --claude-code [--dir <path>]\n                                   install this binary's guides for Claude Code (preview first)\n  toolroll skills install   teach a repo's agents this queue exists (preview first)\n  toolroll demo             a seeded throwaway sandbox \u2014 see it working in 90 seconds\n  toolroll up               app + builder for every saved project \u2014 the normal start\n  toolroll onboard          make your agent Toolroll's lead: add this repo, install its skill (--yes), offer starter flows (--starter)\n  toolroll status           running, queued, ready results, release check and plan windows\n  toolroll integrations     which integrations work, and what to do about the ones that don't (--json)\n  toolroll lead token       mint your lead agent's sign-in: its own work pings nobody\n  toolroll lead say \"<text>\"  (the lead) one short message in its person's chat\n\nTasks \u2014 `toolroll task` prints the whole list,\nand any task command + --help prints it too\n  toolroll approver add <name>\n                               add a person who can approve work\n  toolroll task add <title> queue work\n  toolroll task show <id>   one task: its plan, builds and what it waits for\n  toolroll task approve <id>\n                               the yes \u2014 nothing builds without one\n  toolroll task accept <id> --finish\n                               accept the result you read (--despite \"<why>\": accept it with a reason, without finishing)\n  toolroll task send-back <id> --feedback \"<what to change>\"\n                               send the result back for changes\n  toolroll task retry <id>  build it again\n  toolroll task ready <id>  can I merge it? each check, and what clears a blocker\n  toolroll chat --as <you> --token <t>\n                               talk to your lead: one conversation across every\n                               project; it proposes, you confirm (--say \"\u2026\" for one turn)\n  toolroll card <source>    the data chat shows as a card: tasks, results, flows, spend,\n                               projects, builders, mode, integrations, providers, findings, handover\n  toolroll flows list | show <id> | create | edit | trigger | script | card | archive\n                               set up and inspect flows (writes preview until --yes)\n\nMachine and agent commands (the builder, agent tools, recovery):\n  toolroll internals        lists them; each keeps working as before\n\nWith nothing connected it reports everything it can find below the working\ndirectory. Once you connect repositories it reports those instead.\n\nOptions\n  --all         report everything discoverable, ignoring connected repos\n  --depth <n>   directory levels to descend (default: 6)\n  --hidden      include dot-directories, which are skipped by default\n  --dirty       also read each working tree for uncommitted files\n  --local       branches only: no network, no pull requests, no issues\n  --json        emit a machine-readable envelope instead of a report\n  -o <file>     also write that envelope to a file (requires --json)\n  -h, --help    show this\n\nNothing is written, installed, or configured. Every repository is read\nthrough git with --no-optional-locks, so a scan never contends for the\nindex lock with an editor you have open.\n\n--dirty is off by default because reading a working tree is unbounded\nwork: on a large or cloud-synced repo `git status` can take minutes,\nwhere listing branches takes milliseconds.\n\nlink shows what it would do and changes nothing; add --yes to apply it,\nor --to <dir> to choose where. It never uses sudo, never leaves your\nhome directory, and never touches a file it did not create.";
-/** The commands people rarely type: the builder's own loop, the machine contract and recovery. They all keep working;
- * `toolroll internals` (or `toolroll internals --help`) lists them so top-level help stays about the work. */
-export declare const INTERNALS_HELP = "toolroll internals \u2014 machine and agent commands\n\n  toolroll contract         the machine contract: envelope version + capabilities\n                                   (--commands dumps the declared command guide)\n  toolroll skills list      the guides this exact binary serves\n  toolroll skills get <name>  print one guide (version-matched, never stale)\n  toolroll health           recent server latency, write waits and live streams\n  toolroll ready            what could be started right now\n  toolroll check-progress <run>  current or final approved check progress\n  toolroll task wait <id> [--timeout <seconds>]\n                               wait for this attempt to finish or need a person\n  toolroll task scope <id> --goal <text>\n                               write a task's plan from the command line\n  toolroll claim <id> --runner <name>\n  toolroll heartbeat <lease> / worker release <lease> / reap\n  toolroll tick --runner <name> --token <t> --repo <path>\n                               one unattended pass over the ready set\n  toolroll serve --repo <path>  run only the console\n                               (--editor vscode with --runner: file links\n                               open in VS Code on the device you browse from)\n  toolroll watch / daemon install   run only the builder\n  toolroll doctor           check that Toolroll's service holds no key a build could read\n  toolroll reconcile        recover what the last stretch left behind\n  toolroll release --recover-deploy [--stage <dir>] [--yes]\n  toolroll release --release-gate <id> [--yes]\n                               the release tool's recovery steps (toolroll release <branch> runs them for you)";