toolroll 0.9.104 → 0.9.105

package/dist/server/task-views.js

@@ -21,7 +21,7 @@ import { recentGitReads, taskBaseOf } from "../task-base.js";
 import { assignmentPresentationOf, historicalAssessmentReason } from '../assignment-presentation.js';
 import { html, joinHtml } from "../html.js";
 import { assignmentStatusOf, assignmentWithEvidence } from '../assignment-ui.js';
-import { assignmentOf } from '../assignment.js';
+import { assignmentOf, personCompletionRefusal } from '../assignment.js';
 import { knowledgeContextHtml } from "../knowledge-ui.js";
 import { failedAttemptSentence, failingCheckSuggestion, GENERAL_SUGGESTION, isInternalErrorReason, latestFinishedAttempt, missedRequirementLine, missedRequirementSuggestion, NO_REASON_RECORDED, stopSuggestionOf } from '../needs-you.js';
 import { planAutoPending } from "../plan-auto.js";
@@ -32,6 +32,7 @@ import { readSkillsSnapshot, skillTestResult } from "../project-skills.js";
 import { newestPullRequestOf, publishingOf, pullRequestBlocker } from '../pull-request-flow.js';
 import { structuredHandoffView, terminalDiffView } from "../result-evidence-readers.js";
 import { resultCheckLevel } from '../result-follow-ups.js';
+import { projectCheckSet } from '../check-levels.js';
 import { followThroughView } from "./render-follow-through.js";
 import { skillsSnapshotHtml, skillTestFeedbackHtml } from "../skills-ui.js";
 import { archiveOf } from "../store.js";
@@ -72,10 +73,7 @@ import {} from "../store.js";
 import { taskControlOf } from "../task-control.js";
 import { lastErrorLineOf, missedRequirementOf, workStatusOf } from "../workspace-ui.js";
 export function createTaskViews(runtime) {
-    // The task page's base line reads Git through a frozen view of the project (~0.2-0.5 s on a large repository) and
-    // the page renders it twice per view and again on every live refresh: its answers are kept for a moment.
     const baseGit = recentGitReads();
-    /** The first task's way to Ready shows until the first Ready result, and stays on the installation's first task. */
     function guided(rootId, now) {
         if (runtime.store.isDemo())
             return false;
@@ -125,21 +123,12 @@ export function createTaskViews(runtime) {
         });
         return html `${warning}${active}<details class="task-history" data-root-task="${family.root.id}"><summary>History</summary><ol>${versions}</ol></details>`;
     }
-    /** Keep detailed receipt diagnostics; shared assignment reads own readiness. */
     function freshAssignment(assignment, receipt) {
         if (assignment === null)
             return null;
         const value = assignmentWithEvidence(assignment, receipt === null ? null : receiptStatusOf(receipt), receipt?.runId ?? null);
         return receipt === null ? value : { ...value, attention: [...new Set([...value.attention, ...receipt.facts.evidenceProblems, ...receipt.caveats.filter(reason => !historicalAssessmentReason(reason))])] };
     }
-    /**
-     * One Work row's facts (workspace package 1), from the records the task
-     * page already reads: the dispatch diagnosis, the latest finished
-     * builder/scout run with its machine verdict and any acceptance, the
-     * run's publication, and the live claim. The words come from the pure
-     * projection so this row, the task page, the focused chat, and the
-     * review cockpit cannot disagree about the same run.
-     */
     function workRowOf(task, now, receipt) {
         const ref = runtime.store.lookupRef(task.id);
         const runs = ref === null ? [] : runtime.store.runsFor(ref.id);
@@ -166,6 +155,7 @@ export function createTaskViews(runtime) {
                         reasons: verdict?.reasons ?? [],
                         accepted: runtime.store.proofAcceptance(latest.id) !== null,
                         checkLevel: resultCheckLevel(runtime.store, latest.id, now),
+                        ...(ref?.repo == null ? {} : { checkSet: projectCheckSet(runtime.store, ref.repo) }),
                         review: runtime.reviewFactsFor(latest.id),
                         ...(latest.outcome !== "no-change"
                             ? {}
@@ -178,8 +168,6 @@ export function createTaskViews(runtime) {
             unfinishedRunId: runs.find(one => one.outcome === null && one.role !== "reviewer")?.id ?? null,
             control: ref === null ? { kind: "none" } : taskControlOf(runtime.store, ref.id, now),
         };
-        // Read the same evidence-health projection as the receipt, including
-        // damaged files discovered after a stored verdict was written.
         const result = receipt === undefined && task.state === "done" && latest !== null && (latest.outcome === "built" || latest.outcome === "no-change")
             ? completionReceiptView(runtime.store, latest, runtime.store.artifactsFor(latest.id), runtime.evidenceRoot, runtime.reviewFactsFor(latest.id)) : receipt;
         const status = workStatusOf(facts, result == null ? undefined : receiptStatusOf(result));
@@ -196,7 +184,6 @@ export function createTaskViews(runtime) {
             familyNotice: task.family?.problem ?? (otherActive ? `${otherActive} earlier version${otherActive === 1 ? " is" : "s are"} still waiting or running. Open History.` : null),
             status: assignment === null ? status : { ...assignmentStatus, diagnostics: assignmentPresentationOf(assignment, { workStatus: status, diagnostics: [...(status.diagnostics ?? []), ...(status.tone === "problem" && status.detail !== assignment.detail ? [status] : [])] }).diagnostics }, assignment, assignmentProblem: status.tone === "problem", resultRunId: latest === null ? null : latest.id };
     }
-    /** The compact task list for the master pane, the current row marked. */
     function taskListPane(project, currentId) {
         const rows = familyTasksInView(project, undefined, 100);
         if (currentId !== null && !rows.some(one => one.id === currentId)) {
@@ -208,26 +195,10 @@ export function createTaskViews(runtime) {
             .map(task => html `<a class="item${task.id === currentId ? " current" : ""}" href="${taskHref(task.id)}"><span class="t">${task.title}</span></a>`), "\n");
         return html `<h2>Tasks</h2>\n${rows.length === 0 ? html `<p class="meta">None yet</p>` : items}`;
     }
-    /**
-     * The one liveness fact (round-4 findings 14/15): a run is being built
-     * right now iff its outcome is null AND its lease is the task's current
-     * live claim \u2014 maximum generation, unreleased, strictly unexpired. Every
-     * "running" label, poller, and watch link derives from this; nothing
-     * ever infers liveness from a null outcome alone.
-     */
     function runIsLive(run) {
         return run.outcome === null && runtime.store.currentLiveLease(run.taskRef, runtime.clock()) === run.leaseId;
     }
-    /** Planner, reviewer, and structured-output correction bookkeeping can
-     * finish around a build but are never the task's delivered result. */
     const runIsTaskResult = (run) => run.finishedAt !== null && (run.role === "builder" || run.role === "scout");
-    /** The task screen, shared by the GET and by every refusal that re-renders it. */
-    /**
-     * What a revision task's approval must restate (M6.8): the exact comment
-     * batch, read back through the verified artifact path. A brief that no
-     * longer verifies is a named problem on the screen — approving against
-     * bytes nobody can prove is not approving anything.
-     */
     function revisionViewOf(ref) {
         if (ref === null || ref.revisionBriefArtifact === null)
             return null;
@@ -257,8 +228,6 @@ export function createTaskViews(runtime) {
             return { problem: "the revision brief did not parse" };
         }
     }
-    /** The task view's facts, shared by the full screen and the workbench
-     * pane (attended A1): one assembly, one authorization story. */
     function taskViewData(taskId, who, problem, render = {}) {
         const found = runtime.store.getTask(taskId);
         if (found === null)
@@ -269,30 +238,15 @@ export function createTaskViews(runtime) {
         const now = runtime.clock();
         const scope = runtime.store.getScope(taskId);
         const revision = revisionViewOf(ref);
-        // A broken revision brief blocks the whole approval surface (audit
-        // IV-3): no nonce is minted over a batch nobody can verify.
         const revisionBroken = revision !== null && "problem" in revision;
         const planView = ref === null ? null : planViewOf(ref.id);
         const approvalDigest = scope === null ? null : approvalFormDigest(scope.digest, planView?.sha256 ?? null);
-        // The nonce is minted at render, per viewer, bound to the digest being
-        // shown — the browser approval flow starts here and nowhere else.
-        // …and only through an OPEN consent door (v48): an unreadable route,
-        // a route that cannot run, or a pre-routing row whose approval lapsed
-        // gets recovery copy, never a nonce.
         const routeView = routeViewOf(taskId, ref, scope, now, who);
-        // A read-only refresh (package 2) reads the same facts WITHOUT minting:
-        // a five-second poll must never churn the bounded nonce store, and a
-        // fragment carries no password form to bind a nonce to.
         const nonce = who.via === "cookie" && scope !== null && approvalDigest !== null && !approvalOf(scope).approved && !revisionBroken && ref?.plan !== "requested" && consentDoorOf(scope, routeView).open
             ? render.mintNonce === false ? "unminted" : runtime.mintApprovalNonce(who.name, taskId, approvalDigest)
             : "";
         const runs = ref === null ? [] : runtime.store.runsFor(ref.id);
         const completion = (() => {
-            // v40 fix: a reviewer run finishes AFTER the build it reviews and
-            // carries no proof verdict of its own — without this filter, its
-            // "no-change" outcome would hijack the task's own completion card
-            // the instant a review lands, showing "proof missing" for a proof
-            // that is right there on the builder's run.
             const latest = runs.find(runIsTaskResult);
             if (latest === undefined)
                 return null;
@@ -304,9 +258,6 @@ export function createTaskViews(runtime) {
                 outcome: latest.outcome,
                 hasTerminalDiff: artifacts.some(one => one.kind === "terminal-diff"),
                 hasHandoff: artifacts.some(one => one.kind === "handoff"),
-                // The closed machine-authored verdict (Priority 2), computed once
-                // at completion by adjudicate() and never re-inferred here — null
-                // only for a run that predates the proof system.
                 proofVerdict: verdict?.verdict ?? null,
                 machineVerdict: verdict?.machineVerdict ?? null,
                 proofReasons: verdict?.reasons ?? [],
@@ -314,24 +265,14 @@ export function createTaskViews(runtime) {
                 proofMatrixLinks: evidenceLinksFor(artifacts),
                 proofAccepted: runtime.store.proofAcceptance(latest.id) !== null,
                 qualityMode: latest.qualityMode ?? "default",
-                // Either direction: the ORIGINAL task's page finds the chain by
-                // its own latest run (the one that triggered a draft); a DRAFT
-                // task's page finds the SAME chain by being named as the draft.
                 repairChain: runtime.store.repairChainFor(latest.id) ?? runtime.store.repairChainForDraft(taskId),
-                // v50: the bounded review-retry history of this exact result —
-                // the same projection the CLI and dispatch diagnosis read.
                 reviewRetry: runtime.store.reviewRetryStateOf(latest.id),
-                // The same review facts every other surface projects for this run.
                 review,
                 receipt: latest.outcome === "built" || latest.outcome === "no-change"
                     ? completionReceiptView(runtime.store, latest, artifacts, runtime.evidenceRoot, review)
                     : null,
             };
         })();
-        // Adaptive execution plans (v44): the plan-revision ledger and live
-        // milestone projection, both null for a task with no plan at all.
-        // taskChatFocus below reads the SAME two calls, so the task page and
-        // focused chat always render identical facts (c2).
         const planRevisions = ref === null ? null : revisionLedgerOf(ref.id);
         const milestoneProgress = ref === null ? null : progressOf(ref.id, planRevisions?.current?.document ?? null);
         const family = runtime.familyOf(taskId);
@@ -345,17 +286,13 @@ export function createTaskViews(runtime) {
             task: found,
             status: workRowOf({ ...found, repo: ref?.repo ?? null }, now, completion?.receipt).status,
             dispatch: diagnoseTaskDispatch(runtime.store, taskId, now),
-            // v52: the exact-run control — the same projection the focused
-            // chat and `task show` read.
             control: ref === null ? { kind: "none" } : taskControlOf(runtime.store, ref.id, now),
             canRetryReview: who.via === "cookie" && who.role === "approver",
             strikes: ref?.strikes ?? 0,
             filer: runtime.store.taskFiler(taskId),
-            // v105: a waiting task whose monthly budget is used up says so.
             budgetHold: (() => {
                 if (ref === null || found.state !== "queued")
                     return null;
-                // Only work billed to an API key waits on a budget (its approved agent's, or Claude's by default).
                 const hold = runtime.store.budgetGate(now)({ ...runtime.store.budgetSubject(ref.id),
                     agents: runtime.store.agentsFor([runtime.store.getScope(taskId)?.approvedProfile?.provider ?? "claude"]) });
                 if (hold.over === null)
@@ -363,7 +300,6 @@ export function createTaskViews(runtime) {
                 return hold.why === "unpriced" ? `${budgetHoldWords(hold, monthOf(now).name)}; this waits until then`
                     : `${budgetLabel(hold.over)} monthly budget is used up, so this waits until next month or a higher budget`;
             })(),
-            // Sprint 8: a waiting task the organisation policy stops says which rule, or that it runs lowered.
             policyHold: (() => {
                 if (ref === null || found.state !== "queued")
                     return null;
@@ -395,20 +331,14 @@ export function createTaskViews(runtime) {
             revision,
             planRevisions,
             milestoneProgress,
-            // v40: the fallback for a task page with no completed run yet (a
-            // freshly drafted, unapproved repair) — completion's own branches
-            // cover every case once a run exists.
             repairChain: completion !== null ? null : runtime.store.repairChainForDraft(taskId),
             repo: ref?.repo ?? null,
             filedVia: runtime.store.filedViaOf(taskId),
-            // v126: where the work came from (a flow, an outside event), from what was kept when it was filed.
             origin: (() => { const repos = runtime.workAccess().repos; return originOf(runtime.store, taskId, repo => repos === null || repos.includes(repo)); })(),
             coordinator: (() => {
                 const who = runtime.store.coordinatorProvenanceOf(taskId);
                 if (who === null)
                     return null;
-                // RELATIVE age (round-2 finding 5): "12m ago" reads at a glance;
-                // an absolute stamp makes the operator do arithmetic.
                 const ago = who.filedAt === null
                     ? null
                     : (() => {
@@ -423,18 +353,12 @@ export function createTaskViews(runtime) {
             })(),
             holds: ref === null ? [] : runtime.store.activeHolds(ref.id, now),
             claimed: ref === null ? false : runtime.store.hasLiveClaim(ref.id, now),
-            // The chain, both directions of trust: blockers outside the ceiling
-            // are named but wear no state and no link (same redaction the board
-            // applies to blockerState).
             waitsFor: runtime.store.blockers(taskId).map(blockerId => {
                 const blockerRef = runtime.store.lookupRef(blockerId);
                 const admitted = blockerRef !== null && runtime.visible(blockerRef.repo);
                 const blocker = admitted ? runtime.store.getTask(blockerId) : null;
                 return { id: !admitted && runtime.restricted() ? "restricted task" : blockerId, title: blocker === null ? null : blocker.title, state: blocker === null ? null : blocker.state, admitted };
             }),
-            // Candidates a "wait for" or replacement select may offer: this
-            // TASK's own project, even when the sidebar is in all-project mode.
-            // That keeps repair complete without ever mixing unrelated projects.
             waitCandidates: (() => {
                 if (who.via !== "cookie")
                     return [];
@@ -446,16 +370,12 @@ export function createTaskViews(runtime) {
                         .filter(one => one.id !== taskId && (one.state === "queued" || one.state === "running") && runtime.visible(one.repo))
                         .map(one => ({ id: one.id, title: one.title }));
             })(),
-            // The one liveness fact, computed here where the store is: the run
-            // whose lease is the task's CURRENT claim — not merely the first
-            // unfinished run (round-4 finding, A1).
             liveRunId: (() => {
                 if (ref === null)
                     return null;
                 const found = runtime.store.runsFor(ref.id).find(one => runIsLive(one));
                 return found === undefined ? null : found.id;
             })(),
-            // Live steering: the Claude build that takes Pause right now, and where its latest pause stands.
             livePause: (() => {
                 const run = ref === null ? null : runtime.store.liveInputRun(ref.id, now);
                 if (run === null)
@@ -485,11 +405,8 @@ export function createTaskViews(runtime) {
             mirror: runtime.store.mirrorByTask(taskId),
             scope,
             approvalDigest,
-            // The phase route (v47): one projection for the card, the ceremony,
-            // and the focused chat, with the readiness this task's runners report.
             route: routeView,
             canEditRoute: who.role === "approver",
-            // Results routing (slice 1): the family's saved record, or the one its rows give now; never a reason to fail the page.
             resultRecord: resultRecordWordsOf(runtime.store, taskId, runtime.evidenceRoot, now),
             spendDefaults: runtime.store.getSpendDefaults(),
             permissionDefault: runtime.store.permissionDefault().mode,
@@ -497,9 +414,6 @@ export function createTaskViews(runtime) {
             qualityDefault: runtime.store.qualityDefault().mode,
             qualityMode: ref?.qualityMode ?? null,
             publication: (() => {
-                // The latest publication across this task's runs, with its
-                // OBSERVED CI state (audit SD-5): the reviewer learns PR and CI
-                // here instead of spelunking run pages.
                 if (ref === null)
                     return null;
                 for (const one of runtime.store.runsFor(ref.id)) {
@@ -528,15 +442,10 @@ export function createTaskViews(runtime) {
             autoRelease: ref === null ? null : autoReleaseOf(runtime.store.getScope(ref.externalId)),
             releaseCiRunning: ref !== null && releaseCiRunningOf(runtime.store, ref.externalId) !== null,
             approvalProof: (() => {
-                // The proof of the approval shown: its approver, its exact sealed digest (approvedDigest === digest when approved).
                 const scope = ref === null ? null : runtime.store.getScope(ref.externalId);
                 return scope === null || scope.approvedBy === null || scope.approvedDigest === null ? null
                     : approvalProofOf(runtime.store, ref.externalId, scope.approvedBy, scope.approvedDigest);
             })(),
-            // Cockpit B2: whether this person's remembered password may approve these exact terms (the same rule approve()
-            // applies), and since when.
-            // The one password rule every approve form reads (approval-password.ts): remembered since when, or a local
-            // owner's no-password approval (eligible, or why not and where to go).
             ...(() => {
                 const scope = ref === null ? null : runtime.store.getScope(ref.externalId);
                 if (scope === null || ref === null || who?.via !== "cookie")
@@ -557,14 +466,10 @@ export function createTaskViews(runtime) {
                 return last === null ? null : fastChangeProblem(runtime.store, ref.externalId, last.id);
             })(),
             steerRecent: ref === null ? [] : runtime.store.runsFor(ref.id).filter(one => one.outcome !== null).map(one => one.id).sort((a, b) => b - a).slice(0, 5),
-            // The running attempt's composer, for an approver on a browser session (steer-controls.ts).
             steerComposer: (() => {
                 const run = ref === null ? null : liveAttemptOf(runtime.store, ref.id, now);
                 return run === null ? null : steerControlsFor(runtime.store, ref.externalId, run, now, who?.role === "approver");
             })(),
-            // "publishes as" reads ONLY publicationGrantFor(repo) — the grant
-            // the publisher would act under — never listGrants(), which is
-            // dispatch authority (slice 1c).
             grant: ref === null || ref.repo === null ? null : runtime.store.publicationGrantFor(ref.repo),
             csrf: who.via === "cookie" ? who.session.csrf : "",
             nonce,
@@ -572,12 +477,6 @@ export function createTaskViews(runtime) {
             now,
         };
     }
-    /** The Agents view (v47): the task's route from the ONE resolver dispatch
-     * uses — sealed, proposed, live, a proven pre-routing profile, or
-     * unreadable — projected with the readiness its runners have reported,
-     * and the edit posture an approver's controls need. The scope digest
-     * rides along so every change form can CAS against exactly what was
-     * rendered (an empty value means "I saw no scope"). */
     function routeViewOf(taskId, ref, scope, now, who) {
         if (ref === null)
             return null;
@@ -592,7 +491,6 @@ export function createTaskViews(runtime) {
             replanOnPlanChange: ref.plan === "drafted" && scope !== null && !approvalOf(scope).approved,
             digest: scope?.digest ?? null,
             choices: agentChoicesFor(runtime.store, ref.repo, routed.kind === "route" ? routed.route : null),
-            // Results routing: why an earned rule's model builds it, from the records as they stand now.
             evidence: routed.kind === "route" ? selectionEvidenceWords(runtime.store, routed.route, now) : null,
         };
         if (routed.kind === "route") {
@@ -603,8 +501,6 @@ export function createTaskViews(runtime) {
         }
         return { kind: "unreadable", source: null, projection: null, legacy: null, problem: routed.problem, ...shared };
     }
-    /** Resolve a task-scoped chat lens without trusting its query string.
-     * Only an admitted task becomes model context or visible page copy. */
     function taskChatFocus(taskId, now, who, options = {}) {
         if (taskId === null || taskId.length === 0 || taskId.length > 64 || hasForbiddenControls(taskId))
             return null;
@@ -615,10 +511,6 @@ export function createTaskViews(runtime) {
         const task = family.current;
         const ref = runtime.store.lookupRef(taskId);
         const scope = runtime.store.getScope(taskId);
-        // The focused chat is a lens over the task page's own assembled facts.
-        // Reusing that projection keeps approval nonces, joint approval digests,
-        // revision verification, decisions, and result evidence on one source
-        // of truth instead of growing a chat-only lifecycle.
         const view = who === undefined || family.problem !== null ? null : taskViewData(taskId, who, null, options);
         const runs = view?.runs ?? runtime.store.runsFor(ref.id);
         const latest = runs.find(runIsTaskResult) ?? null;
@@ -640,12 +532,8 @@ export function createTaskViews(runtime) {
             dispatch: diagnoseTaskDispatch(runtime.store, taskId, now),
             scope: scope === null ? "none" : approval.approved ? "approved" : "needs approval",
             plan: ref.plan,
-            // Adaptive execution plans (v44): the identical ledger/progress
-            // projection the task page renders (c2) — reused from `view` when
-            // available, computed fresh only when this call has no `who`.
             planRevisions,
             milestoneProgress: view?.milestoneProgress ?? progressOf(ref.id, planRevisions?.current?.document ?? null),
-            // What a failed task missed, said as the task page says it.
             failure: task.state === "failed" ? failureOf(family.versions.flatMap(version => runtime.store.runsFor(version.refId)), view?.assignment ?? assignmentOf(runtime.store, task.id, now, runtime.workAccess(), runtime.evidenceRoot)) : null,
             claimed: view?.claimed ?? runtime.store.hasLiveClaim(ref.id, now),
             liveRun: live === null ? null : { id: live.id, runner: live.runner, startedAt: live.startedAt, phase: live.phase },
@@ -678,9 +566,6 @@ export function createTaskViews(runtime) {
                     : completionReceiptView(runtime.store, latest, runtime.store.artifactsFor(latest.id), runtime.evidenceRoot, runtime.reviewFactsFor(latest.id)),
         };
     }
-    /** The newest pull request any version of this task opened through Complete; else, for a result completed
-     * without one, the offer to open it (an approver's browser session only). */
-    /** Where "Complete and open a pull request" would open one for this result, or null when it isn't offered. */
     function pullRequestTargetOf(runId) {
         const run = runtime.store.getRun(runId);
         const publishing = publishingOf(runtime.store, run === null ? null : runtime.store.refById(run.taskRef)?.repo ?? null);
@@ -709,7 +594,6 @@ export function createTaskViews(runtime) {
             return null;
         return { taskId: rootId, view: null, offer: { taskId: receipt.taskId, runId: receipt.runId, digest: receipt.digest }, target };
     }
-    /** What went wrong with the latest finished attempt (whatever its outcome, never an older failure). */
     function failureOf(runs, assignment, readLog = true) {
         const last = latestFinishedAttempt(runs);
         if (last === null)
@@ -718,12 +602,6 @@ export function createTaskViews(runtime) {
         return full === null ? { kind: "reason", line: failedAttemptSentence(last.reason), evidence: null, suggestion: stopSuggestionOf(last.reason), link: null }
             : explainAttempt(full, assignment?.receipt?.runId === last.id ? assignment.receipt : null, readLog);
     }
-    /** One finished attempt's failure in plain words: a failing check's last error line (linked to that line in its
-     * saved log), else the first signed requirement it missed with the evidence line behind it, else its recorded reason
-     * in plain words (or that none was recorded). Each comes with one suggestion of what to change, and a link to the
-     * attempt's own result page, where its changes, checks and failure are; machine output reads as an internal error,
-     * its detail behind a link to that line of the attempt's record. `readLog` false (a list's rows) reads no saved
-     * check log: the requirement or the reason, from the database alone. */
     function explainAttempt(run, receipt, readLog = true) {
         const taskId = runtime.store.externalIdFor(run.taskRef) ?? "";
         const page = `${reviewHref(taskId)}&run=${run.id}`;
@@ -760,8 +638,6 @@ export function createTaskViews(runtime) {
         return { kind: "reason", line: failedAttemptSentence(run.reason), evidence: null, suggestion: stopSuggestionOf(run.reason),
             link: internal ? { label: "The recorded error", href: `/r/${run.id}?record=1#run-reason-detail` } : see };
     }
-    /** Run checks in place on a result's commit: an approver's browser session, outside the demo, when the project has a
-     * check and none is waiting or running on it. Comes back to `returnTo`. */
     function runChecksHere(runId, who, returnTo) {
         if (runId === null || who.via !== "cookie" || who.role !== "approver" || runtime.store.isDemo())
             return null;
@@ -771,11 +647,6 @@ export function createTaskViews(runtime) {
             return null;
         return { action: `/r/${runId}/checks`, level: followUps.full ? "full" : "quick", returnTo };
     }
-    /**
-     * One page per task (docs/plans/one-page-task-and-agent.md): the tab the address named, the Result tab's result with
-     * every result attempt to pick from, and every link that would open a result page of this family (its /review deep
-     * link, a build's /r/<n>) pointed at this page's Result tab instead — the person stays on the task.
-     */
     function onePageView(view, family, runs, extras) {
         const root = family?.root.id ?? view.id;
         const current = family?.current.id ?? view.id;
@@ -809,11 +680,9 @@ export function createTaskViews(runtime) {
             ...(view.failure == null ? {} : { failure: { ...view.failure, link: link(view.failure.link) } }),
             ...(view.earlier == null ? {} : { earlier: { ...view.earlier, attempts: view.earlier.attempts.map(one => ({ ...one, href: toTab(one.href) })) } }),
             ...(view.thread === undefined ? {} : { thread: view.thread.map(one => ({ ...one, link: link(one.link) })) }),
-            // The previous result's fold moves to the Result tab when there is one.
             sections: selected === null ? view.sections : view.sections.filter(one => one.id !== "result"),
             tab: extras.tab ?? "activity",
             result: selected === null ? null : { selected, current: extras.result.current, attempts,
-                // Fresh per-render request tokens (32 hex) are not what it shows: left out, so an unchanged result keeps its stamp.
                 revision: createHash("sha256").update(JSON.stringify(selected).replace(/\b[a-f0-9]{32}\b/g, "")).digest("hex").slice(0, 16) },
         };
     }
@@ -821,7 +690,6 @@ export function createTaskViews(runtime) {
         const admittedFamily = runtime.familyOf(taskId);
         if (admittedFamily?.problem != null)
             return runtime.sendScreen(response, status, screen(admittedFamily.root.title, html `<h1>${admittedFamily.root.title}</h1><p>${admittedFamily.current.state}</p><p class="problem" data-history-problem>${admittedFamily.problem}</p>`, { chrome: runtime.chromeFor(admittedFamily.root.repo, "tasks") }));
-        // A read ahead (x-toolroll-read: prefetch, live-pages-and-home.md A1.4) mints nothing: its plan form says "unminted".
         const data = taskViewData(taskId, who, problem, { mintNonce: requestContext.getStore()?.readPurpose !== "prefetch" });
         if (data === null)
             return refuse(response, who, 404, "no such task", "/tasks");
@@ -829,7 +697,6 @@ export function createTaskViews(runtime) {
         const presentedData = { ...data, rootId: family?.root.id ?? taskId, rootTitle: family?.root.title ?? data.task.title,
             ...(family === null || data.assignment != null ? {} : { history: familyHistory(family) }),
             versionLabel: family !== null && family.current.id !== taskId ? `Viewing ${family.versions.findIndex(one => one.id === taskId) === 0 ? "Original" : `Revision ${family.versions.findIndex(one => one.id === taskId)}`} · ${family.current.state === "running" ? "A newer revision is running" : "A newer revision is current"}` : null };
-        // Put away (v145, task-tidy.md): who or what put it away and why, and whether this person can put it away or restore it.
         const archived = archiveOf(runtime.store, taskId);
         presentedData.archived = archived;
         presentedData.canPutAway = who.via === "cookie" && who.role === "approver";
@@ -840,13 +707,11 @@ export function createTaskViews(runtime) {
         if (editPlan)
             presentedData.editPlan = true;
         presentedData.pullRequest = taskPullRequestOf(taskId, who);
-        // The thread reads the whole family: the original, its revisions, and every attempt across them.
         if (family !== null && family.problem === null) {
             presentedData.family = { root: { id: family.root.id, title: family.root.title, createdAt: family.root.createdAt, goal: runtime.store.getScope(family.root.id)?.goal ?? null },
                 versions: family.versions.map(one => ({ id: one.id, title: one.title, state: one.state })),
                 runs: family.versions.flatMap(version => version.id === data.task.id ? data.runs.map(run => ({ ...run, taskId: version.id })) : runtime.store.runsFor(version.refId).map(run => ({ ...run, taskId: version.id }))) };
         }
-        // What went wrong reads the family's latest finished attempt, as the Tasks row does.
         presentedData.failure = failureOf(presentedData.family?.runs ?? data.runs, data.assignment ?? null);
         presentedData.runChecks = runChecksHere(data.assignment?.receipt?.runId ?? null, who, taskHref(taskId));
         const liveRun = data.liveRunId == null ? undefined : data.runs.find(one => one.id === data.liveRunId);
@@ -857,31 +722,21 @@ export function createTaskViews(runtime) {
         const page = taskPage(paneProject === null && !runtime.unscopedMode
             ? runtime.chromeFor(paneProject, "tasks")
             : runtime.chromeFor(paneProject, "tasks", taskListPane(paneProject, family?.root.id ?? taskId)), presentedData);
-        // The task's own conversation, docked beside the page (v77).
         const focus = taskChatFocus(family?.root.id ?? taskId, runtime.clock(), who, { mintNonce: false });
         const docked = focus === null ? null : runtime.dockedConversation(who, focus, null, runtime.clock(), taskHref(focus.id));
-        // The conversation is the page's own thread here, so the page drops its Ask tab;
-        // only an approver is offered a road to message the agent.
         const taskView = page.workspace?.view?.kind === "task" ? { ...page.workspace.view, ...(docked === null ? {} : { tabs: [] }), ...(who.role === "approver" ? {} : { chatHref: null }),
-            // A signed-in page hears the moment the task changes, and who else has it open.
             ...(who.via === "cookie" ? { live: { room: `task:${encodeURIComponent(family?.root.id ?? taskId)}`, at: (() => { try {
                         return taskFingerprint(runtime.store, family?.root.id ?? taskId, runtime.clock());
                     }
                     catch {
                         return null;
                     } })() } } : {}) } : page.workspace?.view;
-        // A refusal that keeps a draft (a scope edit, an armed cancel) or asks for the plan editor reopens on Plan, where the
-        // draft and its error are; anything else on Activity unless the address named a tab.
         const tab = extras.tab ?? "plan";
         const onePage = taskView?.kind === "task" ? onePageView(taskView, family, presentedData.family?.runs ?? data.runs.map(run => ({ ...run, taskId: data.task.id })), { ...extras, tab }) : taskView;
-        // Ship (its pull request's checks, each on one time axis) and a release's own steps, read from the store now.
         const rootId = family?.root.id ?? taskId;
         const oneTaskView = onePage?.kind === "task" ? { ...onePage, ship: shipViewOf(shipChecksForTask(runtime.store, rootId), runtime.clock()),
             release: releaseStepsViewOf(releaseProgressFor(runtime.store, rootId), runtime.clock()),
-            // "Can I merge?" (P1.6): the checklist from the same assignment this page read, each blocker with its own form.
             mergeReady: mergeReadyViewOf(runtime.store, taskId, data.assignment, who, presentedData.runChecks ?? null, taskHref(taskId)) } : onePage;
-        // A check the machine runs (a prepared candidate: a release's check) is said as the check it is, with no agent's
-        // activity, no notes to read, and for a release its own steps instead of the generic Plan → Build stepper.
         if (oneTaskView?.kind === "task" && machineChecked(runtime.store, taskId)) {
             const words = machineCheckWords(runtime.store, taskId, data.liveRunId ?? null, oneTaskView.release ?? null, runtime.clock());
             const card = oneTaskView.status;
@@ -892,15 +747,10 @@ export function createTaskViews(runtime) {
             if (oneTaskView.release != null)
                 oneTaskView.journey = null;
         }
-        // The step rows read the view as the page will show it (its result, its release, its checks words).
         if (oneTaskView?.kind === "task")
             oneTaskView.steps = stepRowsOf(oneTaskView);
-        // The Result tab's no-script page, under the task's own (the same HTML its result page serves), and its script.
         if (extras.result != null) {
             page.body = html `${page.body}<section class="task-result-tab" id="task-result" aria-label="Result">${extras.result.html}</section>`;
-            // The result's own script, as its result page ships it (a password form there keeps it too: Request changes and
-            // the line notes need it).
-            // The app runs its own version (browser/work/result.ts), so a task with a result can open in place.
             page.functional = withScript(page.functional, { script: `${reviewEvidenceScript()}${RESULT_REVIEW_SCRIPT}`, app: [{ kind: "result" }] });
         }
         if (docked !== null)
@@ -910,13 +760,7 @@ export function createTaskViews(runtime) {
         page.refreshSeconds = runtime.liveRefreshSeconds();
         return runtime.sendScreen(response, status, page);
     }
-    /** Shared by task controls and chat proposals; both callers authorize the task first. */
     function armTaskResume(response, who, taskId, named, returnTo, now) {
-        // The resume ceremony's first half (v52): minted by THIS POST, never
-        // a GET. The nonce is bound to the exact run, this approver, and a
-        // digest of the facts the confirmation restates — the run, its
-        // settlement, and the scope's current approval — so a page read
-        // before the approval changed cannot resume under the new terms.
         if (who.via !== "cookie")
             return refuse(response, who, 403, "resuming a task is a browser session's act");
         if (who.role !== "approver")
@@ -954,8 +798,6 @@ export function createTaskViews(runtime) {
             approved: (() => { const scope = runtime.store.getScope(taskId); return scope !== null && approvalOf(scope).approved; })(),
         }));
     }
-    /** The newest plan document for a task, verified before a byte renders.
-     * Its hash is also the plan revision the approval form was minted for. */
     function planViewOf(taskRef) {
         const artifact = runtime.store.latestPlanArtifact(taskRef);
         if (artifact === null)
@@ -968,14 +810,6 @@ export function createTaskViews(runtime) {
             return null;
         }
     }
-    /**
-     * The plan-contract record of the newest drafted plan (contract handoff,
-     * task 1): what the planner was filed, what it proposed, its explicit
-     * amendment, and every mechanical change between the two — verified
-     * before a byte renders, and marked `current` only while the proposed
-     * terms are still exactly the scope row (an operator's later edit turns
-     * the record into history, never a claim about the row).
-     */
     function planContractViewOf(taskRef, scope) {
         const artifact = runtime.store.latestPlanContractArtifact(taskRef);
         if (artifact === null)
@@ -1031,16 +865,6 @@ export function createTaskViews(runtime) {
             return null;
         }
     }
-    /**
-     * The adaptive-plan ledger for one task: the revision currently in force,
-     * any revision still 'blocked' awaiting an operator's accept or reject,
-     * and the full immutable history. A task with no `plan_revision` rows at
-     * all — every task filed before this feature, or one whose first
-     * revision is still 'blocked' — reads `current` as a read-only
-     * projection off the existing planner artifact (`planViewOf`), never
-     * written back as a row: c1's "older builds with no checkpoints remain
-     * readable."
-     */
     function revisionLedgerOf(taskRef) {
         const history = runtime.store.listPlanRevisions(taskRef).map(revisionDocOf).filter((view) => view !== null);
         const currentRow = runtime.store.currentPlanRevision(taskRef);
@@ -1071,12 +895,6 @@ export function createTaskViews(runtime) {
         }
         return { current, pending, history };
     }
-    /** The live milestone projection for a task: every milestone in the
-     * CURRENT revision's document, in order, each carrying the newest
-     * checkpoint's state for its exact id — a checkpoint filed against an
-     * older, differently-worded revision simply has no matching ids, so its
-     * milestones fall back to "pending" rather than showing stale progress
-     * under a plan that no longer says that. */
     function progressOf(taskRef, currentDocument) {
         if (currentDocument === null)
             return null;
@@ -1091,21 +909,6 @@ export function createTaskViews(runtime) {
             return { id: milestone.id, description: milestone.description, state: entry?.state ?? "pending", note: entry?.note ?? null };
         });
     }
-    /**
-     * The review cockpit's projection of ONE completed task (Priority 5):
-     * approved intent from the scope and plan already on file, the result
-     * run's sealed artifacts through the same verified readers the run page
-     * uses, the stored verdict and matrix, the publication
-     * rows. Nothing here is a new record: a manual completion (no run), a
-     * legacy result (no proof verdict), and a broken artifact each read as
-     * exactly what they are. Only the selected result is enriched — the
-     * queue rows carry the done list's own facts and nothing more.
-     */
-    /**
-     * The result detail (workspace package 3): every verified record one
-     * finished run's result presentation reads, assembled once for the run
-     * page, the review cockpit, and the chat's result view. Read-only.
-     */
     function resultDetailOf(run, who, now) {
         const taskId = runtime.store.externalIdFor(run.taskRef) ?? "?";
         const scope = runtime.store.getScope(taskId);
@@ -1115,8 +918,6 @@ export function createTaskViews(runtime) {
         const handoff = structuredHandoffView(artifacts, runtime.evidenceRoot);
         const review = runtime.reviewFactsFor(run.id);
         const receipt = completionReceiptView(runtime.store, run, artifacts, runtime.evidenceRoot, review);
-        // File anchors come from the PARSED sealed patch — a stat path with no
-        // hunk in the patch gets no anchor, never a dangling one.
         const patch = terminal?.patch ?? null;
         const patchOk = patch !== null && !("problem" in patch);
         const parsedPaths = patchOk ? parseReviewDiff(patch.text).files.filter(one => one.hunks.length > 0).map(one => one.path) : [];
@@ -1144,7 +945,7 @@ export function createTaskViews(runtime) {
             try {
                 learning = learningHtml(learningView(runtime.store, runtime.evidenceRoot, learningRepo, who.name), who.via === "cookie" ? who.session.csrf : "", who.role === "approver", run.id);
             }
-            catch { /* Learning failures remain available in Settings; the result is independent. */ }
+            catch { }
             try {
                 const test = skillTestResult(runtime.store, run.id, who.name);
                 if (test) {
@@ -1170,9 +971,12 @@ export function createTaskViews(runtime) {
             ...(() => { const family = runtime.familyOf(taskId); return family === null ? {} : { history: familyHistory(family) }; })(),
             run,
             receipt,
-            assignment: (() => {
+            ...(() => {
                 const value = assignmentOf(runtime.store, taskId, now, runtime.workAccess(), runtime.evidenceRoot);
-                return value?.receipt?.runId === run.id && value.activeTaskId === taskId ? freshAssignment(value, receipt) : null;
+                const assignment = value?.receipt?.runId === run.id && value.activeTaskId === taskId ? freshAssignment(value, receipt) : null;
+                const completeRefusal = assignment?.state !== "ready-to-check" || assignment.receipt === null ? null
+                    : personCompletionRefusal(runtime.store, assignment.receipt.taskId, run.id, who.via === "cookie" ? who.name : null, runtime.evidenceRoot, who.via === "cookie" && who.authority === "local-owner" ? { rootId: assignment.rootId } : null);
+                return { assignment, completeRefusal };
             })(),
             handoff,
             proof,
@@ -1185,7 +989,6 @@ export function createTaskViews(runtime) {
             outsideTouches: files.filter(one => one.outsideTouches).map(one => one.path),
             fileAnchors,
             comments: runtime.store.liveDiffComments(run.id).filter(isRevisionFeedback),
-            // The same check that refuses a saved note's screenshot at revision time decides when it can be removed.
             unusableImageNotes: runtime.store.liveDiffComments(run.id).filter(one => isRevisionFeedback(one) && one.image != null
                 && feedbackImageProblem(runtime.store, runtime.evidenceRoot, run.id, one.image) !== null).map(one => one.id),
             pastComments: runtime.store.allDiffComments(run.id).filter(one => one.reviewerRun === null && (one.consumedBy !== null || one.supersededBy !== null)),
@@ -1195,16 +998,12 @@ export function createTaskViews(runtime) {
                 const child = runtime.store.getTask(one.id);
                 if (child === null || !runtime.visible(runtime.store.lookupRef(one.id)?.repo ?? null))
                     return [];
-                // The same projection the Work list and the child's own page wear.
                 const status = workRowOf({ ...child, repo: runtime.store.lookupRef(one.id)?.repo ?? null }, now).status;
                 return [{ id: one.id, title: one.title, state: one.state, approved: approvalOf(runtime.store.getScope(one.id)).approved, standing: status.label, tone: status.tone }];
             }),
             sourceDigest: scope?.digest ?? null,
             followUps: followUpsFor(runtime.store, runtime.evidenceRoot, run, now),
             route: runtime.store.runRoute(run.id),
-            // Editor links (arc 6): the deployment capability, THIS machine's
-            // runner owning the run, the session's own device-side yes, and a
-            // checkout to open — or nothing renders.
             editor: runtime.options.editorLinks !== undefined && runtime.options.localRunner !== undefined && run.runner === runtime.options.localRunner && who.via === "cookie" && who.session.editorLinks === true && run.worktree !== null && existsSync(run.worktree)
                 ? { worktree: run.worktree }
                 : null,
@@ -1214,15 +1013,12 @@ export function createTaskViews(runtime) {
     }
     return { guided, projectFamilyPeek, familiesInView, familyTasksInView, revisionDestination, earlierLiveVersions, familyHistory, freshAssignment, workRowOf, taskListPane, runIsLive, runIsTaskResult, revisionViewOf, taskViewData, routeViewOf, taskChatFocus, pullRequestTargetOf, taskPullRequestOf, failureOf, explainAttempt, runChecksHere, taskScreen, armTaskResume, planViewOf, planContractViewOf, revisionDocOf, revisionLedgerOf, progressOf, resultDetailOf };
 }
-/** A release task the plane approved (or is checking) itself, for the task page (docs/plans/auto-approve-green.md). */
 function autoReleaseOf(scope) {
     if (scope === null || scope.approvedDigest !== scope.digest || (scope.candidate ?? null) === null)
         return null;
     return scope.approvalBasis === "auto-green" ? { kind: "approved", candidate: scope.candidate }
         : scope.approvalBasis === "auto-check" ? { kind: "checking", candidate: scope.candidate } : null;
 }
-/** A pull request's checks as Ship shows them (src/design/KIT.md timing rows): each check on one elapsed-time axis
- * from the first one's start, its state in the five words' tones, and one line for the whole. Null: no checks read. */
 export function shipViewOf(ship, now) {
     if (ship === null || ship.checks.length === 0)
         return null;
@@ -1242,8 +1038,6 @@ export function shipViewOf(ship, now) {
     const passed = ship.checks.filter(one => one.state === "passed" || one.state === "skipped" || one.state === "neutral").length;
     const failed = ship.checks.filter(one => one.state === "failed" || one.state === "cancelled").length;
     const running = ship.checks.length - passed - failed;
-    // The overall status is the observation's own (the one merges read); the rows only time each check.
-    // `none` (the pull request closed or merged, or GitHub reported no checks) is never painted as passed.
     const state = ship.observed === "failing" ? "failed" : ship.observed === "passing" ? "passed" : ship.observed === "running" ? "running" : "none";
     return {
         pr: ship.prNumber, head: ship.headSha.slice(0, 7), state, rows,
@@ -1253,22 +1047,16 @@ export function shipViewOf(ship, now) {
         observedAt: ship.observedAt,
     };
 }
-/** A release step's name in words (release.ts RELEASE_STEPS). */
 const RELEASE_STEP_WORDS = {
     gate: "Release gate", approval: "Approval", check: "Release check", complete: "Complete the task", quiet: "Wait for quiet", deploy: "Deploy to this Mac",
     link: "Point the CLI at it", ci: "Pull request checks", merge: "Merge into main", tree: "Verify the merged tree", tag: "Tag", publish: "Publish to npm", homebrew: "Homebrew",
 };
-/** A release's steps as its progress view shows them: every step in order on one time axis, the ones not reached
- * queued, and where it stands in one line. Null: this task is no release. */
 export function releaseStepsViewOf(progress, now) {
     if (progress === null)
         return null;
     const origin = Date.parse(progress.startedAt);
     const recorded = new Map(progress.steps.map(one => [one.step, one]));
     const all = RELEASE_STEPS.filter(step => step !== "done");
-    // A release that started part way (one carried under an earlier approval, or resumed from an older journal) shows
-    // the steps from where its own record starts; a step missing between two recorded ones is a write that was lost.
-    // A build running since the stop is the release's check, wherever the release last stopped; what follows it is to come.
     const building = progress.building, checkAt = all.indexOf("check");
     const firstAt = building === null ? all.findIndex(step => recorded.has(step)) : Math.min(all.findIndex(step => recorded.has(step)), checkAt);
     const lastAt = all.reduce((at, step, index) => recorded.has(step) ? index : at, -1);
@@ -1281,28 +1069,22 @@ export function releaseStepsViewOf(progress, now) {
         }
         if (building !== null && all.indexOf(step) > checkAt)
             return { name: RELEASE_STEP_WORDS[step] ?? step, st: "q", start: 0, dur: 0 };
-        // A step with no record is never painted as done: between recorded ones it says so, after them it is queued.
         if (one === undefined)
             return all.indexOf(step) < lastAt ? { name: RELEASE_STEP_WORDS[step] ?? step, sub: "not recorded", st: "q", start: 0, dur: 0 }
                 : { name: RELEASE_STEP_WORDS[step] ?? step, st: "q", start: 0, dur: 0 };
         const start = Date.parse(one.startedAt), end = one.endedAt === null ? now.getTime() : Date.parse(one.endedAt);
-        // A failure the release has gone on from (resumed past it, or a build since) is history, not where it stands.
         const passed = one.state === "failed" && progress.stopped === null;
         const st = one.state === "done" || passed ? "ok" : one.state === "failed" ? "bad" : one.state === "waiting" ? "wait" : "run";
         return { name: RELEASE_STEP_WORDS[step] ?? step, ...(passed ? { sub: "Stopped here, then went on" } : one.detail === null || one.state === "done" ? {} : { sub: one.detail.slice(0, 160) }), st,
             start: Number.isFinite(start) && Number.isFinite(origin) ? Math.max(0, (start - origin) / 1000) : 0, dur: Number.isFinite(start) && Number.isFinite(end) ? Math.max(0, (end - start) / 1000) : 0 };
     });
     const current = rows.findIndex(row => row.st === "run" || row.st === "wait" || row.st === "bad");
-    // Released only on its own evidence: the last step (Homebrew, after publication) recorded done. A merge (authority
-    // `merged`) is not a release: verifying the tree, the tag and publication still follow it.
     const done = progress.stopped === null && recorded.get("homebrew")?.state === "done";
     const at = current === -1 ? null : rows[current];
     const last = lastAt === -1 ? null : RELEASE_STEP_WORDS[all[lastAt]] ?? all[lastAt];
     return {
         tag: progress.tag, version: progress.version, pr: progress.pr,
         rows,
-        // Waiting is a person's act only at Approval; a step waiting on a machine (its check, GitHub's checks, quiet) is the
-        // release running, never "Needs you".
         state: progress.stopped !== null ? "failed" : done ? "done" : at?.st === "wait" && steps[current] === "approval" ? "waiting" : "running",
         at: current === -1 ? null : { step: steps[current], name: at.name, index: current + 1, of: rows.length },
         headline: done ? `Released ${progress.version}` : progress.stopped !== null ? `Stopped at ${RELEASE_STEP_WORDS[progress.stopped.step] ?? progress.stopped.step}`