toolroll 0.9.102 → 0.9.104

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')],

package/dist/operate.js

@@ -89,7 +89,8 @@ import { runKnowledgeApply, runKnowledgeCommand } from "./knowledge-cli.js";
 import { FLOWS_VALUE_FLAGS, runFlowsCommand } from "./flows-cli.js";
 import { runAssignmentCommand } from "./assignment-adapters.js";
 import { applyProjectProfile, runProjectCommand } from "./project-cli.js";
-import { pullRequestLines, runTaskMergeCommand, runTaskOutcomeCommand } from "./task-outcome-cli.js";
+import { proveTaskBuildsStopped, pullRequestLines, runLocalCompletion, runTaskMergeCommand, runTaskOutcomeCommand } from "./task-outcome-cli.js";
+import { requestPlanAsLocalOwner, retryAsLocalOwner } from "./local-owner-acts.js";
 import { withTaskAlias } from "./task-aliases.js";
 import { checklistLines, mergeChecklistOf } from "./merge-checklist.js";
 import { taskReviewBrief, renderReviewBrief } from "./task-review-brief.js";
@@ -821,6 +822,8 @@ export const OPERATE_BOOLEAN_FLAGS = new Set([
     "saved",
     // task complete: also open the result's pull request.
     "pull-request",
+    // task complete as the terminal's local owner: the person says they checked the result themselves.
+    "checked",
     // storage clean --landed: work already in main.
     "landed",
     // up: the exact start-up details (containment) in the terminal too.
@@ -8864,6 +8867,10 @@ function taskAction(action, rest, flags, context) {
     switch (action) {
         case "complete":
         case "revise":
+            // Local-owner slice 1: the terminal's local owner accepts on its own road, which never checks a password; chosen
+            // only inside its chain, where an owner that no longer stands is refused there, never sent down the road below.
+            if (action === "complete" && currentLocalOwner() !== null)
+                return runLocalCompletion(rest, flags, context);
             return runTaskOutcomeCommand(action, rest, flags, { ...context, operator: async () => {
                     const acting = await askCredentials(flags, context);
                     if (acting === null)
@@ -8937,6 +8944,10 @@ function taskAction(action, rest, flags, context) {
         case "require":
             return requireTask(rest, flags, context);
         case "requeue":
+            // Local-owner slice 3: the terminal's local owner retries its own approved build on its own road (no password);
+            // chosen only inside its chain, where an owner that no longer stands is refused there.
+            if (currentLocalOwner() !== null)
+                return localRetryCommand(rest, flags, context);
             return requeueTask(rest, flags, context);
         case "regate":
             return regateTaskCommand(rest, flags, context);
@@ -8947,6 +8958,10 @@ function taskAction(action, rest, flags, context) {
         case "failing-first":
             return failingFirstCommand(rest, followThroughContext(context, flags));
         case "plan":
+            // Local-owner slice 2: the terminal's local owner asks for a plan on its own road (no password, no pins, no mode
+            // pre-authorization); chosen only inside its chain, where an owner that no longer stands is refused there.
+            if (currentLocalOwner() !== null)
+                return localPlanCommand(rest, flags, context);
             return planTaskCommand(rest, flags, context);
         case "review":
             return reviewTaskCommand(rest, flags, context);
@@ -14340,3 +14355,63 @@ function releaseToQueue(store, lease, now) {
         return result;
     });
 }
+// ---- Local owner, slice 2 (docs/plans/local-owner-acts.md §1): ask for a plan in the terminal. Kept last.
+/**
+ * `task plan <id> --digest <planning source>` for the laptop's local owner (the terminal UI's `p`, and `n` on a bigger
+ * task): its own road, which never reaches a password check. The digest is the planning source the screen read
+ * (local-owner-acts.ts planSourceOf), required and only compared. No plan pins (`--provider`, `--model`): choosing which
+ * agent plans needs a password. requestPlanAsLocalOwner proves the rest in one transaction.
+ */
+async function localPlanCommand(positional, flags, context) {
+    const { store, write, json, clock } = context;
+    const command = "task plan";
+    if (flags.has("provider") || flags.has("model")) {
+        const passwordSet = store.accountOf(currentLocalOwner()?.account ?? "")?.passwordSet === true;
+        return fail(write, json, command, "local-owner", `Choosing which agent plans needs your password. ${passwordSet ? "Sign in with your password to do this." : "Set a password first: run \`toolroll password set\`."}`, EXIT.refused);
+    }
+    for (const name of flags.keys())
+        if (!["json", "db", "digest"].includes(name))
+            return fail(write, json, command, "usage", `--${name} is not a ${command} option.`, EXIT.usage);
+    const id = positional[0], digest = flags.get("digest");
+    const usage = "Use task plan <task> --digest <the plan source you read>.";
+    if (positional.length !== 1 || !id || id.length > 64 || /[\x00-\x1f]/.test(id))
+        return fail(write, json, command, "usage", usage, EXIT.usage);
+    if (typeof digest !== "string" || !/^[a-f0-9]{64}$/.test(digest))
+        return fail(write, json, command, "usage", `--digest needs the exact task you read. ${usage}`, EXIT.usage);
+    const done = requestPlanAsLocalOwner(store, id, digest, clock());
+    if (!done.ok)
+        return fail(write, json, command, done.reason, done.message, EXIT.refused);
+    return succeed(write, json, command, { id, replayed: done.replayed, autoPlan: false }, () => [
+        done.replayed ? `${id} · Already asked for a plan.` : `${id} · Asked for a plan. You approve the plan before anything is built.`,
+    ]);
+}
+// ---- Local owner, slice 3 (docs/plans/local-owner-acts.md §2): retry its own approved build in the terminal. Kept last.
+/**
+ * `task requeue <id> --run <build> --digest <scope digest>` (and its alias `task retry`) for the laptop's local owner (the
+ * terminal UI's `r`): its own road, which never reaches a password check. Both pins are required and only compared:
+ * the failed build and the approved scope the screen read. Toolroll's own stop proof runs first, as every completion
+ * does; retryAsLocalOwner then proves everything again in one transaction.
+ */
+async function localRetryCommand(positional, flags, context) {
+    const { store, write, json, clock } = context;
+    const command = "task requeue";
+    for (const name of flags.keys())
+        if (!["json", "db", "run", "digest"].includes(name))
+            return fail(write, json, command, "usage", `--${name} is not a ${command} option.`, EXIT.usage);
+    const id = positional[0], run = flags.get("run"), digest = flags.get("digest");
+    const usage = "Use task requeue <task> --run <the build you read> --digest <its approved plan>.";
+    if (positional.length !== 1 || !id || id.length > 64 || /[\x00-\x1f]/.test(id))
+        return fail(write, json, command, "usage", usage, EXIT.usage);
+    if (typeof run !== "string" || !/^[1-9]\d{0,14}$/.test(run))
+        return fail(write, json, command, "usage", `--run needs the exact build you read. ${usage}`, EXIT.usage);
+    // A scope digest (scope.ts digestOf): 32 hexadecimal characters.
+    if (typeof digest !== "string" || !/^[a-f0-9]{32}$/.test(digest))
+        return fail(write, json, command, "usage", `--digest needs the exact plan you read. ${usage}`, EXIT.usage);
+    await proveTaskBuildsStopped(store, id, clock);
+    const done = retryAsLocalOwner(store, id, { run: Number(run), digest }, clock());
+    if (!done.ok)
+        return fail(write, json, command, done.reason, done.message, EXIT.refused);
+    return succeed(write, json, command, { id, replayed: done.replayed, retries: done.retries }, () => [
+        done.replayed ? `${id} · Already retrying build #${run}.` : `${id} · Retrying build #${run}. A builder starts it next.`,
+    ]);
+}

package/dist/plan-auto.js

@@ -1,5 +1,6 @@
 import { releaseUnattendedRun, reserveUnattendedRun, unattendedGrantStands } from "./flow-unattended.js";
 import { modeTermsFromJson } from "./modes.js";
+import { currentLocalOwner } from "./local-owner.js";
 import { plannerContractOf, plannerSourceDigest } from "./planner-source.js";
 import { modeFilingCoverage, propose, quarantinedAuthor } from "./scope.js";
 export const PLAN_AUTO_SCHEMA = `CREATE TABLE IF NOT EXISTS plan_authorization (
@@ -37,6 +38,10 @@ export function applyModeToNewFiling(store, taskId, actor, now) {
  * planner text. Rewrites, mode renewal, expiry and revocation fail closed. */
 export function authorizePlanUnderMode(store, taskId, actor, now) {
     return store.transact(() => {
+        // A laptop's local owner (no password) never pre-authorizes a plan under a mode, on any road (filing, the plan
+        // button, chat, the terminal): its plan waits for its own approval (local-owner slice 0).
+        if (currentLocalOwner() !== null)
+            return false;
         const ref = store.lookupRef(taskId);
         if (ref === null || ref.repo === null || ref.plan !== "requested" || !plainPlan(store, taskId) || store.hasLiveClaim(ref.id, now))
             return false;

package/dist/project-knowledge.d.ts

@@ -23,19 +23,19 @@ export declare function knowledgeVersion(store: Store, repo: string, actor: stri
 /** Chat reads only an admitted project. Keep the full source in the project UI. */
 export declare function conversationKnowledge(store: Store, repo: string, actor: string, reference?: string, decision?: number): {
     title?: never;
+    references?: never;
     content?: never;
-    history?: never;
     revision: number;
     stale: boolean;
     notice: string;
+    history?: never;
     instructions?: never;
-    references?: never;
     decisions?: never;
     waiting?: never;
 } | {
     title?: never;
+    references?: never;
     content?: never;
-    history?: never;
     stale?: never;
     decision: {
         repo: string;
@@ -54,19 +54,19 @@ export declare function conversationKnowledge(store: Store, repo: string, actor:
     afterwards?: string;
     notice: string;
     revision?: never;
+    history?: never;
     instructions?: never;
-    references?: never;
     decisions?: never;
     waiting?: never;
 } | {
-    history?: never;
+    references?: never;
     stale?: never;
     revision: number;
     title: string;
     content: string;
     notice: string;
+    history?: never;
     instructions?: never;
-    references?: never;
     decisions?: never;
     waiting?: never;
 } | {

package/dist/public-access.d.ts

@@ -50,3 +50,12 @@ export declare function carriesToken(pathname: string, authorization: string | u
 export declare function plainHttpRefusal(transport: Transport, pathname: string, authorization: string | undefined): string | null;
 /** The Strict-Transport-Security value for a request to the configured public https host that arrived over HTTPS. */
 export declare function hstsFor(publicHost: string | null, host: string | undefined, transport: Transport): string | null;
+/** 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 disqualifies the request. serve.ts's fromThisComputer, and guards.ts's check on every
+ * request a local owner's session makes (local-owner slice 0), read it here. */
+export declare function requestFromThisComputer(request: {
+    socket: {
+        remoteAddress?: string | undefined;
+    };
+    headers: Record<string, string | string[] | undefined>;
+}): boolean;

package/dist/public-access.js

@@ -89,3 +89,18 @@ export function plainHttpRefusal(transport, pathname, authorization) {
 export function hstsFor(publicHost, host, transport) {
     return publicHost !== null && host === publicHost && transport.https ? HSTS_VALUE : null;
 }
+/** Any forwarding header at all (Forwarded, X-Forwarded-*, X-Real-IP, Via, …): a sign of a proxy in front. */
+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;
+/** 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 disqualifies the request. serve.ts's fromThisComputer, and guards.ts's check on every
+ * request a local owner's session makes (local-owner slice 0), read it here. */
+export function requestFromThisComputer(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;
+    const host = request.headers["host"];
+    return /^(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}$/.test(typeof host === "string" ? host : "");
+}

package/dist/pull-request-flow.js

@@ -23,6 +23,7 @@ import { assignmentOf, checkAssignmentAsOperator } from "./assignment.js";
 import { requestResultChanges } from "./result-actions.js";
 import { revisionSourceOf } from "./result-review.js";
 import { authenticateApprover, personProof } from "./scope.js";
+import { currentLocalOwner } from "./local-owner.js";
 import { BRANCH_PREFIX, headWithin } from "./names.js";
 import { NIGHTLY_CHECK_ONLY, RELEASE_MERGES_ONLY, nightlyTaskRef, refArchived, releaseTaskRef } from "./store.js";
 import { belongsToRelease } from "./release-authority.js";
@@ -167,6 +168,11 @@ export function pullRequestBlocker(store, runId) {
  */
 export function completeAndOpenPullRequest(store, input, now) {
     return store.transact(() => {
+        // A laptop's local owner (no password) never opens a pull request: it publishes outside this computer. Refused
+        // before anything is read or written, whatever the result (local-owner slice 0).
+        const local = currentLocalOwner();
+        if (local !== null)
+            return refuse("local-owner", `Opening a pull request needs your password. ${store.accountOf(local.account)?.passwordSet === true ? "Sign in with your password to do this." : "Set a password first: run \`toolroll password set\`."}`);
         const current = assignmentOf(store, input.taskId, now, { principal: "operator", repos: input.who.repos }, input.root);
         const receipt = current?.receipt ?? null;
         if (current === null || receipt === null || receipt.runId !== input.runId || receipt.digest !== input.digest) {
@@ -191,6 +197,9 @@ export function completeAndOpenPullRequest(store, input, now) {
  */
 export function owePullRequest(store, runId, actor, flowCard, now) {
     return store.transact(() => {
+        // The belt under every road that owes one: a local owner's chain never does (local-owner slice 0).
+        if (currentLocalOwner() !== null)
+            throw new Error("Opening a pull request needs your password.");
         const run = store.getRun(runId);
         const ref = store.refById(run.taskRef);
         const grant = publicationGrantOf(store, run.taskRef).grant;

package/dist/release-approval.d.ts

@@ -1,22 +1,8 @@
 import { type PullRequestReader, type ReleaseCard, type ReleaseSeal, type TermLine } from "./release-card.js";
 import { type ApproveResult, type Scope } from "./scope.js";
 import { type Notification, type Store } from "./store.js";
-/** The ledger act holding the coordinator's latest reading of the pull request's CI on the exact candidate. */
-export declare const RELEASE_CI_SEEN_ACTION = "release CI observed";
-/** One check's newest attempt, as the coordinator's own gh read it. A re-run is a new check run id. */
-export type ReleaseCiRun = {
-    id: number | null;
-    name: string;
-    status: string;
-    conclusion: string | null;
-};
-export type ReleaseCiSnapshot = {
-    candidate: string;
-    at: string;
-    state: "passed" | "running" | "failed";
-    failed: string[];
-    runs: ReleaseCiRun[];
-};
+import { type ReleaseCiSnapshot } from "./release-refusal.js";
+export { ciWords, releaseApprovalRefusal, releaseCiOf, RELEASE_CI_SEEN_ACTION, type ReleaseCiRun, type ReleaseCiSnapshot } from "./release-refusal.js";
 /**
  * Record what the coordinator just read of the pull request's CI on `candidate` (its verdict and every check's newest
  * attempt), when it differs from the last reading recorded: the sheet and the CLI show it, and the card digest binds
@@ -35,13 +21,9 @@ export declare function recordReleaseCi(store: Store, input: {
     }[];
     now: Date;
 }): boolean;
-/** The coordinator's latest CI reading for this task on exactly `candidate`, or null (not read yet, or another commit). */
-export declare function releaseCiOf(store: Store, taskId: string, candidate: string): ReleaseCiSnapshot | null;
 /** What of a CI reading the card binds: its state and each check's attempt, whether it finished, and how. Queued and
  * in progress read alike (neither is finished); the time it was read is not bound. */
 export declare function ciBinding(ci: ReleaseCiSnapshot | null): unknown;
-/** GitHub CI in one line, as the sheet and the CLI say it. */
-export declare function ciWords(ci: ReleaseCiSnapshot | null, candidate: string): string;
 export type ReleaseApprovalCard = {
     taskId: string;
     taskRef: number;
@@ -189,3 +171,10 @@ export declare function waitingJournals(stateDir: string, expectedFile: (branch:
     journals: WaitingJournal[];
     unreadable: string[];
 };
+/** A release as Home names it (docs/plans/home-other-asks.md, part 1): its version, and why it can't take a yes now
+ * in the sheet's own words (`refusalOf`, the one source), or null when this isn't a release. Reads only; Home never
+ * approves one, it links to the sheet. */
+export declare function releaseAskOf(store: Store, taskId: string): {
+    version: string;
+    refusal: string | null;
+} | null;