toolroll 0.9.92 → 0.9.93

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

@@ -707,8 +707,6 @@ export declare function needActionOf(assignment: AssignmentSnapshot | null, stat
     rebuildable?: boolean;
     refuted?: boolean;
 }): BrowserNeedAction | null;
-/** A build Toolroll can't check at all: the approver ticks that they checked before confirming. */
-export declare const needsCheck: (assignment: AssignmentSnapshot) => boolean;
 /** The server page's form of the same: the need's action first, Request changes as the quiet second. */
 export declare function resultNeedAction(need: BrowserNeedAction, o: ResultPanelOptions, canRequest: boolean): Html;
 /** The outcome in one bounded sentence (repair 2026-09-14): the handoff's

package/dist/server/render-results.js

@@ -731,7 +731,7 @@ export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab,
             checksRunning,
             blocked,
             canRequest: panel.panel.canRequest && panel.panel.request !== null,
-            need: need === null || need.accept != null ? null : need.rebuild != null ? "rebuild" : need.confirm !== null ? "confirm-stopped" : null,
+            need: need === null || need.accept != null ? null : need.rebuild != null ? "rebuild" : need.confirm !== null ? "recheck-stopped" : null,
             next: nextKind === "revise" || nextKind === "draft-repair" ? nextKind : null,
             unanswered: settled === null ? 0 : unanswered.length,
             notRight: 0,
@@ -2009,12 +2009,10 @@ export function needActionOf(assignment, status, csrf, returnTo, result) {
         if (status.need.key === "review-result" || here)
             return null;
     }
-    const confirm = action?.code === "confirm-stopped" && action.target.runId !== null && csrf !== ""
-        ? { action: `${taskHref(assignment.rootId)}/confirm-stopped`, run: action.target.runId, returnTo, checked: needsCheck(assignment) } : null;
+    const confirm = action?.code === "recheck-stopped" && action.target.runId !== null && csrf !== ""
+        ? { action: `${taskHref(assignment.rootId)}/recheck-stopped`, run: action.target.runId, returnTo } : null;
     return { label: status.need.action.label, href: assignmentActionHref(assignment) ?? taskHref(assignment.rootId), confirm };
 }
-/** A build Toolroll can't check at all: the approver ticks that they checked before confirming. */
-export const needsCheck = (assignment) => assignment.need != null && "key" in assignment.need && assignment.need.key === "check-stopped";
 /** The server page's form of the same: the need's action first, Request changes as the quiet second. */
 export function resultNeedAction(need, o, canRequest) {
     const control = need.accept != null
@@ -2022,7 +2020,7 @@ export function resultNeedAction(need, o, canRequest) {
         : need.rebuild != null
             ? postForm(need.rebuild.action, html `<button type="submit" data-primary-action data-rebuild style="min-height:44px">${need.label}</button>`, { attrs: { class: "rebuild" } })
             : need.confirm !== null
-                ? postForm(need.confirm.action, html `${need.confirm.checked === true ? html `<label><input type="checkbox" name="checked" value="yes" required> Nothing from build #${need.confirm.run} is running</label>` : ""}${reauth(html `<label>Your password<input type="password" name="token" autocomplete="current-password" required></label>`)}<button type="submit" style="min-height:44px">${need.label}</button>`, { attrs: { id: "confirm-stopped", class: "confirm-stopped" }, returnTo: need.confirm.returnTo, hidden: { run: need.confirm.run } })
+                ? postForm(need.confirm.action, html `<button type="submit" data-primary-action style="min-height:44px">${need.label}</button>`, { attrs: { id: "recheck-stopped", class: "recheck-stopped" }, returnTo: need.confirm.returnTo, hidden: { run: need.confirm.run } })
                 : html `<a class="button-link" href="${need.href ?? "#"}" data-primary-action>${need.label}</a>`;
     return html `<div class="result-action" data-result-action="need">${control}${canRequest && o.csrf !== "" ? html `<a class="result-feedback-link" href="#request-changes">Request changes</a>` : ""}</div>`;
 }

package/dist/server/render-tasks.js

@@ -50,7 +50,7 @@ import { isOverdue, oneLineOf, projectChip, regionScript, safePrUrl, screen, SEN
 import { steerDestinationWords, steerStandingParts } from "../steer-status.js";
 import { reviewHref, taskChatHref, taskHref } from "./http.js";
 import { coordinatorProposalsSection } from "./render-chat.js";
-import { completionReceiptCard, criterionMatrixHtml, evidenceWords, homePhaseWords, incidentWords, needsCheck, pullRequestCardHtml, reasonWords, receiptStatusOf, repairChainHtml, reportItemsHtml, reviewRetryPanel, runNoun, runOutcomeBadge, semanticCoverageHtml, verificationExplanation, verificationRecovered } from "./render-results.js";
+import { completionReceiptCard, criterionMatrixHtml, evidenceWords, homePhaseWords, incidentWords, pullRequestCardHtml, reasonWords, receiptStatusOf, repairChainHtml, reportItemsHtml, reviewRetryPanel, runNoun, runOutcomeBadge, semanticCoverageHtml, verificationExplanation, verificationRecovered } from "./render-results.js";
 import {} from "./session.js";
 import { linkWords, originNote, requestName, requestWords } from "../task-source.js";
 export function contractChangeHtml(change) {
@@ -2408,8 +2408,8 @@ export function taskBodyParts(data) {
         approve: data.archived != null || sheetInput === null || dependencyChoiceNeeded || data.csrf === "" ? null : approveKitOf(sheetInput, data.approvalFresh ?? null),
         approved: scope !== null && approval.approved ? approvedKitOf(scope, approval, data.approvalProof ?? null) : null,
         more,
-        confirmStopped: data.csrf !== "" && data.assignment?.primaryAction?.code === "confirm-stopped" && data.assignment.primaryAction.target.runId !== null
-            ? { action: `${taskHref(data.assignment.rootId)}/confirm-stopped`, run: data.assignment.primaryAction.target.runId, checked: needsCheck(data.assignment) } : null,
+        recheckStopped: data.csrf !== "" && data.assignment?.primaryAction?.code === "recheck-stopped" && data.assignment.primaryAction.target.runId !== null
+            ? { action: `${taskHref(data.assignment.rootId)}/recheck-stopped`, run: data.assignment.primaryAction.target.runId } : null,
         rebuild,
         // The plan, progress and plan changes are thread entries now; the rest still needs a person here.
         lead: [

package/dist/server/route-table.d.ts

@@ -22,7 +22,7 @@ export type Caller = "anonymous" | "service" | "cookie" | "bearer" | "oauth" | "
 /** What the caller must hold: nothing, read, act (an approver or an `act` token), or a fresh password/provider check on top. */
 export type RouteScope = "none" | "read" | "act" | "step-up";
 /** Where the request's project comes from. */
-export type ProjectResolver = "none" | "session" | "form" | "form-path" | "task" | "run" | "decision" | "incident" | "flow" | "proposal" | "conversation" | "coding" | "adapter";
+export type ProjectResolver = "none" | "session" | "form" | "form-path" | "task" | "task-ref" | "run" | "decision" | "incident" | "flow" | "proposal" | "conversation" | "coding" | "adapter";
 /**
  * What a project-limited account may do here:
  * - `deny`: instance access only.

package/dist/server/route-table.js

@@ -286,6 +286,10 @@ get("tasks", "welcome", "/welcome", { limited: "collection", ...free });
 post("tasks", "welcome.sample", "/welcome/sample", { callers: ["cookie"], project: "none", ...approver("An approver adds projects.", "/welcome") });
 get("tasks", "task.page", `^\\/t\\/${TASK}$`, { project: "task", limited: "resource", ...free, sample: "/t/one" });
 get("tasks", "task.evidence", `^\\/t\\/${TASK}\\/evidence$`, { project: "task", limited: "resource", ...free, sample: "/t/one/evidence" });
+// One-tap release approval (trusted-release-reports.md A6/A7): the sheet, and the push's opaque locator, which only
+// redirects to it once the plane's own state says the task ref is a release in the person's projects.
+get("tasks", "task.release", `^\\/t\\/${TASK}\\/release$`, { project: "task", limited: "resource", ...free, sample: "/t/one/release" });
+get("tasks", "release.locate", `^\\/approve\\/${ID}$`, { project: "task-ref", limited: "resource", ...free, sample: "/approve/1" });
 get("pages", "ledger.export", "/ledger/export", { limited: "unscoped", ...free });
 get("tasks", "runs", "/runs", { limited: "collection", ...free }); // a redirect to /agents now
 get("pages", "menu", "/menu", { limited: "collection", ...free });
@@ -556,7 +560,9 @@ post("tasks", "task.act.route", `^\\/t\\/${TASK}\\/route$`, { project: "task", l
 post("tasks", "task.act.retry-review", `^\\/t\\/${TASK}\\/retry-review$`, { project: "task", limited: "resource", sample: "/t/one/retry-review" });
 post("tasks", "task.act.complete", `^\\/t\\/${TASK}\\/complete$`, { project: "task", limited: "resource", sample: "/t/one/complete", ...approver("Only an approver can mark a result complete.") });
 post("tasks", "task.act.merge", `^\\/t\\/${TASK}\\/merge$`, { project: "task", limited: "resource", sample: "/t/one/merge", ...approver("Only an approver can merge.") });
-post("tasks", "task.act.confirm-stopped", `^\\/t\\/${TASK}\\/confirm-stopped$`, { scope: "step-up", project: "task", limited: "resource", sample: "/t/one/confirm-stopped", ...approver("Only an approver can confirm a build stopped.") });
+// Check again: Toolroll looks at this computer's processes for a finished build once more (stop-proof.ts). Nobody
+// vouches that a build stopped, so no password: it only asks for the look the worker makes on its own anyway.
+post("tasks", "task.act.recheck-stopped", `^\\/t\\/${TASK}\\/recheck-stopped$`, { project: "task", limited: "resource", sample: "/t/one/recheck-stopped", ...approver("Only an approver can have Toolroll check a build again.") });
 post("tasks", "task.act.stop-carrying", `^\\/t\\/${TASK}\\/stop-carrying$`, { project: "task", limited: "resource", sample: "/t/one/stop-carrying", ...approver("Only an approver can stop carrying a release.") });
 post("tasks", "task.act.stop", `^\\/t\\/${TASK}\\/stop$`, { project: "task", limited: "resource", sample: "/t/one/stop" });
 // Putting one task away and bringing it back (task-tidy.md): a person's act, so only a browser session.

package/dist/server/tasks.d.ts

@@ -64,3 +64,18 @@ export declare function createAgentSignalHandlers(runtime: ServerRuntime): {
     "agents.seen": (ctx: HandlerContext) => Promise<void>;
     "agents.watch": (ctx: HandlerContext) => Promise<void>;
 };
+/**
+ * One-tap release approval (docs/plans/trusted-release-reports.md, slice A): the sheet (`/t/<id>/release`), the push's
+ * opaque locator (`/approve/<task ref>`, a GET that only redirects to the sheet) and the sheet's approval, which the
+ * task approval POST hands here once its shared checks (cookie session, CSRF and the browser key at admission, the
+ * single-use nonce, a password or a standing proof) passed. The approval itself is the shared card wrapper around the
+ * unchanged approve() (release-approval.ts approveReleaseCard).
+ */
+export declare function createReleaseSheetHandlers(runtime: ServerRuntime): {
+    routes: {
+        "task.release": (ctx: HandlerContext) => Promise<void>;
+        "release.locate": (ctx: HandlerContext) => Promise<void>;
+    };
+    sheetScreen: (ctx: Pick<HandlerContext, "who" | "response" | "project">, taskId: string, problem: string | null, status: number) => void;
+    approveFromSheet: (ctx: Pick<HandlerContext, "who" | "response" | "project">, taskId: string, cardDigest: string, token: string) => void;
+};

package/dist/server/tasks.js

@@ -44,6 +44,7 @@ import { validKeyTail } from "../live-records.js";
 import { runNotes } from "../live-notes.js";
 import { latestFinishedAttempt, retryNoteOf } from '../needs-you.js';
 import { REMOTE_MESSAGES } from "../operate-remote.js";
+import { proveRunStopped } from "../stop-proof.js";
 import { aggregateNewNames, observeWorktree, parseBaseTreeSnapshot, PEEK_LIMITS } from "../peek.js";
 import { isTaskSize, PHASES as ROUTE_PHASES } from "../phase-routing.js";
 import { applyModeToNewFiling, authorizePlanUnderMode } from "../plan-auto.js";
@@ -59,7 +60,7 @@ import { structuredHandoffView, terminalDiffView } from "../result-evidence-read
 import { fileAddTestsTask, requestFollowUpChecks } from '../result-follow-ups.js';
 import { commentSourceKey, isRevisionFeedback, parseResultTab, resultReturnTarget } from "../result-review.js";
 import { isAlive as runnerAlive } from "../runner.js";
-import { passwordlessSessionFor, acceptanceLinesToInput, acceptanceToLines, approvalOf, approve as approveScope, freshnessFor, localApprovalEligible, spendingOnlyOnSuccess, ssoNowAvailable, withFreshness, modeFilingCoverage, PLACEHOLDER_RUBRIC, proposeGuarded } from "../scope.js";
+import { passwordlessSessionFor, acceptanceLinesToInput, acceptanceToLines, approvalOf, approve as approveScope, freshnessFor, freshlyApprovable, localApprovalEligible, spendingOnlyOnSuccess, ssoNowAvailable, withFreshness, modeFilingCoverage, PLACEHOLDER_RUBRIC, proposeGuarded } from "../scope.js";
 import { subagentNames as subagentNamesOf } from "../spend.js";
 import { verifiedAuthor } from "../store.js";
 import { runCostWords } from "../summary.js";
@@ -78,6 +79,10 @@ import { timingFor } from "../latency-timeline.js";
 import { ACCEPT_ANYWAY_NEEDS_REASON, editorFileHref, proofBundleView, rankReviewQueue, RESULT_REFUSALS, REVIEW_QUEUE_CAP, reviewCockpitDetailParts, reviewCockpitPage, reviewPriorityOf, runFactsFragment, runOutcomeBadge, withRefusal } from "./render-results.js";
 import { approvalFormDigest, approveRefusalWords, checkProgressHtml, consentDoorOf, nonceHashOf, PermissionsWouldChange, requirementsFromEditor, resumeDigestOf, taskOf } from "./render-tasks.js";
 import {} from "./session.js";
+import { approveReleaseCard, releaseApprovalCard, releaseSheetHref, releaseTaskOf } from "../release-approval.js";
+import { releaseSheetPage } from "./render-release.js";
+import { approvalFactsNow } from "./kit.js";
+import { localOwnerRefusal } from "../local-owner.js";
 export function createTasksHandlers(runtime) {
     const { identities, store, peekSay, peekCache, PEEK_CACHE_TTL_MS, peekInFlight, PEEK_GLOBAL_INFLIGHT, peekBySession, PEEK_SESSION_INFLIGHT, clock, peekName, PEEK_FRAGMENT_BYTES, peekEvict, evidenceRoot, sendScreen, chromeFor, visible, consumeApprovalNonce, authenticateApprover, options, mintApprovalNonce, taskScreen, unscopedMode, admissionList, planViewOf, revisionViewOf, runIsTaskResult, leadPrincipal, familyOf, armTaskResume, runIsLive, revisionLedgerOf, resultDetailOf, reviewFactsFor, taskRepoOf, runVisible, restricted, codingActorAllowed, codingProjectAllowed, managedRepos, routeViewOf, workAccess, firstRunStepsNow, revisionDocOf, failureOf, dockedConversation, planContractViewOf, familiesInView, explainAttempt, taskChatFocus, familyTasksInView, liveCeiling, projectOf, ceiling, bustBadge, revisionDestination } = runtime;
     /** A row admitted the address but its path parameter does not parse: the console's unknown page. */
@@ -1284,14 +1289,14 @@ export function createTasksHandlers(runtime) {
         }
         return redirect(response, decisionBack);
     }
-    async function taskConfirmStopped(ctx) {
-        const { url, who, response, now, posted } = ctx;
-        const act = matchTaskPath(url.pathname, "/confirm-stopped$");
+    async function taskRecheckStopped(ctx) {
+        const { url, who, response, posted } = ctx;
+        const act = matchTaskPath(url.pathname, "/recheck-stopped$");
         if (act === null)
             return noPage(who, response);
-        const body = readForm(posted, CONSOLE_FORMS.confirmStopped);
-        // Confirming a finished build stopped is an approver's act behind the password, typed again — the same
-        // record as `toolroll run settle`, refused while anything of the run may still be running.
+        const body = readForm(posted, CONSOLE_FORMS.recheckStopped);
+        // Check again: Toolroll looks at this computer's processes for the build once more (stop-proof.ts) and settles it
+        // when none of them is the build's. Nobody vouches that a build stopped, so there is nothing to confirm here.
         const back = taskHref(act.taskId);
         const ref = store.lookupRef(act.taskId);
         if (ref === null || !visible(ref.repo))
@@ -1302,19 +1307,19 @@ export function createTasksHandlers(runtime) {
         if (run === null || runTask === null || familyOf(runTask)?.root.id !== (familyOf(act.taskId)?.root.id ?? act.taskId)) {
             return taskScreen(response, who, act.taskId, "That build isn't part of this task.", 409);
         }
-        if (!authenticateApprover(who, body.get("token") ?? "", ref.repo).ok || !store.accountCanAccess(who.name, ref.repo)) {
-            return taskScreen(response, who, act.taskId, "That password didn't match. Nothing changed.", 403);
-        }
-        // When Toolroll can't check at all, the approver also says they checked: never a one-click confirmation.
-        if (store.stopQuiescenceFact(run.id)?.kind === "unknown" && body.get("checked") !== "yes") {
-            return taskScreen(response, who, act.taskId, `Make sure nothing from build #${run.id} is running, then tick the box to confirm.`, 409);
-        }
-        const settled = store.settleRunWitnessesByApprover({ runId: run.id, by: who.name, why: "Confirmed in the console that nothing from this build is running." }, now);
-        if (!settled.ok) {
-            return taskScreen(response, who, act.taskId, settled.reason === "alive" || settled.reason === "still-running"
-                ? `Something from build #${run.id} may still be running, so it can't be confirmed stopped yet.` : `Build #${run.id} can't be confirmed stopped.`, 409);
-        }
+        if (!store.accountCanAccess(who.name, ref.repo))
+            return taskScreen(response, who, act.taskId, "You can't act on this project's tasks.", 403);
+        const proved = await proveRunStopped(store, run.id, clock);
         bustBadge();
+        const left = store.stopQuiescenceFact(run.id);
+        if (left !== null) {
+            const words = proved.outcome === "blocked" ? `Build #${proved.run} ${proved.words}.`
+                : left.kind === "alive" || left.kind === "open" ? `Something from build #${left.run} may still be running. Toolroll stops what it proves is the build's on its own.`
+                    : left.kind === "elsewhere" ? `Build #${left.run} ran on another computer; only that computer can check it stopped.`
+                        : left.kind === "unknown" ? `Toolroll still can't prove build #${left.run} stopped from this computer.`
+                            : `Toolroll is still making sure build #${left.run} stopped. This clears on its own.`;
+            return taskScreen(response, who, act.taskId, words, 409);
+        }
         const to = resultReturnTarget(body.get("return"), run.id, runTasks(run.taskRef));
         return redirect(response, body.get("return") ? to : back);
     }
@@ -2458,7 +2463,11 @@ export function createTasksHandlers(runtime) {
                     : requestedReturn === null
                         ? taskHref(taskId)
                         : safeChatReturn(requestedReturn);
+                // The release sheet's Approve release (trusted-release-reports.md A7): the same door, its own page for words.
+                const sheet = body.get("sheet") === "release";
                 const approvalProblem = (message, status) => {
+                    if (sheet)
+                        return releaseSheet.sheetScreen({ who, response, project: null }, taskId, message, status);
                     if (requestedReturn !== null && requestedReturn !== "next") {
                         return redirect(response, chatReturnWithSaid(approvalBack, message));
                     }
@@ -2484,6 +2493,9 @@ export function createTasksHandlers(runtime) {
                     && !(who.authority === "local-owner" && localApprovalEligible(store, who.name, taskId).ok)) {
                     return approvalProblem("approval requires your password, typed again", 400);
                 }
+                // The sheet binds the release card's digest (the nonce was minted for it): the shared card wrapper decides.
+                if (sheet)
+                    return releaseSheet.approveFromSheet({ who, response, project: null }, taskId, digest, token);
                 const scopeRow = store.getScope(taskId);
                 if (scopeRow === null)
                     return approvalProblem("this task has no scope to approve", 409);
@@ -3078,6 +3090,7 @@ export function createTasksHandlers(runtime) {
         return live;
     }
     const tidyHandlers = createTidyHandlers(runtime);
+    const releaseSheet = createReleaseSheetHandlers(runtime);
     /** The question page, with a refusal in its box when an answer was refused (the box keeps the choice to make). */
     function decisionScreen(ctx, id, back, refusal, code, now, draft) {
         const { who, response, project } = ctx;
@@ -3095,6 +3108,7 @@ export function createTasksHandlers(runtime) {
     }
     const registrations = handlersOf("tasks", {
         ...tidyHandlers,
+        ...releaseSheet.routes,
         ...createAgentSignalHandlers(runtime),
         "code.page": showCode("workspace"),
         "code.session": showCode("session"),
@@ -3155,7 +3169,7 @@ export function createTasksHandlers(runtime) {
         "task.act.retry-review": taskAct("retry-review"),
         "task.act.complete": taskAct("complete"),
         "task.act.merge": taskMerge,
-        "task.act.confirm-stopped": taskConfirmStopped,
+        "task.act.recheck-stopped": taskRecheckStopped,
         "task.act.stop": taskAct("stop"),
         "task.act.stop-carrying": taskAct("stop-carrying"),
         "task.act.pause": taskAct("pause"),
@@ -3314,3 +3328,71 @@ export function createAgentSignalHandlers(runtime) {
     }
     return { "agents.seen": agentSeen, "agents.watch": agentWatch };
 }
+/**
+ * One-tap release approval (docs/plans/trusted-release-reports.md, slice A): the sheet (`/t/<id>/release`), the push's
+ * opaque locator (`/approve/<task ref>`, a GET that only redirects to the sheet) and the sheet's approval, which the
+ * task approval POST hands here once its shared checks (cookie session, CSRF and the browser key at admission, the
+ * single-use nonce, a password or a standing proof) passed. The approval itself is the shared card wrapper around the
+ * unchanged approve() (release-approval.ts approveReleaseCard).
+ */
+export function createReleaseSheetHandlers(runtime) {
+    const { store, sendScreen, chromeFor, visible, mintApprovalNonce, clock } = runtime;
+    const missing = (who, response) => refuse(response, who, 404, "There's no release waiting for approval at this address.", "/work");
+    /** The sheet, with a problem said where it happened. */
+    function sheetScreen(ctx, taskId, problem, status) {
+        const { who, response, project } = ctx;
+        const ref = store.lookupRef(taskId);
+        if (ref === null || !visible(ref.repo) || !store.accountCanAccess(who.name, ref.repo))
+            return missing(who, response);
+        const built = releaseApprovalCard(store, taskId);
+        if (!built.ok)
+            return missing(who, response);
+        const card = built.card;
+        const open = card.approved === null && card.refusal === null;
+        // This computer's local owner can't approve a release: the full sign-in comes first (scope.ts localApprovalEligible).
+        const local = who.via === "cookie" && who.authority === "local-owner" ? localOwnerRefusal(store.accountOf(who.name)?.passwordSet === true, releaseSheetHref(taskId)) : null;
+        const nonce = open && local === null && who.via === "cookie" && who.role === "approver" ? mintApprovalNonce(who.name, taskId, card.digest) : "";
+        const remembered = (() => {
+            if (!open || who.via !== "cookie")
+                return false;
+            const fresh = withFreshness("approve-standard", () => freshnessFor(who.name, Date.now(), true));
+            if (fresh === null)
+                return false;
+            const gate = store.approvalGate(taskId, who.name, "person");
+            return freshlyApprovable(store, taskId, card.scope, gate.verdict === "seal" && !gate.protectedWork);
+        })();
+        return sendScreen(response, status, releaseSheetPage(chromeFor(project ?? ref.repo, "work"), { card, nonce, facts: approvalFactsNow({ remembered }), local, problem }));
+    }
+    async function showSheet(ctx) {
+        const task = matchTaskPath(ctx.url.pathname, "/release$");
+        if (task === null)
+            return missing(ctx.who, ctx.response);
+        return sheetScreen(ctx, task.taskId, null, 200);
+    }
+    /** The push's locator: proved a release in the person's projects from the plane's own state, then only redirected. */
+    async function locate(ctx) {
+        const { who, response, url } = ctx;
+        const raw = /^\/approve\/([1-9][0-9]{0,14})$/.exec(url.pathname)?.[1];
+        const ref = raw === undefined ? null : store.refForId(Number(raw));
+        if (ref === null || ref.backend !== "built-in" || !visible(ref.repo) || !store.accountCanAccess(who.name, ref.repo) || releaseTaskOf(store, ref.externalId) === null)
+            return missing(who, response);
+        return redirect(response, releaseSheetHref(ref.externalId));
+    }
+    /** The sheet's Approve release, after the approval POST's shared checks. */
+    function approveFromSheet(ctx, taskId, cardDigest, token) {
+        const { who, response } = ctx;
+        const now = clock();
+        const answer = spendingOnlyOnSuccess(() => withFreshness("approve-standard", () => approveReleaseCard(store, { taskId, cardDigest, approveNow: scopeDigest => approveScope(store, taskId, who.name, now, scopeDigest, token) })), result => !result.ok && !(result.reason === "approve" && result.result.reason === "second-approver" && !result.result.already));
+        if (answer.ok)
+            return redirect(response, releaseSheetHref(taskId));
+        if (answer.reason !== "approve")
+            return sheetScreen(ctx, taskId, answer.message, answer.reason === "not-release" ? 404 : 409);
+        const refused = answer.result;
+        if (refused.reason === "second-approver")
+            return sheetScreen(ctx, taskId, gateWords({ verdict: "vote", have: refused.have, need: 2, already: refused.already }), 200);
+        if (refused.reason === "policy")
+            return sheetScreen(ctx, taskId, refused.message, 403);
+        return sheetScreen(ctx, taskId, approveRefusalWords(refused.reason), refused.reason === "changed" || refused.reason === "unrouted" ? 409 : 403);
+    }
+    return { routes: { "task.release": showSheet, "release.locate": locate }, sheetScreen, approveFromSheet };
+}

package/dist/setup-guide.d.ts

@@ -15,10 +15,10 @@ export declare function detectPreparation(repo: string): {
 } | null;
 /** Browser installation may write only this known file inside its project. */
 export declare function previewProjectInstructions(repo: string): {
-    content?: never;
     ok: false;
     message: string;
     plan?: never;
+    content?: never;
     fingerprint?: never;
     installed?: never;
 } | {
@@ -30,10 +30,10 @@ export declare function previewProjectInstructions(repo: string): {
     installed: boolean;
 };
 export declare function addProjectInstructions(repo: string, fingerprint: string): {
-    content?: never;
     ok: false;
     message: string;
     plan?: never;
+    content?: never;
     fingerprint?: never;
     installed?: never;
 } | import("./skills.js").InstallResult;

package/dist/stop-proof.d.ts

@@ -0,0 +1,67 @@
+import { type StopOptions } from "./run-closeout.js";
+import { type Store } from "./store.js";
+/** How long after a run finished its processes have to go on their own before Toolroll looks. */
+export declare const STOP_PROOF_GRACE_MS = 60000;
+export type StopProofOutcome = 
+/** Proven stopped and settled, in the ledger with its evidence. */
+"settled"
+/** Not yet: inside the grace period, a live child is still tracked here, or a leftover was just stopped. */
+ | "waiting"
+/** This computer can't prove it (can't look, another computer's process, or something it didn't start is in the
+ * folder). Recorded once, in plain words. */
+ | "blocked"
+/** Nothing for this proof to do: already stopped, still open, alive on its own record, or a native sandbox. */
+ | "skipped";
+export type StopProofResult = {
+    run: number;
+    outcome: StopProofOutcome;
+    words: string;
+    stopped?: number;
+};
+export type StopProofOptions = StopOptions & {
+    /** How long after the run finished before Toolroll looks (STOP_PROOF_GRACE_MS). `graceMs` is the SIGTERM grace. */
+    afterFinishMs?: number;
+    /** Which processes have their working directory inside each path; must throw when it can't tell. */
+    cwds?: (paths: readonly string[]) => Map<string, number[]>;
+    /** Every process's command line, by pid; must throw when it can't tell. */
+    commandLines?: () => Map<number, string>;
+    /** The live service's own pid (its ancestors are never targets). */
+    self?: number;
+    /** The worktree note check (worktree.ts); throws when the note can't be read. */
+    occupancy?: (path: string) => {
+        held: true;
+        by: number;
+    } | {
+        held: false;
+    };
+    /** Called after processes were stopped: a cached look must be read again. */
+    refresh?: () => void;
+};
+/** One pass's shared look at this computer: the process table, folders and command lines are read once for every
+ * run the pass checks, and again after anything was stopped. */
+export declare function sharedLook(options?: StopProofOptions): StopProofOptions;
+/** Which processes work inside each path, from the OS: /proc on Linux, lsof on macOS. Unlike a best-effort listing,
+ * it throws when the listing can't be read: no answer is never "nobody". */
+export declare function processesInStrict(paths: readonly string[], listing?: readonly {
+    pid: number;
+    cwd: string;
+}[]): Map<string, number[]>;
+/** Every process's working directory, from the OS; throws when the listing can't be read. */
+export declare function processFolders(): {
+    pid: number;
+    cwd: string;
+}[];
+/** Every process's command line, by pid. Read to match a folder's path in memory only; never stored or shown. */
+export declare function processCommandLines(): Map<number, string>;
+/** Whether a command line names `path` or something inside it (a whole path, never a longer folder's prefix). */
+export declare function namesPath(line: string, path: string): boolean;
+/**
+ * Prove one finished run stopped, on this computer, without asking anyone (see the file's comment). Walks the run's
+ * owned runs one unproven stop at a time. Never signals a process that isn't proven the run's.
+ */
+export declare function proveRunStopped(store: Store, runId: number, clock: () => Date, options?: StopProofOptions): Promise<StopProofResult>;
+/** The worker's pass (operate.ts reconcile): every finished run of this computer whose stop is unproven where
+ * Toolroll's own look can prove it. A batch a pass, oldest first; a blocked run never holds newer ones back. */
+export declare function proveFinishedRunsStopped(store: Store, clock: () => Date, options?: StopProofOptions & {
+    batch?: number;
+}): Promise<StopProofResult[]>;