toolroll 0.9.94 → 0.9.95

package/dist/operate.js

@@ -1,3 +1,4 @@
+import { runCardCommand } from "./card-cli.js";
 import { mintSecret } from "./secret-mint.js";
 import { ACP_AGENTS, ACP_PROVIDER_IDS, isAcpProvider, isKeyedProvider } from "./acp-agents.js";
 import { inspectAcpAgent } from "./acp-inspect.js";
@@ -242,12 +243,15 @@ import { createScheduledFlow, describeSchedule, parseSchedule } from "./flow-sch
 import { fileTaskProposal, validateTaskText } from "./proposal.js";
 import { TEMPLATES, templateByName } from "./templates.js";
 import { isDirectChatProvider, isSubscriptionChatProvider, priceOf, PRICED_MODELS } from "./converse.js";
+import { clearFallbackChain, dispatchEntryOf, entryMovesOnWords, entryWords, fallbackSettingOf, parseEntry, reconcileWalks, setFallbackChain, setPaidGrant } from "./fallback.js";
 import { resolvePhaseAgent, resolveScopeProfile, resolveRouteCandidates, routeOfTask, INSTALLATION_SCOPE } from "./agentconfig.js";
 import { applyModelChoices, stateDigest } from "./model-choices.js";
 import { isTaskSize, legOf, projectRoute, routeDigestOf, routeWords, TASK_SIZES, PHASES as ROUTE_PHASES } from "./phase-routing.js";
 import { observeProviderReadiness, reportProviderReadinessAuthed } from "./runner.js";
 import { retryVanishedWhenStopped } from "./vanished-retry.js";
 import { requestMissingRechecks } from "./check-only.js";
+import { checkRepairOfRun, resumeParkedRepairs, startCheckRepair } from "./check-repair.js";
+import { capturesCommand, evidenceCommand, failingFirstCommand, findingCommand, handoverCommand } from "./follow-through-cli.js";
 import { recordBuilderWish } from "./builder-restart.js";
 import { expireFastStarts, fastRefusalWords, fastStartBuild, keepGrownChange, prepareFastStart } from "./fast-start.js";
 import { fastTermsLines } from "./fast-terms.js";
@@ -321,6 +325,8 @@ export const OPERATE_HELP = `toolroll — operating the queue
   toolroll project activity --json   read the current project supervision report
   toolroll project rules --repo <p>  a project's approval rules; an instance operator changes them with
                                         --not-requester on|off, --protect none|project, --protect-paths "a/**,b/**"
+  toolroll project fallback --repo <p> [--agents provider:model:plan|api-key,…] [--clear] [--allow-paid|--no-paid]
+    Which agents take over when one runs out of its plan. New tasks seal the chain; a paid agent also needs --allow-paid.
   toolroll project network --repo <p> [--allow h,…] [--remove h,…] [--open|--allowlist] [--local any|none]
                                         what the project's builds may reach on the network; an approver changes it
                                         (new scopes seal it; approved ones keep theirs)
@@ -717,7 +723,7 @@ export const TASK_ACTIONS = [
     "add", "new", "keep", "list", "show", "wait", "state", "block", "unblock", "next", "steer", "pause", "continue", "assign",
     "reopen", "scope", "approve", "hold", "unhold", "require", "requeue", "regate", "plan",
     "review", "accept", "repair", "route", "stop", "resume", "complete", "revise", "merge", "ask",
-    "checks", "add-tests", "archive", "restore", "tidy", "ship", "ready",
+    "checks", "add-tests", "archive", "restore", "tidy", "ship", "ready", "handover", "before-after", "failing-first",
 ];
 export const PUBLISH_ACTIONS = ["setup", "grant", "revoke", "status", "unblock", "rearm", "merge", "refire"];
 export const CONFIG_ACTIONS = ["show", "set", "clear"];
@@ -732,8 +738,8 @@ export const KEYS_ACTIONS = ["status", "set", "clear", "verify", "auth"];
 /** Flags whose value is a secret someone types or pastes: taken as the next argument even when it starts with "--". */
 export const SECRET_VALUE_FLAGS = new Set(["token", "password"]);
 export const OPERATE_VALUE_FLAGS = new Set([
-    "key", "db", "runner", "ttl", "state", "on", "reason", "until", "id", "backend", "build", "from",
-    "allow", "selector", "paths", "credentials", "repo", "token", "capacity",
+    "key", "db", "runner", "ttl", "state", "flow", "on", "reason", "until", "id", "backend", "build", "from",
+    "allow", "selector", "paths", "credentials", "repo", "token", "capacity", "agents",
     "goal", "not", "touches", "acceptance", "candidate", "by", "digest", "as", "branch", "pool", "base", "model", "turns",
     "max", "cap", "probe", "kind", "expires", "cmd", "since", "repair-model",
     "choose", "choice", "claim", "revision", "note", "max-open-decisions", "name", "days", "publication", "auto-approve", "review-auto", "port", "host", "allow-host",
@@ -756,7 +762,7 @@ export const OPERATE_VALUE_FLAGS = new Set([
     "command", "timeout-seconds", "setup-digest", "stop-grace", "title", "name", "every", "lines",
     "label", "reviewers", "limit", "role", "key-file", "weekly-usd", "daily-turns", "per-hour", "token-file", "budget-usd", "build-usd", "sync-max-age", "merge-method",
     "phase", "tier", "clear-phase", "size", "risky",
-    "run", "containment", "agent",
+    "run", "containment", "agent", "path", "line", "action", "from-review", "from-check", "task",
     // onboard: the starter flows to switch on.
     "starter",
     // flows: templates, steps, scripts and cards.
@@ -799,6 +805,8 @@ export const OPERATE_BOOLEAN_FLAGS = new Set([
     "html", "csv", "alerts-only",
     // project network: what its builds may reach (--open | --allowlist).
     "open", "allowlist",
+    // project fallback: whether paid fallback agents may spend.
+    "allow-paid", "no-paid",
     // v105: the full export.
     "zip",
     // Settings → Integrations: the last checks, without checking again.
@@ -1314,6 +1322,8 @@ async function dispatch(command, positional, flags, context) {
                 return projectConcurrencyCommand(positional, flags, context);
             if (positional[0] === "network")
                 return projectNetworkCommand(positional, flags, context);
+            if (positional[0] === "fallback")
+                return projectFallbackCommand(positional, flags, context);
             if (positional[0] === "writes")
                 return projectWritesCommand(positional, flags, context);
             if (positional[0] === "check-access")
@@ -1369,8 +1379,14 @@ async function dispatch(command, positional, flags, context) {
             const who = currentLocalOwner() !== null ? localReader(context) : verified !== null && verified.ok ? verified.who : null;
             return runMemoryCommand(positional, flags, { store: context.store, write: context.write, json: context.json, now: context.clock(), actor: who?.name ?? null, repos: who?.repos ?? [], configDir: dirname(context.databaseFile), ...(context.evidenceRoot === undefined ? {} : { evidenceRoot: context.evidenceRoot }) });
         }
+        case "card":
+            return cardCommand(positional, flags, context);
         case "flaky":
             return flakyCommand(positional, flags, context);
+        case "finding":
+            return findingCommand(positional, flags, followThroughContext(context, flags));
+        case "captures":
+            return capturesCommand(positional, followThroughContext(context, flags));
         case "claim":
             return claimCommand(positional, flags, context);
         case "heartbeat":
@@ -2577,6 +2593,8 @@ async function tickCommand(flags, context) {
     const ready = store.listReady(clock(), runner);
     const considered = ready.length;
     const dispatched = [];
+    // Every walk settled before anything dispatches: a crash anywhere leaves a state this pass closes the same way.
+    reconcileWalks(store, clock());
     // The stale-scan (dispatch v3, finding 20): mirrors the courtesy filter
     // kept out of ready are REPORTED here, typed, with a paged episode —
     // an undispatakable tracker item is a 9am fact, not a silent absence.
@@ -2669,7 +2687,15 @@ async function tickCommand(flags, context) {
             }
         }
         const planLeg = route === null ? null : legOf(route.route, "plan");
-        const sealedBuildLeg = route !== null && route.source === "approved" ? legOf(route.route, "build") : null;
+        // A task whose agent ran out runs as the next approved entry: every gate below is keyed to that entry (fallback.ts).
+        const fallback = route !== null && route.source === "approved" && !wantsPlan && !wantsScout ? dispatchEntryOf(store, ref.id, id, clock()) : null;
+        if (fallback !== null && "problem" in fallback) {
+            dispatched.push({ id, outcome: "skipped", reason: "agent-config", detail: `${id}: ${fallback.problem}` });
+            continue;
+        }
+        const sealedBuildLeg = route !== null && route.source === "approved"
+            ? fallback !== null ? { provider: fallback.entry.profile.provider, model: fallback.entry.profile.model, chosen: "fallback" } : legOf(route.route, "build")
+            : null;
         const planFlagged = planProvider !== undefined || planModel !== undefined || providerFlag !== undefined || model !== undefined;
         if (wantsPlan && planLeg !== null && planFlagged) {
             // Pass flags cannot contradict the task's plan leg: a flag that names
@@ -2804,7 +2830,7 @@ async function tickCommand(flags, context) {
         // existing approval refusals own that road, and attestation must
         // never mask them. The gateway re-checks before spawn; this skip only
         // keeps the normal road cheap.
-        const skipProviders = wantsPlan
+        const skipProviders = wantsPlan || fallback !== null
             ? [spec.provider]
             : [store.getScope(id)?.approvedProfile?.provider].filter((one) => one !== null && one !== undefined);
         let unattestedLane = null;
@@ -2841,7 +2867,7 @@ async function tickCommand(flags, context) {
         }
         // Sprint 8: the organisation policy before the claim (build() looks again before spawn, and lowers).
         {
-            const sealed = wantsPlan || wantsScout ? null : store.getScope(id)?.approvedProfile ?? null;
+            const sealed = wantsPlan || wantsScout ? null : fallback?.entry.profile ?? store.getScope(id)?.approvedProfile ?? null;
             const refused = policyHold([sealed !== null ? { profile: sealed }
                     : { provider: spec.provider, model: spec.model, ...(wantsPlan ? { session: "planning" } : wantsScout ? { session: "scouting" } : {}) }]);
             if (refused !== null) {
@@ -2855,7 +2881,8 @@ async function tickCommand(flags, context) {
         // Each provider as it bills now.
         // An ACP agent bills as its declaration for the exact model it would run on this runner.
         const sealedModel = store.getScope(id)?.approvedProfile?.model ?? null;
-        const budgeted = budgetHold(ref.id, [...new Set([spec.provider, ...skipProviders])].map(provider => isAcpProvider(provider) ? store.agentFor(provider, provider === spec.provider ? spec.model ?? sealedModel : sealedModel, runner) : store.agentsFor([provider])[0]));
+        // A paid fallback entry is a dollar spend whatever its provider's current setting says.
+        const budgeted = budgetHold(ref.id, fallback?.paid === true ? [{ provider: spec.provider, billing: "api-key" }] : [...new Set([spec.provider, ...skipProviders])].map(provider => isAcpProvider(provider) ? store.agentFor(provider, provider === spec.provider ? spec.model ?? sealedModel : sealedModel, runner) : store.agentsFor([provider])[0]));
         if (budgeted.over !== null) {
             dispatched.push({ id, outcome: "skipped", reason: "budget", detail: budgetWords(budgeted) });
             continue;
@@ -2879,6 +2906,7 @@ async function tickCommand(flags, context) {
             repo,
             provider: spec.provider,
             ...(spec.model === null ? {} : { model: spec.model }),
+            ...(fallback === null ? {} : { authMode: fallback.entry.authMode }),
             ...(text(flags, "incarnation") === undefined ? {} : { incarnation: text(flags, "incarnation") }),
             ...(text(flags, "max-open-decisions") === undefined
                 ? {}
@@ -3476,12 +3504,16 @@ async function tickCommand(flags, context) {
                     reason: disposition.sealed
                         ? disposition.disposition === "auth-expired"
                             ? "auth-expired — requeued, sign-in needed"
-                            : `${disposition.failureClass}${disposition.disposition === "backoff" ? ` — retry ${disposition.strikes}/3` : disposition.disposition === "stalled" ? " — stalled" : ""}`
+                            : disposition.disposition === "fallback"
+                                ? `out of plan — moved to the next approved agent`
+                                : `${disposition.failureClass}${disposition.disposition === "backoff" ? ` — retry ${disposition.strikes}/3` : disposition.disposition === "stalled" ? " — stalled" : ""}`
                         : "fenced",
                     ...(result.ok ? {} : { detail: result.message.slice(0, 200) }),
                     worktree: leased.worktree.path,
                 });
-                broke++;
+                // Moving on isn't this pass breaking: the task is queued for its next agent.
+                if (!(disposition.sealed && disposition.disposition === "fallback"))
+                    broke++;
                 break;
             case "recorded":
                 // The standalone-only arm; unreachable under the tick policy.
@@ -5004,7 +5036,7 @@ async function modeCommand(positional, flags, context) {
     if (acting === null)
         return fail(write, json, "mode", "usage", "signing or revoking a mode takes `--as <you> --token <t>`", EXIT.usage);
     // Signing a mode that lets a chat app approve is a credential act; any other mode signing or revoking is ordinary.
-    const authed = (flag(flags, "chat-approve") ? credentialApprover(store, acting.name, acting.token) : authenticateApprover(store, acting.name, acting.token));
+    const authed = (flag(flags, "chat-approve") || flag(flags, "repair-auto") ? credentialApprover(store, acting.name, acting.token) : authenticateApprover(store, acting.name, acting.token));
     if (!authed.ok)
         return fail(write, json, "mode", authed.reason, "that is not an active approver, or the token does not match", EXIT.refused);
     if (action === "revoke") {
@@ -5032,8 +5064,18 @@ async function modeCommand(positional, flags, context) {
         terms.autoApproveFiling = true;
     if (flag(flags, "plan-auto"))
         terms.planAuto = true;
-    if (["review-auto", "review-retry-auto", "repair-auto", "repair-max-attempts"].some(name => flags.has(name)))
-        return fail(write, json, "mode set", "invalid", "Separate model review and automatic correction loops have been removed; finished work goes to the lead or user.", EXIT.refused);
+    if (["review-auto", "review-retry-auto"].some(name => flags.has(name)))
+        return fail(write, json, "mode set", "invalid", "Separate model review has been removed; finished work goes to the lead or user.", EXIT.refused);
+    // Repairing failed checks by themselves: never a preset default, only these flags, with a limit you sign.
+    if (flags.has("repair-max-attempts") && !flag(flags, "repair-auto"))
+        return fail(write, json, "mode set", "invalid", "--repair-max-attempts needs --repair-auto", EXIT.refused);
+    if (flag(flags, "repair-auto")) {
+        const limit = Number(text(flags, "repair-max-attempts") ?? 2);
+        if (!Number.isInteger(limit) || limit < 1 || limit > 3)
+            return fail(write, json, "mode set", "invalid", "--repair-max-attempts is 1, 2 or 3", EXIT.refused);
+        terms.repairAuto = true;
+        terms.repairMaxAttempts = limit;
+    }
     if (terms.planAuto && !terms.autoApproveFiling)
         return fail(write, json, "mode set", "invalid", "--plan-auto requires automatic filing approval", EXIT.refused);
     // Approving plans and merges from the signer's paired chat: never a preset default, only this flag.
@@ -6519,6 +6561,8 @@ async function runWatchLoop(args) {
                 void resumeHeldReleases(store, dirname(context.databaseFile), context.clock());
             // A result whose verdict went missing asks for its one automatic recheck (check-only.ts).
             requestMissingRechecks(store, context.evidenceRoot, context.clock());
+            // A failed check that was parked takes its next step once its task is free again (check-repair.ts).
+            resumeParkedRepairs(store, context.evidenceRoot, context.clock());
             const ran = await runWaitingChecks(store, context.evidenceRoot, { now: context.clock, shouldStop: stopping });
             if (ran > 0)
                 progress(`watch: ran ${ran} follow-up check(s)`);
@@ -8891,6 +8935,12 @@ function taskAction(action, rest, flags, context) {
             return requeueTask(rest, flags, context);
         case "regate":
             return regateTaskCommand(rest, flags, context);
+        case "handover":
+            return handoverCommand(rest, followThroughContext(context, flags));
+        case "before-after":
+            return evidenceCommand(rest, flags, followThroughContext(context, flags));
+        case "failing-first":
+            return failingFirstCommand(rest, followThroughContext(context, flags));
         case "plan":
             return planTaskCommand(rest, flags, context);
         case "review":
@@ -9585,9 +9635,18 @@ async function repairTaskCommand(positional, flags, context) {
         const acting = await askCredentials(flags, context);
         if (acting === null)
             return fail(write, json, "task repair", "usage", "Evidence collection requires --as and --token.", EXIT.usage);
-        const authenticated = authenticateApprover(store, acting.name, acting.token);
+        // A failed check names its project: the password proves the person, and their access to the run they named.
+        const failed = checkRepairOfRun(store, runId);
+        const authenticated = authenticateApprover(store, acting.name, acting.token, failed?.repo);
         if (!authenticated.ok)
             return fail(write, json, "task repair", authenticated.reason, describeApproveFailure(authenticated.reason, String(runId)), EXIT.refused);
+        // A failed check waiting for a person: this draft is what they asked for, and its approval below is the normal one.
+        if (failed !== null) {
+            const started = startCheckRepair(store, context.evidenceRoot, runId, clock());
+            if (!started.ok)
+                return fail(write, json, "task repair", "refused", started.message, EXIT.refused);
+            chain = store.repairChainFor(runId);
+        }
         const run = store.getRun(runId), proof = store.proofVerdictFor(runId);
         const repo = run && store.refById(run.taskRef)?.repo;
         if (repo && repo === repoFrom(flags) && proof?.matrix.some(row => row.assessment && row.review?.judgement === "cannot-tell") &&
@@ -13931,8 +13990,100 @@ export async function refreshLearning(store, now, reads) {
         catch { /* advisory: the next pass tries again */ }
     }
 }
+/** `toolroll card <source>`: reads only, for the remembered local login (or --as/--token) and its projects. */
+async function cardCommand(positional, flags, context) {
+    const acting = await askCredentials(flags, context);
+    const verified = acting === null || currentLocalOwner() !== null ? null : verifyApproverByPassword(context.store, acting.name, acting.token, context.store.knownRepos().filter(repo => context.store.accountCanAccess(acting.name, repo)));
+    const who = currentLocalOwner() !== null ? localReader(context) : verified !== null && verified.ok ? verified.who : null;
+    return runCardCommand(positional, flags, { store: context.store, write: context.write, json: context.json, now: context.clock(), actor: who?.name ?? null, repos: who?.repos ?? [], evidenceRoot: context.evidenceRoot,
+        ok: (result, lines) => succeed(context.write, context.json, "card", result, lines),
+        no: (reason, message) => fail(context.write, context.json, "card", reason, message, reason === "usage" ? EXIT.usage : EXIT.refused) });
+}
 /** The laptop's local owner as a reader: its name and its projects. Never a proof: every write proves its own act. */
 function localReader(context) {
     const local = currentLocalOwner();
     return local === null ? null : { name: local.account, repos: context.store.knownRepos().filter(repo => context.store.accountCanAccess(local.account, repo)) };
 }
+/** What the follow-through commands need from this file: its envelope, and a verified person (follow-through-cli.ts). */
+function followThroughContext(context, flags) {
+    const { store, write, json, clock, evidenceRoot } = context;
+    return {
+        store, evidenceRoot, now: clock(),
+        ok: (command, result, lines) => succeed(write, json, command, result, lines),
+        no: (command, reason, message) => fail(write, json, command, reason, message, reason === "usage" ? EXIT.usage : EXIT.refused),
+        prove: async (command, repo) => {
+            const acting = await askCredentials(flags, context);
+            if (acting === null) {
+                fail(write, json, command, "usage", "this takes `--as <you> --token <t>`", EXIT.usage);
+                return null;
+            }
+            const authed = authenticateApprover(store, acting.name, acting.token, repo);
+            if (!authed.ok) {
+                fail(write, json, command, "not-an-approver", "that is not an approver, or the token does not match", EXIT.refused);
+                return null;
+            }
+            return acting.name;
+        },
+    };
+}
+/**
+ * `project fallback --repo <p> [--agents a,b,c] [--clear] [--allow-paid|--no-paid]`: which agents take over when one runs
+ * out of its plan (fallback.ts). New tasks seal the chain; approved ones keep theirs. Changing it is an approver's act
+ * with a password typed now, in the ledger. A lead's token never gets past the store's own check.
+ */
+async function projectFallbackCommand(positional, flags, context) {
+    const command = "project fallback";
+    const allowed = new Set(["repo", "agents", "clear", "allow-paid", "no-paid", "as", "token", "token-file", "token-env", "db", "json"]);
+    for (const name of flags.keys())
+        if (!allowed.has(name))
+            return fail(context.write, context.json, command, "usage", `--${name} is not a project fallback option.`, EXIT.usage);
+    const repoFlag = text(flags, "repo");
+    const agents = text(flags, "agents");
+    const clearing = flags.has("clear"), allowing = flags.has("allow-paid"), withdrawing = flags.has("no-paid");
+    if (positional.length > 1 || repoFlag === undefined || (clearing && agents !== undefined) || (allowing && withdrawing))
+        return fail(context.write, context.json, command, "usage", "Use project fallback --repo <project path> [--agents provider:model:plan|api-key,…] [--clear] [--allow-paid|--no-paid].", EXIT.usage);
+    const repo = await knownProject(context, repoFlag, { listed: true, canonical: true });
+    if (repo === undefined)
+        return fail(context.write, context.json, command, "not-found", "That isn't a project Toolroll knows.", EXIT.refused);
+    const words = () => {
+        const setting = fallbackSettingOf(context.store, repo);
+        if (setting === null)
+            return [`${repo}: no fallback agents. A task stops when its agent runs out of its plan.`];
+        return [`${repo}: when an agent runs out of its plan, the work moves on to:`,
+            ...setting.entries.map((one, at) => `  ${at + 1}. ${entryWords(one)}. ${entryMovesOnWords(one)}.`),
+            setting.paidGrant === null ? "Paid fallback: not allowed." : `Paid fallback: allowed by ${setting.paidGrant.by}.`];
+    };
+    const shown = () => { const setting = fallbackSettingOf(context.store, repo); return { repo, agents: setting?.entries ?? [], paidAllowed: setting?.paidGrant != null }; };
+    if (agents === undefined && !clearing && !allowing && !withdrawing)
+        return succeed(context.write, context.json, command, shown(), words);
+    const parsed = agents === undefined ? [] : agents.split(",").map(one => parseEntry(one.trim()));
+    const bad = parsed.find((one) => typeof one === "string");
+    if (bad !== undefined)
+        return fail(context.write, context.json, command, "usage", bad, EXIT.usage);
+    const acting = await askCredentials(flags, context);
+    const verified = acting === null ? null : credentialApprover(context.store, acting.name, acting.token, repo);
+    if (acting === null || !verified?.ok || !context.store.accountCanAccess(acting.name, repo))
+        return fail(context.write, context.json, command, "refused", "An approver for this project changes its fallback agents, with their password: pass --as and --token.", EXIT.refused);
+    const now = context.clock();
+    const done = context.store.transact(() => {
+        if (clearing) {
+            const one = clearFallbackChain(context.store, repo, acting.name, now);
+            if (!one.ok)
+                return one;
+        }
+        if (agents !== undefined) {
+            const one = setFallbackChain(context.store, repo, parsed, acting.name, now);
+            if (!one.ok)
+                return one;
+        }
+        if (allowing || withdrawing) {
+            const one = setPaidGrant(context.store, repo, allowing, acting.name, now);
+            if (!one.ok)
+                return one;
+        }
+        return { ok: true };
+    });
+    if (!done.ok)
+        return fail(context.write, context.json, command, "refused", done.problem, EXIT.refused);
+    return succeed(context.write, context.json, command, shown(), () => [...words(), "Tasks scoped from now on use this; tasks already approved keep the chain they were approved with."]);
+}

package/dist/plan-login.d.ts

@@ -0,0 +1,14 @@
+import type { Billing } from "./spend.js";
+/** How Codex says it's signed in (`codex login status`): a ChatGPT sign-in is its plan; a key or Bedrock is a key;
+ * null when it says neither (not signed in, or it didn't answer). */
+export declare function codexLoginBilling(binary: string, omitEnv: readonly string[], env?: Record<string, string | undefined>): Promise<Billing | null>;
+/** Providers whose CLI can say, live and machine-readably, that the credential a run will use is a plan. */
+export declare const PLAN_LOGIN_PROVABLE: ReadonlySet<string>;
+/**
+ * How Claude says it is signed in (`claude auth status --json`), read with the run's own environment so it reads the
+ * credential the child will use. Strict: a plan only for a first-party claude.ai login with a named subscription; any
+ * other shape, a key, a cloud provider or no answer is not a plan.
+ */
+export declare function claudeLoginBilling(binary: string, omitEnv: readonly string[], env: Record<string, string | undefined>): Promise<Billing | null>;
+/** The live plan proof for a provider, or null where none exists (the caller refuses). */
+export declare function livePlanLogin(provider: string, binary: string, omitEnv: readonly string[], env: Record<string, string | undefined>): Promise<Billing | null>;

package/dist/plan-login.js

@@ -0,0 +1,58 @@
+/**
+ * How a CLI says it is signed in, read live, right before a run: the gateway's billing evidence, and the proof a
+ * plan-pinned fallback agent needs before it runs (fallback.ts). Only providers listed in PLAN_LOGIN_PROVABLE can be a
+ * plan fallback: for any other there is no live proof, so filing and the chain setting refuse it.
+ */
+import { run as runCommand } from "./exec.js";
+/** How Codex says it's signed in (`codex login status`): a ChatGPT sign-in is its plan; a key or Bedrock is a key;
+ * null when it says neither (not signed in, or it didn't answer). */
+export async function codexLoginBilling(binary, omitEnv, env) {
+    try {
+        const status = await runCommand(binary, ["login", "status"], { timeoutMs: 15_000, omitEnv, processGroup: true,
+            ...(env === undefined ? {} : { env: Object.fromEntries(Object.entries(env).filter((one) => one[1] !== undefined)) }) });
+        const said = `${status.stdout}\n${status.stderr}`;
+        // Strict: the status line itself, at the start of a line. A line naming both is never read as a plan.
+        if (/^Logged in using ChatGPT\s*$/m.test(said) && !/api key|bedrock/i.test(said))
+            return "subscription";
+        // Anything naming a key or Bedrock is read as a key (never a plan): that only ever narrows.
+        return /api key|bedrock/i.test(said) ? "api-key" : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Providers whose CLI can say, live and machine-readably, that the credential a run will use is a plan. */
+export const PLAN_LOGIN_PROVABLE = new Set(["claude", "codex"]);
+/**
+ * How Claude says it is signed in (`claude auth status --json`), read with the run's own environment so it reads the
+ * credential the child will use. Strict: a plan only for a first-party claude.ai login with a named subscription; any
+ * other shape, a key, a cloud provider or no answer is not a plan.
+ */
+export async function claudeLoginBilling(binary, omitEnv, env) {
+    try {
+        const status = await runCommand(binary, ["auth", "status", "--json"], { timeoutMs: 15_000, omitEnv, processGroup: true,
+            env: Object.fromEntries(Object.entries(env).filter((one) => one[1] !== undefined)) });
+        if (status.code !== 0)
+            return null;
+        const read = JSON.parse(status.stdout);
+        if (read === null || typeof read !== "object" || Array.isArray(read))
+            return null;
+        const said = read;
+        if (said["loggedIn"] !== true)
+            return null;
+        if (said["authMethod"] === "claude.ai" && said["apiProvider"] === "firstParty" && typeof said["subscriptionType"] === "string" && /^[a-z0-9_-]{1,32}$/.test(said["subscriptionType"]))
+            return "subscription";
+        return "api-key";
+    }
+    catch {
+        return null;
+    }
+}
+/** The live plan proof for a provider, or null where none exists (the caller refuses). */
+export async function livePlanLogin(provider, binary, omitEnv, env) {
+    if (provider === "codex")
+        return codexLoginBilling(binary, omitEnv, env);
+    if (provider === "claude")
+        return claudeLoginBilling(binary, omitEnv, env);
+    return null;
+}

package/dist/planner.d.ts

@@ -2,7 +2,7 @@ import type { ProviderId } from "./contracts/provider.js";
 import type { Store } from "./store.js";
 import { type ParsedDecision, type Problem } from "./decision.js";
 import { type ParsedPlan, type PlanProblem } from "./plan.js";
-import type { Runner } from "./builder.js";
+import { type Runner } from "./builder.js";
 import { type PlannerSource } from "./planner-source.js";
 export type PlanRequest = {
     /** v105: what's left of a monthly budget this API-key work counts toward (the CLI's own cap), when one does. */

package/dist/planner.js

@@ -32,6 +32,7 @@ import { TEXT_LIMITS } from "./text-limits.js";
 import { invokeAgent } from "./invoke.js";
 import { TOKEN_ENVS as TELEGRAM_TOKEN_ENVS } from "./telegram.js";
 import { evidenceRoot, mailboxName, planFileName, quarantineMailboxes, readMailbox, storeEvidence, writeEvidenceFile, } from "./evidence.js";
+import { gitFailureWords } from "./builder.js";
 import { MARKER as LEASE_MARKER } from "./worktree.js";
 import { liveLogContext } from "./live-detail.js";
 import { openLiveLog } from "./live.js";
@@ -537,7 +538,7 @@ export async function plan(store, request) {
     }
     const revision = await git(GIT, ["--no-optional-locks", "rev-parse", "HEAD"], { cwd: worktree });
     if (revision.code !== 0) {
-        return { ok: false, kind: "failure", reason: "git", message: `could not read the base revision in ${worktree}` };
+        return { ok: false, kind: "failure", reason: "git", message: `could not read the base revision in ${worktree} (${gitFailureWords(revision)})` };
     }
     const baseRevision = revision.stdout.trim();
     store.stampRun(request.runId, { baseRevision });

package/dist/project-delete-ui.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Settings → Project: what Toolroll holds for a project, and deleting
+ * it. An instance operator deletes in two steps: type the project's name,
+ * then read exactly what goes and confirm with their password (or a fresh
+ * sign-in with the identity provider). The repository itself stays.
+ */
+import { type FallbackSetting } from "./fallback.js";
 import type { ProjectSandbox } from "./project-sandbox.js";
 import type { ProjectNetwork } from "./egress.js";
 import type { WritesMode } from "./writes-mode.js";
@@ -49,6 +56,11 @@ export type ProjectSettingsView = {
         setting: ProjectNetwork;
         canChange: boolean;
     };
+    /** Who takes over when an agent runs out of its plan (fallback.ts), and whether this person may change it. */
+    fallback?: {
+        setting: FallbackSetting | null;
+        canChange: boolean;
+    };
     /** Where its builds may write (writes-mode.ts), and whether this person may change it. */
     writes?: {
         setting: WritesMode;

package/dist/project-delete-ui.js

@@ -4,6 +4,7 @@
  * then read exactly what goes and confirm with their password (or a fresh
  * sign-in with the identity provider). The repository itself stays.
  */
+import { entryMovesOnWords, entryWords } from "./fallback.js";
 import { sandboxRuntimeWords } from "./sandbox-runtime.js";
 import { CHECK_ACCESS_WARNINGS, signInHostsMissing } from "./check-access.js";
 import { html, joinHtml, postForm } from "./html.js";
@@ -132,6 +133,22 @@ function networkHtml(view) {
                     note("Tasks scoped from now on use this; tasks already approved keep the network they were approved with."),
                 ]) }))]) });
 }
+function fallbackHtml(view) {
+    const fallback = view.fallback;
+    if (fallback === undefined)
+        return "";
+    const { setting } = fallback;
+    const lead = setting === null ? html `When an agent runs out of its plan, the task stops.` : html `When an agent runs out of its plan, the work moves to the next agent here.`;
+    const lines = setting === null ? "" : joinHtml(setting.entries.map(one => note(`${entryWords(one)}. ${entryMovesOnWords(one)}.`)));
+    return settingsSection({ id: "fallback", title: "Fallback agents", state: setting === null ? "" : ` · ${setting.entries.length}`, lead,
+        body: joinHtml([lines, !fallback.canChange ? APPROVER_CHANGES : disclose("Change", kitSectionForm({ proof: "project-fallback", action: "/settings/project/fallback", id: "fallback-form", gate: true, hidden: { repo: view.repo },
+                body: joinHtml([
+                    formRow("Agents, in order", "One per line: provider:model:plan or provider:model:api-key. Empty turns this off.", textarea({ id: "fallback-agents", name: "agents", value: setting === null ? "" : setting.entries.map(one => `${one.provider}:${one.model}:${one.authMode === "subscription" ? "plan" : "api-key"}`).join("\n"), rows: 3,
+                        attrs: { autocomplete: "off", autocapitalize: "off", spellcheck: "false", placeholder: "codex:gpt-5.6:plan", "aria-label": "Fallback agents, in order" } }), "top"),
+                    formRow("Paid fallback", "An agent on an API key spends money. It runs only while this is on.", switchInput({ id: "fallback-paid", name: "paid", label: "Allowed", on: setting?.paidGrant != null, attrs: { value: "on", "aria-label": "Allow paid fallback agents to spend" } }), "inline"),
+                    note("Tasks scoped from now on use this; tasks already approved keep the chain they were approved with."),
+                ]) }))]) });
+}
 /** Live view: hidden by default; showing commands takes the password, hiding them is one step. */
 function liveViewHtml(view) {
     const live = view.liveView;
@@ -205,7 +222,7 @@ export function projectSettingsHtml(view, said) {
             formRow("Recorded remote", view.remoteUrl ? null : "None. Landed work waits for your review.", view.remoteUrl ? mono(view.remoteUrl) : html ``, view.remoteUrl ? "wide" : "inline"),
             disclose("Change remote", joinHtml([note("An owner or instance operator can run:"), codeLine("toolroll repos add <project> --remote <url>")])),
         ]) });
-    const settings = joinHtml([buildsHtml(view), accessHtml(view), networkHtml(view), writesHtml(view), sandboxHtml(view), checkAccessHtml(view), liveViewHtml(view), codeMapHtml(view)]);
+    const settings = joinHtml([buildsHtml(view), accessHtml(view), networkHtml(view), fallbackHtml(view), writesHtml(view), sandboxHtml(view), checkAccessHtml(view), liveViewHtml(view), codeMapHtml(view)]);
     if (!view.canDelete)
         return joinHtml([answer, project, settings, note("An instance operator can remove or delete a project.")]);
     const deleteBody = view.running.length > 0

package/dist/project-delete.js

@@ -50,6 +50,8 @@ const SETTINGS = [
     ["intake_grant", "repo"], ["capability", "repo"], ["project_tool", "repo"],
     ["learning_policy", "repo"], ["operating_mode", "repo"], ["project_knowledge", "repo"], ["live_detail_setting", "repo"],
     ["project_decision", "repo"], ["flow_script", "repo"], ["workflow_recipe", "repo"], ["team_lead_project", "project"],
+    // Its fallback agents and, on the same row, its paid fallback grant (fallback.ts).
+    ["fallback_setting", "repo"],
 ];
 /** The project's Models rows, counted with its settings and deleted by forgetProjectModels only. */
 export const MODEL_SETTINGS = Object.freeze([["phase_config", "scope"], ["phase_tier_config", "scope"], ["phase_tier_alternate", "scope"]]);
@@ -264,6 +266,10 @@ function deleteRows(store, repo, d, now) {
     del("diff_comment", `${IN("run")} OR ${IN("reviewer_run")} OR ${IN("artifact")}`, R, R, A);
     del("review_request", `${IN("run")} OR ${IN("reviewer_run")}`, R, R);
     del("repair_chain", IN("source_run"), R);
+    // What happens to a result after its agent finishes (fleet-schema.ts): a project's own rows, answers first.
+    del("finding_answer", "finding IN (SELECT id FROM finding WHERE repo = ?)", repo);
+    for (const table of ["finding", "check_repair", "evidence_pair", "failing_first", "provider_capture"])
+        del(table, "repo = ?", repo);
     for (const table of ["incident", "proof_acceptance", "proof_verdict", "run_process", "run_route", "run_spend", "run_tool", "run_note", "run_stop", "run_checkpoint", "execution_slot"])
         del(table, IN("run"), R);
     del("code_map_delivery", IN("run"), R);

package/dist/project-knowledge.d.ts

@@ -22,18 +22,18 @@ export type KnowledgeView = ReturnType<typeof knowledgeView>;
 export declare function knowledgeVersion(store: Store, repo: string, actor: string, revision: number): Knowledge;
 /** Chat reads only an admitted project. Keep the full source in the project UI. */
 export declare function conversationKnowledge(store: Store, repo: string, actor: string, reference?: string, decision?: number): {
-    title?: never;
+    references?: never;
     revision: number;
     stale: boolean;
     notice: string;
+    title?: never;
     content?: never;
     history?: never;
     instructions?: never;
-    references?: never;
     decisions?: never;
     waiting?: never;
 } | {
-    title?: never;
+    references?: never;
     stale?: never;
     decision: {
         repo: string;
@@ -51,14 +51,15 @@ export declare function conversationKnowledge(store: Store, repo: string, actor:
     };
     afterwards?: string;
     notice: string;
+    title?: never;
     content?: never;
     revision?: never;
     history?: never;
     instructions?: never;
-    references?: never;
     decisions?: never;
     waiting?: never;
 } | {
+    references?: never;
     stale?: never;
     revision: number;
     title: string;
@@ -66,12 +67,11 @@ export declare function conversationKnowledge(store: Store, repo: string, actor:
     notice: string;
     history?: never;
     instructions?: never;
-    references?: never;
     decisions?: never;
     waiting?: never;
 } | {
-    title?: never;
     stale?: never;
+    title?: never;
     content?: never;
     revision: number;
     history: {

package/dist/project-tools.d.ts

@@ -109,7 +109,7 @@ export declare function testTool(spec: ToolSpec, values: Record<string, string>,
     timeoutMs?: number;
     env?: NodeJS.ProcessEnv;
     omitEnv?: readonly string[];
-    server: ToolServer;
+    server: ToolServer | Promise<ToolServer>;
 }): Promise<{
     ok: true;
     tools: string[];
@@ -126,7 +126,7 @@ export declare function listProjectToolActions(spec: ToolSpec, values: Record<st
     timeoutMs?: number;
     env?: NodeJS.ProcessEnv;
     omitEnv?: readonly string[];
-    server: ToolServer;
+    server: ToolServer | Promise<ToolServer>;
 }): Promise<{
     ok: true;
     actions: ToolActionInfo[];
@@ -152,7 +152,7 @@ export declare function callProjectTool(spec: ToolSpec, values: Record<string, s
     timeoutMs?: number;
     env?: NodeJS.ProcessEnv;
     omitEnv?: readonly string[];
-    server: ToolServer;
+    server: ToolServer | Promise<ToolServer>;
 }): Promise<ToolCall>;
 /** The exact servers one launch gets, and those left out with why (`repo`: the project, from the run's record). */
 export type ToolLaunch = {
@@ -312,7 +312,7 @@ export type ToolServer = {
 export declare function toolServerFor(store: ToolServerStore, repo: string, options?: {
     home?: string;
     available?: () => boolean;
-}): ToolServer;
+}): Promise<ToolServer>;
 /** Each project's `.mcp.json` as the console last read it off its thread (its background pass): what its pages and the
  * lead offer, so neither reads a project folder on the console's thread. */
 export declare const savedProjectMcp: Map<string, Record<string, unknown> | null>;