toolroll 0.9.61 → 0.9.63

package/dist/browser-workspace.d.ts

@@ -1115,6 +1115,34 @@ export type BrowserFlowView = {
     /** Where the flow stands (v88): the live stream's nudge names it, and a page that already shows it doesn't read again. */
     live: string | null;
     canEdit: boolean;
+    /** "Runs on its own" (flow-unattended.ts): the live grant, and whether this person can sign one (why not, when not). */
+    unattended: {
+        active: {
+            until: string;
+            untilWords: string;
+            signedBy: string;
+            budgetMicrousd: number | null;
+            dailyRunCap: number | null;
+            runsToday: number;
+            words: string[];
+            covers: string[];
+        } | null;
+        canSign: boolean;
+        problem: string | null;
+        maxDays: number;
+        scheduled: boolean;
+        terms: {
+            head: string[];
+            rules: string[];
+        };
+        /** The schedules a signature could cover: plain ones always, `optional` ones (outside content, said why) only when picked. */
+        schedules: {
+            id: number;
+            words: string;
+            optional: string | null;
+        }[];
+        schedulesDigest: string;
+    };
     approvers: string[];
     /** The projects a Build zone may work in: the flow's own first, then others the viewer can reach. */
     projects?: {

package/dist/chat-actions.js

@@ -1331,9 +1331,9 @@ function runFlowAction(store, payload, actor, repos, root, now) {
     if (payload.operation.startsWith("flow_trigger_")) {
         const trigger = store.getFlowTrigger(Number(req["trigger"]));
         if (payload.operation === "flow_trigger_remove")
-            removeFlowTrigger(store, trigger, now, configDirOf(store));
+            removeFlowTrigger(store, trigger, now, configDirOf(store), actor);
         else
-            store.updateFlowTrigger(trigger.id, { state: payload.operation === "flow_trigger_pause" ? "paused" : "active" }, now);
+            store.updateFlowTrigger(trigger.id, { state: payload.operation === "flow_trigger_pause" ? "paused" : "active" }, now, actor);
         return { said: payload.operation === "flow_trigger_remove" ? "Trigger removed." : payload.operation === "flow_trigger_pause" ? "Trigger paused." : "Trigger on again.", href: `/flows/${trigger.flow}` };
     }
     const card = store.getFlowCard(Number(req["card"]));

package/dist/check-levels.js

@@ -153,6 +153,9 @@ export function suggestQuickCommand(repo) {
     const has = (name) => typeof scripts[name] === "string";
     const runner = existsSync(join(repo, "pnpm-lock.yaml")) ? "pnpm" : existsSync(join(repo, "yarn.lock")) ? "yarn" : "npm";
     const run = (name) => runner === "npm" ? `npm run ${name}` : `${runner} ${name}`;
+    // A project's own quick script knows its tests best (Toolroll's runs the attack suite when a guard changes).
+    if (has("check:quick"))
+        return run("check:quick");
     const exec = runner === "npm" ? "npx" : `${runner} exec`;
     const typecheck = ["typecheck", "type-check", "check-types", "tsc"].find(has) ?? null;
     const changed = "$(git diff --name-only HEAD~1)";

package/dist/claim.js

@@ -1116,7 +1116,7 @@ function sealPlan(store, leaseId, args) {
                     ? ""
                     : "The filed goal, exclusions, touches, and acceptance criteria are reproduced exactly.\n"
                 : `It AMENDS the filed contract (${oneLine(describeContractChanges(contractChanges).join("; "), 300)})${amendment === null ? "" : ` — because: ${oneLine(amendment, 200)}`}\n`) +
-            (autoApproved ? "Approved under the signed operating mode. The next build may proceed with the original terms and required quality checks." : "Review, edit, and approve the scope — nothing builds until you do."),
+            (autoApproved ? `${store.getScope(taskId)?.approvalBasis === "grant" ? "Approved because its flow runs on its own." : "Approved under the signed operating mode."} The next build may proceed with the original terms and required quality checks.` : "Review, edit, and approve the scope — nothing builds until you do."),
     }, now);
     return { ok: true, changes: contractChanges.length, amendment };
 }

package/dist/cli-help.d.ts

@@ -2,4 +2,4 @@
  * 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 a control plane for unattended coding agents\n\nUsage\n  toolroll [path...]        report what is in flight\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: gate, your approval, deploy, merge, tag, publish\n                                   (resumable: rerun to continue; --help)\n  toolroll contract         the machine contract: envelope version + capabilities\n                                   (--commands dumps the declared command guide)\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 skills list      the guides this exact binary serves\n  toolroll skills get <name>  print one guide (version-matched, never stale)\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 health           recent server latency, write waits and live streams\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 credential: its own work pings nobody\n  toolroll lead say \"<text>\"  (the lead) one short message in its person's chat\n\nOperating the queue \u2014 `toolroll task` prints the whole surface,\nand any queue command + --help prints it too\n  toolroll approver add <name>\n                               mint the credential that lets a person say yes\n  toolroll ready            what could be dispatched 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 add <title> queue work\n  toolroll task scope <id> --goal <text>\n                               state what success is; approval binds to it\n  toolroll task approve <id>\n                               the yes \u2014 nothing builds without one\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 flows list | show <id> | create | edit | trigger | script | card | archive\n                               set up and inspect flows (writes preview until --yes)\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 serve --repo <path>  advanced: 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   advanced: run only the builder\n  toolroll reconcile        recover what the last stretch left behind\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.";
+export declare const HELP = "toolroll \u2014 a control plane for unattended coding agents\n\nUsage\n  toolroll [path...]        report what is in flight\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: gate, your approval, deploy, merge, tag, publish\n                                   (resumable: rerun to continue; --help)\n  toolroll contract         the machine contract: envelope version + capabilities\n                                   (--commands dumps the declared command guide)\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 skills list      the guides this exact binary serves\n  toolroll skills get <name>  print one guide (version-matched, never stale)\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 health           recent server latency, write waits and live streams\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 credential: its own work pings nobody\n  toolroll lead say \"<text>\"  (the lead) one short message in its person's chat\n\nOperating the queue \u2014 `toolroll task` prints the whole surface,\nand any queue command + --help prints it too\n  toolroll approver add <name>\n                               mint the credential that lets a person say yes\n  toolroll ready            what could be dispatched 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 add <title> queue work\n  toolroll task scope <id> --goal <text>\n                               state what success is; approval binds to it\n  toolroll task approve <id>\n                               the yes \u2014 nothing builds without one\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 flows list | show <id> | create | edit | trigger | script | card | archive\n                               set up and inspect flows (writes preview until --yes)\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 serve --repo <path>  advanced: 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   advanced: 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\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.";

package/dist/cli-help.js

@@ -63,6 +63,7 @@ and any queue command + --help prints it too
                                (--editor vscode with --runner: file links
                                open in VS Code on the device you browse from)
   toolroll watch / daemon install   advanced: run only the builder
+  toolroll doctor           check that Toolroll's service holds no key a build could read
   toolroll reconcile        recover what the last stretch left behind
 
 With nothing connected it reports everything it can find below the working

package/dist/cli.js

@@ -313,6 +313,9 @@ async function dispatch(argv, write, mainOptions) {
     // Command families below load when their command runs, so one command never pays for the others.
     if (argv[0] === 'health')
         return (await import("./health-cli.js")).runHealthCommand(argv.slice(1), write, mainOptions.team ?? mainOptions.remote);
+    // This computer's own service, read here and never on a central server.
+    if (argv[0] === 'doctor')
+        return (await import("./doctor.js")).runDoctorCommand(argv.slice(1), write);
     const central = await maybeRunRemoteCommand(argv, mainOptions.remote ?? mainOptions.team);
     if (typeof central === "number")
         return central;
@@ -506,7 +509,14 @@ async function runReposCommand(argv, write, onboard) {
     const tokenAt = argv.indexOf("--token");
     const tokenFlag = tokenAt === -1 ? undefined : argv[tokenAt + 1];
     const bare = argv.filter((argument, index) => argument !== "--json" && (tokenAt === -1 || (index !== tokenAt && index !== tokenAt + 1)));
-    const [action, ...paths] = bare;
+    const remoteAt = bare.indexOf("--remote");
+    const remoteUrl = remoteAt === -1 ? undefined : bare[remoteAt + 1];
+    const [action, ...paths] = bare.filter((_, i) => remoteAt === -1 || (i !== remoteAt && i !== remoteAt + 1));
+    if (remoteAt !== -1 && (action !== "add" || bare.filter(v => v === "--remote").length !== 1 || remoteUrl === undefined || remoteUrl.startsWith("-") || paths.length > 1)) {
+        const message = "Use repos add <project> --remote <url> for one project.";
+        write(json ? envelopeJson({ ok: false, command: "repos", reason: "usage", message }) : message);
+        return USAGE_EXIT;
+    }
     const databaseFile = databasePath(process.env, homedir());
     const file = registryBeside(databaseFile);
     if (tokenAt !== -1 && (tokenFlag === undefined || tokenFlag.startsWith("-"))) {
@@ -529,11 +539,18 @@ async function runReposCommand(argv, write, onboard) {
         return 1;
     }
     if (action === undefined) {
-        if (json) {
-            write(envelopeJson({ ok: true, command: "repos", count: loaded.repos.length, repos: loaded.repos, file }));
-            return 0;
+        const store = openStore(databaseFile);
+        try {
+            const projects = loaded.repos.map(repo => ({ repo, remoteUrl: store.projectRemote(repo) }));
+            if (json) {
+                write(envelopeJson({ ok: true, command: "repos", count: loaded.repos.length, repos: loaded.repos, projects, file }));
+                return 0;
+            }
+            return listRepos(loaded.repos, file, write, new Map(projects.map(p => [p.repo, p.remoteUrl])));
+        }
+        finally {
+            store.close();
         }
-        return listRepos(loaded.repos, file, write);
     }
     if (action !== "add" && action !== "remove") {
         const message = `unknown command \`repos ${action}\` — try \`repos\`, \`repos add\`, \`repos remove\`, or \`repos add-from-github <owner/name>\``;
@@ -545,7 +562,7 @@ async function runReposCommand(argv, write, onboard) {
     const lines = [];
     const said = {};
     const say = json ? (line) => lines.push(line) : write;
-    const code = await withAdmission({ databaseFile, registryFile: file, ...(leadToken === undefined ? {} : { leadToken }) }, say, said, admission => action === "add" ? addToRepos(admission, targets, say, said) : removeFromRepos(admission, targets, say, said));
+    const code = await withAdmission({ databaseFile, registryFile: file, ...(leadToken === undefined ? {} : { leadToken }) }, say, said, admission => action === "add" ? addToRepos(admission, targets, say, said, remoteUrl) : removeFromRepos(admission, targets, say, said));
     if (json) {
         write(envelopeJson({
             ok: code === 0,
@@ -582,7 +599,7 @@ async function withAdmission(where, write, said, body) {
         store.close();
     }
 }
-function listRepos(repos, file, write) {
+function listRepos(repos, file, write, remotes) {
     if (repos.length === 0) {
         write("No repositories connected. Toolroll reports on everything it can find.");
         write("");
@@ -592,8 +609,10 @@ function listRepos(repos, file, write) {
         return 0;
     }
     write(`${repos.length === 1 ? "1 repository" : `${repos.length} repositories`} connected:`);
-    for (const repo of repos)
+    for (const repo of repos) {
         write(`  ${repo}${existsSync(repo) ? "" : "   (missing)"}`);
+        write(`    Recorded remote: ${remotes.get(repo) ?? "None"}`);
+    }
     write("");
     write("  toolroll repos add <path>      add another; it is in the console at once");
     write("  toolroll repos remove <path>   take one out of the console; its tasks stay");
@@ -606,7 +625,7 @@ function listRepos(repos, file, write) {
 function admissionExit(reason) {
     return reason === "not-git" || reason === "unavailable" ? USAGE_EXIT : 1;
 }
-async function addToRepos(admission, targets, write, said) {
+async function addToRepos(admission, targets, write, said, remoteUrl) {
     // Every folder is proved before anything is written: one that is not a
     // repository fails here, not later and further away.
     let refused = false;
@@ -624,7 +643,7 @@ async function addToRepos(admission, targets, write, said) {
     const running = consoleRunning(admission.store, now);
     const projects = [];
     for (const path of targets) {
-        const admitted = await admitProject(admission.store, { registryFile: admission.registryFile, path, actor: admission.actor, now });
+        const admitted = await admitProject(admission.store, { registryFile: admission.registryFile, path, actor: admission.actor, now, captureOrigin: true, ...(remoteUrl === undefined ? {} : { remoteUrl }) });
         if (!admitted.ok) {
             // The updater's own taxonomy survives (verification finding 4): a held
             // lock or a malformed registry is an operational fact, never "usage".
@@ -633,8 +652,9 @@ async function addToRepos(admission, targets, write, said) {
             write(admitted.message);
             return admissionExit(admitted.reason);
         }
-        projects.push({ repo: admitted.repo, name: admitted.name, added: admitted.added });
+        projects.push({ repo: admitted.repo, name: admitted.name, added: admitted.added, remoteUrl: admitted.remote.url });
         write(addedWords(admitted.name, admitted.added, running));
+        write(`Recorded remote: ${admitted.remote.url ?? "None. Use repos add <project> --remote <url> to record one."}`);
     }
     said.projects = projects;
     return 0;

package/dist/contracts/cli.d.ts

@@ -647,6 +647,14 @@ export declare const COMMAND_OUTPUTS: {
             readable: z.ZodBoolean;
             zones: z.ZodArray<z.ZodUnknown>;
             triggers: z.ZodArray<z.ZodUnknown>;
+            unattended: z.ZodNullable<z.ZodObject<{
+                until: z.ZodString;
+                signedBy: z.ZodString;
+                budgetMicrousd: z.ZodNullable<z.ZodNumber>;
+                dailyRunCap: z.ZodNullable<z.ZodNumber>;
+                runsToday: z.ZodNumber;
+                covers: z.ZodArray<z.ZodString>;
+            }, z.core.$loose>>;
         }, z.core.$loose>;
     }, z.core.$loose>, z.ZodObject<{
         envelopeVersion: z.ZodLiteral<1>;

package/dist/contracts/cli.js

@@ -184,7 +184,9 @@ export const COMMAND_OUTPUTS = {
     "task unhold": answers("task unhold", { id: str }),
     "task wait": answers("task wait", { task: str, outcome: str }),
     "flows list": answers("flows list", { flows: z.array(flowListed) }),
-    "flows show": answers("flows show", { flow: z.looseObject({ id: int, name: str, repo: str, project: str, readable: z.boolean(), zones: list, triggers: list }) }),
+    "flows show": answers("flows show", { flow: z.looseObject({ id: int, name: str, repo: str, project: str, readable: z.boolean(), zones: list, triggers: list,
+            // Whether the flow runs on its own, and until when (null: it doesn't).
+            unattended: nullable(z.looseObject({ until: str, signedBy: str, budgetMicrousd: nullable(int), dailyRunCap: nullable(int), runsToday: int, covers: z.array(str) })) }) }),
     grants: answers("grants", { count: int, grants: list }),
     "runner list": answers("runner list", { count: int, runners: list }),
     "incident list": answers("incident list", { incidents: list }),

package/dist/contracts/console-api.d.ts

@@ -73,7 +73,7 @@ export declare const CONSOLE_FORMS: {
     readonly kit: FormContract<"repo">;
     readonly subagents: FormContract<"choice" | "dailyTurns" | "id" | "manager" | "model" | "name" | "note" | "op" | "repo" | "schedule" | "soul" | "state" | "template" | "text" | "tool" | `field.${string}` | `over.${string}` | `undo.${string}` | `use.${string}`>;
     readonly galleryUse: FormContract<string>;
-    readonly flows: FormContract<"about" | "address" | "answers" | "approve" | "body" | "choice" | "confirm" | "decision" | "definition" | "description" | "document" | "draft" | "entry" | "file" | "key" | "label" | "language" | "name" | "note" | "owner" | "password" | "previewed" | "remove" | "repo" | "revision" | "secret" | "stage" | "template" | "timeoutMinutes" | "title" | "trigger" | "url" | "value" | "watching" | `param.${string}`>;
+    readonly flows: FormContract<"about" | "address" | "answers" | "approve" | "body" | "budget" | "choice" | "confirm" | "days" | "decision" | "definition" | "description" | "document" | "draft" | "entry" | "file" | "include" | "key" | "label" | "language" | "name" | "note" | "owner" | "password" | "previewed" | "remove" | "repo" | "revision" | "runs" | "schedules" | "secret" | "stage" | "template" | "timeoutMinutes" | "title" | "trigger" | "url" | "value" | "watching" | `param.${string}`>;
     readonly spendBudget: FormContract<"action" | "password" | "stop" | "target" | "usd">;
     readonly projectConcurrency: FormContract<"concurrency" | "repo">;
     readonly projectDelete: FormContract<"name" | "password" | "repo" | "step">;
@@ -318,6 +318,15 @@ export declare const flowViewSchema: z.ZodObject<{
     selectedCard: z.ZodNullable<z.ZodNumber>;
     live: z.ZodNullable<z.ZodString>;
     canEdit: z.ZodBoolean;
+    unattended: z.ZodObject<{
+        active: z.ZodNullable<z.ZodObject<{
+            until: z.ZodString;
+            signedBy: z.ZodString;
+        }, z.core.$loose>>;
+        canSign: z.ZodBoolean;
+        problem: z.ZodNullable<z.ZodString>;
+        scheduled: z.ZodBoolean;
+    }, z.core.$loose>;
     approvers: z.ZodArray<z.ZodString>;
     kinds: z.ZodArray<z.ZodObject<{
         kind: z.ZodString;
@@ -467,6 +476,15 @@ export declare const CONSOLE_RESPONSES: {
             selectedCard: z.ZodNullable<z.ZodNumber>;
             live: z.ZodNullable<z.ZodString>;
             canEdit: z.ZodBoolean;
+            unattended: z.ZodObject<{
+                active: z.ZodNullable<z.ZodObject<{
+                    until: z.ZodString;
+                    signedBy: z.ZodString;
+                }, z.core.$loose>>;
+                canSign: z.ZodBoolean;
+                problem: z.ZodNullable<z.ZodString>;
+                scheduled: z.ZodBoolean;
+            }, z.core.$loose>;
             approvers: z.ZodArray<z.ZodString>;
             kinds: z.ZodArray<z.ZodObject<{
                 kind: z.ZodString;

package/dist/contracts/console-api.js

@@ -82,7 +82,7 @@ export const CONSOLE_FORMS = {
     kit: formContract("POST /kits/<kit>/<act>", ["repo"]),
     subagents: formContract("POST /settings/lead/subagents/new, /settings/lead/subagents/<id>/<part>, /settings/lead/subagents/questions/<id>/answer", ["choice", "text", "repo", "template", "name", "soul", "op", "id", "schedule", "tool", "state", "note", "model", "dailyTurns", "manager"], { prefixes: ["use.", "undo.", "field.", "over."] }),
     galleryUse: formContract("POST /flows/new/<template>", ["repo", "send-result", "name", "intent", "previewed"], { dynamic: true }),
-    flows: formContract("POST /flows/new, /flows/example, /flows/import, /flows/<id>/<act>, /flows/<id>/cards/<card>/<act>, /flows/<id>/triggers/<trigger>/<act>", ["repo", "document", "url", "confirm", "previewed", "template", "name", "answers", "password", "secret", "trigger", "approve", "remove", "about", "body", "timeoutMinutes", "language", "file", "address", "key", "definition", "owner", "revision", "value", "title", "description", "stage", "decision", "note", "draft", "choice", "entry", "label", "watching"], { prefixes: ["param."] }),
+    flows: formContract("POST /flows/new, /flows/example, /flows/import, /flows/<id>/<act>, /flows/<id>/cards/<card>/<act>, /flows/<id>/triggers/<trigger>/<act>", ["repo", "document", "url", "confirm", "previewed", "template", "name", "answers", "password", "secret", "trigger", "approve", "remove", "about", "body", "timeoutMinutes", "language", "file", "address", "key", "definition", "owner", "revision", "value", "title", "description", "stage", "decision", "note", "draft", "choice", "entry", "label", "watching", "days", "budget", "runs", "include", "schedules"], { prefixes: ["param."] }),
     spendBudget: formContract("POST /spend/budget", ["password", "target", "action", "usd", "stop"]),
     projectConcurrency: formContract("POST /settings/project/concurrency", ["repo", "concurrency"]),
     projectDelete: formContract("POST /settings/project/delete", ["repo", "name", "step", "password"]),
@@ -255,6 +255,7 @@ export const flowViewSchema = z.looseObject({
     selectedCard: z.number().nullable(),
     live: z.string().nullable(),
     canEdit: z.boolean(),
+    unattended: z.looseObject({ active: z.looseObject({ until: z.string(), signedBy: z.string() }).nullable(), canSign: z.boolean(), problem: z.string().nullable(), scheduled: z.boolean() }),
     approvers: z.array(z.string()),
     kinds: z.array(z.looseObject({ kind: z.string(), label: z.string() })),
     colors: z.array(z.string()),

package/dist/contracts/integration-metadata.d.ts

@@ -22,11 +22,12 @@ export declare const protectedResourceSchema: z.ZodObject<{
     authorization_servers: z.ZodOptional<z.ZodArray<z.ZodString>>;
     scopes_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
-/** RFC 8414 (or OpenID) authorization-server metadata: where to sign in, trade a code, and register. */
+/** RFC 8414 (or OpenID) authorization-server metadata: where to sign in, trade a code, register, and revoke. */
 export declare const authorizationServerSchema: z.ZodObject<{
     authorization_endpoint: z.ZodOptional<z.ZodString>;
     token_endpoint: z.ZodOptional<z.ZodString>;
     registration_endpoint: z.ZodOptional<z.ZodString>;
+    revocation_endpoint: z.ZodOptional<z.ZodString>;
     code_challenge_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 /** RFC 7591 registration answer: the client Toolroll is, and its secret when the server gives one. */

package/dist/contracts/integration-metadata.js

@@ -44,11 +44,12 @@ export const protectedResourceSchema = z.object({
     authorization_servers: z.array(z.string()).optional(),
     scopes_supported: z.array(z.string().regex(SCOPE_TOKEN)).optional(),
 });
-/** RFC 8414 (or OpenID) authorization-server metadata: where to sign in, trade a code, and register. */
+/** RFC 8414 (or OpenID) authorization-server metadata: where to sign in, trade a code, register, and revoke. */
 export const authorizationServerSchema = z.object({
     authorization_endpoint: z.string().optional(),
     token_endpoint: z.string().optional(),
     registration_endpoint: z.string().optional(),
+    revocation_endpoint: z.string().optional(),
     code_challenge_methods_supported: z.array(z.string()).optional(),
 });
 /** RFC 7591 registration answer: the client Toolroll is, and its secret when the server gives one. */

package/dist/desktop-update.d.ts

@@ -94,6 +94,7 @@ export declare function prepareDesktopUpdate(stateDir: string, installed: string
 export declare function sqliteLock(file: string, busyTimeoutMs?: number): DatabaseSync | null;
 export declare const installationLock: (j: UpdateJournal) => DatabaseSync | null;
 export declare function desktopUpdateStatus(stateDir: string): {
+    version?: never;
     active: boolean;
     phase: string;
     detail: string;
@@ -107,7 +108,6 @@ export declare function desktopUpdateStatus(stateDir: string): {
     wasRunning?: never;
     backupPath?: never;
     updateId?: never;
-    version?: never;
     buildId?: never;
     workDir?: never;
 } | {

package/dist/dispatch.js

@@ -15,6 +15,8 @@ import { REVIEW_TOKENS, resultStatusOf, reviewFactsOf } from "./workspace-ui.js"
 import { replacedWords } from "./task-status.js";
 import { failedAttemptSentence, latestFinishedAttempt } from "./needs-you.js";
 import { buildReviewOf } from "./review-switch.js";
+import { grantStandsSql } from "./flow-unattended.js";
+import { accountReachesSql } from "./project-access.js";
 import { BUILT_IN, parseCapabilityKey } from "./store.js";
 export const DEFAULT_MAX_OPEN_DECISIONS = 5;
 /**
@@ -75,13 +77,14 @@ export function scopeApprovedForDispatch(store, taskRef, now) {
         .prepare(`SELECT 1 AS hit FROM task_scope
        JOIN task_ref ON task_ref.id = ? AND task_scope.task_id = task_ref.external_id
        WHERE task_scope.approved_digest = task_scope.digest AND task_scope.approved_at IS NOT NULL
-         AND (COALESCE(task_scope.approval_basis, 'password') <> 'mode'
-           OR EXISTS (SELECT 1 FROM operating_mode om
+         AND (COALESCE(task_scope.approval_basis, 'password') NOT IN ('mode', 'grant')
+           OR (task_scope.approval_basis = 'mode' AND EXISTS (SELECT 1 FROM operating_mode om
                       JOIN approver signer ON signer.name = om.signed_by
                      WHERE om.repo = task_ref.repo AND om.revoked_at IS NULL
                        AND om.absolute_expiry > ? AND om.digest = task_scope.mode_digest
-                       AND signer.revoked_at IS NULL AND signer.role = 'approver'))`)
-        .get(taskRef, now.toISOString());
+                       AND signer.revoked_at IS NULL AND signer.role = 'approver' AND ${accountReachesSql("signer", "task_ref.repo")}))
+           OR (task_scope.approval_basis = 'grant' AND ${grantStandsSql("task_scope.mode_digest", "?", "task_ref.repo")}))`)
+        .get(taskRef, now.toISOString(), now.toISOString());
     return row !== undefined;
 }
 /** The phase the ordinary dispatch loop would choose before it resolves an

package/dist/doctor.d.ts

@@ -0,0 +1,53 @@
+import { type SupervisorRunner } from "./daemon.js";
+/** Something that holds a credential a build could read, by name only, and what the owner does about it. */
+export type DoctorFinding = {
+    where: string;
+    names: string[];
+    steps: string[];
+};
+/** Something the doctor could not read: never taken for clean. */
+export type DoctorUnreadable = {
+    where: string;
+    problem: string;
+    steps: string[];
+};
+export type DoctorReport = {
+    ok: boolean;
+    checked: string[];
+    findings: DoctorFinding[];
+    unreadable: DoctorUnreadable[];
+    notes: string[];
+};
+export type DoctorDeps = {
+    platform?: NodeJS.Platform;
+    home?: string;
+    uid?: number;
+    /** Runs the read-only supervisor and process queries (launchctl, systemctl, ps). */
+    run?: SupervisorRunner;
+    /** Where Linux keeps its process files (a test's stand-in). */
+    procRoot?: string;
+    /** The doctor's own environment: the terminal a `toolroll up` would start from. */
+    env?: NodeJS.ProcessEnv;
+};
+/** The names among `pairs` that hold a credential: a provider key, a credential-looking name, or a key-shaped value.
+ * Values are only tested here and never leave. */
+export declare function credentialNames(pairs: Iterable<readonly [string, string]>): string[];
+/** A running process's environment names (never values) that hold a credential: macOS through `ps -E`, which reads
+ * KERN_PROCARGS2; Linux from /proc/<pid>/environ. */
+export declare function processCredentialNames(pid: number, deps: {
+    platform: NodeJS.Platform;
+    run: SupervisorRunner;
+    procRoot?: string;
+}): Promise<{
+    ok: true;
+    names: string[];
+} | {
+    ok: false;
+    problem: string;
+}>;
+/** Audit what Toolroll's service holds. Reads only; the report names variables, never their values. */
+export declare function auditServiceEnvironment(deps?: DoctorDeps): Promise<DoctorReport>;
+/** The report as the owner reads it: one state, then each finding with its steps; detail after. */
+export declare function doctorLines(report: DoctorReport): string[];
+export declare const DOCTOR_HELP = "toolroll doctor [--json]\nChecks that Toolroll's service holds no API key, token or password a build could read: its service definitions, what `daemon install` writes, the environment its manager hands it, and its running process. Reads only: it names what it finds and the steps to fix it, and never changes a file or restarts anything.";
+export declare function runDoctorCommand(argv: readonly string[], write: (line: string) => void, deps?: DoctorDeps): Promise<number>;