toolroll 0.9.103 → 0.9.104

package/dist/serve.js

@@ -20,8 +20,6 @@ import { html, htmlString, jsonScript, textHtml } from "./html.js";
 import { browserAssetsAvailable, browserWorkspaceDocument } from './browser-shell.js';
 import { accessKey, countsKey, indexKey, projectSummaryOf, RevisionCache, summaryKey } from './console-chrome.js';
 import { usageChipOf } from './limits-ui.js';
-/** Any header a proxy adds: a request carrying one is never "from this computer" (password freshness, one-time links). */
-const PROXY_HEADER = /^(forwarded|via|x-forwarded-.+|x-real-ip|x-client-ip|x-original-.+|x-cluster-client-ip|true-client-ip|cf-connecting-ip|fastly-client-ip|x-proxyuser-ip)$/i;
 /** How often the background checks look at what is due (docs/plans/get-side-effects.md), and how often this
  * computer's agent sign-ins are asked again. */
 const BACKGROUND_CHECKS_MS = 30_000;
@@ -137,7 +135,7 @@ import { canonicalProject, projectName, resolveCeiling, rowVisible } from "./pro
 import { noteSignInProbe, signInNotices } from "./provider-auth.js";
 import { createConnectionChecker } from "./provider-connection.js";
 import { ALL_CREDENTIAL_ENV } from "./provider.js";
-import { hstsFor, LOOPBACK_PEERS, plainHttpRefusal, transportOf } from "./public-access.js";
+import { hstsFor, LOOPBACK_PEERS, plainHttpRefusal, requestFromThisComputer, transportOf } from "./public-access.js";
 import { attachReadExecutor, defaultReadWorkers, ReadExecutor } from "./read-executor.js";
 import { cachedRelease, isNewer, runnerVersions, updateChecksOff } from "./releases.js";
 import { limitWords, FLUSH_MS as REQUEST_BUDGET_FLUSH_MS, RequestBudget, SOURCE_BUDGET_DEFAULTS, SourceAdmission } from "./request-budget.js";
@@ -158,7 +156,7 @@ import { createPeopleHandlers } from './server/people-tokens.js';
 import { createSettingsHandlers } from './server/settings.js';
 import { readPurpose, requestContext } from "./server/request-context.js";
 import { inPlaceRoute, prefetchRoute } from "./server/in-place.js";
-import { asLocalOwner, localModeOn, localOwnerRefusal, localOwnerStandsNow } from "./local-owner.js";
+import { LOCAL_OWNER_ELSEWHERE, asLocalOwner, localModeOn, localOwnerRefusal, localOwnerStandsNow } from "./local-owner.js";
 import { defaultAgentOf, fillDefaultRouting } from "./model-choices.js";
 import { chromeScript, DEMO_BANNER, DEMO_BANNER_SHORT, focusDocument, KBD_HELP, pinnedTheme, QUEUE_VIEW, refuse, screen, SENSITIVE_INPUT, shell, sidebarScript } from "./server/chrome.js";
 import { BODY_CAP, form, loginHref, passwordSetNext, refusalNext, matchTaskPath, page, projectChatHref, redactedPath, redirect, respond, safeReturn, SHUTDOWN_WAIT_MS, taskChatHref } from "./server/http.js";
@@ -379,16 +377,9 @@ export function createDecisionServer(options) {
     /** v147: this console start's key epoch (easy-start C2): the browser-key wave binds each session's mutation key to it. */
     const keyEpoch = options.keyEpoch ?? randomBytes(16).toString("hex");
     /** This computer, and nothing in front of it: a loopback peer that names a loopback address, with no sign of a proxy —
-     * any forwarding header at all (Forwarded, X-Forwarded-*, X-Real-IP, Via, …) disqualifies the request. */
-    const fromThisComputer = (request) => {
-        const peer = request.socket.remoteAddress ?? "";
-        if (!LOOPBACK_PEERS.has(peer))
-            return false;
-        for (const name of Object.keys(request.headers))
-            if (PROXY_HEADER.test(name))
-                return false;
-        return /^(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}$/.test(request.headers.host ?? "");
-    };
+     * any forwarding header at all (Forwarded, X-Forwarded-*, X-Real-IP, Via, …) disqualifies the request. The one reading
+     * (public-access.ts), which guards.ts also applies to every request a local owner's session makes. */
+    const fromThisComputer = (request) => requestFromThisComputer(request);
     /**
      * Cockpit B2: a request's password-freshness facts — the one place they are made (scope.ts honours them). Every
      * reader looks at the session as it is at the moment of the act, never a snapshot taken before the body arrived:
@@ -911,6 +902,14 @@ export function createDecisionServer(options) {
         const refusedToken = {};
         const who = identify(request, touch, edgeRoute?.domain === 'live', refusedToken);
         timeline.mark("signed in");
+        // Local-owner slice 0: a local owner's session presented from anywhere but this computer (another address, a
+        // proxy, a tailnet or LAN name) signs in no one and changes nothing. Sign-in pages still answer (a password signs
+        // in there); everything else is refused in plain words.
+        if (refusedToken.elsewhere === true && edgeRoute?.domain !== 'people') {
+            request.resume();
+            response.setHeader("x-toolroll-refused", "local-owner-elsewhere");
+            return respond(response, 403, "text/plain; charset=utf-8", LOCAL_OWNER_ELSEWHERE);
+        }
         if (refusedToken.principal !== undefined) {
             if (refuseBudget(requestBudget.admit(refusedToken.principal.tokenId, "api")))
                 return;

package/dist/server/guards.d.ts

@@ -58,6 +58,7 @@ export declare function createSharedGuards(runtime: GuardsRuntime): {
     projectRequestAllowed: (route: RouteDeclaration, source: RouteDeclaration['project'], url: URL, who: Who, request: IncomingMessage, response: ServerResponse, body: URLSearchParams | null) => boolean;
     identify: (request: IncomingMessage, touch?: boolean, limited?: boolean, refusedToken?: {
         principal?: Principal;
+        elsewhere?: boolean;
     }) => Who | null;
     lookupSession: (candidate: string, touch?: boolean) => Session | null;
     restricted: () => boolean;

package/dist/server/guards.js

@@ -15,6 +15,7 @@ import { requestContext } from "./request-context.js";
 import { refuse } from "./chrome.js";
 import { matchTaskPath } from "./http.js";
 import { PersistentSessions, SESSION_COOKIE, sessionWithinLifetime } from "./session.js";
+import { requestFromThisComputer } from "../public-access.js";
 export function createSharedGuards(runtime) {
     const syncIdentities = syncProjectIdentities();
     // v99: wrong passwords. One address guessing across names runs out of tries here; each name
@@ -333,7 +334,16 @@ export function createSharedGuards(runtime) {
         const match = new RegExp(`(?:^|;\\s*)${SESSION_COOKIE}=([0-9a-f]{64})`).exec(cookies);
         if (match === null)
             return null;
-        const session = lookupSession(match[1], touch);
+        // Local-owner slice 0: a local owner's session works only from this computer — a loopback peer naming a loopback
+        // Host, with no forwarding header — on every request, not only when it was made. From anywhere else it signs in
+        // no one, and is not touched (refusedToken.elsewhere says why, for the refusal).
+        const found = lookupSession(match[1], false);
+        if (found !== null && found.authority !== "full" && !requestFromThisComputer(request)) {
+            if (refusedToken !== undefined)
+                refusedToken.elsewhere = true;
+            return null;
+        }
+        const session = touch && found !== null ? lookupSession(match[1], true) : found;
         return session === null ? null : { name: session.name, via: "cookie", session, role: session.role, authority: session.authority };
     }
     /**

package/dist/server/remote.d.ts

@@ -12,6 +12,7 @@ import { type Who } from "./session.js";
 export interface RemoteRuntime {
     identify: (request: IncomingMessage, touch?: boolean, limited?: boolean, refusedToken?: {
         principal?: Principal;
+        elsewhere?: boolean;
     }) => Who | null;
     store: Store;
     admitPasswordSource: (request: IncomingMessage) => Admission;

package/dist/server/render-results.d.ts

@@ -247,6 +247,10 @@ export type ReviewCockpitView = {
         retry: {
             action: string;
             note: string;
+            pins?: {
+                run: number;
+                digest: string;
+            } | null;
         } | null;
         acceptAnyway?: {
             action: string;

package/dist/server/render-tasks.d.ts

@@ -513,6 +513,15 @@ export declare function taskBodyParts(data: {
         needsTwo: boolean;
     } | null;
     plan: "requested" | "drafted" | null;
+    /** Local-owner slice 2: the planning source this page read (local-owner-acts.ts planSourceOf), which the plan button
+     * posts so a local owner's request binds to exactly it. Null when it can't be read. */
+    planSource?: string | null;
+    /** Local-owner slice 3: the build and approved plan this page read (local-owner-acts.ts retryPinsOf), which Retry posts
+     * so a local owner's retry binds to exactly them. */
+    retryPins?: {
+        run: number;
+        digest: string;
+    } | null;
     planDocument: string | null;
     planAuto?: boolean;
     /** Hash of the verified plan artifact currently shown. */

package/dist/server/render-tasks.js

@@ -2096,9 +2096,9 @@ export function taskBodyParts(data) {
     // A failed task's status card carries Retry itself (the same requeue); here it would be a second ink act.
     const cardRetries = task.state === "failed" && data.assignment != null && data.csrf !== "";
     const primaryAct = stopControlsActive || cardRetries ? null : stalled && !data.claimed
-        ? { html: act("requeue", "Retry, keeping the branch and workspace"), why: "Clears the repeated failures and queues the task again. The branch and workspace are kept.", whyClass: "retry" }
+        ? { html: act("requeue", "Retry, keeping the branch and workspace", data.retryPins == null ? {} : { run: String(data.retryPins.run), digest: data.retryPins.digest }), why: "Clears the repeated failures and queues the task again. The branch and workspace are kept.", whyClass: "retry" }
         : canPlan
-            ? { html: act("plan", "plan first"), why: "plan first sends an agent to read the project, ask you questions and propose a plan. Nothing builds until you approve it.", whyClass: "plan" }
+            ? { html: act("plan", "plan first", data.planSource == null ? {} : { source: data.planSource }), why: "plan first sends an agent to read the project, ask you questions and propose a plan. Nothing builds until you approve it.", whyClass: "plan" }
             : data.plan === "requested"
                 ? null
                 : task.state === "queued" && !data.claimed && (data.position?.position ?? 1) > 1
@@ -2464,9 +2464,9 @@ export function taskBodyParts(data) {
     };
     // Build again, in place, names its form after the card's own act.
     const rebuild = data.csrf !== "" && data.assignment?.primaryAction?.code === "retry-task" && data.assignment.need != null && "key" in data.assignment.need && data.assignment.need.key === "rebuild"
-        ? { action: `${taskHref(data.assignment.rootId)}/requeue` } : null;
+        ? { action: `${taskHref(data.assignment.rootId)}/requeue`, pins: data.retryPins ?? null } : null;
     const retry = failedCard && task.state === "failed" && !data.claimed && !stopControlsActive && data.csrf !== ""
-        ? { action: `${taskHref(task.id)}/requeue`, ...(data.failure == null ? {} : { note: retryNoteOf(data.failure.suggestion) }) } : null;
+        ? { action: `${taskHref(task.id)}/requeue`, pins: data.retryPins ?? null, ...(data.failure == null ? {} : { note: retryNoteOf(data.failure.suggestion) }) } : null;
     // Run checks happens in place: a status row's Run checks posts here and comes back; with nothing to run, the row offers nothing.
     const runChecks = data.runChecks ?? null;
     // A row's link to a result in Chat opens that result's own page instead: Chat would only lead back here.

package/dist/server/route-table.js

@@ -79,6 +79,10 @@ const LOCAL_POSTS = Object.freeze({
     "task.act.resume-arm": "resume-run",
     "task.act.resume": "resume-run",
     "task.act.complete": "complete-task",
+    // Local-owner slice 2: the plan button, on its own road (tasks.ts localOwnerPlan; the writer checks this exact act).
+    "task.act.plan": "request-plan",
+    // Local-owner slice 3: Retry, on its own road (tasks.ts localOwnerRetry; the writer checks this exact act).
+    "task.act.requeue": "retry-build",
     "run.act.revise": "request-revision",
     "run.act.note": "request-revision",
     "run.act.comment": "request-revision",

package/dist/server/runtime.d.ts

@@ -92,6 +92,7 @@ export interface ServerRuntime {
     taskRooms: TaskRooms;
     identify: (request: IncomingMessage, touch?: boolean, limited?: boolean, refusedToken?: {
         principal?: Principal;
+        elsewhere?: boolean;
     }) => Who | null;
     liveCeiling: () => {
         repos: string[];

package/dist/server/task-views.js

@@ -25,6 +25,7 @@ import { assignmentOf } from '../assignment.js';
 import { knowledgeContextHtml } from "../knowledge-ui.js";
 import { failedAttemptSentence, failingCheckSuggestion, GENERAL_SUGGESTION, isInternalErrorReason, latestFinishedAttempt, missedRequirementLine, missedRequirementSuggestion, NO_REASON_RECORDED, stopSuggestionOf } from '../needs-you.js';
 import { planAutoPending } from "../plan-auto.js";
+import { planSourceOf, retryPinsOf } from "../local-owner-acts.js";
 import { readKnowledgeSnapshot } from "../project-knowledge.js";
 import { learningView } from "../project-learning.js";
 import { readSkillsSnapshot, skillTestResult } from "../project-skills.js";
@@ -384,6 +385,8 @@ export function createTaskViews(runtime) {
             })(),
             plan: ref?.plan ?? null,
             planAuto: planAutoPending(runtime.store, taskId, now),
+            planSource: planSourceOf(runtime.store, taskId),
+            retryPins: retryPinsOf(runtime.store, taskId),
             planDocument: planView?.document ?? null,
             planSha: planView?.sha256 ?? null,
             planContract: ref === null || planView === null ? null : planContractViewOf(ref.id, scope),

package/dist/server/tasks.d.ts

@@ -81,3 +81,28 @@ export type ApprovalOutcome = "approved" | "vote" | "approved-not-rebuilt" | "re
 /** The answer to an approval asked in place: its named outcome and the same words the page would show, as JSON. Written
  * only after the approve route's proofs, by the caller that knows the outcome. */
 export declare function answerApprovalInPlace(response: ServerResponse, outcome: ApprovalOutcome, words: string, status: number): void;
+/**
+ * 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 declare function localOwnerPlan(store: Store, taskId: string, source: string | null | undefined, now: Date): {
+    ok: true;
+} | {
+    ok: false;
+    status: number;
+    message: string;
+};
+/**
+ * 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 declare function localOwnerRetry(store: Store, taskId: string, run: string | null | undefined, digest: string | null | undefined, now: Date): {
+    ok: true;
+    replayed: boolean;
+} | {
+    ok: false;
+    status: number;
+    message: string;
+};

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. */