toolroll 0.9.102 → 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?: {
@@ -1725,8 +1738,9 @@ export type BrowserHomeView = {
         value: number;
         href: string;
     }[];
-    /** What needs you, by what is asked, in this order: approve, answer, wrong, review, other (anything none of the four
-     * fits). `count` is the exact total for that ask, past the rows listed. */
+    /** What needs you, by what is asked, in this order: release, approve, answer, flow, wrong, review, setup, other
+     * (anything none of the others fits; docs/plans/home-other-asks.md). `count` is the exact total for that ask, past the
+     * rows listed. */
     groups: {
         key: BrowserHomeAsk;
         label: string;
@@ -1761,9 +1775,10 @@ export type BrowserHomeView = {
     /** While the first run is open (no first result yet): the welcome's address, linked as Finish setup. */
     setup?: string | null;
 };
-/** What a waiting row asks (work-index.ts WorkAskGroup). */
-export type BrowserHomeAsk = 'approve' | 'answer' | 'wrong' | 'review' | 'other';
+/** What a waiting row asks (work-index.ts WorkAskGroup), plus a flow card waiting on you and a first-run step. */
+export type BrowserHomeAsk = 'release' | 'approve' | 'answer' | 'flow' | 'wrong' | 'review' | 'setup' | 'other';
 export type BrowserHomeRow = {
+    /** A task row's family id; a row that isn't a task is namespaced (`release:<task>`, `flow:<card>`, `setup:<step>`). */
     id: string;
     title: string;
     href: string;
@@ -1777,7 +1792,8 @@ export type BrowserHomeRow = {
     reason: string | null;
     /** One line: what it asks, or what the agent is doing now. */
     line: string | null;
-    /** The one act that resolves it (a link), or null. */
+    /** The one act that resolves it (a link), or null. A release, a flow card or a setup step is never acted on at
+     * Home: its one link opens its own page. */
     action: {
         label: string;
         href: string;

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,20 +97,20 @@ 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): {
-    error?: never;
+    version?: never;
     active: boolean;
     phase: string;
     detail: string;
     running: boolean;
     canResume: boolean;
     canCancel: boolean;
+    error?: never;
     automaticRecovery?: never;
     recoveryAttempts?: never;
     recoveryRepairs?: never;
     wasRunning?: never;
     backupPath?: never;
     updateId?: never;
-    version?: never;
     buildId?: never;
     workDir?: never;
 } | {

package/dist/flow-engine.d.ts

@@ -9,6 +9,9 @@ export type FlowAdvance = {
 export declare function flowDefinitionOf(flow: FlowRow): FlowDefinition | null;
 /** Where a card's link opens: the flow's canvas with the card selected. */
 export declare const flowCardHref: (flow: number, card: number) => string;
+/** A reply wait that timed out with nowhere to send the card asks its owner (or the flow's owner) to move it on: the
+ * card's waiting words end with this (flows-ui.ts flowCardWaitsOn reads it). */
+export declare const NO_REPLY_MOVE_ON = "Move the card on when you're ready.";
 /** Where a confirmed flow action may point: a flow's canvas, maybe with one card open. */
 export declare const FLOW_HREF: RegExp;
 /** Advance every active card in one project's flows. */

package/dist/flow-engine.js

@@ -36,6 +36,9 @@ export function flowDefinitionOf(flow) {
 }
 /** Where a card's link opens: the flow's canvas with the card selected. */
 export const flowCardHref = (flow, card) => `/flows/${flow}?card=${card}`;
+/** A reply wait that timed out with nowhere to send the card asks its owner (or the flow's owner) to move it on: the
+ * card's waiting words end with this (flows-ui.ts flowCardWaitsOn reads it). */
+export const NO_REPLY_MOVE_ON = "Move the card on when you're ready.";
 /** Where a confirmed flow action may point: a flow's canvas, maybe with one card open. */
 export const FLOW_HREF = /^\/flows\/[1-9][0-9]{0,9}(\?card=[1-9][0-9]{0,9})?$/;
 const ACCEPTANCE = FLOW_ACCEPTANCE;
@@ -173,7 +176,7 @@ function advanceCard(store, flow, definition, card, now, options, outcome) {
                     outcome.moved++;
                 return;
             }
-            const waiting = `No reply after ${words}. Move the card on when you're ready.`;
+            const waiting = `No reply after ${words}. ${NO_REPLY_MOVE_ON}`;
             if (card.waiting !== waiting) {
                 store.updateFlowCard(card.id, { waiting }, now);
                 notifyPeople(store, card, [card.owner ?? flow.owner], null, { key: `no-reply:${card.entry}`, subject: `No reply to “${card.title}” after ${words}`, body: `It's waiting in ${stage.title}.`, attention: true }, now);

package/dist/flows-ui.d.ts

@@ -1,5 +1,6 @@
 import type { BrowserFlowView } from "./browser-workspace.js";
-import type { FlowRow, Store } from "./store.js";
+import { type FlowStage } from "./flows.js";
+import type { FlowCardRow, FlowRow, Store, SubagentQuestionRow } from "./store.js";
 import { type FlowFile, type FlowImportPlan } from "./flow-share.js";
 import { type Html } from "./html.js";
 /** The flow page's fallback rules, plus the Flows list and the import preview (kit pieces; only layout here). */
@@ -24,6 +25,35 @@ export declare function flowImportHtml(input: {
     previewed: string;
     problem: string | null;
 }): Html;
+/** Why a card waits on this person now (docs/plans/home-other-asks.md part 4, v2.3): the one rule the flow page's
+ * Decide and Home's Flow decisions both read, so they never disagree. Each needs approver standing:
+ * - `decide`: an approval zone it is theirs to decide (the zone's decider, the flow's owner for "to owner", any approver
+ *   when none is named), and no subagent of the zone deciding it first;
+ * - `choose`: a "Person chooses" zone waiting on them (flow-send.ts flowChoiceAt);
+ * - `answer`: its subagent's open question or tool-call request asked of them;
+ * - `browser`: a check zone waiting for browser use, which only an approver with every project may allow;
+ * - `reply`: a reply wait that ran out with nowhere to go, asking the card's owner (else the flow's) to move it on.
+ * `reads` passes what the caller already read (a missing key is read here). */
+export type FlowCardWait = {
+    decide: boolean;
+    choose: boolean;
+    answer: boolean;
+    browser: boolean;
+    reply: boolean;
+};
+export declare function flowCardWaitsOn(store: Store, flow: FlowRow, card: FlowCardRow, viewer: {
+    name: string;
+    approver: boolean;
+}, reads?: {
+    stage?: FlowStage | undefined;
+    asked?: SubagentQuestionRow | null;
+    choosing?: {
+        person: string;
+    } | null;
+    browser?: {
+        status: string;
+    } | null;
+}): FlowCardWait;
 /** One flow's canvas for one person. */
 export declare function flowView(store: Store, flow: FlowRow, viewer: {
     name: string;

package/dist/flows-ui.js

@@ -1,7 +1,7 @@
 /** Flows in the console: the list of a person's flows, and one flow's canvas
  * (the React view's data, plus a plain fallback page the view replaces). */
 import { liveAttemptOf, steerControlsFor } from "./steer-controls.js";
-import { draftFor, flowDefinitionOf } from "./flow-engine.js";
+import { draftFor, flowDefinitionOf, NO_REPLY_MOVE_ON } from "./flow-engine.js";
 import { describeStandingOrder } from "./flow-schedule.js";
 import { describeTrigger, triggerHeadline, FLOW_TRIGGER_KINDS, FLOW_TRIGGER_WORDS, githubRepoOf, HOOK_PATH, hookReady, planeStatusLink, readHooksBase, readLinearKey, senderOf, takesDeliveries, triggerConfigOf } from "./flow-triggers.js";
 import { SENDER_WORDS } from "./webhook-signing.js";
@@ -14,7 +14,7 @@ import { parseSortDecision, sortChip } from "./flow-sort.js";
 import { flowSecretNames, readEmailSettings, sendingReady } from "./flow-actions.js";
 import { projectToolsOf, secretsSetFor, toolStanding } from "./project-tools.js";
 import { flowFingerprint } from "./flow-live.js";
-import { flowChoiceAt, readFlowSend } from "./flow-send.js";
+import { flowChoiceAt, flowPersonOf, readFlowSend } from "./flow-send.js";
 import { itemCaption, whyLines } from "./flow-items.js";
 import { FLOW_FILE_MAX_BYTES } from "./flow-share.js";
 import { googleConnected } from "./google-mail.js";
@@ -224,6 +224,37 @@ const historyText = (event, title, sorts = new Set()) => {
         default: return `Moved to ${title(event.toStage)}${who}${note}`;
     }
 };
+export function flowCardWaitsOn(store, flow, card, viewer, reads = {}) {
+    const none = { decide: false, choose: false, answer: false, browser: false, reply: false };
+    if (!viewer.approver || card.state !== "active")
+        return none;
+    const stage = "stage" in reads ? reads.stage : flowDefinitionOf(flow)?.stages.find(one => one.id === card.stage);
+    // Its subagent's open question is the person's to answer whatever zone it is in, even one since removed from the flow
+    // (the flow page shows it and takes the answer).
+    const asked = "asked" in reads ? reads.asked ?? null : store.openSubagentQuestionOn(card.id, card.entry);
+    const answer = asked !== null && asked.state === "open" && asked.askedOf === viewer.name && store.getSubagent(asked.subagent) !== null;
+    if (stage === undefined)
+        return { ...none, answer };
+    const decider = stage.kind === "approval" ? deciderOf(stage, flow) : null;
+    // While its subagent is deciding (v92), the card isn't anyone else's to decide yet.
+    const subagentDeciding = stage.subagent !== undefined && card.waiting !== null && card.waiting.endsWith(" is deciding");
+    const choosing = stage.kind !== "choose" ? null : "choosing" in reads ? reads.choosing ?? null : flowChoiceAt(store, card.id, card.entry);
+    const browser = stage.kind !== "check" || stage.browser !== true ? null : "browser" in reads ? reads.browser ?? null : browserViewOf(store, flow);
+    const wait = stage.wait ?? { for: "reply" };
+    return {
+        decide: stage.kind === "approval" && (decider === null || decider === viewer.name) && !subagentDeciding,
+        choose: choosing !== null && choosing.person === viewer.name,
+        answer,
+        browser: browserWaitOn(card, stage, browser) && store.accountOf(viewer.name)?.projects === null,
+        reply: stage.kind === "wait" && wait.for === "reply" && card.waiting !== null && card.waiting.startsWith("No reply after ") && card.waiting.endsWith(NO_REPLY_MOVE_ON)
+            && flowPersonOf(card, flow) === viewer.name,
+    };
+}
+/** A check zone's card waiting for browser use (flow-browser.ts): the flow's browser isn't allowed and the card says so. */
+function browserWaitOn(card, stage, browser) {
+    return card.state === "active" && stage?.kind === "check" && stage.browser === true && browser !== null && browser.status !== "allowed"
+        && card.waiting !== null && card.waiting.startsWith(`${stage.title} starts a browser`);
+}
 /** One flow's canvas for one person. */
 export function flowView(store, flow, viewer, selectedCard, setup = { dir: null, repos: [] }) {
     const definition = flowDefinitionOf(flow);
@@ -249,10 +280,12 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
         const canReadTask = taskRepo !== null && (taskRepo === flow.repo || (setup.repos.includes(taskRepo) && store.accountCanAccess(viewer.name, taskRepo)));
         const discussion = store.flowComments(card.id);
         const watchers = store.flowCardWatchers(card.id);
-        const decider = stage?.kind === "approval" ? deciderOf(stage, flow) : null;
-        // While its subagent is deciding (v92), the card isn't anyone else's to decide yet.
-        const subagentDeciding = stage?.subagent !== undefined && card.waiting !== null && card.waiting.endsWith(" is deciding");
-        const canDecide = viewer.approver && card.state === "active" && stage?.kind === "approval" && (decider === null || decider === viewer.name) && !subagentDeciding;
+        // Its open question: one of its own, or (v94) a tool call waiting for approval.
+        const asked = card.state === "active" ? store.openSubagentQuestionOn(card.id, card.entry) : null;
+        // "Person chooses" (flow-send.ts): what was sent, and the options, for the person it waits on; the latest send otherwise.
+        const choosing = card.state === "active" && stage?.kind === "choose" ? flowChoiceAt(store, card.id, card.entry) : null;
+        // Who may decide it here: the one rule Home reads too (flowCardWaitsOn).
+        const canDecide = flowCardWaitsOn(store, flow, card, viewer, { stage, asked, choosing, browser: browserNow }).decide;
         // History reads moves and ownership together, newest first.
         const owned = discussion.filter(one => one.kind === "owner").map(one => ({ text: one.body === "" ? `${one.author} left it without an owner` : one.body === one.author ? `${one.author} took it on` : `${one.author} made ${one.body} the owner`, at: one.at }));
         const moves = store.flowEvents(card.id).map(event => ({ text: historyText(event, title, sortZones), at: event.at }));
@@ -266,8 +299,6 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
             at: until.toISOString(),
             label: stage.wait !== undefined && stage.wait.for !== "hours" ? (stage.wait.for === "reply" ? "No reply by" : "Moves on at") : stage.limit.to !== null ? `Moves to ${title(stage.limit.to)} at` : "Reminder at",
         };
-        // Its open question: one of its own, or (v94) a tool call waiting for approval.
-        const asked = card.state === "active" ? store.openSubagentQuestionOn(card.id, card.entry) : null;
         const pending = asked?.toolCall == null ? null : store.subagentCall(asked.toolCall);
         // A decision its subagent handed over carries what the subagent said (v92).
         const turn = card.state === "active" && stage?.kind === "approval" && stage.subagent !== undefined ? store.flowStepRun(card.id, card.entry) : null;
@@ -284,8 +315,6 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
             }
         }
         const asker = asked === null || asked.state !== "open" ? null : store.getSubagent(asked.subagent);
-        // "Person chooses" (flow-send.ts): what was sent, and the options, for the person it waits on; the latest send otherwise.
-        const choosing = card.state === "active" && stage?.kind === "choose" ? flowChoiceAt(store, card.id, card.entry) : null;
         const latest = store.flowSends(card.id)[0] ?? null;
         const sentContent = latest === null ? null : readFlowSend(latest.contentJson);
         // On the card itself: where it came from (the card's title is right above), and only the links the panel doesn't already have.
@@ -295,8 +324,7 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
             // After research: the same numbered items the message carried, each beside its screenshot.
             ...(content.items === undefined ? {} : { items: content.items.map((item, index) => ({ number: index + 1, title: item.title, lines: whyLines(item.why), source: item.source, url: item.url,
                     image: item.shot === null || content.shots === null ? null : { src: `/r/${content.shots.run}/evidence/${item.shot}`, caption: itemCaption(index + 1, item) } })) }) });
-        const browserWait = card.state === "active" && stage?.kind === "check" && stage.browser === true && browser !== null && browser.status !== "allowed"
-            && card.waiting !== null && card.waiting.startsWith(`${stage.title} starts a browser`);
+        const browserWait = browserWaitOn(card, stage, browser);
         return {
             id: card.id, title: card.title, description: card.description, stage: card.stage, state: card.state,
             waiting: card.state === "active" && card.task !== null && (stage?.kind === "task" || stage?.kind === "report")

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;