toolroll 0.9.103 → 0.9.104

package/dist/tui-source.js

@@ -8,7 +8,9 @@
  * nothing ever prompts on the terminal the screen owns.
  */
 import { dirname, join } from "node:path";
-import { assignmentOf } from "./assignment.js";
+import { assignmentOf, owedAcceptance } from "./assignment.js";
+import { familyChangedFiles } from "./result-completion.js";
+import { checkBackingOf, receiptChecksOf, requirementWordOf } from "./task-status.js";
 import { checklistLines, mergeChecklistOf } from "./merge-checklist.js";
 import { runAsLocalOwner } from "./local-owner.js";
 import { snapshotLiveRuns } from "./peek-cli.js";
@@ -21,14 +23,18 @@ import { memoryWaiting } from "./lesson-notes.js";
 import { homeGroupOf } from "./home-groups.js";
 import { terminalText } from "./terminal-text.js";
 import { welcomeHere, welcomeLines } from "./welcome-facts.js";
+import { planSourceOf, retryPinsOf } from "./local-owner-acts.js";
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 const words = (value, fallback = "") => typeof value === "string" ? value : fallback;
 /** Text for the screen: whatever wrote it (an agent, a person, a project's name), escapes and controls never reach the
  * terminal (terminal-text.ts). Every displayed string below goes through here; ids and digests are only acted on. */
 const shown = (value, fallback = "") => terminalText(words(value, fallback));
-/** What a refused write says, and whether it is a local-owner refusal (the screen then leads to a password). */
+/** What a refused write says, and whether it is a local-owner refusal (the screen then leads to a password), or a
+ * result that changed since the screen read it. */
 function refusalOf(envelope) {
     const message = shown(envelope.message, "That was refused.");
+    if (envelope.reason === "stale")
+        return { ok: false, message, needsPassword: false, changed: true };
     return { ok: false, message, needsPassword: envelope.reason === "refused" || envelope.reason === "machine-proof" || envelope.reason === "person-required" || /password/i.test(message) };
 }
 const routeLines = (store, id) => { const words = routeChangeOf(store, id); return words === null ? [] : [words]; };
@@ -116,6 +122,8 @@ export function createTuiSource(options) {
             return {
                 id, title: shown(task["title"], id), status: shown(status["label"], words(work["state"])), detail: shown(status["detail"]),
                 plan, liveRunId: typeof work["liveRunId"] === "number" ? work["liveRunId"] : null, hasResult, decisions, ready,
+                planAsk: store === null ? null : planAskOf(store, id),
+                retry: (() => { const pins = store === null ? null : retryPinsOf(store, id); return pins === null ? null : { runId: pins.run, digest: pins.digest }; })(),
             };
         },
         live(id) {
@@ -141,9 +149,14 @@ export function createTuiSource(options) {
             let argv;
             let done;
             switch (act.kind) {
+                // A task too big to build straight away: filed, then its plan asked for at once (local-owner slice 2), below.
                 case "new":
                     argv = ["task", "add", act.text, ...(act.repo === null ? [] : ["--repo", act.repo])];
-                    done = "Filed. Its plan will be ready for you to approve.";
+                    done = "Filed.";
+                    break;
+                case "plan":
+                    argv = ["task", "plan", act.id, "--digest", act.source];
+                    done = "Asked for a plan. You'll approve it before anything is built.";
                     break;
                 case "build":
                     argv = ["task", "new", "--build", act.preview, "--digest", act.digest];
@@ -165,33 +178,49 @@ export function createTuiSource(options) {
                     argv = ["decide", String(act.decision), "--choose", act.option];
                     done = "Answered.";
                     break;
-                // Retry is today's requeue (the console's Retry), the same command and the same refusals.
+                // Retry: exactly the build and approved plan the screen read (local-owner slice 3), never the current ones.
                 case "retry":
-                    argv = ["task", "retry", act.id];
-                    done = "Queued again. A builder starts it next.";
+                    argv = ["task", "requeue", act.id, "--run", String(act.runId), "--digest", act.digest];
+                    done = "Retrying. A builder starts it next.";
                     break;
-                case "complete": {
-                    const store = read();
-                    let digest;
-                    try {
-                        digest = store === null ? undefined : assignmentOf(store, act.id, clock(), { principal: "operator", repos: null })?.receipt?.digest;
-                    }
-                    catch {
-                        digest = undefined;
-                    }
-                    if (digest === undefined)
-                        return { ok: false, message: "This task has no finished result to accept.", needsPassword: false };
-                    argv = ["task", "complete", act.id, "--digest", digest];
-                    done = "Accepted.";
+                // Accept: exactly the result the Accept screen read, never the one current when this is sent (the command
+                // refuses a result that changed meanwhile). The person's yes to their own check, or a reason, only when given.
+                case "complete":
+                    argv = ["task", "complete", act.id, "--run", String(act.runId), "--digest", act.digest, ...(act.checked ? ["--checked"] : []), ...(act.reason === null ? [] : ["--reason", act.reason])];
+                    done = "Accepted. The task is done.";
                     break;
-                }
             }
             const answer = await command(argv);
             if (answer.ok !== true)
                 return refusalOf(answer);
+            if (act.kind === "complete" && answer["replayed"] === true)
+                return { ok: true, message: "Already accepted. The task is done." };
+            if (act.kind === "plan" && answer["replayed"] === true)
+                return { ok: true, message: "Already asked for a plan." };
+            if (act.kind === "retry" && answer["replayed"] === true)
+                return { ok: true, message: "Already retrying. A builder starts it next." };
             const filed = act.kind === "new" ? words(record(answer["task"])["id"], words(answer["id"])) : act.kind === "build" ? words(answer["task"]) : "";
+            // Filed in a project: ask for its plan now, bound to the task just filed (the screen promised a plan).
+            if (act.kind === "new" && filed !== "" && act.repo !== null) {
+                const store = read();
+                const ask = store === null ? null : planAskOf(store, filed);
+                const asked = ask === null ? null : await command(["task", "plan", filed, "--digest", ask.source]);
+                const message = asked?.ok === true ? "Filed. Planning: you'll approve the plan before anything is built." : `Filed. It wasn't sent for a plan: ${shown(asked?.message, "it can't be planned now.")}`;
+                return { ok: true, message, id: filed };
+            }
             return { ok: true, message: done, ...(filed === "" ? {} : { id: filed }) };
         },
+        async result(id) {
+            const store = read();
+            if (store === null)
+                return null;
+            try {
+                return resultOf(store, id, clock(), evidenceRoot);
+            }
+            catch {
+                return null;
+            }
+        },
         async fastTerms(text, repo) {
             if (repo === null)
                 return null;
@@ -242,3 +271,45 @@ function learningLine(store, repos, now) {
     const parts = [flaky === 0 ? "" : `${flaky} flaky test${flaky === 1 ? "" : "s"}: open the project's Flaky tests in the browser`, memory === 0 ? "" : `${memory} project memory suggestion${memory === 1 ? "" : "s"}: open Settings → Knowledge`].filter(Boolean);
     return parts.length === 0 ? null : parts.join(" · ");
 }
+/** The Accept screen's one read of a task's current result (local-owner slice 1): which build and receipt it pins, and
+ * what the result page would show about it — the agent's summary, the files changed, each requirement and how it is
+ * shown, the actual check status, and what accepting it needs from the person. Text from outside is cleaned here. */
+function resultOf(store, id, now, evidenceRoot) {
+    const assignment = assignmentOf(store, id, now, { principal: "operator", repos: null }, evidenceRoot);
+    const receipt = assignment?.receipt ?? null;
+    if (assignment === null || receipt === null)
+        return null;
+    const blockers = assignment.readiness?.blockers ?? [];
+    const owed = assignment.state === "ready-to-check" ? owedAcceptance(receipt, blockers) : null;
+    // An exception's own blocker is what its reason answers; any other one stands in the way of accepting.
+    const standing = blockers.filter(one => !(owed === "exception" && one.key === "criteria")).map(one => terminalText(one.message));
+    const notNow = assignment.state === "complete" ? "This result is already accepted." : assignment.state === "ready-to-check" ? null : terminalText(assignment.detail || "This result isn't ready to accept.");
+    const changed = familyChangedFiles(store, receipt.taskId, receipt.runId, evidenceRoot);
+    const backing = checkBackingOf(receiptChecksOf(receipt));
+    let checks = [];
+    try {
+        const list = mergeChecklistOf(store, id, now, { principal: "operator", repos: null }, evidenceRoot);
+        checks = list === null ? [] : checklistLines(list).map(line => terminalText(line));
+    }
+    catch {
+        checks = [];
+    }
+    return {
+        id, runId: receipt.runId, digest: receipt.digest, title: terminalText(assignment.title),
+        ready: notNow === null && standing.length === 0, blockers: notNow === null ? standing : [notNow],
+        summary: (receipt.agentReport ?? "").split("\n").map(line => terminalText(line).trimEnd()).filter(line => line.trim() !== "").slice(0, 8),
+        files: changed === null ? null : { names: changed.slice(0, 10).map(name => terminalText(name)), more: Math.max(0, changed.length - 10) },
+        requirements: (receipt.proof?.matrix ?? []).map(row => ({ word: requirementWordOf(row, receipt.proof?.verdict ?? null, backing), statement: terminalText(row.statement ?? row.id ?? "") })),
+        checks, owed,
+    };
+}
+/** Whether a plan can be asked for this task now, and the planning source a request binds to (local-owner slice 2): a
+ * queued task with no plan asked or drafted and no approved plan. What the screen offers only; the command decides. */
+function planAskOf(store, id) {
+    const ref = store.lookupRef(id);
+    const scope = store.getScope(id);
+    if (ref === null || ref.plan !== null || store.getTask(id)?.state !== "queued" || (scope !== null && scope.approvedAt !== null && scope.approvedDigest === scope.digest))
+        return null;
+    const source = planSourceOf(store, id);
+    return source === null ? null : { source };
+}