toolroll 0.9.92 → 0.9.94

package/dist/task-status.js

@@ -13,7 +13,7 @@
 import { DEFAULT_LEAD_NAME } from "./lead-identity.js";
 import { html } from "./html.js";
 import { FAILED_CHECK } from "./result-acts.js";
-import { CODE_NEED, NEEDS, needSentence, waitSentence } from "./needs-you.js";
+import { CODE_READING, NEEDS, needSentence, waitSentence } from "./needs-you.js";
 /** A cancelled task with a successor reads "Replaced by <id>" everywhere, never "Cancelled". */
 export const replacedWords = (successor) => `Replaced by ${successor}`;
 const REPLACED = /^Replaced by \S+/;
@@ -28,6 +28,8 @@ export const CHECKS_LABEL = "Project checks";
 export const PR_CI_LABEL = "PR CI";
 /** The one verb for opening a saved result, on every surface. */
 export const OPEN_RESULT = "Open result";
+/** A machine-run check under way (a prepared candidate: no agent runs), on every surface that has no richer words. */
+export const MACHINE_CHECK_RUNNING = "Running the check on the prepared version.";
 export const CHECKED_AT_RELEASE = "Checked at release";
 export function releaseStateOf(checks) {
     if (checks?.level !== "off" || checks.status === "passed" || checks.status === "failed")
@@ -162,46 +164,47 @@ function sentenceOf(headline, facts) {
     const reason = facts.reason?.trim() || null;
     const sha = short(facts.checks?.head ?? null);
     switch (headline) {
-        case "Queued": return reason ?? "Waiting for a worker.";
+        case "Queued": return reason ?? "Waiting for a builder.";
         case "Planning": return reason ?? "The lead is writing the plan.";
         // One plain sentence per need (needs-you.ts); a recorded reason only where the need keeps one.
         case "Needs you": return facts.stage === "finished" ? resultAsk(facts) ?? needSentence("review-result", reason, facts.needContext) : needSentence(facts.need ?? "other", reason, facts.needContext);
         case "Waiting": return waitSentence(facts.wait, reason, facts.needContext);
         case "Building": return facts.stage === "checking" ? "Checks are running on the change."
-            : facts.stage === "reviewing" ? "Reviewing the change before it reaches you." : reason ?? "An agent is working on it.";
+            : facts.stage === "reviewing" ? "Reviewing the change before it reaches you."
+                : facts.machine === true ? MACHINE_CHECK_RUNNING : reason ?? "An agent is working on it.";
         case "Ready for review":
             if (facts.report)
-                return "The report is ready to read. Read it, then mark it complete.";
+                return "The report is ready to read. Read it, then accept it.";
             if (releaseStateOf(facts.checks) === "covered")
-                return `Checked at release on ${short(facts.checks.release.head) ?? "its release"}. Review the change, then mark it complete.`;
+                return `Checked at release on ${short(facts.checks.release.head) ?? "its release"}. Review the change, then accept it.`;
             if (facts.checks?.level === "off" && facts.checks.status !== "passed")
-                return "Checked at release. Review the change, then mark it complete.";
+                return "Checked at release. Review the change, then accept it.";
             if (facts.checks?.status === "passed") {
                 // The Checks row names the others and the batch commit; the sentence doesn't repeat them.
                 const peers = facts.checks.batch?.state === "together" ? facts.checks.batch.peers.length : 0;
                 if (peers > 0)
-                    return `Checks passed together with ${peers === 1 ? "1 other result" : `${peers} other results`}. Review the change, then mark it complete.`;
-                return `${facts.checks.level === "quick" ? "Quick checks" : "Checks"} passed${sha === null ? "" : ` on ${sha}`}. Review the change, then mark it complete.`;
+                    return `Checks passed together with ${peers === 1 ? "1 other result" : `${peers} other results`}. Review the change, then accept it.`;
+                return `${facts.checks.level === "quick" ? "Quick checks" : "Checks"} passed${sha === null ? "" : ` on ${sha}`}. Review the change, then accept it.`;
             }
             if (facts.checks?.batch?.state === "waiting")
-                return "Its full check runs with other results within 10 minutes. Review the change, then mark it complete.";
+                return "Its full check runs with other results within 10 minutes. Review the change, then accept it.";
             if (facts.checks?.status === "unavailable")
-                return `${facts.checks.cause === "command-changed" ? CHECK_COMMAND_CHANGED : CHECK_UNREADABLE} Review the change, then mark it complete.`;
+                return `${facts.checks.cause === "command-changed" ? CHECK_COMMAND_CHANGED : CHECK_UNREADABLE} Review the change, then accept it.`;
             // Never claim a check that isn't known to have passed.
             if (facts.checks == null)
-                return "Review the change, then mark it complete.";
-            return "Built without a passing project check. Review the change, then mark it complete.";
+                return "Review the change, then accept it.";
+            return "Built without a passing project check. Review the change, then accept it.";
         case "Complete": {
             // Landed work says why once; its merged pull request is that reason, not a second sentence.
             if (facts.landed)
-                return `Marked complete automatically: ${facts.landed}.`;
-            const by = facts.completedBy ? `Marked complete by ${facts.completedBy}.` : "Marked complete.";
+                return `Accepted automatically: ${facts.landed}.`;
+            const by = facts.completedBy ? `Accepted by ${facts.completedBy}.` : "Accepted.";
             const pr = facts.pullRequest;
             return pr?.state === "merged" ? `${by} ${pr.number === null ? "Its pull request" : `Pull request #${pr.number}`} merged.` : by;
         }
         case "Failed":
             if (facts.checks?.status === "failed")
-                return `${facts.checks.level === "quick" ? "Quick checks" : "Checks"} failed${sha === null ? "" : ` on ${sha}`}. See what broke, then retry or ask for changes.`;
+                return `${facts.checks.level === "quick" ? "Quick checks" : "Checks"} failed${sha === null ? "" : ` on ${sha}`}. See what broke, then retry or send it back.`;
             return reason ?? "The last attempt stopped before it finished. Review it, then retry.";
         case "Stopped": return reason ?? "Stopped by a person. The work so far is kept.";
     }
@@ -291,13 +294,13 @@ function detailsOf(headline, facts) {
     if (evidence != null) {
         const action = { label: "See what was kept", href: facts.links?.result ?? null };
         if (evidence.damaged > 0)
-            row("evidence", "Saved evidence", "Some saved files changed", problem(headline), headline === "Failed" ? {} : { action });
+            row("evidence", "Saved files", "Some saved files changed", problem(headline), headline === "Failed" ? {} : { action });
         else if (evidence.missing > 0)
-            row("evidence", "Saved evidence", "Some saved files are missing", problem(headline), headline === "Failed" ? {} : { action });
+            row("evidence", "Saved files", "Some saved files are missing", problem(headline), headline === "Failed" ? {} : { action });
         else if (evidence.shortened > 0)
-            row("evidence", "Saved evidence", "Some output shortened", "note", { action });
+            row("evidence", "Saved files", "Some output shortened", "note", { action });
         else
-            row("evidence", "Saved evidence", "Complete", "ok");
+            row("evidence", "Saved files", "All kept", "ok");
     }
     return rows;
 }
@@ -331,24 +334,9 @@ export function statusOf(facts) {
 /** The name most surfaces already import. */
 export const taskStatusOf = statusOf;
 // ---- reading the existing projections ----------------------------------------
-/** Every dispatch or work-index code, as the stage it means. Unknown codes that
- * wait on a person stay Needs you; everything else waits in the queue. */
-const CODE_STAGE = {
-    queued: ["queued"], ready: ["queued"], "worker-at-capacity": ["queued"], "retry-scheduled": ["queued"], updating: ["queued"],
-    "waiting-dependency": ["queued"], "scouting-ready": ["queued"], "planning-ready": ["queued"], "provider-quota": ["queued"],
-    // A request the planner cannot be given (too long to hand back, say) waits on a person to shorten it.
-    "planner-source": ["needs-you", "fix-request"],
-    running: ["building"], reviewing: ["reviewing"], "review-pending": ["building"], "checks-running": ["checking"],
-    "signed-out": ["needs-you", "sign-in"],
-    "needs-approval": ["needs-you", "approval"],
-    "waiting-decision": ["needs-you", "answer"], "decision-queue": ["needs-you", "answer"],
-    "build-stopping": ["waiting"], "other-computer": ["waiting"],
-    stopping: ["stopped"], stopped: ["stopped"], paused: ["stopped"], cancelled: ["stopped"],
-    failed: ["failed"], "waiting-incident": ["failed"], "checks-failed": ["failed"],
-    "ready-to-check": ["finished"], "ready-to-review": ["finished"], "report-ready": ["finished"], "no-change": ["finished"],
-    "pr-opened": ["finished"], "merge-observed": ["finished"], "pr-closed": ["finished"], "agent-attested": ["finished"], "accepted-exception": ["finished"],
-    complete: ["complete"],
-};
+/** Codes that read Needs you whoever asks (their reason is a person's by nature). Any other need reads Needs you
+ * only when the caller says a person is needed; otherwise it waits in the queue. */
+const ALWAYS_NEEDS = new Set(["planner-source", "signed-out", "needs-approval", "waiting-decision", "decision-queue"]);
 /** Queue reasons worth a sentence of their own; any other queued or
  * building reason is scheduler wording, and the default sentence is plainer. */
 const QUEUED_REASONS = new Set(["worker-at-capacity", "waiting-dependency", "retry-scheduled", "updating", "planning-ready", "scouting-ready", "provider-quota"]);
@@ -359,15 +347,18 @@ export function plainReasonOf(stage, code, detail) {
         return QUEUED_REASONS.has(code) ? detail ?? null : null;
     return detail ?? null;
 }
+/** Every dispatch or work-index code, as the stage it means (needs-you.ts CODE_READING, the one table). Unknown
+ * codes that wait on a person stay Needs you; everything else waits in the queue. */
 export function stageOfCode(code, options = {}) {
     if (code === "running" && options.planning)
         return { stage: "planning" };
     if (code === "held")
         return options.operatorHold === false ? { stage: "needs-you", need: "hold" } : { stage: "stopped" };
-    const known = CODE_STAGE[code];
-    if (known !== undefined)
-        return known[1] === undefined ? { stage: known[0] } : { stage: known[0], need: known[1] };
-    return options.needsPerson === false ? { stage: "queued" } : { stage: "needs-you", need: CODE_NEED[code] ?? "other" };
+    const known = Object.prototype.hasOwnProperty.call(CODE_READING, code) ? CODE_READING[code] : undefined;
+    if (known !== undefined && (known.stage !== "needs-you" || ALWAYS_NEEDS.has(code))) {
+        return { stage: known.stage, ...(known.need === undefined ? {} : { need: known.need }), ...(known.wait === undefined ? {} : { wait: known.wait }) };
+    }
+    return options.needsPerson === false ? { stage: "queued" } : { stage: "needs-you", need: known?.need ?? "other" };
 }
 /** The pull request as the task page's follower reports it, or the bare publication row. */
 export function pullRequestFactOf(publication) {
@@ -473,7 +464,7 @@ const quoted = (statement) => {
 function unresolvedAsk(row, word) {
     const what = word === "Not shown yet" && screenshotMissing(row) ? "A screenshot is missing for"
         : word === "Not shown yet" ? "Nothing shows this requirement is met" : word === "Unverified" ? "This requirement couldn't be verified" : "This requirement isn't met";
-    return `${what}: ${quoted(row.statement) || row.id || "a requirement"}. Ask for changes, or accept the result with a reason.`;
+    return `${what}: ${quoted(row.statement) || row.id || "a requirement"}. Send it back, or accept the result with a reason.`;
 }
 /** Requirements from the stored matrix: met, the ones only a person confirms, and the total. */
 export function requirementsOf(matrix, release) {
@@ -482,7 +473,7 @@ export function requirementsOf(matrix, release) {
     const words = matrix.map(row => requirementWordOf(row, null, release));
     const yours = matrix.find((_, index) => words[index] === "You check");
     const unshown = matrix.filter((row, index) => words[index] === "Not shown yet" && screenshotMissing(row));
-    const ask = yours !== undefined ? `Check this requirement yourself, then mark it complete: ${quoted(yours.statement)}`
+    const ask = yours !== undefined ? `Check this requirement yourself, then accept it: ${quoted(yours.statement)}`
         : unshown.length > 0 ? unresolvedAsk(unshown[0], "Not shown yet") : null;
     return { met: words.filter(word => word === "Met").length, total: matrix.length, yours: words.filter(word => word === "You check").length,
         missed: words.filter(word => word === "Not met" || word === "Not shown yet").length,
@@ -499,12 +490,12 @@ export function completionBlockersOf(f) {
     const release = releaseStateOf(f.checks);
     const backing = checkBackingOf(f.checks);
     if (!f.report && f.checks?.status === "failed") {
-        blockers.push({ key: "check-failed", message: `Checks failed${f.checks.exitCode === null ? "" : ` (exit ${f.checks.exitCode})`}. Fix them and run checks again, or ask for changes.` });
+        blockers.push({ key: "check-failed", message: `Checks failed${f.checks.exitCode === null ? "" : ` (exit ${f.checks.exitCode})`}. Fix them and run checks again, or send it back.` });
     }
     else if (!f.report && f.checkRequired && f.checks?.status !== "passed" && release === undefined) {
-        blockers.push({ key: "check-missing", message: checksUnderway(f.checks) ? "Its project check hasn't finished yet. Mark it complete once it passes."
-                : f.checks?.status === "unavailable" ? f.checks.cause === "command-changed" ? `${CHECK_COMMAND_CHANGED.replace(/; run checks again\.$/, ".")} Run checks again, then mark it complete.` : `${CHECK_UNREADABLE} Run checks on it, then mark it complete.`
-                    : "No passing project check is recorded for this result. Run checks on it, then mark it complete." });
+        blockers.push({ key: "check-missing", message: checksUnderway(f.checks) ? "Its project check hasn't finished yet. Accept it once it passes."
+                : f.checks?.status === "unavailable" ? f.checks.cause === "command-changed" ? `${CHECK_COMMAND_CHANGED.replace(/; run checks again\.$/, ".")} Run checks again, then accept it.` : `${CHECK_UNREADABLE} Run checks on it, then accept it.`
+                    : "No passing project check is recorded for this result. Run checks on it, then accept it." });
     }
     if (!f.accepted && f.checks?.status !== "failed") {
         const refuted = f.verdict === "refuted";
@@ -514,11 +505,11 @@ export function completionBlockersOf(f) {
             blockers.push({ key: "criteria", message: unresolvedAsk(unresolved[0].row, unresolved[0].word) });
         else if (unresolved.length > 1) {
             const ids = unresolved.map(one => one.row.id ?? "?");
-            blockers.push({ key: "criteria", message: `${unresolved.length} requirements ${unresolved.every(one => one.word === "Unverified") ? "couldn't be verified" : "aren't met yet"} (${ids.slice(0, 6).join(", ")}${ids.length > 6 ? ", …" : ""}). Ask for changes, or accept the result with a reason.` });
+            blockers.push({ key: "criteria", message: `${unresolved.length} requirements ${unresolved.every(one => one.word === "Unverified") ? "couldn't be verified" : "aren't met yet"} (${ids.slice(0, 6).join(", ")}${ids.length > 6 ? ", …" : ""}). Send it back, or accept the result with a reason.` });
         }
     }
     if (f.high > 0)
-        blockers.push({ key: "high", message: `The automatic review found ${f.high === 1 ? "a high-severity problem" : `${f.high} high-severity problems`}. Ask for changes before marking it complete.` });
+        blockers.push({ key: "high", message: `The automatic review found ${f.high === 1 ? "a high-severity problem" : `${f.high} high-severity problems`}. Send it back before accepting it.` });
     return blockers;
 }
 /** A refuted report verifies none of its requirements, whatever it marked met (a person's acceptance doesn't change that). */

package/dist/teardown-git.d.ts

@@ -46,6 +46,10 @@ export declare const INCLUDE_PARSE_TIMED_OUT = "Git didn't finish reading it in
 export type GitBinding = {
     repo?: string | null;
 };
+/** The shared git folder of a recorded project, read from disk and proven as boundDirs proves it: the project's own
+ * real `.git` folder, holding no `commondir`. No pointer file or `commondir` an agent can write decides it, and no git
+ * runs (a page visit reads this). Throws with the reason otherwise. */
+export declare function recordedCommonDir(repo: string): string;
 /** Settings fixed on every write through a view: `worktree add` records absolute paths (relative ones would need a
  * config write, which a view keeps); no transport at all (a caller that fetches allows its one protocol by name, as the
  * nightly check's local fetch does with protocol.file.allow); and no split index (its shared index files would be
@@ -55,6 +59,12 @@ export declare const WRITE_VIEW_FLAGS: readonly string[];
  * program (anything but INERT_LFS). A file that
  * isn't a plain one, or doesn't parse, counts as naming one. */
 export declare function lfsExtensionIn(checkout: string, gitFile?: string, limit?: Limit): boolean;
+/** The hardened runners' own reads before the caller's command (the checkout's config listing): their own bounds, never
+ * the caller's. A caller's small `maxBuffer` is for its own command's output (builder.ts reads one ls-tree line with
+ * 2 KiB): inherited, it failed the config listing once a project's .git/config grew past 2 KiB (one [branch] section per
+ * work branch), and every prepared release check then failed as "its config couldn't be read" (runs 3316–3324). */
+export declare const CONFIG_READ_BYTES: number;
+export declare const CONFIG_READ_MS = 30000;
 /** Every command runs against a view of the checkout's repository (gitView) whose config and info are copies the
  * plane made, inspected there, so neither can change between the inspection and the run. `mode` "read" is for reading
  * a checkout an agent may still be writing (the code page): every command also takes readFlags(), and the view holds
@@ -143,4 +153,10 @@ export declare function lazyFetchSetting(listing: string): string | null;
  * command and protocol settings refused, a partial clone refused) is the config git then runs with.
  */
 export declare function lazyFetchSafeGit(inner?: Runner): Runner;
+/**
+ * The checkout a folder sits in, for choosing a folder (easy-start): the nearest parent holding a `.git`, then read
+ * through checkoutGitSync, so a config that includes another file (a FIFO), or sets a command, is refused and the read
+ * is bounded. Null when there is no checkout or it can't be read that way.
+ */
+export declare function checkoutTop(dir: string, timeoutMs?: number): string | null;
 export {};

package/dist/teardown-git.js

@@ -477,6 +477,12 @@ function boundDirs(checkout, binding = {}) {
     }
     return dirs;
 }
+/** The shared git folder of a recorded project, read from disk and proven as boundDirs proves it: the project's own
+ * real `.git` folder, holding no `commondir`. No pointer file or `commondir` an agent can write decides it, and no git
+ * runs (a page visit reads this). Throws with the reason otherwise. */
+export function recordedCommonDir(repo) {
+    return boundDirs(repo, { repo }).common;
+}
 /** What git keeps only per worktree and the plane never links: HEAD (git won't take it as a link) and the pointers. */
 /** What the plane links of a worktree's own git folder (git writes them in place through the link: the index and its
  * logs by lockfile, per-worktree refs and logs inside the folders), whether or not they exist yet; a rebase's,
@@ -1061,6 +1067,28 @@ export function lfsExtensionIn(checkout, gitFile = "git", limit) {
     const parsed = spawnSync(gitFile, ["config", "--file", path, "--no-includes", "--name-only", "--list", "-z"], { cwd: "/", encoding: "utf8", timeout: setupTimeout(limit), killSignal: "SIGKILL", env: { PATH: process.env["PATH"] ?? "", GIT_CONFIG_NOSYSTEM: "1", GIT_CONFIG_GLOBAL: "/dev/null", HOME: "/nonexistent" } });
     return parsed.status !== 0 || parsed.stdout.split("\0").filter(Boolean).some(name => lfsCommand(name) || ["include", "includeif"].includes(keyParts(name).section));
 }
+/** The hardened runners' own reads before the caller's command (the checkout's config listing): their own bounds, never
+ * the caller's. A caller's small `maxBuffer` is for its own command's output (builder.ts reads one ls-tree line with
+ * 2 KiB): inherited, it failed the config listing once a project's .git/config grew past 2 KiB (one [branch] section per
+ * work branch), and every prepared release check then failed as "its config couldn't be read" (runs 3316–3324). */
+export const CONFIG_READ_BYTES = 16 * 1024 * 1024;
+export const CONFIG_READ_MS = 30_000;
+/** What of a caller's options an internal read keeps: where it runs and with what environment and containment —
+ * never its time limit, output limit, stdin or output callbacks. */
+function internalOptions(options, env) {
+    const { cwd, envAllowlist, omitEnv, fence, fenceGrants, confinement, processGroup, owner, signal } = options ?? {};
+    return { ...(cwd === undefined ? {} : { cwd }), ...(envAllowlist === undefined ? {} : { envAllowlist }), ...(omitEnv === undefined ? {} : { omitEnv }),
+        ...(fence === undefined ? {} : { fence }), ...(fenceGrants === undefined ? {} : { fenceGrants }), ...(confinement === undefined ? {} : { confinement }),
+        ...(processGroup === undefined ? {} : { processGroup }), ...(owner === undefined ? {} : { owner }), ...(signal === undefined ? {} : { signal }),
+        env, timeoutMs: CONFIG_READ_MS, maxBuffer: CONFIG_READ_BYTES };
+}
+/** Why the checkout's config listing failed, in words, for the refusal: git's own first line, or what stopped it. */
+function listingFailure(result) {
+    if (result.timedOut)
+        return `its config couldn't be read (the read ran past ${CONFIG_READ_MS / 1000} s)`;
+    const said = `${result.stderr}`.split("\n").map(line => line.trim()).find(line => line !== "");
+    return `its config couldn't be read${said === undefined ? ` (git exited ${result.code})` : ` (${said.slice(0, 300)})`}`;
+}
 /** Every command runs against a view of the checkout's repository (gitView) whose config and info are copies the
  * plane made, inspected there, so neither can change between the inspection and the run. `mode` "read" is for reading
  * a checkout an agent may still be writing (the code page): every command also takes readFlags(), and the view holds
@@ -1089,10 +1117,10 @@ export function checkoutGit(inner = run, mode = "build", binding = {}) {
             }
             try {
                 const viewed = { ...options, env: { ...(options?.env ?? {}), ...view.env } };
-                // The checkout's own config may name no command.
-                const own = await inner("git", ["--no-optional-locks", "config", "--list", "--show-scope", "-z"], viewed);
+                // The checkout's own config may name no command. Read with this runner's own bounds (internalOptions).
+                const own = await inner("git", ["--no-optional-locks", "config", "--list", "--show-scope", "-z"], internalOptions(options, viewed.env));
                 if (own.code !== 0)
-                    return refused("its config couldn't be read");
+                    return refused(listingFailure(own));
                 const key = commandSetting(own.stdout, { lfsChecked: true });
                 if (key !== null)
                     return refused(`the checkout's git config sets ${key}, which can run a command`);
@@ -1185,9 +1213,11 @@ export function viewedGitSync(cwd, args, options = {}) {
         const env = { PATH: process.env["PATH"] ?? "", HOME: process.env["HOME"] ?? "", LANG: "C", GIT_CONFIG_NOSYSTEM: "1", GIT_CONFIG_GLOBAL: "/dev/null", GIT_TERMINAL_PROMPT: "0", ...view.env };
         const timeoutNow = () => { expire(); return limit === undefined ? options.timeoutMs ?? 60_000 : Math.max(1, Math.min(options.timeoutMs ?? 60_000, limit())); };
         const fixed = { cwd, env, encoding: "utf8", killSignal: "SIGKILL", maxBuffer: options.maxBuffer ?? 1_048_576, stdio: ["ignore", "pipe", "pipe"] };
-        const own = spawnSync(gitFile, ["--no-optional-locks", "config", "--list", "--show-scope", "-z"], { ...fixed, timeout: timeoutNow() });
+        // Its own bounds, never the caller's output limit (CONFIG_READ_BYTES); a caller's deadline still holds.
+        const own = spawnSync(gitFile, ["--no-optional-locks", "config", "--list", "--show-scope", "-z"], { ...fixed, maxBuffer: CONFIG_READ_BYTES,
+            timeout: limit === undefined ? CONFIG_READ_MS : Math.max(1, Math.min(CONFIG_READ_MS, limit())) });
         if (own.status !== 0)
-            throw new Error("its config couldn't be read");
+            throw new Error(own.error !== undefined ? `its config couldn't be read (${own.error.message.slice(0, 300)})` : "its config couldn't be read");
         const key = commandSetting(own.stdout, { lfsChecked: true });
         if (key !== null)
             throw new Error(`the checkout's git config sets ${key}, which can run a command`);
@@ -1333,3 +1363,31 @@ export function lazyFetchSafeGit(inner = run) {
     // repository's config and its includes as git found them, and an include naming a FIFO could hang the plane.
     return checkoutGit(inner, "read");
 }
+/**
+ * The checkout a folder sits in, for choosing a folder (easy-start): the nearest parent holding a `.git`, then read
+ * through checkoutGitSync, so a config that includes another file (a FIFO), or sets a command, is refused and the read
+ * is bounded. Null when there is no checkout or it can't be read that way.
+ */
+export function checkoutTop(dir, timeoutMs = 10_000) {
+    let at;
+    try {
+        at = realpathSync(dir);
+    }
+    catch {
+        return null;
+    }
+    for (;;) {
+        if (existsSync(join(at, ".git"))) {
+            try {
+                return checkoutGitSync(at, ["rev-parse", "--show-toplevel"], { timeoutMs }).trim() || null;
+            }
+            catch {
+                return null;
+            }
+        }
+        const up = dirname(at);
+        if (up === at)
+            return null;
+        at = up;
+    }
+}

package/dist/telegram-progress.js

@@ -4,6 +4,7 @@
  * CLI show: Ready for review once the saved result can be inspected, Complete
  * once the lead or a person has marked that exact result. Slack, Discord and
  * Teams send this same card. */
+import { machineChecked } from "./machine-check.js";
 import { assignmentOf } from "./assignment.js";
 import { chatResultHref, chatControlHref } from "./chat-controls.js";
 import { phoneText, projectLabel } from "./telegram-status.js";
@@ -55,8 +56,8 @@ export function telegramProgressCard(store, run, taskId, project, now = new Date
     }
     else if (accessBlocked) {
         facts = { stage: "needs-you", need: "other", reason: holds.some(hold => hold.ownerKind === "backoff")
-                ? "The worker can't read the project folder. It retries after a short pause; check its folder access."
-                : "The worker can't read the project folder. Restore its access, then resume." };
+                ? "The builder can't read the project folder. It retries after a short pause; check its folder access."
+                : "The builder can't read the project folder. Restore its access, then resume." };
     }
     else if (run.outcome === null && stop !== null && stop.resumedAt === null) {
         facts = { stage: "stopped", reason: stop.settledAt === null ? "Stopping. Waiting for the running process to end." : "Paused by a person. Inspect the saved work, then resume." };
@@ -65,7 +66,8 @@ export function telegramProgressCard(store, run, taskId, project, now = new Date
         facts = { stage: "stopped", reason: `On hold: ${phoneText(operatorHold.reason, 150)}` };
     }
     else if (run.outcome === null) {
-        facts = { stage: run.phase !== null && run.phase !== "agent-running" ? "checking" : run.role === "planner" ? "planning" : "building" };
+        facts = { stage: run.phase !== null && run.phase !== "agent-running" ? "checking" : run.role === "planner" ? "planning" : "building",
+            ...(machineChecked(store, taskId) ? { machine: true } : {}) };
     }
     else if (run.outcome === "parked") {
         facts = { stage: "needs-you", need: "answer" };

package/dist/telegram-status.js

@@ -1,4 +1,5 @@
 import { publicChatText } from './chat-display.js';
+import { machineChecked } from "./machine-check.js";
 import { manualReviewOnly } from "./proof.js";
 /** Read-only phone views over the same dispatch and proof records as chat.
  * No provider calls, repository access, new workflow state, or inferred success. */
@@ -65,7 +66,8 @@ function headlineFor(store, id, d, read_ = {}) {
             return taskStatusOf(assignmentStatusFacts(assignment));
     }
     const finished = read.stage === "finished" || read.stage === "complete" || read.stage === "failed";
-    return taskStatusOf({ stage: read.stage, ...(read.need === undefined ? {} : { need: read.need }), reason: finished ? null : plainReasonOf(read.stage, d.code, d.detail),
+    return taskStatusOf({ stage: read.stage, ...(read.need === undefined ? {} : { need: read.need }), ...(read.wait === undefined ? {} : { wait: read.wait }), reason: finished ? null : plainReasonOf(read.stage, d.code, d.detail),
+        ...(machineChecked(store, id) ? { machine: true } : {}),
         checks: read.stage === "failed" && d.code === "proof-refuted" ? { status: "failed", exitCode: null, head: null } : null });
 }
 function groupOf(d) {
@@ -238,7 +240,7 @@ export function phoneTaskView(store, repos, id, now, root) {
         const hiddenDependency = blocker !== null && (blocker.repo === null || !repos.includes(blocker.repo));
         lines.push(hiddenDependency ? "A required task outside this phone view has not finished. Open the dependency in the console." : plain(shared.sentence, 650));
         if (d.nextAt !== null)
-            lines.push(`Earliest recorded wake: ${plain(d.nextAt, 40)} (a connected worker is still required).`);
+            lines.push(`Earliest recorded wake: ${plain(d.nextAt, 40)} (a connected builder is still required).`);
         const runs = store.runsFor(ref.id);
         const result = task.state === "done" ? runs.find(r => (r.role === "builder" || r.role === "scout") && (r.outcome === "built" || r.outcome === "no-change") && r.finishedAt !== null) : undefined;
         const latest = result ?? runs[0];
@@ -262,14 +264,14 @@ export function phoneTaskView(store, repos, id, now, root) {
                 : approvedCheckStateOf(approvedCheckOf(proof.verdict, proof.reasons, checksFactOf(assignmentChecksForRun(store, root, result.id, now), result.headRevision)));
             const verifiedWords = root === undefined ? "Open the result to see its checks" : checkNow === "passed" ? "Checks passed at completion"
                 : checkNow === "failed" ? "Checks failed" : checkNow === "running" ? "Checks running" : "The check result couldn't be read";
-            const proofWords = { verified: verifiedWords, attested: "Checks reported by the agent, not run by Toolroll", short: "Required saved material is missing", refuted: "The saved result conflicts with the approved scope" };
+            const proofWords = { verified: verifiedWords, attested: "Checks reported by the agent, not run by Toolroll", short: "Required saved material is missing", refuted: "The saved result doesn't match the approved plan" };
             lines.push(`Checks: ${proof === null ? "No completion record saved" : manualReviewOnly(proof) ? accepted ? "Accepted by a person; the recorded checks are unchanged" : "A person must inspect this result; no recorded check failed" : proofWords[proof.verdict]}.`);
             if (manualReviewOnly(proof) && !accepted)
                 lines.push('Reply “Send the result summary” for the checks, notes and screenshots.');
             if (proof !== null && proof.matrix.length > 0)
                 lines.push(`Requirements: ${proof.matrix.filter(row => row.state === "pass").length}/${proof.matrix.length} satisfied in the saved record.`);
             if (accepted && !manualReviewOnly(proof))
-                lines.push("An operator accepted this result; that does not change its recorded checks.");
+                lines.push("An approver accepted this result; that does not change its recorded checks.");
             const publication = store.publicationForRun(result.id);
             const delivery = publication?.remoteState === "MERGED" ? `#${publication.prNumber ?? "?"} merged` : publication?.remoteState === "CLOSED" ? `#${publication.prNumber ?? "?"} closed without merging` : publication?.state === "opened" ? `#${publication.prNumber ?? "?"} open` : publication?.state === "pushed" || publication?.state === "intended" ? "Opening…" : publication?.state === "failed" ? "Couldn't open; the commit is safe locally" : null;
             if (delivery !== null)

package/dist/test-infra.d.ts

@@ -24,3 +24,11 @@ export declare function testInfrastructure(files: ReadonlyMap<string, string>, a
  * the other rules don't already trust: any source file that is neither a test nor product code.
  */
 export declare function mightName(open: Unresolved, path: string, found: TestInfrastructure): boolean;
+/** Whether a path is a test file by any extension a test runner could be pointed at, not only those run today. */
+export declare const isTestPath: (path: string) => boolean;
+/**
+ * Why a new test file can't carry on what it imports, or null (docs/plans/trusted-release-reports.md, H4). A test file is
+ * never infrastructure here, so nothing else looks at an edge between two of them, and importing one runs its top level
+ * (its `vi.mock`s and hooks included) in the importer. A computed import might name one, so it refuses too.
+ */
+export declare function testImportProblem(path: string, text: string): string | null;

package/dist/test-infra.js

@@ -319,3 +319,21 @@ export function mightName(open, path, found) {
     const stem = path.replace(/\.[^/.]+$/, "");
     return path === prefix || stem === prefix.replace(/\.(?:[cm]?js|jsx)$/, "") || path.startsWith(`${prefix}/`) || (open.specifier !== null && open.specifier.endsWith("/") === false && path.startsWith(prefix));
 }
+/** Whether a path is a test file by any extension a test runner could be pointed at, not only those run today. */
+export const isTestPath = (path) => TEST.test(path);
+/** A specifier that names a test file, whatever it is spelled as: `./a.test.js`, `../b.test`, `@/c.test.ts`. */
+const NAMES_TEST = /\.test(?:\.[cm]?[jt]sx?)?(?:[?#].*)?$/;
+/**
+ * Why a new test file can't carry on what it imports, or null (docs/plans/trusted-release-reports.md, H4). A test file is
+ * never infrastructure here, so nothing else looks at an edge between two of them, and importing one runs its top level
+ * (its `vi.mock`s and hooks included) in the importer. A computed import might name one, so it refuses too.
+ */
+export function testImportProblem(path, text) {
+    const { literal, computed, soft } = specifiersOf(path, text);
+    const named = [...literal, ...soft].find(spec => NAMES_TEST.test(spec));
+    if (named !== undefined)
+        return `${path} imports another test file (${named}), which would run its code here`;
+    if (computed.length > 0)
+        return `${path} imports a path it computes, which might name another test file`;
+    return null;
+}

package/dist/tidy.js

@@ -478,7 +478,7 @@ export function familyRepoOf(store, refs) {
 }
 /** "Archived by tidy: <reason>" or "Archived by <person>: <reason>": the one sentence every surface shows. */
 export function archivedWords(archived) {
-    return `Archived by ${archived.byKind === "tidy" ? "tidy" : archived.by}: ${archived.reason}`;
+    return `${archived.byKind === "tidy" ? "Archived automatically" : `Archived by ${archived.by}`}: ${archived.reason}`;
 }
 /** The release journals beside the store's own database file (none for an in-memory one). */
 export function releaseFactsOf(store) {

package/dist/toolroll-update-ui.js

@@ -24,7 +24,7 @@ export function updateStepsHtml(j, running, options = {}) {
     const items = UPDATE_STEPS.map((step, i) => {
         const state = j.phase === "complete" || i < last ? "done" : i > last ? "waiting" : failed ? "failed" : finished ? "waiting" : "now";
         // Only where it adds something: which work it waits for, or what went wrong.
-        const detail = state === "now" && step === "draining" && j.waiting ? html `${j.waiting.on}.${j.waiting.action ? html ` If nothing of it is running, run <code class="k-mono">${j.waiting.action}</code>.` : ""}`
+        const detail = state === "now" && step === "draining" && j.waiting ? html `${j.waiting.on}.${j.waiting.action ? html ` To have Toolroll check again, run <code class="k-mono">${j.waiting.action}</code>.` : ""}`
             : (state === "now" && step === "draining") || (state === "failed" && j.phase === "rolling-back") ? html `${j.detail}` : "";
         return settingsRecord({ title: STEP_WORDS[step], sub: detail, when: STEP_CHIP[state], attrs: { "data-step": step, "data-state": state } });
     });
@@ -43,7 +43,7 @@ function outcomeHtml(j) {
     // Stopped on a finished run it can't show has ended: what is in the way and the one command, nothing more.
     if (j.phase === "refused" && j.waiting) {
         return settingsSection({ id: "update-outcome", title: `Update to ${j.to.version} stopped: run #${j.waiting.run} is in the way`,
-            body: html `<div data-update-outcome="stopped">${infoLine(`${j.waiting.on}. New work resumed.`)}${j.waiting.action ? note(html `If nothing of it is running, run <code class="k-mono">${j.waiting.action}</code>, then update again.`) : note("Update again once it has stopped.")}</div>` });
+            body: html `<div data-update-outcome="stopped">${infoLine(`${j.waiting.on}. New work resumed.`)}${j.waiting.action ? note(html `To have Toolroll check again, run <code class="k-mono">${j.waiting.action}</code>, then update again.`) : note("Update again once it has stopped.")}</div>` });
     }
     const title = j.phase === "refused" ? `Didn't update to ${j.to.version}` : j.phase === "restored" ? `Update to ${j.to.version} didn't finish` : "The update needs attention";
     return settingsSection({ id: "update-outcome", title, state: html ` ${chip("Failed", "failed")}`,

package/dist/toolroll-update.js

@@ -39,7 +39,10 @@ import { installLaunchdService, launchdPlist, stopLaunchdService, writeFileDurab
 import { LAPTOP_LABEL_DARWIN, LAPTOP_LABEL_LINUX, unitFlag } from "./laptop-service.js";
 import { processGone, readRunnerProcessRecord, realProcessProbe, recordStandsFor, RUNNER_PROCESS_DIR } from "./runner-process.js";
 import { NAME } from "./names.js";
-import { orphanKey, updateSafeSchema, V117_RENAMED_COLUMNS, V117_RENAMED_TABLES, V118_MERGED_TABLES, V119_ADDED_COLUMNS, V120_ADDED_COLUMNS, V121_ADDED_COLUMNS, V122_ADDED_COLUMNS, V123_ADDED_COLUMNS, V125_ADDED_COLUMNS, V126_ADDED_COLUMNS, V128_ADDED_COLUMNS, V129_ADDED_COLUMNS, V134_ADDED_COLUMNS, V135_ADDED_COLUMNS, V138_ADDED_COLUMNS, V143_ADDED_COLUMNS, V147_ADDED_COLUMNS, V148_ADDED_COLUMNS } from "./store.js";
+import { V151_ADDED_COLUMNS } from "./storage.js";
+import { orphanKey, updateSafeSchema, V117_RENAMED_COLUMNS, V117_RENAMED_TABLES, V118_MERGED_TABLES, V119_ADDED_COLUMNS, V120_ADDED_COLUMNS, V121_ADDED_COLUMNS, V122_ADDED_COLUMNS, V123_ADDED_COLUMNS, V125_ADDED_COLUMNS, V126_ADDED_COLUMNS, V128_ADDED_COLUMNS, V129_ADDED_COLUMNS, V134_ADDED_COLUMNS, V135_ADDED_COLUMNS, V138_ADDED_COLUMNS, V143_ADDED_COLUMNS, V147_ADDED_COLUMNS, V148_ADDED_COLUMNS, V150_ADDED_COLUMNS } from "./store.js";
+import { V152_ADDED_COLUMNS } from "./code-map-store.js";
+import { V153_ADDED_COLUMNS } from "./plain-schema.js";
 import { isNewer, REGISTRY } from "./releases.js";
 import { markNeverIndex } from "./never-index.js";
 import { readRuntimeUpdateJournal, RUNTIME_PHASES, RUNTIME_UPDATE_STEPS, stagedStartedAt, updaterStartingOf } from "./contracts/update-journal.js";
@@ -379,12 +382,16 @@ function addedColumns(...versions) {
     return rules;
 }
 /** Rules on tables that later gained declared columns (addedColumns merges into these instead of replacing them). */
-const EARLIER_RULES = { flow_trigger: { fromRoutines: "trigger" } };
+const EARLIER_RULES = { flow_trigger: { fromRoutines: "trigger" },
+    // v114: a finished run whose process witnesses have all exited keeps one summary row in place of them (v150 adds
+    // their machine id).
+    run_process: { compacted: { into: "run_process_summary", sum: "witnesses" } } };
 const HISTORY_RULES = {
     ...Object.fromEntries(Object.entries(CHAT_MOVES).map(([table, moved]) => [table, { moved }])),
     action_ledger: { appendOnly: true }, ledger_seal: { appendOnly: true }, ledger_checkpoint: { appendOnly: true },
-    // v114: a finished run whose process witnesses have all exited keeps one summary row in place of them.
-    run_process: { compacted: { into: "run_process_summary", sum: "witnesses" } }, run_process_summary: { summarizes: "run_process" },
+    // v114: a finished run whose process witnesses have all exited keeps one summary row in place of them (the
+    // run_process rule is in EARLIER_RULES, under its v150 column).
+    run_process: EARLIER_RULES["run_process"], run_process_summary: { summarizes: "run_process" },
     // v114: single-destination delivery columns may be dropped only once their values are legacy receipts.
     notification: { dropped: ["attempts", "last_attempt_at", "last_error", "delivered_at", "receipt", "claim_owner", "claim_expires_at"], carried: { into: "notification_delivery", destination: LEGACY_DESTINATION } },
     notification_delivery: { receives: LEGACY_DESTINATION },
@@ -414,7 +421,13 @@ const HISTORY_RULES = {
     // v147: an account's password flag reads set (1), a browser session reads full with no local binding or key, and the
     // console record reads no key epoch.
     // v148: a run's execution class and a revision's origin read none (NULL), and a project's suggestion switch reads on.
-    ...Object.fromEntries(Object.entries(addedColumns(V119_ADDED_COLUMNS, V120_ADDED_COLUMNS, V121_ADDED_COLUMNS, V122_ADDED_COLUMNS, V123_ADDED_COLUMNS, V125_ADDED_COLUMNS, V126_ADDED_COLUMNS, V128_ADDED_COLUMNS, V129_ADDED_COLUMNS, V134_ADDED_COLUMNS, V135_ADDED_COLUMNS, V138_ADDED_COLUMNS, V143_ADDED_COLUMNS, V147_ADDED_COLUMNS, V148_ADDED_COLUMNS))
+    // v149 adds tables only (the learning-loops records): no saved row changes, so no rule is needed for it.
+    // v150: a saved process witness reads no machine id (NULL), and is matched by host name as before.
+    // v151: a saved cleanup setting's idle limit reads none (NULL): the default.
+    // v152: a saved project's code map reads on, with no enrollment yet; the code map's tables are new.
+    // v153: a saved task reads no fast start and a saved project no fast-start setting (NULL); its tables are new.
+    // v154 adds a table only (check_stamp): no saved row changes, so no rule is needed for it.
+    ...Object.fromEntries(Object.entries(addedColumns(V119_ADDED_COLUMNS, V120_ADDED_COLUMNS, V121_ADDED_COLUMNS, V122_ADDED_COLUMNS, V123_ADDED_COLUMNS, V125_ADDED_COLUMNS, V126_ADDED_COLUMNS, V128_ADDED_COLUMNS, V129_ADDED_COLUMNS, V134_ADDED_COLUMNS, V135_ADDED_COLUMNS, V138_ADDED_COLUMNS, V143_ADDED_COLUMNS, V147_ADDED_COLUMNS, V148_ADDED_COLUMNS, V150_ADDED_COLUMNS, V151_ADDED_COLUMNS, V152_ADDED_COLUMNS, V153_ADDED_COLUMNS))
         .map(([table, rule]) => [table, { ...EARLIER_RULES[table], ...rule }])),
 };
 /** The tables a migration may remove whole (v115's removed features). */

package/dist/tui-contract.d.ts

@@ -42,6 +42,8 @@ export type TuiTask = {
     /** A finished result that can be marked Complete or sent back with a revision. */
     readonly hasResult: boolean;
     readonly decisions: readonly TuiDecision[];
+    /** "Can I merge?" (merge-checklist.ts, `toolroll task ready`'s lines): the answer, then each check. Empty: no result. */
+    readonly ready?: readonly string[];
 };
 /** The welcome's steps, as lines (welcome-facts.ts). */
 export type TuiSetup = {
@@ -56,11 +58,19 @@ export type TuiSnapshot = {
     readonly projects: readonly string[];
     /** Whether the local owner has set a password (decides where a refusal leads). */
     readonly passwordSet: boolean;
+    /** One line about flaky tests and project memory waiting, and the commands that show them; null when there's nothing. */
+    readonly learning?: string | null;
 };
 export type TuiAct = {
     readonly kind: "new";
     readonly text: string;
     readonly repo: string | null;
+}
+/** Build: the terms the person just read (fast-start.ts). */
+ | {
+    readonly kind: "build";
+    readonly preview: string;
+    readonly digest: string;
 } | {
     readonly kind: "approve";
     readonly id: string;
@@ -76,11 +86,23 @@ export type TuiAct = {
 } | {
     readonly kind: "complete";
     readonly id: string;
+} | {
+    readonly kind: "retry";
+    readonly id: string;
 } | {
     readonly kind: "answer";
     readonly decision: number;
     readonly option: string;
 };
+/** What Build would approve: the same lines every approval surface reads. */
+export type TuiFastTerms = {
+    readonly preview: string;
+    readonly digest: string;
+    readonly terms: readonly {
+        readonly label: string;
+        readonly words: string;
+    }[];
+};
 /** A write's answer: its words. `needsPassword`: refused because the local owner may not do it. */
 export type TuiActResult = {
     readonly ok: true;
@@ -100,6 +122,8 @@ export interface TuiSource {
     /** A counter that moves when the plane's work changes (the store's wake sequence). */
     changed(): number;
     act(act: TuiAct): Promise<TuiActResult>;
+    /** A small task's exact terms, or null when it takes the ordinary road (New task then files it). */
+    fastTerms(text: string, repo: string | null): Promise<TuiFastTerms | null>;
     /** The welcome's steps, or null once setup is done. */
     setup(): Promise<TuiSetup | null>;
 }