toolroll 0.9.93 → 0.9.94

package/dist/result-follow-ups.d.ts

@@ -28,7 +28,7 @@ export type FollowUpCheck = {
     head: string;
     actor: string;
     at: string;
-    why: "person" | "pull-request" | "batch";
+    why: "person" | "pull-request" | "batch" | "recheck";
     /** The approved command's digest when checks were asked for: only that exact command runs. */
     digest: string;
     state: "waiting" | "running" | "passed" | "failed" | "not-run";
@@ -55,7 +55,7 @@ export declare function requestFollowUpChecks(store: Store, input: {
     runId: number;
     level: RunLevel;
     actor: string;
-    why?: "person" | "pull-request";
+    why?: "person" | "pull-request" | "recheck";
 }, now: Date): {
     ok: true;
     request: number;

package/dist/result-follow-ups.js

@@ -1,4 +1,6 @@
-import { checkoutRunner, ranAtLine, widestRan } from "./invoke.js";
+import { widerThan } from "./check-access.js";
+import { recheckStanding } from "./check-only-standing.js";
+import { actualCheckAccess, checkoutLaunchOf, checkoutRunner, ranAtLine, widestRan } from "./invoke.js";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -72,7 +74,7 @@ export function followUpChecksOf(store, runId, now = new Date(), root) {
         const started = rows.find(row => row.action === CHECKS_STARTED && row.outcome === String(request.id)) ?? null;
         const finished = rows.find(row => row.action === CHECKS_FINISHED && row.outcome.startsWith(`${request.id}:`)) ?? null;
         const base = { request: request.id, runId, level: request.outcome, head, digest, actor: request.actor, at: request.at,
-            why: why === "pull-request" ? "pull-request" : why === "batch" ? "batch" : "person", exitCode: null, logArtifactId: null, note: null,
+            why: why === "pull-request" ? "pull-request" : why === "batch" ? "batch" : why === "recheck" ? "recheck" : "person", exitCode: null, logArtifactId: null, note: null,
             ...(why === "batch" ? { base: /^[a-f0-9]{40}$/.test(recordedBase) ? recordedBase : null } : {}) };
         if (finished !== null) {
             const status = finished.outcome.slice(String(request.id).length + 1);
@@ -200,6 +202,18 @@ export async function runFollowUpCheck(store, root, request, deps = {}) {
         finish("not-run", "The result's commit changed after checks were asked for.");
         return followUpChecksOf(store, runId, now(), root).find(one => one.request === request) ?? null;
     }
+    // An automatic recheck runs only on its check-only authorization, read again now (check-only.ts): no record, no run.
+    const authorized = wanted.why === "recheck" ? recheckStanding(store, { request, runId, head: target.head, digest: wanted.digest }) : null;
+    if (wanted.why === "recheck" && !authorized?.ok) {
+        finish("not-run", authorized?.problem ?? "Its authorization couldn't be read.");
+        return followUpChecksOf(store, runId, now(), root).find(one => one.request === request) ?? null;
+    }
+    /** Every command of an automatic recheck, refused at the moment it would run wider than the build's own access. */
+    const launched = (inner) => !authorized?.ok ? inner : (file, args, options) => {
+        if (widerThan(actualCheckAccess(store, checkoutLaunchOf(store, target.repo, [runId]).access), authorized.access))
+            return Promise.resolve({ code: 126, stdout: "", stderr: "", notFound: true, timedOut: false });
+        return inner(file, args, options);
+    };
     const folder = mkdtempSync(join(deps.scratch ?? tmpdir(), "toolroll-checks-"));
     const checkout = join(folder, "checkout");
     const log = [];
@@ -220,7 +234,7 @@ export async function runFollowUpCheck(store, root, request, deps = {}) {
             let ready = true;
             if (setup !== null) {
                 const shell = approvedCommandShell(setup.command);
-                const prepared = await runWithIsolatedDatabase(checkoutRunner(store, target.repo, checkout, runner, [runId], level => ranAt.push(level)), shell.file, shell.args, { cwd: checkout, timeoutMs: setup.timeoutMs, processGroup: true, envAllowlist: SETUP_ENV_ALLOWLIST, omitEnv: SETUP_ENV_DENYLIST });
+                const prepared = await runWithIsolatedDatabase(launched(checkoutRunner(store, target.repo, checkout, runner, [runId], level => ranAt.push(level))), shell.file, shell.args, { cwd: checkout, timeoutMs: setup.timeoutMs, processGroup: true, envAllowlist: SETUP_ENV_ALLOWLIST, omitEnv: SETUP_ENV_DENYLIST });
                 note("Approved project setup", setup.command, prepared);
                 if (prepared.code !== 0 || prepared.timedOut || prepared.notFound) {
                     ready = false;
@@ -235,7 +249,7 @@ export async function runFollowUpCheck(store, root, request, deps = {}) {
                 }
                 else {
                     const shell = approvedCommandShell(live.command);
-                    const ran = await runWithIsolatedDatabase(checkoutRunner(store, target.repo, checkout, runner, [runId], level => ranAt.push(level)), shell.file, shell.args, { cwd: checkout, timeoutMs: live.timeoutMs, processGroup: true, envAllowlist: SETUP_ENV_ALLOWLIST, omitEnv: SETUP_ENV_DENYLIST });
+                    const ran = await runWithIsolatedDatabase(launched(checkoutRunner(store, target.repo, checkout, runner, [runId], level => ranAt.push(level))), shell.file, shell.args, { cwd: checkout, timeoutMs: live.timeoutMs, processGroup: true, envAllowlist: SETUP_ENV_ALLOWLIST, omitEnv: SETUP_ENV_DENYLIST });
                     note(`${CHECK_LEVEL_WORDS[target.level]} check`, live.command, ran);
                     result = ran.timedOut ? { ran: false, failure: "The check ran out of time." } : ran.notFound ? { ran: false, failure: "The check couldn't start." } : { ran: true, exitCode: ran.code };
                 }

package/dist/result-review.d.ts

@@ -129,7 +129,7 @@ export type SharedResultFacts = {
      * else from the run record — `headSource` says which. */
     base: string | null;
     head: string | null;
-    headSource: "sealed diff" | "run record" | null;
+    headSource: "saved diff" | "build record" | null;
     /** Signed criteria passed, from the machine's matrix; null = no rubric. */
     checks: {
         passed: number;

package/dist/route-change-check.d.ts

@@ -0,0 +1,4 @@
+import type { Scope } from "./scope.js";
+import type { Store } from "./store.js";
+/** Whether a line on record for this exact plan describes some other route. An Approve under it is a yes to the wrong words. */
+export declare function routeChangeProblem(store: Store, taskId: string, scope: Scope): boolean;

package/dist/route-change-check.js

@@ -0,0 +1,13 @@
+/** The approval's one question about a "what changed" line (route-change.ts), apart so scope.ts loads it without the rest. */
+import { routeDigestOf, routeFromJson } from "./phase-routing.js";
+/** Whether a line on record for this exact plan describes some other route. An Approve under it is a yes to the wrong words. */
+export function routeChangeProblem(store, taskId, scope) {
+    const ref = store.lookupRef(taskId);
+    if (ref === null)
+        return false;
+    const row = store.handle.prepare("SELECT to_route_digest FROM route_change WHERE task_ref = ? AND scope_digest = ?").get(ref.id, scope.digest);
+    if (row === undefined)
+        return false;
+    const route = routeFromJson(scope.proposedRouteJson ?? null);
+    return route === null || routeDigestOf(route) !== row["to_route_digest"];
+}

package/dist/route-change.d.ts

@@ -0,0 +1,22 @@
+import { type PhaseRoute } from "./phase-routing.js";
+import { type Scope } from "./scope.js";
+import { type Store } from "./store.js";
+/** The sentence for what changed between the seal and the proposal. */
+export declare function routeChangeWords(sealed: {
+    route: PhaseRoute | null;
+    profile: Scope["approvedProfile"] | null | undefined;
+    authMode?: string | null;
+}, next: {
+    route: PhaseRoute;
+    authMode?: string | null;
+}): string;
+/** File the same words on today's route, and keep the line. Null: nothing to propose (a release, nothing changed, or no
+ * route Toolroll can name), and the task stays as it is. It seals nothing. */
+export declare function proposeNewRoute(store: Store, taskRef: number, taskId: string, now: Date): {
+    words: string;
+} | null;
+/** The line for this task's waiting plan, or null. Only while it describes exactly the plan up for approval. */
+export declare function routeChangeOf(store: Store, taskId: string): string | null;
+/** Each sweep: an unapproved row from before routing gets its route, and the same one Approve. A standing old approval
+ * is left alone (the stale check reaches it if its route ever differs). */
+export declare function routeLegacyPlans(store: Store, now: Date): number;

package/dist/route-change.js

@@ -0,0 +1,89 @@
+/**
+ * One step to approve a new route (docs/plans/plain-toolroll.md P2.5). There are no route classes: an approval stays
+ * bound to its exact route, and dispatch runs on no other bytes. When the route a task would dispatch on differs from the
+ * sealed one, Toolroll files the same words again on today's route (nothing is sealed) and keeps one "what changed" line,
+ * bound to that route's digest, for the one Approve. A legacy row with no route gets the same.
+ *
+ * approve() reads routeChangeProblem: a line that doesn't describe the route being approved refuses "changed".
+ */
+import { providerName } from "./provider-auth.js";
+import { legOf, routeDigestOf, routeFromJson } from "./phase-routing.js";
+import { deployGateScope, releaseCheckScope } from "./scope.js";
+import { BUILT_IN } from "./store.js";
+const ROLE = { plan: "planner", build: "builder", repair: "repair agent", review: "reviewer" };
+const named = (one) => `${providerName(one.provider)} ${one.model ?? "(its default model)"}`;
+const billing = (mode) => mode === "api-key" ? "API key" : mode === "subscription" ? "subscription" : null;
+/** The sentence for what changed between the seal and the proposal. */
+export function routeChangeWords(sealed, next) {
+    const changes = [];
+    for (const phase of ["build", "plan", "repair", "review"]) {
+        const now = legOf(next.route, phase);
+        const was = sealed.route !== null ? legOf(sealed.route, phase) : phase === "build" && sealed.profile != null ? { provider: sealed.profile.provider, model: "model" in sealed.profile ? (sealed.profile.model ?? null) : null } : null;
+        if (was === null) {
+            if (phase === "build")
+                changes.push(`The builder is ${named(now)}`);
+            continue;
+        }
+        if (was.provider === now.provider && was.model === now.model)
+            continue;
+        const line = `changes from ${named(was)} to ${named(now)}`;
+        // The repair agent is the builder's usual twin: one change is one sentence.
+        if (changes.some(one => one.endsWith(line)))
+            continue;
+        changes.push(`${changes.length === 0 ? "The" : "the"} ${ROLE[phase]} ${line}`);
+    }
+    const from = billing(sealed.authMode), to = billing(next.authMode);
+    const paid = from !== null && to !== null && from !== to ? ` (${from} → ${to})` : "";
+    if (changes.length === 0)
+        return "The agents' settings changed since you approved this. Approve to continue.";
+    return `${changes.join("; ")}${paid}. Approve to continue.`;
+}
+/** File the same words on today's route, and keep the line. Null: nothing to propose (a release, nothing changed, or no
+ * route Toolroll can name), and the task stays as it is. It seals nothing. */
+export function proposeNewRoute(store, taskRef, taskId, now) {
+    return store.transact(() => {
+        const before = store.getScope(taskId);
+        if (before === null || deployGateScope(before) || releaseCheckScope(before))
+            return null;
+        const sealedRoute = routeFromJson(before.approvedRouteJson ?? null);
+        const refiled = store.refileScope(taskId, now);
+        if (refiled === null || refiled.profileState === "unresolved")
+            return null;
+        const route = routeFromJson(refiled.proposedRouteJson ?? null);
+        if (route === null)
+            return null;
+        if (refiled.approvedDigest === refiled.digest)
+            return null;
+        // How the last attempt billed, against how the new builder would: said when they differ.
+        const lastBilled = store.runsFor(taskRef).find(one => one.role === "builder")?.authMode ?? null;
+        const billed = store.agentsFor([legOf(route, "build").provider])[0]?.billing ?? null;
+        const words = routeChangeWords({ route: sealedRoute, profile: before.approvedProfile ?? null, authMode: lastBilled }, { route, authMode: billed });
+        store.handle.prepare(`INSERT INTO route_change (task_ref, scope_digest, to_route_digest, words, created_at) VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT (task_ref) DO UPDATE SET scope_digest = excluded.scope_digest, to_route_digest = excluded.to_route_digest, words = excluded.words, created_at = excluded.created_at`)
+            .run(taskRef, refiled.digest, routeDigestOf(route), words, now.toISOString());
+        return { words };
+    });
+}
+/** The line for this task's waiting plan, or null. Only while it describes exactly the plan up for approval. */
+export function routeChangeOf(store, taskId) {
+    const ref = store.lookupRef(taskId);
+    if (ref === null)
+        return null;
+    const row = store.handle.prepare("SELECT scope_digest, to_route_digest, words FROM route_change WHERE task_ref = ?").get(ref.id);
+    const scope = store.getScope(taskId);
+    if (row === undefined || scope === null || scope.digest !== row["scope_digest"] || scope.approvedDigest === scope.digest)
+        return null;
+    const route = routeFromJson(scope.proposedRouteJson ?? null);
+    return route !== null && routeDigestOf(route) === row["to_route_digest"] ? String(row["words"]) : null;
+}
+/** Each sweep: an unapproved row from before routing gets its route, and the same one Approve. A standing old approval
+ * is left alone (the stale check reaches it if its route ever differs). */
+export function routeLegacyPlans(store, now) {
+    const rows = store.handle.prepare(`SELECT r.id AS ref, r.external_id AS task FROM task_scope s JOIN task_ref r ON r.external_id = s.task_id AND r.backend = ? JOIN task t ON t.id = r.external_id
+    WHERE s.route_era IS NULL AND t.state = 'queued' AND (s.approved_digest IS NULL OR s.approved_digest <> s.digest) LIMIT 20`).all(BUILT_IN);
+    let routed = 0;
+    for (const row of rows)
+        if (proposeNewRoute(store, Number(row["ref"]), String(row["task"]), now) !== null)
+            routed++;
+    return routed;
+}

package/dist/route-hooks.js

@@ -80,8 +80,9 @@ const VERB = String.raw `(?:INSERT(?:\s+OR\s+\w+)?\s+INTO|REPLACE\s+INTO|UPDATE(
 const writes = (tables) => new RegExp(String.raw `\b${VERB}\s+(?:main\s*\.\s*)?["\`\[]?(?:${tables.join("|")})["\`\]]?(?![\w])`, "i");
 const ROUTING_WRITE = writes([...ROUTING_TABLES, "route_rule_one_winner"]);
 const MODELS_WRITE = writes(MODELS_TABLES);
-/** The two columns only route-store.ts writes: any write statement that names one. */
-const COLUMN_WRITE = /\b(?:INSERT|REPLACE|UPDATE)\b[^]*\b(?:exec_class|revision_origin)\b/i;
+/** The two columns only route-store.ts writes: any write statement that names one. A lesson note keeps its own copy of
+ * how a revision was asked for: that one INSERT into its own table is not this column, and only it is left out. */
+const COLUMN_WRITE = /\b(?:INSERT(?!\s+INTO\s+lesson_note\b)|REPLACE|UPDATE)\b[^]*\b(?:exec_class|revision_origin)\b/i;
 /** Each string or template text in the file that writes a protected row, with the function it's in ("" at the top
  * level): `Class#method`, or the top-level function. */
 export function protectedWrites(file, source) {

package/dist/route-results.d.ts

@@ -1,5 +1,5 @@
 import { INELIGIBLE_REASONS, type RecordReason, type RecordState, type ResultRecordView, type Selection } from "./contracts/route-results.js";
-import { type Store } from "./store.js";
+import { type Run, type Store } from "./store.js";
 export { cohortOf, EXEC_CLASS_OF_REASON, execClassOf, type CohortInput, type CohortRow } from "./route-store.js";
 /** How long an accepted result waits before it counts, and how long a result may wait for an answer. */
 export declare const MATURE_AFTER_MS: number;
@@ -39,6 +39,11 @@ export type RecordValue = {
     /** The family is quiet, or past ACCUMULATE_FOR_MS: with a final verdict, the record closes. */
     accumulationEnded: boolean;
 };
+/** Whether the first built run among `runs` passed its own check; null when none is recorded. The code map's report reads
+ * this too, so the two never disagree on what a first check is. */
+export declare function firstCheckPassedOf(store: Store, runs: readonly Pick<Run, "id" | "outcome">[]): boolean | null;
+/** How many of these task versions are a person's revision. */
+export declare function personRevisionsOf(store: Store, refs: readonly number[]): number;
 /**
  * A task family's record, evaluated now from its rows (null: no code-writing run, or a family whose lineage can't be
  * proved). The order is the plan's: what can't be attributed to one model and one cohort first, then a live attempt

package/dist/route-results.js

@@ -54,6 +54,17 @@ function classOfRun(run, kept) {
     return "model";
 }
 const FAILED_OUTCOMES = new Set(["failed", "interrupted"]);
+/** Whether the first built run among `runs` passed its own check; null when none is recorded. The code map's report reads
+ * this too, so the two never disagree on what a first check is. */
+export function firstCheckPassedOf(store, runs) {
+    const first = runs.find(run => run.outcome === "built");
+    const status = first === undefined ? null : store.runCheckFor(first.id)?.status ?? null;
+    return status === "passed" ? true : status === "failed" ? false : null;
+}
+/** How many of these task versions are a person's revision. */
+export function personRevisionsOf(store, refs) {
+    return Number(store.handle.prepare("SELECT COUNT(*) AS n FROM task_ref WHERE id IN (SELECT value FROM json_each(?)) AND revision_origin = 'person'").get(JSON.stringify(refs))?.["n"] ?? 0);
+}
 /**
  * A task family's record, evaluated now from its rows (null: no code-writing run, or a family whose lineage can't be
  * proved). The order is the plan's: what can't be attributed to one model and one cohort first, then a live attempt
@@ -106,10 +117,8 @@ export function evaluateFamily(store, rootTaskId, evidenceRoot, now) {
         else
             agentTurns += run.agentTurns;
     }
-    const firstBuilt = runs.find(run => run.outcome === "built");
-    const firstCheck = firstBuilt === undefined ? null : store.runCheckFor(firstBuilt.id)?.status ?? null;
-    const personRevisions = store.handle.prepare("SELECT COUNT(*) AS n FROM task_ref WHERE id IN (SELECT value FROM json_each(?)) AND revision_origin = 'person'")
-        .get(JSON.stringify(family.versions.filter(one => one.id !== family.root.id).map(one => one.refId)))?.["n"];
+    const firstCheck = firstCheckPassedOf(store, runs);
+    const personRevisions = personRevisionsOf(store, family.versions.filter(one => one.id !== family.root.id).map(one => one.refId));
     const quiet = family.versions.every(one => one.state === "done" || one.state === "cancelled" || one.state === "failed") && runs.every(run => run.outcome !== null);
     let modelFailures = 0, infraFailures = 0;
     for (const run of runs) {
@@ -129,7 +138,7 @@ export function evaluateFamily(store, rootTaskId, evidenceRoot, now) {
         firstStartedAt: first?.startedAt ?? runs[0].startedAt, acceptedAt: null, decidedAt: null, modelFailures, infraFailures,
         apiMicrousd, subscriptionRuns, subscriptionTokens, unknownRuns, remediationRuns,
         selections: attributed.map(one => one.selection).filter((one) => one !== null), settled: false,
-        personRevisions: Number(personRevisions ?? 0), firstCheckPassed: firstCheck === "passed" ? true : firstCheck === "failed" ? false : null,
+        personRevisions, firstCheckPassed: firstCheck,
         agentTurns, turnsUnknownRuns,
         accumulationEnded: quiet || now.getTime() >= Date.parse(first?.startedAt ?? runs[0].startedAt) + ACCUMULATE_FOR_MS,
     };

package/dist/run-closeout.d.ts

@@ -1,4 +1,4 @@
-import type { Store, WorktreeRow } from "./store.js";
+import { type Store, type WorktreeRow } from "./store.js";
 /** How long a process has after SIGTERM before SIGKILL. */
 export declare const STOP_GRACE_MS = 10000;
 export type ProcessRow = {

package/dist/run-closeout.js

@@ -15,9 +15,9 @@
  */
 import { execFileSync } from "node:child_process";
 import { existsSync, readdirSync, readlinkSync, realpathSync } from "node:fs";
-import { hostname } from "node:os";
 import { basename, sep } from "node:path";
 import { ownedProcessCount, runOwnerTag } from "./exec.js";
+import { localWitnessSql } from "./store.js";
 import { sleep as defaultSleep } from "./sleep.js";
 /** How long a process has after SIGTERM before SIGKILL. */
 export const STOP_GRACE_MS = 10_000;
@@ -138,10 +138,11 @@ export async function closeOutRuns(store, clock, options = {}) {
     if (process.platform === "win32")
         return [];
     const db = store.handle;
+    const local = localWitnessSql(db, "p"), mine = localWitnessSql(db);
     const runs = db.prepare(`SELECT DISTINCT p.run AS run FROM run_process p JOIN run r ON r.id = p.run JOIN task_ref t ON t.id = r.task_ref
-    WHERE p.exited_at IS NULL AND p.pid IS NOT NULL AND p.containment IS NULL AND p.container IS NULL AND p.host = ?
+    WHERE p.exited_at IS NULL AND p.pid IS NOT NULL AND p.containment IS NULL AND p.container IS NULL AND ${local.sql}
       AND r.outcome IS NOT NULL${options.repo === undefined ? "" : " AND t.repo = ?"} ORDER BY p.run`)
-        .all(...[hostname(), ...(options.repo === undefined ? [] : [options.repo])]).map(row => Number(row["run"]));
+        .all(...[...local.params, ...(options.repo === undefined ? [] : [options.repo])]).map(row => Number(row["run"]));
     const out = [];
     if (runs.length === 0)
         return out;
@@ -151,7 +152,7 @@ export async function closeOutRuns(store, clock, options = {}) {
         if (ownedProcessCount(runOwnerTag(store, runId)) > 0)
             continue;
         const witnesses = db.prepare(`SELECT pid, process_group, observed_at FROM run_process
-      WHERE run = ? AND exited_at IS NULL AND pid IS NOT NULL AND containment IS NULL AND container IS NULL AND host = ?`).all(runId, hostname())
+      WHERE run = ? AND exited_at IS NULL AND pid IS NOT NULL AND containment IS NULL AND container IS NULL AND ${mine.sql}`).all(runId, ...mine.params)
             .map(row => ({ pid: Number(row["pid"]), group: Number(row["process_group"]) === 1, observedAt: Date.parse(String(row["observed_at"])) }))
             .filter(one => Number.isFinite(one.observedAt));
         if (witnesses.length === 0)
@@ -252,8 +253,9 @@ export function checkoutTargets(census, inside, roots, guard) {
 function finishedRunProcesses(store, census) {
     const byPid = new Map(census.map(row => [row.pid, row]));
     const roots = new Set();
+    const local = localWitnessSql(store.handle, "p");
     const rows = store.handle.prepare(`SELECT p.pid AS pid, p.observed_at AS observed_at FROM run_process p JOIN run r ON r.id = p.run
-    WHERE p.exited_at IS NULL AND p.pid IS NOT NULL AND p.host = ? AND r.outcome IS NOT NULL`).all(hostname());
+    WHERE p.exited_at IS NULL AND p.pid IS NOT NULL AND ${local.sql} AND r.outcome IS NOT NULL`).all(...local.params);
     for (const row of rows) {
         const now = byPid.get(Number(row["pid"]));
         const observedAt = Date.parse(String(row["observed_at"]));

package/dist/runner-process.js

@@ -13,6 +13,7 @@
  * The record is the plane's own state (the folder that holds the database). It grants nothing by itself: it can
  * only let a name whose every recorded holder has exited be taken over early.
  */
+import { sameMachineHost } from "./machine-identity.js";
 import { createHash, createHmac, randomUUID, timingSafeEqual } from "node:crypto";
 import { execFileSync } from "node:child_process";
 import { closeSync, fstatSync, lstatSync, mkdirSync, openSync, readSync, realpathSync, renameSync, rmSync, writeFileSync, fsyncSync, constants } from "node:fs";
@@ -195,7 +196,7 @@ export function holderProvedGone(record, holder, host, probe = realProcessProbe)
     if (typeof record.signature !== "string" || !/^[a-f0-9]{64}$/.test(record.signature)
         || !timingSafeEqual(Buffer.from(record.signature, "hex"), Buffer.from(expected, "hex")))
         return { gone: false, why: "its process record is not authenticated" };
-    if (record.runner !== holder.runner.name || record.host !== holder.runner.host || record.host !== host)
+    if (record.runner !== holder.runner.name || record.host !== holder.runner.host || !sameMachineHost(record.host, host))
         return { gone: false, why: "its record is for another worker or machine" };
     if (record.registeredAt !== holder.runner.registeredAt || record.credential !== credentialDigest(holder.credentialHash))
         return { gone: false, why: "its record is from an earlier start" };
@@ -229,7 +230,7 @@ export function recordStandsFor(record, holder, host) {
     if (typeof record.signature !== "string" || !/^[a-f0-9]{64}$/.test(record.signature)
         || !timingSafeEqual(Buffer.from(record.signature, "hex"), Buffer.from(expected, "hex")))
         return "its process record is not authenticated";
-    if (record.runner !== holder.runner.name || record.host !== holder.runner.host || record.host !== host)
+    if (record.runner !== holder.runner.name || record.host !== holder.runner.host || !sameMachineHost(record.host, host))
         return "its record is for another worker or machine";
     if (record.registeredAt !== holder.runner.registeredAt || record.credential !== credentialDigest(holder.credentialHash))
         return "its record is from an earlier start";

package/dist/runner.js

@@ -380,7 +380,8 @@ export function recoverDead(store, now, livenessMs = DEFAULT_LIVENESS_MS) {
             const claims = store.releaseClaimsOf(candidate.name, now, requeued);
             const worktrees = store.releaseWorktreesOf(candidate.name, now);
             const settled = store.recoverRunnerWork(candidate.name, now);
-            return { runner: candidate.name, claims, worktrees, runs: settled.runs, requeued: [...new Set([...requeued, ...settled.requeued])] };
+            // Only what recovery left in the queue: a vanished build it stopped for a person isn't requeued (vanished-retry.ts).
+            return { runner: candidate.name, claims, worktrees, runs: settled.runs, requeued: [...new Set([...requeued, ...settled.requeued])].filter(id => store.getTask(id)?.state === "queued") };
         });
         if (recovery !== null)
             recovered.push(recovery);

package/dist/scope.d.ts

@@ -793,7 +793,12 @@ export declare function fileAndSealUnderMode(store: Store, input: ScopeInput & {
     reason: "no-mode" | "not-signer" | "not-covered" | "coordinator-filed" | "acceptance-required" | "profile-unresolved";
     detail?: string;
 };
-export declare function approve(store: Store, taskId: string, by: string, now: Date, sawDigest: string, token: string, mutation?: Mutation): ApproveResult;
+export declare function approve(store: Store, taskId: string, by: string, now: Date, sawDigest: string, token: string, mutation?: Mutation, 
+/** A fast start (fast-start.ts): Build is this same yes, with its marker in the proof. Only that road passes it. */
+fastStart?: {
+    rule: string;
+    at: string;
+}): ApproveResult;
 /** The ledger act that records how an approval's person was proved (password-now, sso-now, fresh-password, fresh-sso). */
 export declare const APPROVAL_PROOF = "approval proved";
 /** The proof row's detail: when the person was proved, the generation, and the exact digest they said yes to. */

package/dist/scope.js

@@ -2,6 +2,8 @@
 export { ACCEPTANCE_LIMITS, EVIDENCE_KINDS } from "./contracts/acceptance-terms.js";
 import { mintSecret } from "./secret-mint.js";
 import { passwordlessOn } from "./passwordless.js";
+import { routeChangeProblem } from "./route-change-check.js";
+import { issueImported } from "./task-source.js";
 import { currentPasswordSource, passwordGuardOf, provenPasswordAccount } from "./sign-in-guard.js";
 import { validateScopeText } from "./task-text.js";
 import { contractChangesOf } from "./contract-changes.js";
@@ -1070,7 +1072,9 @@ export function fileAndSealUnderMode(store, input) {
         return { ok: true, scope: store.getScope(input.taskId), basis: "mode" };
     });
 }
-export function approve(store, taskId, by, now, sawDigest, token, mutation = {}) {
+export function approve(store, taskId, by, now, sawDigest, token, mutation = {}, 
+/** A fast start (fast-start.ts): Build is this same yes, with its marker in the proof. Only that road passes it. */
+fastStart) {
     // Read and write in one transaction, re-reading inside it — the credential
     // check included, so a token rotated between authentication and the write
     // cannot leave an approval signed by an authority that no longer exists.
@@ -1089,7 +1093,7 @@ export function approve(store, taskId, by, now, sawDigest, token, mutation = {})
         // localApprovalEligible, read again here inside the seal's transaction).
         const local = authenticated.method === "local-owner" ? currentLocalOwner() : null;
         if (authenticated.method === "local-owner") {
-            if (local === null || local.act !== "approve-plan")
+            if (local === null || (local.act !== "approve-plan" && !(local.act === "build-now" && fastStart !== undefined)))
                 return { ok: false, reason: "policy", message: localOwnerRefusal(store.accountOf(by)?.passwordSet === true, "/").message };
             const eligible = localApprovalEligible(store, by, taskId);
             if (!eligible.ok)
@@ -1106,6 +1110,12 @@ export function approve(store, taskId, by, now, sawDigest, token, mutation = {})
         // the new one in silence — which is the whole failure this guards.
         if (sawDigest !== scope.digest)
             return { ok: false, reason: "changed" };
+        // The "what changed" line a person read describes this exact route, or this yes isn't to what they read (route-change.ts).
+        if (routeChangeProblem(store, taskId, scope))
+            return { ok: false, reason: "changed" };
+        // A fast start is never a task from outside (github-import.ts): that takes the ordinary ceremony.
+        if (fastStart !== undefined && issueImported(store, taskId))
+            return { ok: false, reason: "policy", message: "A task from outside takes the ordinary approval." };
         // An unresolved scope cannot say exactly what would run, so nobody can
         // agree to it (foundations finding 16) — restatement is the road.
         if (scope.profileState === "unresolved") {
@@ -1144,7 +1154,7 @@ export function approve(store, taskId, by, now, sawDigest, token, mutation = {})
         // How the person was proved, beside every yes they give (a vote kept for protected work, or the seal): a password
         // typed now, a re-check now, or a remembered one — with when, the credential generation and the exact digest.
         const proved = () => store.recordAction({ at: now.toISOString(), actor: by, repo: store.lookupRef(taskId)?.repo ?? null, taskId, runId: null, action: APPROVAL_PROOF,
-            outcome: authenticated.method, source: "work", detail: approvalProofDetail(authenticated.at, store.accountOf(by)?.generation ?? 0, scope.digest, local === null ? undefined : { generation: local.localGeneration, transport: local.transport }) });
+            outcome: authenticated.method, source: "work", detail: (fastStart === undefined ? approvalProofDetail : fastProofDetail(fastStart))(authenticated.at, store.accountOf(by)?.generation ?? 0, scope.digest, local === null ? undefined : { generation: local.localGeneration, transport: local.transport }) });
         if (gate.verdict === "vote") {
             // The same person again adds nothing: no new vote, no proof row (and the approval roads refund a re-check).
             if (gate.already)
@@ -1185,6 +1195,9 @@ export function approve(store, taskId, by, now, sawDigest, token, mutation = {})
 export const APPROVAL_PROOF = "approval proved";
 /** The proof row's detail: when the person was proved, the generation, and the exact digest they said yes to. */
 export const approvalProofDetail = (at, generation, digest, local) => `${new Date(at).toISOString()} · generation ${generation}${local === undefined ? "" : ` · local ${local.generation} ${local.transport}`} · digest ${digest}`;
+/** A fast start's proof: the v1 record proofDetailOf reads, with the marker. `local` keeps the legacy words
+ * localSealStandsSql reads, so a local owner's seal stands on the same rule. */
+const fastProofDetail = (fastStart) => (at, generation, digest, local) => JSON.stringify({ v: 1, at: new Date(at).toISOString(), generation, digest, fastStart, ...(local === undefined ? {} : { local: `proof · local ${local.generation} ${local.transport} · seal` }) });
 /** The proof of THIS approval: the approver's own row for these exact bytes (never another approval's words). */
 export function approvalProofOf(store, taskId, by, digest) {
     const rows = store.handle.prepare("SELECT outcome, detail FROM action_ledger WHERE task_id = ? AND action = ? AND actor = ? ORDER BY id DESC LIMIT 50").all(taskId, APPROVAL_PROOF, by);
@@ -1321,8 +1334,8 @@ export function acceptanceWords(criteria) {
     if (criteria.length === 0)
         return [];
     return [
-        `  acceptance   ${criteria[0].id}: ${criteria[0].statement} [requires: ${criteria[0].evidence.join(", ")}]`,
-        ...criteria.slice(1).map(c => `               ${c.id}: ${c.statement} [requires: ${c.evidence.join(", ")}]`),
+        `  done when    ${criteria[0].id}: ${criteria[0].statement} [shown by: ${criteria[0].evidence.join(", ")}]`,
+        ...criteria.slice(1).map(c => `               ${c.id}: ${c.statement} [shown by: ${c.evidence.join(", ")}]`),
     ];
 }
 /** The route's approval-card lines (v47): the WORKING route the digest
@@ -1340,8 +1353,8 @@ evidence = null) {
     return [
         `  goal         ${scope.goal}`,
         ...(scope.outOfScope === null ? [] : [`  not this     ${scope.outOfScope}`]),
-        ...(scope.candidate ? [`  candidate    ${scope.candidate} — checked out by the machine, no agent runs`] : []),
-        ...(scope.touches.length === 0 ? [] : [`  touches      ${scope.touches.join(", ")}`]),
+        ...(scope.candidate ? [`  commit       ${scope.candidate.slice(0, 7)} — checked out by Toolroll, no agent runs`] : []),
+        ...(scope.touches.length === 0 ? [] : [`  files        ${scope.touches.join(", ")}`]),
         ...acceptanceWords(scope.acceptance),
         ...(scope.budgetMicrousd === null
             ? []
@@ -1358,7 +1371,7 @@ evidence = null) {
         ...(scope.profile === null || scope.profile === undefined ? [] : ((terms) => [`  reads        ${terms.reads}`, ...(terms.mach === null ? [] : [`  services     ${terms.mach}`])])(sandboxTermsWords(scope.profile))),
         ...releaseTermsWords(scope.releaseTerms ?? null),
         ...(scope.releaseCheck == null ? [] : [`  release      ${releaseCheckSentence(scope.releaseCheck)}`]),
-        `  reference    ${scope.digest}`,
+        `  version      ${scope.digest.slice(0, 8)} (the full plan version is in --json)`,
         `  approved     ${describeApproval(approval)}`,
     ];
 }
@@ -1394,7 +1407,7 @@ function describeApproval(approval) {
     if (approval.approved)
         return `yes, by ${approval.by} at ${approval.at}`;
     if (approval.reason === "changed") {
-        return "no — it was approved, then the scope was rewritten; approve it again";
+        return "no — edited after approval; approve it again";
     }
     return "no — nothing will build this until somebody agrees to it";
 }

package/dist/serve.d.ts

@@ -4,7 +4,7 @@ export declare function createDecisionServer(options: ServeOptions): DecisionSer
 export { PAGE_CSS, pinnedTheme, SENSITIVE_INPUT } from "./server/chrome.js";
 export { redactedPath, SHUTDOWN_WAIT_MS, type ServeOptions } from "./server/http.js";
 export { TASK_COMPOSER_MODES, type TaskComposerMode } from "./server/render-chat.js";
-export { inboxFingerprints, parseInboxTab, queueScript, type InboxTab } from "./server/render-pages.js";
+export { queueScript } from "./server/render-pages.js";
 export { ssoStepUps, wrongHostPage } from "./server/render-people.js";
 export { diffFileAnchor, editorFileHref, needActionOf, orderChangedFiles, plainConclusionOf, rankReviewQueue, reviewFilePriority, reviewPriorityOf, runFactsFragment, withinSignedTouches, type ReviewFileRow, type ReviewPriority, type ReviewQueueFacts } from "./server/render-results.js";
 export { decisionAnswerScript, earlierVersionsWords, revisionLineageWords, type RouteView } from "./server/render-tasks.js";