toolroll 0.9.102 → 0.9.104

package/dist/server/tasks.js

@@ -30,6 +30,7 @@ import { codingShippingHtml } from '../coding-shipping-ui.js';
 import { codingWorkspaceHtml, codingWorkspaceScript } from '../coding-ui.js';
 import { CodingActionError } from '../coding-workspace.js';
 import { checkResponse, CONSOLE_FORMS, readForm } from "../contracts/console-api.js";
+import { LOCAL_TASK_CHANGED, requestPlanAsLocalOwner, retryAsLocalOwner, retryPinsOf } from "../local-owner-acts.js";
 import { hasForbiddenControls, validateNote } from "../decision.js";
 import { builderReadyFor, diagnoseTaskDispatch, firstRunBuilderRepo } from "../dispatch.js";
 import { firstTaskSuggestions, withBuilderStep } from "../first-run.js";
@@ -276,7 +277,7 @@ export function createTasksHandlers(runtime) {
             const latest = latestFinishedAttempt(runs);
             // Retry from here only when the task failed, nothing holds it, and this is its latest attempt or a result it delivered.
             const retry = failedTask?.state === "failed" && (latest?.id === selected.run.id || delivered) && csrf !== "" && who.role === "approver" && store.currentLiveLease(attemptRun.taskRef, now) === null
-                ? { action: `${taskHref(selected.taskId)}/requeue` } : null;
+                ? { action: `${taskHref(selected.taskId)}/requeue`, pins: retryPinsOf(store, selected.taskId) } : null;
             // Accept anyway: the same acceptance this task's latest result takes, never for an older one or one already accepted.
             const family = delivered ? familyOf(selected.taskId) : null;
             const acceptAnyway = delivered && csrf !== "" && who.role === "approver" && family?.current.id === selected.taskId && family.problem === null &&
@@ -1895,11 +1896,22 @@ export function createTasksHandlers(runtime) {
                     return refuse(response, who, 403, "steering is a browser session's act");
                 if (note !== "" && !validateNote(note).ok)
                     return taskScreen(response, who, taskId, "that note will not store, so nothing was retried", 400);
-                const requeued = store.requeueTask(taskId, who.name, now);
-                if (!requeued.ok) {
-                    return taskScreen(response, who, taskId, `not requeued: ${requeued.reason}`, 409);
+                // Local-owner slice 3: the laptop's local owner retries its own approved build on its own road, bound to the
+                // build and plan the page read. The same request again files no second note.
+                let replayed = false;
+                if (who.via === "cookie" && who.authority === "local-owner") {
+                    const retried = localOwnerRetry(store, taskId, body.get("run"), body.get("digest"), now);
+                    if (!retried.ok)
+                        return taskScreen(response, who, taskId, retried.message, retried.status);
+                    replayed = retried.replayed;
+                }
+                else {
+                    const requeued = store.requeueTask(taskId, who.name, now);
+                    if (!requeued.ok) {
+                        return taskScreen(response, who, taskId, `not requeued: ${requeued.reason}`, 409);
+                    }
                 }
-                if (note !== "") {
+                if (note !== "" && !replayed) {
                     const filed = store.fileSteerNote(taskId, verifiedAuthor(who.name), note, now);
                     if (!filed.ok)
                         return taskScreen(response, who, taskId, "Retried. The note wasn't saved; add it under Steering.", 409);
@@ -1954,6 +1966,11 @@ export function createTasksHandlers(runtime) {
                 return redirect(response, taskHref(filed.id));
             }
             case "plan": {
+                // Local-owner slice 2: the laptop's local owner asks on its own road, bound to the planning source it read.
+                if (who.via === "cookie" && who.authority === "local-owner") {
+                    const asked = localOwnerPlan(store, taskId, readForm(posted, CONSOLE_FORMS.taskPlan).get("source"), now);
+                    return asked.ok ? redirect(response, taskHref(taskId)) : taskScreen(response, who, taskId, asked.message, asked.status);
+                }
                 // The operator's explicit ask, refused transactionally when the
                 // moment has passed — approved scope, live claim, or a plan
                 // already under way (Codex planning review's requestPlan guard).
@@ -1961,7 +1978,8 @@ export function createTasksHandlers(runtime) {
                 if (!asked.ok) {
                     return taskScreen(response, who, taskId, `not planned: ${asked.reason}`, 409);
                 }
-                if (who.via === "cookie")
+                // Only a full session: a local owner never pre-authorizes (plan-auto.ts refuses it there too).
+                if (who.via === "cookie" && who.authority === "full")
                     authorizePlanUnderMode(store, taskId, who.name, now);
                 return redirect(response, taskHref(taskId));
             }
@@ -3339,3 +3357,25 @@ export function createReleaseSheetHandlers(runtime) {
 export function answerApprovalInPlace(response, outcome, words, status) {
     respond(response, status, "application/json; charset=utf-8", JSON.stringify({ outcome, words }));
 }
+/**
+ * The task page's plan button for the laptop's local owner (local-owner slice 2): bound to the planning source the page
+ * read (the form's hidden `source`), never the task as it is now; the writer (local-owner-acts.ts) proves the rest in one
+ * transaction. No mode pre-authorization and no pins: the full session's road above is never reached from here.
+ */
+export function localOwnerPlan(store, taskId, source, now) {
+    if (typeof source !== "string" || !/^[a-f0-9]{64}$/.test(source))
+        return { ok: false, status: 409, message: LOCAL_TASK_CHANGED };
+    const done = requestPlanAsLocalOwner(store, taskId, source, now);
+    return done.ok ? { ok: true } : { ok: false, status: done.reason === "local-owner" || done.reason === "refused" ? 403 : 409, message: done.message };
+}
+/**
+ * Retry for the laptop's local owner (local-owner slice 3): bound to the build and the approved plan the page read (the
+ * form's hidden `run` and `digest`), never the task as it is now; the writer proves the rest in one transaction. A form
+ * that carries neither (an older page) is refused, never bound to whatever is current.
+ */
+export function localOwnerRetry(store, taskId, run, digest, now) {
+    if (typeof run !== "string" || !/^[1-9][0-9]{0,14}$/.test(run) || typeof digest !== "string" || !/^[a-f0-9]{32}$/.test(digest))
+        return { ok: false, status: 409, message: LOCAL_TASK_CHANGED };
+    const done = retryAsLocalOwner(store, taskId, { run: Number(run), digest }, now);
+    return done.ok ? { ok: true, replayed: done.replayed } : { ok: false, status: done.reason === "local-owner" || done.reason === "refused" || done.reason === "limit" ? 403 : 409, message: done.message };
+}

package/dist/surface.js

@@ -222,7 +222,11 @@ const GUIDE_ROWS = [
             { name: 'token-env', takesValue: true, meaning: 'scoped coordinator credential environment variable' },
             { name: 'token-file', takesValue: true, meaning: 'scoped coordinator credential file; defaults to selected project reference' },
             ...(action === 'complete' ? [{ name: 'digest', takesValue: true, meaning: 'exact receipt from assignment show; required for JSON or scoped agents' },
-                { name: 'pull-request', takesValue: false, meaning: "also open the result's pull request from that commit, as the console's Complete does; an approver's sign-in (--as/--token), never a scoped credential; refuses with pull-requests-off and the setup command" }]
+                { name: 'pull-request', takesValue: false, meaning: "also open the result's pull request from that commit, as the console's Complete does; an approver's sign-in (--as/--token), never a scoped credential; refuses with pull-requests-off and the setup command" },
+                // Local-owner slice 1: the terminal UI's Accept, for the laptop's local owner only (no password).
+                { name: 'run', takesValue: true, meaning: "the terminal's local owner: the exact build of the result read; required there with --digest" },
+                { name: 'checked', takesValue: false, meaning: "the terminal's local owner: you checked the result yourself; required when it owes your own check" },
+                { name: 'reason', takesValue: true, meaning: "the terminal's local owner: why you accept a result whose requirement isn't shown; required for an exception" }]
                 : [{ name: 'feedback', takesValue: true, meaning: 'specific requested change' }, { name: 'run', takesValue: true, meaning: 'exact result run; defaults to current result' }, { name: 'source', takesValue: true, meaning: 'exact scope digest; defaults to current terms' }, { name: 'key', takesValue: true, meaning: '32 hexadecimal characters for exact replay; defaults to a stable feedback identity' }]),
         ],
     })),
@@ -297,7 +301,9 @@ const GUIDE_ROWS = [
         positionals: [{ name: "id", required: true, meaning: "the task" }],
         flags: [jsonFlag, dbFlag, keyFlag,
             { name: "provider", takesValue: true, meaning: "pin which provider plans THIS task (plan phase only)" },
-            { name: "model", takesValue: true, meaning: "the pinned plan model, riding --provider" }],
+            { name: "model", takesValue: true, meaning: "the pinned plan model, riding --provider" },
+            // Local-owner slice 2: the terminal UI's plan request, for the laptop's local owner only (no password, no pins).
+            { name: "digest", takesValue: true, meaning: "the terminal's local owner: the exact planning source read; required there, and --provider/--model are refused" }],
         notableReasons: ["unknown-task"] },
     { invocation: "task hold", synopsis: "park a task with a reason", audience: "agent", agentMayInvoke: true, mutation: "keyed",
         positionals: [{ name: "id", required: true, meaning: "the task" }],
@@ -592,6 +598,10 @@ const LOCAL_ALLOW = {
     "task continue": "resume-run",
     "task unhold": "resume-run",
     "task complete": "complete-task",
+    // Local-owner slice 2: its own road (operate.ts localPlanCommand); the writer checks this exact act.
+    "task plan": "request-plan",
+    // Local-owner slice 3: its own road (operate.ts localRetryCommand); the writer checks this exact act.
+    "task requeue": "retry-build",
     "task revise": "request-revision",
     "task archive": "archive-task",
     "task restore": "archive-task",

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

@@ -28,3 +28,21 @@ export declare function runTaskMergeCommand(positional: readonly string[], flags
 }): Promise<number>;
 /** The lines `task show` prints for a task's pull request. */
 export declare function pullRequestLines(view: PullRequestView | null): string[];
+/** Toolroll's own stop proof for every finished build of a task's family whose stop it can prove here. Best effort: a
+ * failure leaves the completion's own refusal to say what is still unproven. */
+export declare function proveTaskBuildsStopped(store: Store, task: string, clock: () => Date): Promise<void>;
+/**
+ * `task complete` for the laptop's local owner (local-owner slice 1; the terminal UI's Accept): the exact result the
+ * screen read, accepted and completed with no password. Its own road: it never reaches a password check (so it never
+ * moves the sign-in guard), and is chosen only inside the local owner's chain; there, an owner who no longer stands is
+ * refused, never handed to another road. Everything is pinned: `--run` and `--digest` are required (never defaulted
+ * to the current result), `--checked` is the person's explicit yes to a check they made, and `--reason` (trimmed, not
+ * empty) is an exception's why. No pull request: that needs a password.
+ */
+export declare function runLocalCompletion(positional: readonly string[], flags: Map<string, string | true>, context: {
+    store: Store;
+    evidenceRoot: string;
+    json: boolean;
+    write: (line: string) => void;
+    now: Date;
+}): Promise<number>;

package/dist/task-outcome-cli.js

@@ -1,6 +1,8 @@
 /** Everyday task verbs over the existing completion and revision boundaries. */
 import { createHash } from 'node:crypto';
-import { assignmentOf, checkAssignmentAsOperator } from './assignment.js';
+import { assignmentOf, checkAssignmentAsOperator, completeAsLocalOwner } from './assignment.js';
+import { currentLocalOwner } from './local-owner.js';
+import { validateNote } from './decision.js';
 import { assignmentForCoordinator, coordinatorToken } from './assignment-adapters.js';
 import { authenticateCoordinator } from './coordinator.js';
 import { reproveApprover } from './principal.js';
@@ -179,7 +181,7 @@ export function pullRequestLines(view) {
 }
 /** Toolroll's own stop proof for every finished build of a task's family whose stop it can prove here. Best effort: a
  * failure leaves the completion's own refusal to say what is still unproven. */
-async function proveTaskBuildsStopped(store, task, clock) {
+export async function proveTaskBuildsStopped(store, task, clock) {
     try {
         const family = store.taskFamilyOf(task, null, true);
         const refs = family === null ? [store.lookupRef(task)?.id].filter((one) => one !== undefined) : family.versions.map(version => version.refId);
@@ -191,3 +193,59 @@ async function proveTaskBuildsStopped(store, task, clock) {
     }
     catch { /* the completion below refuses with what is still unproven */ }
 }
+/**
+ * `task complete` for the laptop's local owner (local-owner slice 1; the terminal UI's Accept): the exact result the
+ * screen read, accepted and completed with no password. Its own road: it never reaches a password check (so it never
+ * moves the sign-in guard), and is chosen only inside the local owner's chain; there, an owner who no longer stands is
+ * refused, never handed to another road. Everything is pinned: `--run` and `--digest` are required (never defaulted
+ * to the current result), `--checked` is the person's explicit yes to a check they made, and `--reason` (trimmed, not
+ * empty) is an exception's why. No pull request: that needs a password.
+ */
+export async function runLocalCompletion(positional, flags, context) {
+    const command = 'task complete';
+    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;
+    };
+    const fail = (reason, message) => emit({ ok: false, reason, message });
+    const usage = 'Use task complete <task> --run <build> --digest <result> [--checked] [--reason "why"].';
+    const allowed = new Set(['json', 'db', 'run', 'digest', 'checked', 'reason', 'pull-request']);
+    for (const key of flags.keys())
+        if (!allowed.has(key))
+            return fail('usage', `--${key} is not a ${command} option.`);
+    if (flags.has('pull-request'))
+        return fail('local-owner', `Opening a pull request needs your password. ${context.store.accountOf(currentLocalOwner()?.account ?? '')?.passwordSet === true ? 'Sign in with your password to do this.' : 'Set a password first: run `toolroll password set`.'}`);
+    const task = positional[0];
+    if (positional.length !== 1 || !task || task.length > 64 || /[\x00-\x1f]/.test(task))
+        return fail('usage', usage);
+    const run = flags.get('run'), digest = flags.get('digest'), checked = flags.get('checked'), reason = flags.get('reason');
+    if (typeof run !== 'string' || !/^[1-9]\d{0,14}$/.test(run))
+        return fail('usage', `--run needs the exact build number of the result you read. ${usage}`);
+    if (typeof digest !== 'string' || !/^[a-f0-9]{64}$/.test(digest))
+        return fail('usage', `--digest needs the exact result you read. ${usage}`);
+    if (checked !== undefined && checked !== true)
+        return fail('usage', '--checked takes no value.');
+    let why = null;
+    if (reason !== undefined) {
+        // An exception's reason says something: trimmed here, at the command's edge, and never empty or only spaces.
+        if (typeof reason !== 'string' || reason.trim() === '')
+            return fail('usage', 'Say why you accept it anyway: --reason "<why>".');
+        const validated = validateNote(reason);
+        if (!validated.ok)
+            return fail('usage', `--reason: ${validated.problem}.`);
+        why = validated.note;
+    }
+    const { store, now, evidenceRoot } = context;
+    // Toolroll's own stop proof first, as every completion (a build it hasn't proven stopped is refused below).
+    await proveTaskBuildsStopped(store, task, () => now);
+    const done = completeAsLocalOwner(store, task, { runId: Number(run), receiptDigest: digest, checked: checked === true, reason: why }, now, evidenceRoot);
+    if (!done.ok)
+        return emit(done);
+    const { assignment } = done;
+    const receipt = assignment.receipt;
+    return emit({ ok: true, replayed: done.replayed, accepted: done.accepted, result: assignment }, [
+        `${assignment.rootId} · ${done.replayed ? 'Already accepted' : 'Accepted'}`,
+        `Result: ${receipt.taskId} · build #${receipt.runId} · ${receipt.head?.slice(0, 7) ?? 'no commit'}`,
+        ...(assignment.readiness?.checksOff ? [] : [receipt.checks.detail]),
+    ]);
+}

package/dist/tui-contract.d.ts

@@ -46,6 +46,16 @@ export type TuiTask = {
     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[];
+    /** `p` (local-owner slice 2): the planning source read now, which the request binds to; null when no plan can be asked. */
+    readonly planAsk?: {
+        readonly source: string;
+    } | null;
+    /** `r` (local-owner slice 3): the latest finished build and the approved plan read now, which a retry binds to; null
+     * when there is nothing to retry. */
+    readonly retry?: {
+        readonly runId: number;
+        readonly digest: string;
+    } | null;
 };
 /** The welcome's steps, as lines (welcome-facts.ts). */
 export type TuiSetup = {
@@ -85,12 +95,29 @@ export type TuiAct = {
     readonly kind: "revise";
     readonly id: string;
     readonly text: string;
-} | {
+}
+/** Accept: exactly the result the Accept screen read (its build and receipt, pinned when it opened), with the person's
+ * explicit yes to their own check, or an exception's reason, when the result owes one. */
+ | {
     readonly kind: "complete";
     readonly id: string;
-} | {
+    readonly runId: number;
+    readonly digest: string;
+    readonly checked: boolean;
+    readonly reason: string | null;
+}
+/** Retry: exactly the build and approved plan the screen read (the command refuses a task that changed meanwhile). */
+ | {
     readonly kind: "retry";
     readonly id: string;
+    readonly runId: number;
+    readonly digest: string;
+}
+/** Plan it: exactly the planning source the screen read (the command refuses a task that changed meanwhile). */
+ | {
+    readonly kind: "plan";
+    readonly id: string;
+    readonly source: string;
 } | {
     readonly kind: "answer";
     readonly decision: number;
@@ -105,7 +132,8 @@ export type TuiFastTerms = {
         readonly words: string;
     }[];
 };
-/** A write's answer: its words. `needsPassword`: refused because the local owner may not do it. */
+/** A write's answer: its words. `needsPassword`: refused because the local owner may not do it. `changed`: refused
+ * because what it named (a result) changed since the screen read it. */
 export type TuiActResult = {
     readonly ok: true;
     readonly message: string;
@@ -114,6 +142,34 @@ export type TuiActResult = {
     readonly ok: false;
     readonly message: string;
     readonly needsPassword: boolean;
+    readonly changed?: boolean;
+};
+/** A finished result as the Accept screen reads it once and pins: which build and receipt, and what it shows. */
+export type TuiResult = {
+    /** The task Accept names, and the exact result: what the answer submits, never read again before it is sent. */
+    readonly id: string;
+    readonly runId: number;
+    readonly digest: string;
+    readonly title: string;
+    /** Ready to accept now; when not, why not (a failed check, a build not yet proven stopped), and no Accept is offered. */
+    readonly ready: boolean;
+    readonly blockers: readonly string[];
+    /** The agent's own summary of what it did (empty when it left none). */
+    readonly summary: readonly string[];
+    /** The files the result changed (the first ten), how many more, or null when they can't be read. */
+    readonly files: {
+        readonly names: readonly string[];
+        readonly more: number;
+    } | null;
+    /** Each requirement and how it is shown ("Met", "You check", "Not shown yet"…). */
+    readonly requirements: readonly {
+        readonly word: string;
+        readonly statement: string;
+    }[];
+    /** "Can I merge?": the actual check status, the same lines as `toolroll task ready`. */
+    readonly checks: readonly string[];
+    /** What accepting it needs from the person: their own check, a reason, or nothing more. */
+    readonly owed: "person-check" | "exception" | null;
 };
 /** The plane, as the screen sees it. */
 export interface TuiSource {
@@ -124,6 +180,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>;
+    /** The task's current finished result, read once for the Accept screen; null when it has none. */
+    result(id: string): Promise<TuiResult | null>;
     /** 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. */

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 };
+}