toolroll 0.9.93 → 0.9.95

package/dist/surface.js

@@ -1,6 +1,9 @@
 import { KNOWLEDGE_DESCRIPTORS } from "./knowledge-cli.js";
 import { MEMORY_DESCRIPTORS } from "./memory-cli.js";
+import { CARD_DESCRIPTOR } from "./card-cli.js";
+import { FLAKY_DESCRIPTORS } from "./flaky-cli.js";
 import { MODELS_DESCRIPTORS } from "./models-cli.js";
+import { MAP_DESCRIPTORS } from "./code-map-cli.js";
 import { FLOWS_DESCRIPTORS } from "./flows-cli.js";
 /**
  * The declared command guide (arc 5): the agent-facing surface as data,
@@ -117,10 +120,13 @@ const GUIDE_ROWS = [
     operator("demo", "a seeded throwaway sandbox"),
     ...KNOWLEDGE_DESCRIPTORS.map(spec => ({ invocation: `knowledge ${spec.action}`, synopsis: spec.synopsis, audience: "audience" in spec ? spec.audience : "agent", agentMayInvoke: !("audience" in spec), mutation: spec.mutation, flags: spec.flags, ...(spec.takesQuery ? { positionals: [{ name: "query", required: true, meaning: "search text or source file for impact" }] } : {}) })),
     ...MEMORY_DESCRIPTORS.map(spec => ({ invocation: `memory ${spec.action}`, synopsis: spec.synopsis, audience: "audience" in spec ? spec.audience : "agent", agentMayInvoke: !("audience" in spec), mutation: spec.mutation, flags: spec.flags, ...(spec.takesQuery ? { positionals: [{ name: "query", required: true, meaning: "search text, a decision id, or the decision sentence" }] } : {}) })),
+    { invocation: CARD_DESCRIPTOR.invocation, synopsis: CARD_DESCRIPTOR.synopsis, audience: "agent", agentMayInvoke: true, mutation: "none", flags: CARD_DESCRIPTOR.flags, positionals: [{ name: "source", required: true, meaning: "which data to show" }] },
+    ...FLAKY_DESCRIPTORS.map(spec => ({ invocation: `flaky ${spec.action}`, synopsis: spec.synopsis, audience: "agent", agentMayInvoke: true, mutation: spec.mutation, flags: spec.flags, ...(spec.takesQuery ? { positionals: [{ name: "identity", required: true, meaning: "a row's key from flaky list" }] } : {}) })),
     // Flow writes carry an approver's credential: an agent runs them only as the person asked, after showing the preview.
     // Letting a flow run on its own raises authority: the owner's own password ceremony, never an agent's act.
     ...FLOWS_DESCRIPTORS.map(spec => ({ invocation: `flows ${spec.action}`, synopsis: spec.synopsis, audience: "audience" in spec ? spec.audience : "agent", agentMayInvoke: !("audience" in spec), mutation: spec.mutation, flags: spec.flags,
         ...("positionals" in spec ? { positionals: spec.positionals.map(name => ({ name, required: true, meaning: name === "flow" ? "a flow id from flows list" : name === "card" ? "a card id from flows show" : name === "on|off" ? "on signs the grant, off revokes it" : "a trigger id from flows show, or for trigger add its settings as JSON, a JSON file, or -" })) } : {}) })),
+    ...MAP_DESCRIPTORS.map(spec => ({ invocation: spec.action === "" ? "map" : `map ${spec.action}`, synopsis: spec.synopsis, audience: "audience" in spec ? spec.audience : "agent", agentMayInvoke: !("audience" in spec), mutation: spec.mutation, flags: spec.flags, ...(spec.positional === null ? {} : { positionals: [{ name: "target", required: true, meaning: spec.positional }] }) })),
     ...MODELS_DESCRIPTORS.map(spec => ({ invocation: `models ${spec.action}`, synopsis: spec.synopsis, audience: "agent", agentMayInvoke: true, mutation: spec.mutation, flags: spec.flags, ...(spec.takesQuery ? { positionals: [{ name: "target", required: true, meaning: "positional" in spec ? spec.positional : "the CLI to update, or on/off" }] } : {}) })),
     // ---- the queue (agent surface) ----
     { invocation: "status", synopsis: "running work, queued reasons, results to review, the latest release check and plan windows", audience: "agent", agentMayInvoke: true, mutation: "none", flags: [jsonFlag, dbFlag] },
@@ -153,6 +159,21 @@ const GUIDE_ROWS = [
             { name: "token", takesValue: true, meaning: "a lead token: filed as the lead, so it pings nobody" },
             { name: "checks", takesValue: true, meaning: "quick|full|off: this task's checks, overriding the project's level (\"skip the tests\" is off)" }],
         notableReasons: ["duplicate", "usage", "unknown-task", "unauthenticated"] },
+    { invocation: "task new", synopsis: "start a small task at a terminal: shows the exact terms, then Build now? is your approval", audience: "operator", agentMayInvoke: false, mutation: "unkeyed",
+        positionals: [{ name: "words", required: false, meaning: "what should change" }],
+        flags: [dbFlag,
+            { name: "repo", takesValue: true, meaning: "the project" },
+            { name: "as", takesValue: true, meaning: "the approver" },
+            { name: "token", takesValue: true, meaning: "their password" },
+            { name: "from", takesValue: true, meaning: "a github.com issue or pull request of this project: quoted, then filed for your approval" },
+            { name: "preview", takesValue: false, meaning: "the terminal UI's own: the exact terms, nothing started" },
+            { name: "build", takesValue: true, meaning: "the terminal UI's own: Build on those terms" },
+            { name: "digest", takesValue: true, meaning: "the terms the person read" }],
+        notableReasons: ["person-only", "usage"] },
+    { invocation: "task keep", synopsis: "a fast start that grew: propose a plan for its exact commit, for you to approve", audience: "operator", agentMayInvoke: false, mutation: "unkeyed",
+        positionals: [{ name: "id", required: true, meaning: "the task" }],
+        flags: [jsonFlag, dbFlag, { name: "as", takesValue: true, meaning: "the approver" }, { name: "token", takesValue: true, meaning: "their password" }],
+        notableReasons: ["usage", "refused"] },
     { invocation: "task ask", synopsis: "hand a task to a person: one message saying why, and the task is theirs", audience: "agent", agentMayInvoke: true, mutation: "unkeyed",
         positionals: [{ name: "id", required: true, meaning: "the task" }],
         flags: [jsonFlag, dbFlag,
@@ -169,6 +190,10 @@ const GUIDE_ROWS = [
         audience: "agent", agentMayInvoke: true, mutation: "none",
         positionals: [{ name: "task", required: true, meaning: "any version of the task" }], flags: [jsonFlag, dbFlag],
         notableReasons: ["unknown-task", "no-pull-request"] },
+    { invocation: "task ready", synopsis: "Can I merge? The task's checklist from Toolroll's records, each blocker with the act that clears it (Run checks, Retry, Ask the agent to fix)",
+        audience: "agent", agentMayInvoke: true, mutation: "none",
+        positionals: [{ name: "task", required: true, meaning: "any version of the task" }], flags: [jsonFlag, dbFlag],
+        notableReasons: ["unknown-task"] },
     { invocation: "task add-tests", synopsis: "file a small task to write tests for the task's latest change; it waits for approval like any task",
         audience: "agent", agentMayInvoke: true, mutation: "identity-idempotent",
         positionals: [{ name: "task", required: true, meaning: "any version of the task" }], flags: [jsonFlag, dbFlag],
@@ -298,8 +323,25 @@ const GUIDE_ROWS = [
             { name: "all", takesValue: false, meaning: "include LOW findings within the compact packet's limit; extra findings are counted" },
             { name: "token", takesValue: true, meaning: "the lead token (or TOOLROLL_LEAD_TOKEN)" }],
         notableReasons: ["usage", "unauthenticated", "not-found"] },
-    operator("task accept", "record an explicit acceptance with limitations; does not change checks or prove deployment"),
-    operator("task repair", "inspect or approve an existing historical repair draft; use task revise for new feedback"),
+    { ...operator("task accept", "accept a result: --finish (or --digest <receipt>) is exactly task complete's completion of the exact receipt; --despite \"<reason>\" records an acceptance with limitations and never completes; a bare call refuses"),
+        positionals: [{ name: "id", required: true, meaning: "the task" }],
+        flags: [jsonFlag, dbFlag, { name: "finish", takesValue: false, meaning: "accept the result and finish the task: task complete's exact-receipt completion; --json and scoped agents pass --digest" },
+            { name: "digest", takesValue: true, meaning: "the exact receipt from assignment show; accepts and finishes exactly that result" },
+            { name: "despite", takesValue: true, meaning: "accept with this reason, without finishing; never combines with --finish or --digest (--note is its alias)" }],
+        notableReasons: ["usage", "unknown-task", "no-run", "not-ready"] },
+    operator("task repair", "inspect or approve a repair draft; --yes starts the repair a failed check is waiting for, under the normal plan approval"),
+    operatorRead("task handover", "where a task stands, from Toolroll's records: revision, decisions, rejected approaches, open findings, checks and the next action"),
+    operator("task before-after", "before-and-after evidence: read it, save a failing result, or rerun the same check on the latest commit with no agent"),
+    operator("task failing-first", "ask a bug fix's next attempt to write a failing test first (on|off); shown in the result as the agent's report"),
+    operatorRead("finding list", "findings still waiting on someone, or every finding of --task <id>"),
+    operatorRead("finding show", "one finding: its text, evidence and how it stands"),
+    operator("finding send", "send a finding to the task that owns the code; the owner must accept it or reject it with a reason"),
+    operator("finding resend", "send an answered finding back, one more round; past the limit it goes to a person"),
+    operator("finding close", "a person's decision on a finding"),
+    operatorRead("captures list", "what providers said when attempts failed, the ones mentioning limits first; nothing routes on these"),
+    operatorRead("captures show", "one saved provider failure"),
+    operatorRead("captures export", "one saved provider failure as a fixture"),
+    operator("captures mark", "a person's reading of a capture: exhausted or not-exhausted"),
     operator("task route", "which configured agents plan, build and repair this task; phase and size changes require renewed approval"),
     operator("task reopen", "resume external work its tracker closed and has been SEEN open again"),
     operator("task stop", "stop ONE exact live attempt (--run <id>): durable before any process is signalled, answers 'stopping' until its own processes are established gone; work, branch, and evidence preserved; no strike, no retry"),
@@ -448,6 +490,8 @@ const GUIDE_ROWS = [
  * project access. A row missing here fails the contract test, and runs nowhere remotely meanwhile.
  */
 const REMOTE_NO = [
+    // A fast start is a person at this computer (fast-start.ts).
+    "task new", "task keep",
     // Answered by the local CLI, or a client of a central server itself.
     "", "pulls", "graph", "repos", "repos add", "repos remove", "repos add-from-github", "contract", "skills list", "skills get", "skills install",
     "link", "unlink", "update", "release", "demo", "chat",
@@ -465,6 +509,9 @@ const REMOTE_NO = [
     // Earned rules (results routing): the project's own results, and its rules' doors, with this machine's sign-in; a
     // remote token never changes which models run (the rule door refuses it in the write too).
     "models suggestions", "models accept", "models dismiss", "models turn-off", "models keep", "models try", "models stop",
+    // The code map's switch, holdout and report: this machine's sign-in, never a token's (code-map-acts.ts refuses one in
+    // the write too).
+    "map on", "map off", "map holdout end", "map report",
     // Publication and release.
     "publish", "publish status", "publish merge", "publish refire", "publish unblock", "publish rearm", "publish grant", "publish revoke",
     // A repository's authority grants on this machine.
@@ -476,12 +523,17 @@ const REMOTE_NO = [
     // Reads this machine owner's own Claude and Codex session files (~/.claude, ~/.codex).
     "memory propose",
 ];
+const REMOTE_FOLLOW_THROUGH = [
+    // On the server's machine or in the console: each writes through a verified person, and they read saved model text.
+    "task handover", "task before-after", "task failing-first", "finding list", "finding show", "finding send", "finding resend", "finding close",
+    "captures list", "captures show", "captures export", "captures mark",
+];
 const REMOTE_STEP_UP = [
     "proposals", "decide", "task regate", "task approve", "task accept", "task merge", "run settle",
     // Putting tasks away and restoring them: a person's act, in the console or on the server's machine.
     "task archive", "task restore", "task tidy", "knowledge apply",
     // Changing project memory: a person's own password, never a token (the lead only proposes it in chat).
-    "memory decide", "memory retire", "memory apply",
+    "memory decide", "memory retire", "memory apply", "memory tidy", "memory restore", "memory unmerge",
     "flows card approve", "flows card send-back", "flows script approve", "flows unattended",
     "approver list", "approver add", "people list", "people invite", "people projects", "people revoke",
     // A person's own API tokens: a password step-up on the server's machine, or the console. Never with a token.
@@ -491,14 +543,16 @@ const REMOTE_STEP_UP = [
 ];
 const REMOTE_YES = [
     "status", "integrations", "ready", "gaps", "grants", "sync", "audit",
-    "task add", "task ask", "task checks", "task ship", "task add-tests", "task list", "task show", "check-progress", "task wait", "task complete", "task revise",
+    "task add", "task ask", "task checks", "task ship", "task ready", "task add-tests", "task list", "task show", "check-progress", "task wait", "task complete", "task revise",
     "task state", "task block", "task unblock", "task next", "task steer", "task pause", "task continue", "task assign", "task scope", "task plan", "task hold", "task unhold", "task require",
     "task requeue", "task review", "task repair", "task route", "task reopen", "task stop", "task resume",
     "runner list", "coordinator list", "cap list", "cap add", "outbox list", "incident list", "incident resolve",
     "config show", "verify show", "intake show", "intake run", "intake preview", "intake pr-comments", "template list", "template show",
     "webhook status", "review show", "chat-approval show", "chat-approval off",
     "knowledge search", "knowledge impact", "knowledge refresh",
+    "map", "map area", "map file", "map search", "map refresh",
     "memory search", "memory decisions", "memory show", "memory review", "memory status",
+    "flaky list", "flaky show", "card",
     "flows list", "flows show", "flows export", "flows create", "flows edit", "flows trigger add", "flows trigger pause", "flows trigger resume",
     "flows trigger remove", "flows card add", "flows archive",
     "models status", "models list",
@@ -506,11 +560,12 @@ const REMOTE_YES = [
 /** Every row's remote policy, by invocation. Exported for the contract test, which holds it to the guide exactly. */
 export const REMOTE_POLICY = new Map([
     ...REMOTE_NO.map(invocation => [invocation, "no"]),
+    ...REMOTE_FOLLOW_THROUGH.map(invocation => [invocation, "no"]),
     ...REMOTE_STEP_UP.map(invocation => [invocation, "step-up"]),
     ...REMOTE_YES.map(invocation => [invocation, "yes"]),
 ]);
 /** How many times each invocation was classified — the contract test refuses a row stated twice. */
-export const REMOTE_POLICY_COUNT = REMOTE_NO.length + REMOTE_STEP_UP.length + REMOTE_YES.length;
+export const REMOTE_POLICY_COUNT = REMOTE_NO.length + REMOTE_FOLLOW_THROUGH.length + REMOTE_STEP_UP.length + REMOTE_YES.length;
 /**
  * Easy-start C3: the commands a laptop's local owner may run through the terminal UI (local-owner.ts runAsLocalOwner),
  * each with the act it is; every other row (and every command with no row) is refused to the local owner before any
@@ -518,10 +573,14 @@ export const REMOTE_POLICY_COUNT = REMOTE_NO.length + REMOTE_STEP_UP.length + RE
  */
 const LOCAL_ALLOW = {
     // Reads.
-    pulls: "read", graph: "read", repos: "read", status: "read", ready: "read", gaps: "read", contract: "read", "skills list": "read", "skills get": "read",
+    pulls: "read", graph: "read", repos: "read", map: "read", "map area": "read", "map file": "read", "map search": "read", status: "read", ready: "read", gaps: "read", contract: "read", "skills list": "read", "skills get": "read",
+    "flaky list": "read", "flaky show": "read", card: "read", "memory review": "read", "memory status": "read", "memory decisions": "read", "memory show": "read",
+    // Learning loops (D3): a lesson note or a clean-up, decided by a person at the laptop (the writers check the act).
+    "memory apply": "memory-review", "memory tidy": "memory-review", "memory restore": "memory-review", "memory unmerge": "memory-review",
     "task list": "read", "task show": "read", "task state": "read", "task wait": "read", "check-progress": "read", "review show": "read", welcome: "read",
     // Acts (plan C1's list).
     "task add": "file-task",
+    "task new": "build-now",
     chat: "lead-send",
     "task steer": "lead-send",
     "task approve": "approve-plan",
@@ -542,6 +601,8 @@ const LOCAL_ALLOW = {
     "models turn-off": "routing-turn-off",
     "models dismiss": "dismiss-suggestion",
     "models stop": "trial-stop",
+    "map on": "code-map-switch",
+    "map off": "code-map-switch",
 };
 /** Every guide row's local-owner mark, by invocation: `allow` with its act, else `deny`. Exported for the inventory test. */
 export const LOCAL_POLICY = new Map(GUIDE_ROWS.map(row => [row.invocation,

package/dist/sweep-quarantine.d.ts

@@ -7,6 +7,7 @@ type Journal<T> = {
     pid: number;
     host: string;
     bootId: string | null;
+    machineId?: string | null;
 };
 export type Quarantine<T> = {
     path: string;

package/dist/sweep-quarantine.js

@@ -7,16 +7,17 @@ import { existsSync, linkSync, lstatSync, readFileSync, readdirSync, renameSync,
 import { hostname } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { currentBootId, provenDeadByBootChange } from "./boot-identity.js";
+import { currentMachineId, isThisMachine } from "./machine-identity.js";
 export const QUARANTINE_NOTE = ".toolroll-sweep.json";
 const PREFIX = ".toolroll-trash-";
 const freshPath = (root) => join(root, `${PREFIX}${randomBytes(16).toString("hex")}`);
-const owner = () => ({ pid: process.pid, host: hostname(), bootId: currentBootId() });
+const owner = () => ({ pid: process.pid, host: hostname(), bootId: currentBootId(), machineId: currentMachineId() });
 function alive(one) {
     if (one.pid === 0)
         return false;
-    if (one.host !== hostname())
+    if (!isThisMachine(one))
         return true;
-    if (one.bootId !== null && provenDeadByBootChange(one))
+    if (one.bootId !== null && provenDeadByBootChange(one, { host: one.host, bootId: currentBootId() }))
         return false;
     try {
         process.kill(one.pid, 0);
@@ -31,7 +32,8 @@ function read(path) {
         const j = JSON.parse(readFileSync(join(path, QUARANTINE_NOTE), "utf8"));
         return j.version === 1 && typeof j.name === "string" && j.name !== "." && j.name !== ".." &&
             j.name !== "" && !/[\\/\0]/.test(j.name) && Number.isSafeInteger(j.pid) && j.pid >= 0 && typeof j.host === "string" &&
-            (j.bootId === null || typeof j.bootId === "string") && typeof j.deleting === "boolean" ? j : null;
+            (j.bootId === null || typeof j.bootId === "string") && (j.machineId === undefined || j.machineId === null || typeof j.machineId === "string")
+            && typeof j.deleting === "boolean" ? j : null;
     }
     catch {
         return null;

package/dist/tamper-scan.d.ts

@@ -0,0 +1,4 @@
+/** Every expression in `text` that could reach the runner, with its arguments, spaces collapsed. */
+export declare function runnerExpressions(path: string, text: string): string[];
+/** What the candidate has that the base doesn't, as a multiset: an edited argument is a new expression, a moved one isn't. */
+export declare function tamperFindings(path: string, base: string | null, candidate: string): string[];

package/dist/tamper-scan.js

@@ -0,0 +1,90 @@
+/**
+ * A heuristic over changed code (docs/plans/trusted-release-reports.md, H4): the expressions that could reach the test
+ * runner, compared whole. Round 1 of the plan counted these forms, and Codex's finding 5 was that a count misses an
+ * edit: `process.exit(1)` becoming `process.exit(0)` counts the same. So this keeps each expression's text, its
+ * arguments included, and each binding that aliases a runner object, and reports what the candidate has that the base
+ * doesn't.
+ *
+ * It decides nothing. It isn't wired to any approval: it makes tampering visible, can't make it impossible, and the
+ * rate at which it flags honest work is measured first (scripts/tamper-measure.mjs).
+ */
+import { createRequire } from "node:module";
+let compiler;
+const typescript = () => compiler ??= createRequire(import.meta.url)("typescript-parser");
+const PROCESS_MEMBERS = new Set(["exit", "exitCode", "kill", "send", "channel", "ppid", "binding", "dlopen", "reallyExit", "abort"]);
+const RUNNER_OBJECTS = new Set(["process", "globalThis", "global", "vi"]);
+const TEST_GLOBALS = new Set(["expect", "test", "it", "describe", "vi"]);
+const IMPORTS = /^(?:node:)?process$|^@vitest\/|^vitest\/(?!config$)|^tinypool$|^birpc$|^(?:node:)?vm$|^(?:node:)?inspector$/;
+const HARNESS_WORDS = /node_modules\/|\/proc\/|RUNNER_|ACTIONS_|TOOLROLL_CHECK|shard-report|NODE_OPTIONS|\bsudo\b|__vitest/;
+const TEST_ENV = /^(?:VITEST.*|TOOLROLL_TEST.*|CI|NODE_ENV)$/;
+const TEST_FILE = /\.test\.[cm]?[jt]sx?$/;
+/** Every expression in `text` that could reach the runner, with its arguments, spaces collapsed. */
+export function runnerExpressions(path, text) {
+    const tsc = typescript();
+    const source = tsc.createSourceFile(path, text, tsc.ScriptTarget.Latest, true, /x$/.test(path) ? tsc.ScriptKind.TSX : tsc.ScriptKind.TS);
+    const found = [];
+    const said = (node) => found.push(node.getText(source).replace(/\s+/g, " ").slice(0, 200));
+    const named = (node, names) => tsc.isIdentifier(node) && names.has(node.text);
+    // The call or assignment a member is part of, so what it is called with or set to counts.
+    const whole = (node) => (tsc.isCallExpression(node.parent) && node.parent.expression === node) || (tsc.isBinaryExpression(node.parent) && node.parent.left === node) ? node.parent : node;
+    const visit = (node) => {
+        if (tsc.isImportDeclaration(node) && tsc.isStringLiteral(node.moduleSpecifier) && IMPORTS.test(node.moduleSpecifier.text))
+            said(node);
+        else if (tsc.isCallExpression(node) && (node.expression.kind === tsc.SyntaxKind.ImportKeyword || (tsc.isIdentifier(node.expression) && node.expression.text === "require"))
+            && node.arguments[0] !== undefined && tsc.isStringLiteral(node.arguments[0]) && IMPORTS.test(node.arguments[0].text))
+            said(node);
+        else if (tsc.isPropertyAccessExpression(node) && tsc.isIdentifier(node.expression)) {
+            const object = node.expression.text, member = node.name.text;
+            if (object === "process" && (PROCESS_MEMBERS.has(member) || member.startsWith("_")))
+                said(whole(node));
+            if (object === "require" && member === "cache")
+                said(node);
+            if (object === "Module" && member.startsWith("_"))
+                said(whole(node));
+            if (object === "module" && member === "register")
+                said(whole(node));
+        }
+        else if (tsc.isElementAccessExpression(node) && named(node.expression, RUNNER_OBJECTS) && !tsc.isStringLiteralLike(node.argumentExpression))
+            said(node);
+        else if (tsc.isCallExpression(node) && tsc.isIdentifier(node.expression) && (node.expression.text === "eval" || node.expression.text === "Function"))
+            said(node);
+        else if (tsc.isNewExpression(node) && tsc.isIdentifier(node.expression) && node.expression.text === "Function")
+            said(node);
+        else if (tsc.isBinaryExpression(node) && node.operatorToken.kind === tsc.SyntaxKind.EqualsToken) {
+            const left = node.left;
+            if (named(left, TEST_GLOBALS) || (tsc.isPropertyAccessExpression(left) && (named(left.expression, TEST_GLOBALS) || named(left.expression, new Set(["globalThis"])) || (tsc.isPropertyAccessExpression(left.expression) && left.expression.name.text === "prototype"))))
+                said(node);
+        }
+        else if (tsc.isCallExpression(node) && tsc.isPropertyAccessExpression(node.expression) && node.expression.name.text === "defineProperty" && node.arguments[0] !== undefined
+            && (named(node.arguments[0], TEST_GLOBALS) || named(node.arguments[0], RUNNER_OBJECTS)))
+            said(node);
+        // A binding: another name for a runner object, or pieces taken out of one.
+        else if (tsc.isVariableDeclaration(node) && node.initializer !== undefined && named(node.initializer, RUNNER_OBJECTS))
+            said(node);
+        else if (tsc.isStringLiteralLike(node) && HARNESS_WORDS.test(node.text))
+            said(node);
+        // Product code telling a test from the real thing.
+        if (!TEST_FILE.test(path) && tsc.isPropertyAccessExpression(node) && TEST_ENV.test(node.name.text) && tsc.isPropertyAccessExpression(node.expression) && node.expression.name.text === "env")
+            said(node);
+        if (!TEST_FILE.test(path) && tsc.isElementAccessExpression(node) && tsc.isStringLiteralLike(node.argumentExpression) && TEST_ENV.test(node.argumentExpression.text) && tsc.isPropertyAccessExpression(node.expression) && node.expression.name.text === "env")
+            said(node);
+        tsc.forEachChild(node, visit);
+    };
+    visit(source);
+    return found;
+}
+/** What the candidate has that the base doesn't, as a multiset: an edited argument is a new expression, a moved one isn't. */
+export function tamperFindings(path, base, candidate) {
+    const left = new Map();
+    for (const one of base === null ? [] : runnerExpressions(path, base))
+        left.set(one, (left.get(one) ?? 0) + 1);
+    const added = [];
+    for (const one of runnerExpressions(path, candidate)) {
+        const count = left.get(one) ?? 0;
+        if (count > 0)
+            left.set(one, count - 1);
+        else
+            added.push(one);
+    }
+    return added;
+}

package/dist/task-aliases.d.ts

@@ -0,0 +1,5 @@
+/** People's names for task commands (docs/plans/plain-toolroll.md P1.3): each is exactly the command it names, read
+ * before anything else looks at the command, so a remote, local-owner or contract rule sees only the original. */
+export declare const TASK_ALIASES: Readonly<Record<string, string>>;
+/** `task <alias> …` as the command it names; anything else unchanged. */
+export declare function withTaskAlias(argv: readonly string[]): readonly string[];

package/dist/task-aliases.js

@@ -0,0 +1,9 @@
+/** People's names for task commands (docs/plans/plain-toolroll.md P1.3): each is exactly the command it names, read
+ * before anything else looks at the command, so a remote, local-owner or contract rule sees only the original. */
+export const TASK_ALIASES = { "send-back": "revise", retry: "requeue", recheck: "regate" };
+/** `task <alias> …` as the command it names; anything else unchanged. */
+export function withTaskAlias(argv) {
+    if (argv[0] !== "task" || argv[1] === undefined || !Object.prototype.hasOwnProperty.call(TASK_ALIASES, argv[1]))
+        return argv;
+    return ["task", TASK_ALIASES[argv[1]], ...argv.slice(2)];
+}

package/dist/task-control.d.ts

@@ -19,6 +19,7 @@
  * hold, recovery, and invocation-gateway machinery. This
  * module only names the door and the fence.
  */
+import type { StopVia } from "./store.js";
 import { type DispatchDiagnosis } from "./dispatch.js";
 import type { Run, RunStop, Store } from "./store.js";
 /** How often a running attempt re-reads its stop row while a child runs.
@@ -86,7 +87,7 @@ export type ResumeRequest = {
     taskId: string;
     runId: number;
     by: string;
-    via: "cli" | "web";
+    via: StopVia;
     /** The workspace occupancy probe (the worktree pool's `inUse`): a
      * checkout some process still holds is not quiescent, whatever the
      * rows say — the concrete gate names the pid. */

package/dist/task-control.js

@@ -19,6 +19,7 @@
  * hold, recovery, and invocation-gateway machinery. This
  * module only names the door and the fence.
  */
+import { existsSync } from "node:fs";
 import { ownedProcessCount, runOwnerTag, terminateOwnedProcesses } from "./exec.js";
 import { diagnoseTaskDispatch } from "./dispatch.js";
 /** How often a running attempt re-reads its stop row while a child runs.
@@ -195,7 +196,9 @@ export function taskControlOf(store, taskRef, now) {
     if (newest !== null) {
         const stop = store.stopOf(newest.id);
         if (stop !== null && stop.settledAt !== null && stop.resumedAt === null) {
-            return { kind: "paused", run: newest.id, role: newest.role, stop, outcome: newest.outcome, committed: newest.committed === true, worktree: newest.worktree };
+            return { kind: "paused", run: newest.id, role: newest.role, stop, outcome: newest.outcome, committed: newest.committed === true,
+                // A folder idle cleanup removed held nothing uncommitted: a later run makes it again from the branch.
+                worktree: newest.worktree !== null && existsSync(newest.worktree) ? newest.worktree : null };
         }
     }
     const newestReview = runs.find(run => run.role === "reviewer" && isAttemptRoot(store, run)) ?? null;

package/dist/task-outcome-cli.d.ts

@@ -9,6 +9,8 @@ export declare function runTaskOutcomeCommand(action: 'complete' | 'revise', pos
     write: (line: string) => void;
     now: Date;
     operator: () => Promise<VerifiedApprover | null>;
+    /** The command it answers as: `task accept --finish` is this same completion under its own name. */
+    command?: string;
 }): Promise<number>;
 /** `task merge <task>`: the console's Merge — the newest pull request any version of the task opened through
  * Complete, merged behind the approver's password once a fresh read shows its checks passing. */

package/dist/task-outcome-cli.js

@@ -12,7 +12,7 @@ import { envelopeJson } from './envelope.js';
 import { completeAndOpenPullRequest, mergeAsPerson, MERGE_NEEDS_PERSON, newestPullRequestOf, publishingOf, pullRequestViewOf } from './pull-request-flow.js';
 import { proveRunStopped } from './stop-proof.js';
 export async function runTaskOutcomeCommand(action, positional, flags, context) {
-    const command = `task ${action}`;
+    const command = context.command ?? `task ${action}`;
     const emit = (result, lines) => {
         context.write(context.json ? envelopeJson({ ...result, command }) : result.ok ? (lines ?? []).join('\n') : result.message ?? 'The action was refused.');
         return result.ok ? 0 : result.reason === 'usage' ? 2 : 3;
@@ -21,21 +21,21 @@ export async function runTaskOutcomeCommand(action, positional, flags, context)
     const allowed = new Set(['json', 'db', 'as', 'token', 'token-env', 'token-file', ...(action === 'complete' ? ['digest', 'pull-request'] : ['feedback', 'run', 'source', 'key'])]);
     for (const key of flags.keys())
         if (!allowed.has(key))
-            return fail('usage', `--${key} is not a task ${action} option.`);
+            return fail('usage', `--${key} is not a ${command} option.`);
     const task = positional[0];
     if (positional.length !== 1 || !task || task.length > 64 || /[\x00-\x1f]/.test(task))
-        return fail('usage', `Use task ${action} <task>${action === 'complete' ? ' --digest <receipt> [--pull-request]' : ' --feedback "requested change"'}.`);
+        return fail('usage', `Use ${command} <task>${action === 'complete' ? `${command === 'task accept' ? ' --finish' : ''} --digest <receipt> [--pull-request]` : ' --feedback "requested change"'}.`);
     const pullRequest = flags.has('pull-request');
     const credential = coordinatorToken(flags, process.env);
     if ('ok' in credential)
         return emit(credential);
     if (credential.token !== null && (flags.has('as') || flags.has('token')))
-        return fail('usage', 'Choose a scoped credential or your operator sign-in.');
+        return fail('usage', 'Choose your lead\'s credential or your own sign-in, not both.');
     if (credential.token !== null && pullRequest)
-        return fail('unauthenticated', 'Opening a pull request is an approver\'s act. Use your operator sign-in (--as and --token), not a scoped credential.');
+        return fail('unauthenticated', 'Opening a pull request is an approver\'s act. Use your own sign-in (--as and --token), not your lead\'s credential.');
     const operator = credential.token === null ? await context.operator() : null;
     if (credential.token === null && operator === null)
-        return fail('unauthenticated', 'Sign in with up, or supply --as and --token. Agents can use --token-file or --token-env with a scoped credential.');
+        return fail('unauthenticated', 'Sign in with up, or supply --as and --token. Your lead can use --token-file or --token-env with its own credential.');
     const { store, now, evidenceRoot } = context;
     // A result whose build Toolroll hasn't yet proven stopped: it looks now (stop-proof.ts), so completing never waits
     // on a person to confirm it, only on Toolroll's own check (a refusal says "stopping" until it lands).
@@ -44,7 +44,7 @@ export async function runTaskOutcomeCommand(action, positional, flags, context)
     return store.transact(() => {
         const coordinator = credential.token === null ? null : authenticateCoordinator(store, credential.token);
         if (coordinator !== null && !coordinator.ok)
-            return fail('unauthenticated', 'The scoped credential is invalid or revoked.');
+            return fail('unauthenticated', 'That credential is invalid or revoked.');
         if (operator !== null && !reproveApprover(store, operator).ok)
             return fail('unauthenticated', 'Your sign-in is no longer valid.');
         const repos = coordinator?.ok ? coordinator.who.repos : operator.repos;
@@ -54,12 +54,12 @@ export async function runTaskOutcomeCommand(action, positional, flags, context)
         if (action === 'complete') {
             const supplied = flags.get('digest');
             if (supplied !== undefined && (typeof supplied !== 'string' || !/^[a-f0-9]{64}$/.test(supplied)))
-                return fail('usage', '--digest requires the exact receipt from assignment show.');
+                return fail('usage', '--digest needs the exact result version from assignment show.');
             if (supplied === undefined && (context.json || coordinator !== null))
-                return fail('usage', 'Read assignment show <task>, then pass its exact --digest to mark that result complete.');
+                return fail('usage', 'Read assignment show <task>, then pass its exact --digest to accept that result.');
             const digest = typeof supplied === 'string' ? supplied : current.receipt?.digest;
             if (!digest)
-                return fail('not-ready', 'This task has no finished result to mark complete.');
+                return fail('not-ready', 'This task has no finished result to accept.');
             if (pullRequest) {
                 // The console's "Complete and open a pull request": the same exact-receipt completion and owed PR, one transaction.
                 const repo = store.lookupRef(current.activeTaskId)?.repo ?? null;
@@ -67,19 +67,19 @@ export async function runTaskOutcomeCommand(action, positional, flags, context)
                 if (!publishing.on)
                     return fail('pull-requests-off', `Pull requests aren't set up for this project. Turn them on with: toolroll publish setup --repo ${repo ?? '<path>'} --yes`);
                 if (publishing.legacy)
-                    return fail('pull-requests-off', 'This project opens a pull request for every build. Complete without --pull-request.');
+                    return fail('pull-requests-off', 'This project opens a pull request for every build. Accept without --pull-request.');
                 const runId = current.receipt?.runId;
                 if (runId === undefined)
-                    return fail('not-ready', 'This task has no finished result to mark complete.');
+                    return fail('not-ready', 'This task has no finished result to accept.');
                 const opened = completeAndOpenPullRequest(store, { taskId: task, digest, runId, who: operator, root: evidenceRoot }, now);
                 if (!opened.ok)
                     return emit(opened);
                 const link = opened.publication.prUrl;
                 return emit({ ok: true, result: assignmentOf(store, task, now, { principal: 'operator', repos }, evidenceRoot), pullRequest: pullRequestViewOf(store, runId) }, [
-                    `${current.rootId} · Complete`,
-                    `Result: ${current.activeTaskId} · run ${runId} · ${opened.publication.headSha}`,
-                    link === null ? `Pull request: opening from ${opened.publication.headSha.slice(0, 12)} into ${publishing.githubRepo} ${publishing.base}. toolroll task show ${current.rootId} prints its link.` : `Pull request: ${link}`,
-                    `Next: CI is watched on GitHub. Merge when green: toolroll task merge ${current.rootId}`,
+                    `${current.rootId} · Accepted`,
+                    `Result: ${current.activeTaskId} · build #${runId} · ${opened.publication.headSha.slice(0, 7)}`,
+                    link === null ? `Pull request: opening from ${opened.publication.headSha.slice(0, 7)} into ${publishing.githubRepo} ${publishing.base}. toolroll task show ${current.rootId} prints its link.` : `Pull request: ${link}`,
+                    `Next: Toolroll follows its CI on GitHub. Merge when green: toolroll task merge ${current.rootId}`,
                 ]);
             }
             const changed = credential.token !== null
@@ -89,7 +89,7 @@ export async function runTaskOutcomeCommand(action, positional, flags, context)
                 return emit(changed);
             const assignment = 'body' in changed ? changed.body : changed.assignment;
             // Checks deliberately Off: nothing to say about them here.
-            return emit({ ok: true, result: assignment }, [`${current.rootId} · Complete`, `Result: ${current.activeTaskId} · run ${current.receipt.runId} · ${current.receipt.head ?? 'no commit'}`,
+            return emit({ ok: true, result: assignment }, [`${current.rootId} · Accepted`, `Result: ${current.activeTaskId} · build #${current.receipt.runId} · ${current.receipt.head?.slice(0, 7) ?? 'no commit'}`,
                 ...(current.readiness?.checksOff ? [] : [current.receipt.checks.detail])]);
         }
         const feedback = flags.get('feedback'), runFlag = flags.get('run'), sourceFlag = flags.get('source'), keyFlag = flags.get('key');

package/dist/task-sizing.d.ts

@@ -42,6 +42,11 @@ export declare function classifyTask(input: SizingInput, sizer: Sizer | null, bu
 /** Install the process's classifier for filings (the CLI, the console, the worker); returns how to remove it. Unset,
  * filings keep the description's size — tests never spend a turn. */
 export declare function installFilingSizer(sizer: Sizer, budgetMs?: number): () => void;
+/** The classifier this process filed with, and its budget (fast-start.ts waits for it; null: no answer will come). */
+export declare const filingSizer: () => {
+    sizer: Sizer | null;
+    budget: number;
+};
 /**
  * After a filing: ask the classifier (within the budget) and apply its size
  * to the still-unapproved task. Runs in the background; the filing already

package/dist/task-sizing.js

@@ -185,6 +185,8 @@ export function installFilingSizer(sizer, budgetMs = SIZING_BUDGET_MS) {
     return () => { installed = previous; budget = previousBudget; };
 }
 let budget = SIZING_BUDGET_MS;
+/** The classifier this process filed with, and its budget (fast-start.ts waits for it; null: no answer will come). */
+export const filingSizer = () => ({ sizer: installed, budget });
 /**
  * After a filing: ask the classifier (within the budget) and apply its size
  * to the still-unapproved task. Runs in the background; the filing already

package/dist/task-source.d.ts

@@ -5,6 +5,10 @@
  * task link and zone. Every word shown comes from that snapshot — never from today's trigger settings.
  */
 import type { FlowCardSource, Store } from "./store.js";
+/** A task filed from a GitHub issue or pull request (github-import.ts): its filed-via, and its snapshot's proof. Its
+ * provenance is outside text however it reaches a seal, and a revision keeps it (markRevision copies the snapshot). */
+export declare const ISSUE_IMPORT_FILED_VIA = "issue-import";
+export declare const ISSUE_IMPORT_VERIFIED = "github-import";
 /** What a task keeps of the card it was filed from. */
 export type TaskSourceSnapshot = {
     label: string;
@@ -68,3 +72,6 @@ export declare function requestName(request: NonNullable<TaskOrigin["request"]>)
 export declare function requestWords(request: NonNullable<TaskOrigin["request"]>): string;
 /** The one line an approval shows about an outside event that started its work: context, never a term agreed to. */
 export declare function originNote(origin: TaskOrigin | null | undefined): string | null;
+/** Whether this task, or the task it revises, came from a GitHub import. Unreadable provenance on a row counts: it was
+ * written by the import road, and nothing here widens on a doubt. */
+export declare function issueImported(store: Pick<Store, "filedViaOf" | "taskSourceOf">, taskId: string): boolean;

package/dist/task-source.js

@@ -1,4 +1,8 @@
 import { SENDER_WORDS } from "./webhook-signing.js";
+/** A task filed from a GitHub issue or pull request (github-import.ts): its filed-via, and its snapshot's proof. Its
+ * provenance is outside text however it reaches a seal, and a revision keeps it (markRevision copies the snapshot). */
+export const ISSUE_IMPORT_FILED_VIA = "issue-import";
+export const ISSUE_IMPORT_VERIFIED = "github-import";
 /** The snapshot an outside event's card gives its task, or null when the card didn't come from one (a person's, a poll's). */
 export function snapshotOf(source) {
     if (source === null || typeof source.verified !== "string")
@@ -49,6 +53,8 @@ export function linkWords(url, max = 72) {
 }
 /** How a snapshot's delivery was proved, in words: "signed by Sentry", or "unsigned". */
 export function provedWords(snapshot) {
+    if (snapshot.verified === ISSUE_IMPORT_VERIFIED)
+        return "read from GitHub";
     const by = snapshot.verified === "github" ? "GitHub" : snapshot.verified === "linear" ? "Linear" : SENDER_WORDS[snapshot.verified] ?? snapshot.verified;
     return snapshot.verified === "none" ? "unsigned" : `signed by ${by}`;
 }
@@ -107,3 +113,11 @@ export function originNote(origin) {
     const where = origin.source.host === null ? "" : ` · ${origin.source.host}`;
     return `Started by an outside event: ${origin.source.label} (${origin.source.proved})${where}. The agent reads what it sent as data, not instructions.`;
 }
+/** Whether this task, or the task it revises, came from a GitHub import. Unreadable provenance on a row counts: it was
+ * written by the import road, and nothing here widens on a doubt. */
+export function issueImported(store, taskId) {
+    if (store.filedViaOf(taskId) === ISSUE_IMPORT_FILED_VIA)
+        return true;
+    const kept = store.taskSourceOf(taskId);
+    return kept !== null && (kept.sourceJson.includes(`"verified":"${ISSUE_IMPORT_VERIFIED}"`) || readSnapshot(kept.sourceJson) === null);
+}

package/dist/task-status.d.ts

@@ -14,6 +14,8 @@ export declare const CHECKS_LABEL = "Project checks";
 export declare const PR_CI_LABEL = "PR CI";
 /** The one verb for opening a saved result, on every surface. */
 export declare 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 declare const MACHINE_CHECK_RUNNING = "Running the check on the prepared version.";
 export type DetailKey = "checks" | "pull-request" | "requirements" | "evidence";
 /** The row's small icon: the only coloured part of a detail. `failed` is red
  * and only ever appears under the Failed headline; `note` is amber. */
@@ -132,6 +134,9 @@ export type TaskStatusFacts = {
     reason?: string | null;
     /** A research report rather than a code change. */
     report?: boolean;
+    /** The machine runs this task's check on a prepared candidate; no agent runs (machine-check.ts). Building then says
+     * the check is running, never "an agent". */
+    machine?: boolean;
     checks?: ChecksFact | null;
     pullRequest?: PullRequestFact | null;
     /** `unverified`: the report is refuted, so no requirement counts as met however it was marked. `missed`: the ones it
@@ -184,6 +189,8 @@ export declare function statusOf(facts: TaskStatusFacts): TaskStatus;
 /** The name most surfaces already import. */
 export declare const taskStatusOf: typeof statusOf;
 export declare function plainReasonOf(stage: TaskStage, code: string, detail: string | null | undefined): string | 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 declare function stageOfCode(code: string, options?: {
     needsPerson?: boolean;
     planning?: boolean;
@@ -191,6 +198,7 @@ export declare function stageOfCode(code: string, options?: {
 }): {
     stage: TaskStage;
     need?: TaskStatusFacts["need"];
+    wait?: WaitKey;
 };
 /** The pull request as the task page's follower reports it, or the bare publication row. */
 export declare function pullRequestFactOf(publication: {
@@ -309,6 +317,7 @@ export declare function stageOfDispatch(d: {
 }): {
     stage: TaskStage;
     need?: TaskStatusFacts["need"];
+    wait?: WaitKey;
 };
 /** The demo runs no checks: a Checks row that would offer to run one (or open one that never ran) says so instead. */
 export declare const DEMO_CHECKS = "Can't run in the demo";