toolroll 0.9.103 → 0.9.104

package/dist/browser-workspace.d.ts

@@ -392,8 +392,13 @@ export type BrowserTaskView = {
         run: number;
     } | null;
     /** Build again, in place, when the status asks for it (a result built to an earlier plan). */
+    /** `pins`: the build and approved plan the page read, which a local owner's Retry binds to (local-owner slice 3). */
     rebuild?: {
         action: string;
+        pins?: {
+            run: number;
+            digest: string;
+        } | null;
     } | null;
     /** What a failed task missed, in one line (the requirement it missed, the failing check's error line, or the stop
      * reason), the evidence line behind it, one suggestion of what to change, and where to see it (its build's result
@@ -402,6 +407,10 @@ export type BrowserTaskView = {
     retry?: {
         action: string;
         note?: string;
+        pins?: {
+            run: number;
+            digest: string;
+        } | null;
     } | null;
     /** Run checks in place, on a status row that offers it: posts and comes back to this page. */
     runChecks?: BrowserRunChecks | null;
@@ -867,6 +876,10 @@ export type BrowserResultView = {
             retry: {
                 action: string;
                 note: string;
+                pins?: {
+                    run: number;
+                    digest: string;
+                } | null;
             } | null;
             /** A failed task's delivered result, accepted only in outline with a reason (the task's accept-proof). */
             acceptAnyway?: {

package/dist/contracts/console-api.d.ts

@@ -202,7 +202,8 @@ export declare const CONSOLE_FORMS: {
     readonly taskRepairDependency: FormContract<"blocker" | "operation" | "replacement">;
     readonly taskNext: FormContract<"undo">;
     readonly taskReopen: FormContract<"token">;
-    readonly taskRequeue: FormContract<"note" | "return">;
+    readonly taskRequeue: FormContract<"digest" | "note" | "return" | "run">;
+    readonly taskPlan: FormContract<"source">;
     readonly taskFollowUp: FormContract<"index">;
     readonly taskPlanEdit: FormContract<"plan-document" | "saw-plan">;
     readonly taskRevision: FormContract<"revision-id" | "token">;
@@ -218,7 +219,7 @@ export declare const CONSOLE_FORMS: {
 };
 export type ConsoleFormName = keyof typeof CONSOLE_FORMS;
 /** The console POSTs whose handlers read no field (sign-out not even the shared guard): their contract is the empty form. */
-export declare const BODILESS_POSTS: readonly ["POST /settings/models/<unknown action>", "POST /r/<run>/draft-repair", "POST /ledger/checkpoint", "POST /settings/backups/now", "POST /mode/revoke", "POST /settings/telegram/retry", "POST /providers/<provider>/resume", "POST /logout", "POST /t/<task>/unhold", "POST /t/<task>/stop-carrying", "POST /t/<task>/plan", "POST /t/<task>/retry-review", "POST /settings/updates/check", "POST /settings/storage/check", "POST /projects/github", "POST /code/<session>/ship/preview"];
+export declare const BODILESS_POSTS: readonly ["POST /settings/models/<unknown action>", "POST /r/<run>/draft-repair", "POST /ledger/checkpoint", "POST /settings/backups/now", "POST /mode/revoke", "POST /settings/telegram/retry", "POST /providers/<provider>/resume", "POST /logout", "POST /t/<task>/unhold", "POST /t/<task>/stop-carrying", "POST /t/<task>/retry-review", "POST /settings/updates/check", "POST /settings/storage/check", "POST /projects/github", "POST /code/<session>/ship/preview"];
 /** The field names a console form's handler may read. */
 export type FormFieldOf<N extends ConsoleFormName> = (typeof CONSOLE_FORMS)[N] extends FormContract<infer K> ? K : never;
 /** `GET /ledger?format=json`: the chain's state, a page of entries (newest first) and the cursor for the next. */

package/dist/contracts/console-api.js

@@ -220,7 +220,10 @@ export const CONSOLE_FORMS = {
     taskRepairDependency: formContract("POST /t/<task>/repair-dependency", ["blocker", "operation", "replacement"]),
     taskNext: formContract("POST /t/<task>/next", ["undo"]),
     taskReopen: formContract("POST /t/<task>/reopen", ["token"]),
-    taskRequeue: formContract("POST /t/<task>/requeue", ["note", "return"]),
+    // Local-owner slice 3: the build and approved plan the page read (`run`, `digest`), read only for the laptop's local owner.
+    taskRequeue: formContract("POST /t/<task>/requeue", ["note", "return", "run", "digest"]),
+    // Local-owner slice 2: the planning source the page read (planner-source.ts), read only for the laptop's local owner.
+    taskPlan: formContract("POST /t/<task>/plan", ["source"]),
     taskFollowUp: formContract("POST /t/<task>/follow-up", ["index"]),
     taskPlanEdit: formContract("POST /t/<task>/plan-edit", ["saw-plan", "plan-document"]),
     taskRevision: formContract("POST /t/<task>/accept-revision|reject-revision", ["revision-id", "token"]),
@@ -248,7 +251,6 @@ export const BODILESS_POSTS = [
     "POST /logout",
     "POST /t/<task>/unhold",
     "POST /t/<task>/stop-carrying",
-    "POST /t/<task>/plan",
     "POST /t/<task>/retry-review",
     // Check now and its kin (docs/plans/get-side-effects.md): the form token only, no fields read.
     "POST /settings/updates/check",

package/dist/desktop-update.d.ts

@@ -97,6 +97,7 @@ export declare function sqliteLock(file: string, busyTimeoutMs?: number): Databa
 export declare function lockHeld(file: string): boolean;
 export declare const installationLock: (j: UpdateJournal) => DatabaseSync | null;
 export declare function desktopUpdateStatus(stateDir: string): {
+    version?: never;
     active: boolean;
     phase: string;
     detail: string;
@@ -110,7 +111,6 @@ export declare function desktopUpdateStatus(stateDir: string): {
     wasRunning?: never;
     backupPath?: never;
     updateId?: never;
-    version?: never;
     buildId?: never;
     workDir?: never;
 } | {

package/dist/keymap.d.ts

@@ -15,7 +15,7 @@ export type WebShortcut = {
     kind: "help";
 };
 /** What a key does in the terminal UI, or null with the reason it has none there (a named gap). */
-export type TuiShortcut = "new" | "ink" | "send-back" | "retry" | "list" | "help";
+export type TuiShortcut = "new" | "ink" | "send-back" | "retry" | "plan" | "list" | "help";
 export type Shortcut = {
     keys: string;
     says: string;
@@ -30,6 +30,8 @@ export declare const INK_ACT_SELECTORS: readonly ["[data-ink-approve]", '[data-i
 export declare const SEND_BACK_SELECTORS: readonly ['[data-act="request-changes"]', '[data-act="revise"]', 'a.result-feedback-link[href="#request-changes"]'];
 /** Retry: the result's Retry, or the failed box's own Retry form. */
 export declare const RETRY_SELECTORS: readonly ['[data-act="retry"]', 'form[data-retry] button[type="submit"]', 'form[data-rebuild] button[type="submit"]'];
+/** Plan it: the task page's own plan button (local-owner slice 2). */
+export declare const PLAN_SELECTORS: readonly ['form[action$="/plan"] button[type="submit"]'];
 export declare const SHORTCUTS: readonly Shortcut[];
 /** The keys typed, as the help list shows them: "g h" reads "g then h". */
 export declare const keyWords: (keys: string) => string;

package/dist/keymap.js

@@ -8,11 +8,14 @@ export const INK_ACT_SELECTORS = ["[data-ink-approve]", '[data-ink-act="accept"]
 export const SEND_BACK_SELECTORS = ['[data-act="request-changes"]', '[data-act="revise"]', 'a.result-feedback-link[href="#request-changes"]'];
 /** Retry: the result's Retry, or the failed box's own Retry form. */
 export const RETRY_SELECTORS = ['[data-act="retry"]', 'form[data-retry] button[type="submit"]', 'form[data-rebuild] button[type="submit"]'];
+/** Plan it: the task page's own plan button (local-owner slice 2). */
+export const PLAN_SELECTORS = ['form[action$="/plan"] button[type="submit"]'];
 export const SHORTCUTS = [
     { keys: "n", says: "new task", web: { kind: "go", href: "/tasks/new" }, tui: "new" },
     { keys: "a", says: "Approve or Accept (presses the button on the page)", web: { kind: "press", selectors: INK_ACT_SELECTORS }, tui: "ink" },
     { keys: "b", says: "Send back (opens its note)", web: { kind: "press", selectors: SEND_BACK_SELECTORS }, tui: "send-back" },
     { keys: "r", says: "Retry (presses the button on the page)", web: { kind: "press", selectors: RETRY_SELECTORS }, tui: "retry" },
+    { keys: "p", says: "Ask for a plan (presses the button on the page)", web: { kind: "press", selectors: PLAN_SELECTORS }, tui: "plan" },
     { keys: "/", says: "search", web: { kind: "search" }, tui: { none: "The terminal has no search; press w to open the console." } },
     { keys: "g h", says: "go Home", web: { kind: "go", href: "/" }, tui: "list" },
     { keys: "g t", says: "go to Tasks", web: { kind: "go", href: "/tasks" }, tui: "list" },

package/dist/local-owner-acts.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The laptop's local owner's password-free acts beyond approving and accepting (docs/plans/local-owner-acts.md, slices
+ * 2 and 3): asking for a plan, and retrying its own approved build. One writer per act, shared by the terminal (the
+ * CLI rows `task plan` and `task requeue`, run as the local owner) and the browser (the task page's plan button and
+ * Retry, posted by a local owner's session). Each writer proves everything inside its own transaction: the local owner
+ * acting now as exactly this act (localActNow, never `proveAccountNow` saying yes to any act), the owner's current reach
+ * into the project, the one work rule (scope.ts localWorkEligible), the exact thing the screen read, and the act's own
+ * guards. Neither is ever chosen for anyone else: a password session, an API token, the lead, a chat bot or a machine
+ * keeps the road it had.
+ */
+import type { Store } from "./store.js";
+/** What a refused local act says, and a reason the surfaces branch on. */
+export type LocalActRefusal = {
+    ok: false;
+    reason: string;
+    message: string;
+};
+/** The ledger act a local owner's plan request is kept under: the planning source it was bound to, and its transport. */
+export declare const LOCAL_PLAN_ACTION = "task plan (local owner)";
+/** What a stale screen hears: the task is not what it read. */
+export declare const LOCAL_TASK_CHANGED = "This task changed. Look at it again.";
+/**
+ * The planning source a screen binds a plan request to (planner-source.ts): the digest over everything the planner
+ * would be given, the filed scope when there is one and the title alone when there is none. Null when it can't be read.
+ */
+export declare function planSourceOf(store: Store, taskId: string): string | null;
+/**
+ * Ask for a plan, as the laptop's local owner, with no password (local-owner slice 2). In one transaction: the owner
+ * acting now as exactly `request-plan`; its current reach into the task's project; the task not put away; the one work
+ * rule for planning (no release, protected, two-person, escalated, coordinator, imported or unsandboxed work); no plan
+ * pins saved on the task (a local request never plans with an agent someone chose; it refuses rather than ignoring or
+ * clearing them, so what plans is exactly what the screen's terms say); and the planning source still the one the
+ * screen read (`source`). A request already made, with that source unchanged, answers "already" and writes nothing.
+ * Otherwise any unchanged-plan pre-authorization saved on the task is withdrawn (with its audit row), so the plan this
+ * asks for can only be approved by a person's own yes; then requestPlan's own guards (queued, not planned, not
+ * approved, no live claim); then the request's ledger row. It approves nothing, pins nothing and pre-authorizes nothing.
+ */
+export declare function requestPlanAsLocalOwner(store: Store, taskId: string, source: string, now: Date): {
+    ok: true;
+    replayed: boolean;
+} | LocalActRefusal;
+/** The ledger act a local owner's retry is kept under: the build it retried, the exact seal it spent, and its transport. */
+export declare const LOCAL_RETRY_ACTION = "task requeue (local owner)";
+/** Local retries per task and exact seal: then a note (Send back) or a password. */
+export declare const LOCAL_RETRY_LIMIT = 3;
+/** The fourth local retry of one approval. */
+export declare const LOCAL_RETRY_SPENT = "You've retried this 3 times. Send it back with a note, or sign in with your password to retry again.";
+/** What a retry hears while Toolroll can't yet prove the last build stopped. */
+export declare const LOCAL_RETRY_STOPPING = "The last build is still stopping. Try again in a moment.";
+/**
+ * What a Retry binds to (local-owner slice 3): the task's latest finished build and its approved scope digest, when the
+ * task failed or finished and its scope is approved as it stands. What a screen offers only; the writer decides.
+ */
+export declare function retryPinsOf(store: Store, taskId: string): {
+    run: number;
+    digest: string;
+} | null;
+/**
+ * Retry the local owner's own approved build after it stopped (a console restart, a model error), with no password
+ * (local-owner slice 3). One transaction, in this order:
+ * - the owner acting now as exactly `retry-build`, and its current reach into the task's project;
+ * - the task's current approval is this owner's own person yes on the exact seal (personApprovalOf: the ceremony or a
+ *   chat tap, a person's proof for those bytes — never a mode, grant, schedule, automatic or carried seal, the lead, or
+ *   another person), still standing for dispatch, and on work the owner could approve again now (localWorkEligible);
+ * - bound to what the screen read: `digest` is the approved scope digest, and `run` the latest finished build;
+ * - the same request again (this owner's retry of `run` under this seal) answers "already" and writes nothing while
+ *   that build is still the latest one;
+ * - its own stop proof: no unfinished run of the task, no run after `run`, Toolroll's durable stop facts settled for
+ *   every run (an expired claim alone proves nothing), no final result (accepted or published) in any task state, and a
+ *   failed task or a finished one whose result wasn't accepted (requeueEligibility re-reads the claim and archive);
+ * - at most three local retries of this task under this exact seal (a fresh approval, even of the same bytes, is a new
+ *   seal), then the words that lead to a note or a password;
+ * - then the requeue (incidents resolved, strikes cleared, as the console's Retry) and its ledger row.
+ * Nothing about the scope, route, model, chain, budget or permissions is written.
+ */
+export declare function retryAsLocalOwner(store: Store, taskId: string, pins: {
+    run: number;
+    digest: string;
+}, now: Date): {
+    ok: true;
+    replayed: boolean;
+    retries: number;
+} | LocalActRefusal;

package/dist/local-owner-acts.js

@@ -0,0 +1,221 @@
+import { refArchived, requeueEligibility } from "./store.js";
+import { LOCAL_OWNER_LAPSED, localActNow } from "./local-owner.js";
+import { approverStanding, localWorkEligible, personApprovalOf } from "./scope.js";
+import { plannerContractOf, plannerSourceDigest } from "./planner-source.js";
+import { scopeApprovedForDispatch } from "./dispatch.js";
+/** The ledger act a local owner's plan request is kept under: the planning source it was bound to, and its transport. */
+export const LOCAL_PLAN_ACTION = "task plan (local owner)";
+/** What a stale screen hears: the task is not what it read. */
+export const LOCAL_TASK_CHANGED = "This task changed. Look at it again.";
+/**
+ * The planning source a screen binds a plan request to (planner-source.ts): the digest over everything the planner
+ * would be given, the filed scope when there is one and the title alone when there is none. Null when it can't be read.
+ */
+export function planSourceOf(store, taskId) {
+    const contract = plannerContractOf(store, taskId);
+    return contract.ok ? plannerSourceDigest(contract.contract) : null;
+}
+/**
+ * Ask for a plan, as the laptop's local owner, with no password (local-owner slice 2). In one transaction: the owner
+ * acting now as exactly `request-plan`; its current reach into the task's project; the task not put away; the one work
+ * rule for planning (no release, protected, two-person, escalated, coordinator, imported or unsandboxed work); no plan
+ * pins saved on the task (a local request never plans with an agent someone chose; it refuses rather than ignoring or
+ * clearing them, so what plans is exactly what the screen's terms say); and the planning source still the one the
+ * screen read (`source`). A request already made, with that source unchanged, answers "already" and writes nothing.
+ * Otherwise any unchanged-plan pre-authorization saved on the task is withdrawn (with its audit row), so the plan this
+ * asks for can only be approved by a person's own yes; then requestPlan's own guards (queued, not planned, not
+ * approved, no live claim); then the request's ledger row. It approves nothing, pins nothing and pre-authorizes nothing.
+ */
+export function requestPlanAsLocalOwner(store, taskId, source, now) {
+    try {
+        return store.transact(() => {
+            const local = localActNow(store, "request-plan");
+            if (local === null)
+                return { ok: false, reason: "local-owner", message: LOCAL_OWNER_LAPSED };
+            const ref = store.lookupRef(taskId);
+            if (ref === null || store.getTask(taskId) === null)
+                return { ok: false, reason: "not-found", message: "That task is unavailable in your projects." };
+            if (!approverStanding(store, local.account, ref.repo).ok)
+                return { ok: false, reason: "not-found", message: "That task is unavailable in your projects." };
+            if (refArchived(store, ref.id))
+                return { ok: false, reason: "archived", message: "This task is put away. Restore it first." };
+            const eligible = localWorkEligible(store, local.account, taskId, { act: "plan" });
+            if (!eligible.ok)
+                return { ok: false, reason: "refused", message: eligible.message };
+            if (ref.planProvider !== null || ref.planModel !== null) {
+                return { ok: false, reason: "refused", message: "This task names its own planning agent, so planning it needs your password." };
+            }
+            if (planSourceOf(store, taskId) !== source)
+                return { ok: false, reason: "stale", message: LOCAL_TASK_CHANGED };
+            // An unchanged-plan pre-authorization on the task (a mode or a flow's grant armed it on this or an earlier request)
+            // never stands behind the local owner's "you'll approve it before anything is built": withdrawn here, in the same
+            // transaction and before the "already asked" answer below, and said in the ledger.
+            const armed = store.handle.prepare("SELECT signed_by, basis FROM plan_authorization WHERE task_id = ?").get(taskId);
+            if (armed !== undefined) {
+                store.handle.prepare("DELETE FROM plan_authorization WHERE task_id = ?").run(taskId);
+                store.recordAction({ at: now.toISOString(), actor: `operator:${local.account}`, repo: ref.repo, taskId, runId: null, source: "request",
+                    action: "unchanged plan pre-authorization withdrawn", outcome: "withdrawn",
+                    detail: JSON.stringify({ v: 1, signedBy: String(armed["signed_by"]), basis: String(armed["basis"]), why: "the local owner asked for the plan" }) });
+            }
+            // Asked already (by anyone), with nothing about the task changed: the same answer, and nothing else written.
+            if (ref.plan === "requested" || ref.plan === "drafted")
+                return { ok: true, replayed: true };
+            const asked = store.requestPlan(ref.id, now);
+            if (!asked.ok)
+                throw new Undone({ ok: false, reason: "refused", message: `This task can't be planned now: ${asked.reason}.` });
+            store.recordAction({ at: now.toISOString(), actor: `operator:${local.account}`, repo: ref.repo, taskId, runId: null, action: LOCAL_PLAN_ACTION,
+                outcome: "requested", source: "request", detail: JSON.stringify({ v: 1, source, via: local.transport }) });
+            return { ok: true, replayed: false };
+        });
+    }
+    catch (error) {
+        if (error instanceof Undone)
+            return error.result;
+        // Store.transact's own re-check found the bound owner no longer standing: the same refusal, said, never a crash.
+        if (error instanceof Error && error.message === LOCAL_OWNER_LAPSED)
+            return { ok: false, reason: "local-owner", message: LOCAL_OWNER_LAPSED };
+        throw error;
+    }
+}
+// ---- Retry the owner's own approved build (slice 3) ---------------------------------------------------------------------
+/** The ledger act a local owner's retry is kept under: the build it retried, the exact seal it spent, and its transport. */
+export const LOCAL_RETRY_ACTION = "task requeue (local owner)";
+/** Local retries per task and exact seal: then a note (Send back) or a password. */
+export const LOCAL_RETRY_LIMIT = 3;
+/** The fourth local retry of one approval. */
+export const LOCAL_RETRY_SPENT = `You've retried this ${LOCAL_RETRY_LIMIT} times. Send it back with a note, or sign in with your password to retry again.`;
+/** What a retry hears while Toolroll can't yet prove the last build stopped. */
+export const LOCAL_RETRY_STOPPING = "The last build is still stopping. Try again in a moment.";
+const sameSeal = (a, b) => {
+    const one = a;
+    return one !== null && typeof one === "object" && one.by === b.by && one.at === b.at && one.digest === b.digest;
+};
+/**
+ * What a Retry binds to (local-owner slice 3): the task's latest finished build and its approved scope digest, when the
+ * task failed or finished and its scope is approved as it stands. What a screen offers only; the writer decides.
+ */
+export function retryPinsOf(store, taskId) {
+    const ref = store.lookupRef(taskId);
+    const scope = store.getScope(taskId);
+    const state = store.getTask(taskId)?.state;
+    if (ref === null || scope === null || scope.approvedAt === null || scope.approvedDigest !== scope.digest || (state !== "failed" && state !== "done"))
+        return null;
+    const last = store.lastBuilderRun(ref.id);
+    return last === null ? null : { run: last.id, digest: scope.digest };
+}
+/** This owner's earlier retries of this task under exactly this seal: the builds they retried. */
+function localRetriesOf(store, taskId, account, seal) {
+    const rows = store.handle.prepare("SELECT run_id, detail FROM action_ledger WHERE action = ? AND task_id = ? AND actor = ? ORDER BY id")
+        .all(LOCAL_RETRY_ACTION, taskId, `operator:${account}`);
+    const runs = [];
+    for (const row of rows) {
+        let detail;
+        try {
+            detail = JSON.parse(String(row["detail"] ?? ""));
+        }
+        catch {
+            continue;
+        }
+        const bound = detail;
+        if (bound.v === 1 && sameSeal(bound.seal, seal))
+            runs.push(Number(row["run_id"]));
+    }
+    return runs;
+}
+/**
+ * Retry the local owner's own approved build after it stopped (a console restart, a model error), with no password
+ * (local-owner slice 3). One transaction, in this order:
+ * - the owner acting now as exactly `retry-build`, and its current reach into the task's project;
+ * - the task's current approval is this owner's own person yes on the exact seal (personApprovalOf: the ceremony or a
+ *   chat tap, a person's proof for those bytes — never a mode, grant, schedule, automatic or carried seal, the lead, or
+ *   another person), still standing for dispatch, and on work the owner could approve again now (localWorkEligible);
+ * - bound to what the screen read: `digest` is the approved scope digest, and `run` the latest finished build;
+ * - the same request again (this owner's retry of `run` under this seal) answers "already" and writes nothing while
+ *   that build is still the latest one;
+ * - its own stop proof: no unfinished run of the task, no run after `run`, Toolroll's durable stop facts settled for
+ *   every run (an expired claim alone proves nothing), no final result (accepted or published) in any task state, and a
+ *   failed task or a finished one whose result wasn't accepted (requeueEligibility re-reads the claim and archive);
+ * - at most three local retries of this task under this exact seal (a fresh approval, even of the same bytes, is a new
+ *   seal), then the words that lead to a note or a password;
+ * - then the requeue (incidents resolved, strikes cleared, as the console's Retry) and its ledger row.
+ * Nothing about the scope, route, model, chain, budget or permissions is written.
+ */
+export function retryAsLocalOwner(store, taskId, pins, now) {
+    try {
+        return store.transact(() => {
+            const local = localActNow(store, "retry-build");
+            if (local === null)
+                return { ok: false, reason: "local-owner", message: LOCAL_OWNER_LAPSED };
+            const ref = store.lookupRef(taskId);
+            if (ref === null || store.getTask(taskId) === null || !approverStanding(store, local.account, ref.repo).ok) {
+                return { ok: false, reason: "not-found", message: "That task is unavailable in your projects." };
+            }
+            const person = personApprovalOf(store, taskId);
+            if (!person.ok || person.by !== local.account) {
+                return { ok: false, reason: "refused", message: "Only a build of your own approval can be retried without a password. Sign in with your password to retry it." };
+            }
+            const scope = store.getScope(taskId);
+            const seal = { by: scope.approvedBy, at: scope.approvedAt, digest: scope.approvedDigest };
+            if (scope.digest !== pins.digest)
+                return { ok: false, reason: "stale", message: LOCAL_TASK_CHANGED };
+            if (!scopeApprovedForDispatch(store, ref.id, now)) {
+                return { ok: false, reason: "refused", message: "This approval no longer stands. Approve the plan again, or sign in with your password." };
+            }
+            const eligible = localWorkEligible(store, local.account, taskId, { act: "retry" });
+            if (!eligible.ok)
+                return { ok: false, reason: "refused", message: eligible.message };
+            const latest = store.lastBuilderRun(ref.id);
+            const retried = localRetriesOf(store, taskId, local.account, seal);
+            // The same request again: recognised from its own ledger row while that retry is still waiting or building, with
+            // the owner and approval proved above.
+            const state = store.getTask(taskId).state;
+            if (retried.includes(pins.run) && latest?.id === pins.run && (state === "queued" || state === "running"))
+                return { ok: true, replayed: true, retries: retried.length };
+            if (store.handle.prepare("SELECT 1 AS hit FROM run WHERE task_ref = ? AND finished_at IS NULL LIMIT 1").get(ref.id) !== undefined) {
+                return { ok: false, reason: "stopping", message: LOCAL_RETRY_STOPPING };
+            }
+            if (latest === null || latest.id !== pins.run || store.handle.prepare("SELECT 1 AS hit FROM run WHERE task_ref = ? AND id > ? LIMIT 1").get(ref.id, pins.run) !== undefined) {
+                return { ok: false, reason: "stale", message: LOCAL_TASK_CHANGED };
+            }
+            for (const run of store.runsFor(ref.id)) {
+                if (store.stopQuiescenceFact(run.id) !== null)
+                    return { ok: false, reason: "stopping", message: LOCAL_RETRY_STOPPING };
+            }
+            if (store.finalResultReason(pins.run) !== null) {
+                return { ok: false, reason: "final", message: "This result was accepted or published, so it isn't built again. Send it back with a note instead." };
+            }
+            const eligibility = requeueEligibility(store, taskId, now);
+            if (!eligibility.ok) {
+                return eligibility.reason === "archived" ? { ok: false, reason: "archived", message: "This task is put away. Restore it first." }
+                    : eligibility.reason === "claimed" ? { ok: false, reason: "stopping", message: LOCAL_RETRY_STOPPING }
+                        : { ok: false, reason: "refused", message: "This task has nothing to retry." };
+            }
+            if (eligibility.state !== "failed" && !(eligibility.state === "done" && eligibility.rejectedRun === pins.run)) {
+                return { ok: false, reason: "refused", message: "This task has nothing to retry." };
+            }
+            if (retried.length >= LOCAL_RETRY_LIMIT)
+                return { ok: false, reason: "limit", message: LOCAL_RETRY_SPENT };
+            const requeued = store.requeueTask(taskId, local.account, now);
+            if (!requeued.ok)
+                throw new Undone({ ok: false, reason: "refused", message: "This task has nothing to retry." });
+            store.recordAction({ at: now.toISOString(), actor: `operator:${local.account}`, repo: ref.repo, taskId, runId: pins.run, action: LOCAL_RETRY_ACTION,
+                outcome: "requeued", source: "request", detail: JSON.stringify({ v: 1, seal, via: local.transport }) });
+            return { ok: true, replayed: false, retries: retried.length + 1 };
+        });
+    }
+    catch (error) {
+        if (error instanceof Undone)
+            return error.result;
+        if (error instanceof Error && error.message === LOCAL_OWNER_LAPSED)
+            return { ok: false, reason: "local-owner", message: LOCAL_OWNER_LAPSED };
+        throw error;
+    }
+}
+/** A refusal found after a write began: thrown so the transaction rolls back, then answered. */
+class Undone extends Error {
+    result;
+    constructor(result) {
+        super(result.message);
+        this.result = result;
+    }
+}

package/dist/local-owner.d.ts

@@ -10,7 +10,7 @@ export declare function authorityOf(value: unknown): Authority | null;
  * The acts a local owner may do (plan C1). Ids only: each surface (a route row, a chat action, a CLI command) names
  * the act it is, and an act not in this list is refused to a local owner.
  */
-export declare const LOCAL_OWNER_ACTS: readonly ["file-task", "lead-send", "approve-plan", "build-now", "answer-question", "stop-run", "pause-run", "resume-run", "complete-task", "request-revision", "archive-task", "add-project", "choose-default-agent", "mark-seen", "watch-agent", "read", "routing-turn-off", "dismiss-suggestion", "trial-stop", "code-map-switch", "memory-review"];
+export declare const LOCAL_OWNER_ACTS: readonly ["file-task", "lead-send", "approve-plan", "build-now", "answer-question", "stop-run", "pause-run", "resume-run", "complete-task", "request-revision", "archive-task", "add-project", "choose-default-agent", "mark-seen", "watch-agent", "read", "routing-turn-off", "dismiss-suggestion", "trial-stop", "code-map-switch", "memory-review", "request-plan", "retry-build"];
 export type LocalOwnerAct = (typeof LOCAL_OWNER_ACTS)[number];
 /** Whether a runtime string names an act a local owner may do. */
 export declare function localOwnerAct(value: unknown): value is LocalOwnerAct;
@@ -122,3 +122,14 @@ export declare function localOwnerStandsNow(store: Pick<Store, "handle" | "accou
 export declare const LOCAL_OWNER_LAPSED = "This local sign-in no longer stands. Run `toolroll open` to sign in again.";
 /** What widening a launch's confinement hears while local mode is on (plan C5). */
 export declare const LOCAL_MODE_CONFINES = "Turn off local mode first.";
+/** What a local owner's browser session hears from anywhere but this computer (another address, a proxy, a tailnet or
+ * LAN name): it works only on the computer running Toolroll (local-owner slice 0). */
+export declare const LOCAL_OWNER_ELSEWHERE = "This sign-in works only on the computer running Toolroll. To use Toolroll from here, set a password on that computer (run `toolroll password set`) and sign in with it.";
+/**
+ * The local owner acting now as exactly `act` (local-owner slice 1, `localActNow`), or null: the one in flight (its
+ * terminal command, or its browser request not yet answered), still standing (re-read here, so call it inside the
+ * write's own transaction), with exactly this act. A lead's token or a remote API run in the chain is never the local
+ * owner, so it is null there too. Every password-free writer that needs one act calls this; none relies on
+ * `proveAccountNow` saying yes to any act.
+ */
+export declare function localActNow(store: Pick<Store, "handle" | "accountOf" | "webSession">, act: LocalOwnerAct): LocalPrincipal | null;

package/dist/local-owner.js

@@ -7,6 +7,8 @@
  * Types and pure helpers only: enforcement (route marks, the chat confirm gate, the prover's order) reads these.
  */
 import { AsyncLocalStorage } from "node:async_hooks";
+import { currentActor } from "./actor.js";
+import { activeRemote } from "./remote-run.js";
 export const AUTHORITIES = Object.freeze(["full", "local-owner"]);
 /** A runtime string as an authority; anything else is null (never "full" by default). */
 export function authorityOf(value) {
@@ -47,6 +49,12 @@ export const LOCAL_OWNER_ACTS = Object.freeze([
     // Learning loops (D3): deciding a lesson note or a clean-up of project memory. The writers (memory-pass.ts decideProposal,
     // memory-tidy.ts) check this exact act; instruction proposals stay with full authority.
     "memory-review",
+    // Local-owner slice 2 (docs/plans/local-owner-acts.md §1): ask for a plan. It approves nothing, pins no agent and is
+    // never pre-authorized under a mode; the writer (local-owner-acts.ts requestPlanAsLocalOwner) checks this exact act.
+    "request-plan",
+    // Local-owner slice 3 (§2): retry the owner's own approved build after it stopped. Only the owner's own person yes,
+    // on work it could approve again now, three times per seal; the writer (local-owner-acts.ts retryAsLocalOwner) checks it.
+    "retry-build",
 ]);
 const ACT_SET = new Set(LOCAL_OWNER_ACTS);
 /** Whether a runtime string names an act a local owner may do. */
@@ -239,3 +247,21 @@ export function localOwnerStandsNow(store, principal) {
 export const LOCAL_OWNER_LAPSED = "This local sign-in no longer stands. Run `toolroll open` to sign in again.";
 /** What widening a launch's confinement hears while local mode is on (plan C5). */
 export const LOCAL_MODE_CONFINES = "Turn off local mode first.";
+/** What a local owner's browser session hears from anywhere but this computer (another address, a proxy, a tailnet or
+ * LAN name): it works only on the computer running Toolroll (local-owner slice 0). */
+export const LOCAL_OWNER_ELSEWHERE = "This sign-in works only on the computer running Toolroll. To use Toolroll from here, set a password on that computer (run `toolroll password set`) and sign in with it.";
+/**
+ * The local owner acting now as exactly `act` (local-owner slice 1, `localActNow`), or null: the one in flight (its
+ * terminal command, or its browser request not yet answered), still standing (re-read here, so call it inside the
+ * write's own transaction), with exactly this act. A lead's token or a remote API run in the chain is never the local
+ * owner, so it is null there too. Every password-free writer that needs one act calls this; none relies on
+ * `proveAccountNow` saying yes to any act.
+ */
+export function localActNow(store, act) {
+    if (activeRemote() !== null || currentActor()?.lead === true)
+        return null;
+    const local = currentLocalOwner();
+    if (local === null || local.act !== act || !localOwnerInFlight(local) || !localOwnerStandsNow(store, local))
+        return null;
+    return local;
+}

package/dist/operate-remote-arguments.js

@@ -25,7 +25,8 @@ export const REMOTE_ARGUMENTS = new Map([
     ['task list', args('', 'state view limit cursor')],
     ['task show', args('id:task')],
     ['task wait', args('id:task', 'timeout')],
-    ['task complete', args('task:task', 'digest', { run: 'run', 'pull-request': 'refused' })],
+    // --checked and --reason are the terminal's local owner's own (a person's check is never an API token's): refused.
+    ['task complete', args('task:task', 'digest', { run: 'run', 'pull-request': 'refused', checked: 'refused', reason: 'refused' })],
     ['task revise', args('task:task', 'feedback source key', { run: 'run' })],
     ['task state', args('id:task state', 'key reason', { 'replaced-by': 'task' })],
     ['task block', args('id:task', 'key', { on: 'task' })],
@@ -38,7 +39,8 @@ export const REMOTE_ARGUMENTS = new Map([
     ['task continue', args('id:task', 'request key', { run: 'run' })],
     ['task assign', args('id:task', 'key runner anyone')],
     ['task scope', args('id:task', 'key goal not touches budget-usd risk acceptance candidate model provider repair-model')],
-    ['task plan', args('id:task', 'key provider model')],
+    // --digest is the terminal's local owner's own (its plan request binds to the source it read): refused remotely.
+    ['task plan', args('id:task', 'key provider model', { digest: 'refused' })],
     ['task hold', args('id:task', 'key reason until')],
     ['task unhold', args('id:task', 'key')],
     ['task require', args('id:task', 'key cap require')],