toolroll 0.9.53 → 0.9.55

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

@@ -0,0 +1,632 @@
+/** Task pages: approval, agents, plans, controls, decisions and the task body. */
+import { type Html } from "../html.js";
+import { type RunActivity } from "../activity-line.js";
+import { type AgentChoice } from "../agentconfig.js";
+import { type AssignmentSnapshot } from "../assignment.js";
+import { type BrowserTaskView } from "../browser-workspace.js";
+import { type FormView } from "../contracts/console-api.js";
+import { type DispatchDiagnosis } from "../dispatch.js";
+import { type ReportView } from "../evidence.js";
+import { type Gap } from "../gaps.js";
+import { type FailureExplanation } from "../needs-you.js";
+import { type RouteOverride, type RouteProjection } from "../phase-routing.js";
+import { type MilestoneState } from "../plan.js";
+import { type ContractChange } from "../planner-source.js";
+import { type CriterionMatrixRow, type ProofVerdict } from "../proof.js";
+import { type Phase } from "../provider.js";
+import { type QualityMode } from "../quality.js";
+import { type AcceptanceCriterion, type Scope, type UnattendedPermissionMode } from "../scope.js";
+import { type Artifact, type CheckProgress, type CoordinatorProposal, type Decision, type ExternalMirror, type Hold, type Incident, type PlanRevisionKind, type PlanRevisionStatus, type Publication, type PublicationGrant, type RepairChainRow, type ReviewRetryState, type RevisionLineage, type Run, type SteerNote, type Store, type Task } from "../store.js";
+import { type TaskControlView } from "../task-control.js";
+import { type DisplayStatus, type PublicationFacts, type ReviewFacts, type WorkStatus } from "../workspace-ui.js";
+import { type Chrome, type Screen } from "./chrome.js";
+import { type CompletionReceiptView, type EvidenceLinkMap, type TaskPullRequest } from "./render-results.js";
+import { type Who } from "./session.js";
+/** What the task and approval views show about a drafted plan's contract
+ * (contract handoff, task 1). A problem is a named problem, never a blank. */
+export type PlanContractView = {
+    run: number;
+    problem: string;
+} | {
+    run: number;
+    sourceDigest: string;
+    /** Whether a scope was filed before planning (false: legacy road). */
+    filed: boolean;
+    amendment: string | null;
+    changes: ContractChange[];
+    changeWords: string[];
+    /** The proposed terms are still exactly the scope row. */
+    current: boolean;
+    /** A revision: the terms before planning were copied from the previous version, not filed by a person. */
+    revision?: boolean;
+};
+export declare function contractChangeHtml(change: ContractChange): Html;
+/**
+ * The contract panel (contract handoff, task 1): whether the drafted plan
+ * reproduced the filed goal, exclusions, touches, and rubric exactly, or
+ * proposes an amendment — every addition, change, and removal listed, the
+ * planner's stated reason beside them, and the plain consequence that
+ * approving binds the AMENDED terms. "full" is the task page's card;
+ * "ceremony" is the restatement inside the approval form and /next.
+ */
+export declare function planContractHtml(view: PlanContractView | null, mode: "full" | "ceremony"): Html;
+/** The exact path limits, one per line (UI polish 2026-09-13): a long
+ * comma run was the least readable term on a phone. Every path, verbatim. */
+export declare function approvalPathsHtml(touches: readonly string[]): Html;
+/** The rubric, restated above the seal (v39) — the same claim the digest
+ * line already makes ("approval binds to this exact wording") extended to
+ * the acceptance terms: an id in Geist Mono (a machine fact the proof must
+ * answer by), a statement in Geist, the signed evidence kinds after
+ * it. `how` never renders here — it is advisory, never signed. Empty
+ * renders nothing: a grandfathered scope's ceremony is unchanged. */
+export declare function acceptanceCeremonyHtml(criteria: readonly AcceptanceCriterion[]): Html;
+/** "claude" + "opus" → "Claude Opus"; "claude-opus-5-5" → "Claude Opus 5.5"; anything else keeps its exact id. */
+export declare function agentNameWords(provider: string, model: string | null): string;
+/** The permission a sealed profile grants, in two or three words. */
+export declare function permissionWordsOf(profile: Scope["profile"] | null | undefined): string | null;
+/** One plain sentence for a revision (approval critique, Oct 2):
+ * "Fixes what build #9 missed: <criterion>." The notes, paths and lineage
+ * stay in the Details fold. */
+export declare function revisionSentence(revision: Extract<RevisionView, {
+    sourceRun: number;
+}>, acceptance: readonly AcceptanceCriterion[]): string;
+/** A planner's amendment, said plainly and kept in view: approving binds
+ * the amended terms, so this is never folded away. */
+export declare function approvalAmendmentHtml(view: PlanContractView | null | undefined): Html;
+/**
+ * The approval sheet (approval critique, Oct 2): the plan open, in plain
+ * rows — Goal, Changes, Won't touch, Done when — one line of who builds,
+ * one Approve & start beside the password, and every remaining signed
+ * term (lineage, routing, runtime limits, the seal) in one Details fold.
+ * Presentation only: the same hidden fields, nonce, digest and password
+ * post to the same route, and the task page and chat card share it.
+ */
+export declare function approvalSheetHtml(input: {
+    surface: "task" | "chat";
+    action: string;
+    csrf: string;
+    nonce: string;
+    digest: string;
+    returnTo: string | null;
+    scope: Scope;
+    planDocument: string | null;
+    planContract: PlanContractView | null | undefined;
+    revision: Extract<RevisionView, {
+        sourceRun: number;
+    }> | null;
+    revisionSourceHref: string;
+    /** A machine-drafted repair: the build it repairs. */
+    repairChain: RepairChainRow | null;
+    route: RouteView | null | undefined;
+    coordinator: {
+        label: string;
+        filedAgo: string | null;
+    } | null;
+    deliverable: "branch" | "report";
+    editHref: string;
+    notNowHref: string;
+    sticky: boolean;
+    /** Earlier versions of this task still queued or running, and how many of them are running. */
+    earlier: {
+        active: number;
+        running: number;
+    };
+    /** The in-place editor (task page): the scope route, a draft the server
+     * refused (with why), whether it opens on arrival, and the plan's steps editor. */
+    edit: {
+        action: string;
+        draft: URLSearchParams | null;
+        problem: string | null;
+        open: boolean;
+        stepsHref: string | null;
+    } | null;
+}): Html;
+/** Earlier versions of a task still in flight, in plain words: queued
+ * while they only wait, running once one has started; null when none. */
+export declare function earlierVersionsWords(active: number, running: number): string | null;
+/** An in-place plan edit that would change the agent's permissions: thrown to roll the save back. */
+export declare class PermissionsWouldChange extends Error {
+}
+/** Evidence kinds in plain words, for the signed criteria in Details. */
+export declare const EVIDENCE_PLAIN: Record<string, string>;
+/** The permission choice a sealed profile carries, as the scope form names it. */
+export declare function permissionModeOfProfile(profile: Scope["profile"] | null | undefined): UnattendedPermissionMode | null;
+/** Done when, from the in-place editor: each line keeps its requirement's
+ * id by position, and its evidence and guidance while its words stand; a
+ * rewritten one is yours to check, like an added one; an emptied one is
+ * dropped. */
+export declare function requirementsFromEditor(body: FormView<"requirement" | "requirement-new">, current: readonly AcceptanceCriterion[]): unknown[];
+/**
+ * THE CONSENT DOOR (v48): whether a yes can be given on this scope right
+ * now — one answer for the task page, the focused chat, and /next, so no
+ * surface mints a nonce or shows a password the others would refuse.
+ * Closed when the scope cannot say exactly what would run: an unresolved
+ * profile, a routed row whose route cannot be read, a route with a stated
+ * problem, or a pre-routing row whose old approval no longer stands (its
+ * profile alone can no longer be agreed to — re-filing routes it). An
+ * approved legacy row never reaches here: its old yes is grandfathered.
+ * Every closed answer carries the words and the one road that opens it.
+ */
+export type ConsentDoor = {
+    open: true;
+} | {
+    open: false;
+    title: string;
+    why: string;
+    road: "scope" | "agents";
+};
+export declare function consentDoorOf(scope: Scope | null, route: RouteView | null | undefined): ConsentDoor;
+/** The closed door, rendered: no nonce, no password, no approve button —
+ * the reason and the one act that opens it. */
+export declare function consentClosedHtml(taskId: string, door: ConsentDoor & {
+    open: false;
+}, surface: "task" | "chat" | "next"): Html;
+export declare function profileWords(scope: Pick<Scope, "profile" | "profileState" | "unresolvedReason" | "digestVersion">): Html;
+/** The Agents view every console surface renders (v47): the SAME
+ * projection the CLI prints — who plans, builds, and revises,
+ * whether each was recommended, overridden, or pinned, its reasons, and
+ * the readiness the task's runners have reported (ready / unavailable /
+ * unknown — an unknown is said, never upgraded). Readiness is volatile and
+ * never part of what an approval signs, so the ceremony shows the agents
+ * and their reasons only. */
+export type RouteView = {
+    kind: "route" | "legacy" | "unreadable";
+    source: "approved" | "proposed" | "live" | null;
+    projection: RouteProjection | null;
+    /** A proven pre-routing row: its approved agent profile, nothing more. */
+    legacy: {
+        provider: string;
+        model: string;
+        repairModel: string;
+        approved: boolean;
+    } | null;
+    /** A routed row whose agents cannot be read — fail closed, in words. */
+    problem: string | null;
+    overrides: RouteOverride[];
+    /** An approver may edit: a live claim or a viewer session refuses. */
+    editable: boolean;
+    editableWhy: string | null;
+    /** A planner change after a draft landed asks for a real re-plan. */
+    replanOnPlanChange: boolean;
+    /** The scope digest the change forms CAS against; null = no scope yet. */
+    digest: string | null;
+    /** v48: the configured, role-valid agents an approver may choose from —
+     * every option an exact pair the operator named once in configuration.
+     * The form offers these and nothing else. */
+    choices: Record<Phase, AgentChoice[]>;
+};
+export declare const ROLE_NOUN: Record<RouteProjection["legs"][number]["phase"], string>;
+export declare function agentsStandingWords(view: RouteView): string;
+/** The size line an approval leads its agents with — "Small change: fast
+ * model, no plan" — and, quietly, why it was sized so. */
+export declare function sizeLineHtml(projection: RouteProjection): Html;
+/** What a size does, for a proposal card. */
+export declare function sizeConsequence(size: string, risky: boolean): string;
+/** The one plain-English line: who does what. */
+export declare function agentsSummaryWords(view: RouteView): string;
+/** A risk badge only when there is something to say: a risky change, or an
+ * older route sealed at elevated or high risk. */
+export declare function riskBadgeHtml(projection: RouteProjection): Html;
+/** Neutral metadata badges: risk (when not routine), posture, and standing. */
+export declare function agentsBadgesHtml(view: RouteView): Html;
+/** Volatile availability, per provider on the route — shown beside the
+ * agents, never inside the approval's terms. */
+export declare function agentsAvailabilityHtml(projection: RouteProjection): Html;
+/** The closed details: one row per role, with the reasons. */
+export declare function agentsWhyHtml(projection: RouteProjection, summaryLabel?: string): Html;
+/** The ceremony's agents block: what the yes agrees to — the agents and
+ * their reasons. Availability is volatile and deliberately absent here. */
+export declare function agentsCeremonyHtml(view: RouteView | null | undefined): Html;
+/** The runtime limits the sealed profile binds — permissions, turn and
+ * time bounds, repairs — restated on the ceremony as
+ * a CLOSED disclosure (v48): a term the yes covers, one tap away, never a
+ * wall of switches between the reader and the password. An unresolved
+ * profile still speaks in the open: that is a refusal, not a detail. */
+export declare function runtimeDetailsHtml(scope: Pick<Scope, "profile" | "profileState" | "unresolvedReason" | "digestVersion">): Html;
+/** The task page's Agents card: the summary, availability, closed reasons,
+ * and — for an approver — closed change controls. Every change re-files
+ * the scope; an approval given under the earlier agents needs renewing. */
+export declare function agentsCardHtml(taskId: string, view: RouteView | null | undefined, canEdit: boolean): Html;
+/** The chat's always-visible strip: the summary and a way to the details. */
+export declare function agentsStripHtml(view: RouteView | null, taskId: string): Html;
+/** A ceremony nonce as stored: the sha256 hex of the value the form carried. */
+export declare function nonceHashOf(value: string): string;
+/** The approve POST's refusal, in words a person can act on. */
+export declare function approveRefusalWords(reason: string): string;
+/** The browser's one-click approval binds not only the signed scope but the
+ * exact advisory plan revision shown beside it. The scope digest remains the
+ * durable authority; this composite makes a stale open tab fail when somebody
+ * edits the plan before approval. The empty middle slot keeps the bytes of
+ * forms already open (it once held other terms, always empty here). */
+export declare function approvalFormDigest(scopeDigest: string, planSha: string | null): string;
+/** The one task-level road from a truthful dispatch diagnosis to its nearest
+ * existing repair. This is navigation, never authority: every destination
+ * still owns its original confirmation, password, CSRF, and transactional
+ * checks. Keeping the map here also means the focused chat and task overview
+ * cannot send a person to different fixes for the same gate. */
+export declare function taskRecoveryHref(taskId: string, diagnosis: DispatchDiagnosis | null): string | null;
+/** The resume ceremony's digest (v52): the exact run, its settlement, and
+ * the scope approval as it stands — a nonce minted over one set of facts
+ * cannot confirm a resume under another. */
+export declare function resumeDigestOf(taskId: string, runId: number, settledAt: string, scope: Scope | null): string;
+export declare const stopWhen: (iso: string) => string;
+/**
+ * The exact-run control (v52): ONE component on the task page, the
+ * focused chat, and the status fragment, so every surface names the same
+ * run and shows the same state. Stop is one guarded post naming the run;
+ * Stopping… is a disabled control with who asked and when; Resume opens
+ * the password ceremony; a stopped review points at Review again. Forms
+ * carry the CSRF token and the exact run id, nothing else.
+ */
+/** Presentation only: the same projected words and action on all task
+ * surfaces. Approval keeps its action on the exact-terms disclosure. */
+export declare function taskStatusCard(status: DisplayStatus & {
+    diagnostics?: WorkStatus["diagnostics"];
+}, taskId: string, dispatch: DispatchDiagnosis | null, runId: number | null, approvalAction?: boolean): Html;
+export declare function checkProgressHtml(progress: CheckProgress | null, id?: string): Html;
+export declare function taskControlDetailsHtml(control: TaskControlView, taskId: string, csrf: string, surface: "task" | "chat", inert?: boolean, stopElsewhere?: boolean): Html;
+/** `stopElsewhere`: the Building card already carries this exact run's Stop, so the control card keeps only its details.
+ * `csrf` is only a guard now: an empty one (a read-only surface) renders no forms; postForm writes the field. */
+export declare function taskControlHtml(control: TaskControlView, taskId: string, csrf: string, surface: "task" | "chat", inert?: boolean, stopElsewhere?: boolean): Html;
+/** The resume confirmation (v52): the exact run restated, what resuming
+ * does and does not do, the gate that would still keep work from
+ * starting, and the password typed again. */
+export declare function resumeCeremonyPage(chrome: Chrome, data: {
+    taskId: string;
+    taskTitle: string;
+    control: TaskControlView & {
+        kind: "paused";
+    };
+    nonceValue: string;
+    /** Unused: postForm writes the CSRF field (kept for the caller). */
+    csrf: string;
+    returnTo: "task" | "chat";
+    gate: DispatchDiagnosis | null;
+    approved: boolean;
+}): Screen;
+export declare function taskViewSwitch(taskId: string, active: "overview" | "ask"): Html;
+export declare function publicationFactsOf(publication: Publication | null): PublicationFacts;
+/** Where a status's next act lives, for a row that links out. */
+export declare function statusActionHref(status: DisplayStatus, taskId: string, runId: number | null, prUrl: string | null, repo?: string | null): string | null;
+/** The one status line every surface renders: a dot in the tone, the
+ * label, and the `data-work-status` token tests and CSS key off. */
+/** A not-yet-finished task's shared headline from its dispatch diagnosis (task-status.ts). */
+export declare function dispatchHeadline(d: DispatchDiagnosis): string;
+export declare function statusLineHtml(status: DisplayStatus, extra?: Html | ""): Html;
+export declare function workDiagnosticsHtml(diagnostics: WorkStatus["diagnostics"]): Html;
+/**
+ * The decision card everywhere a person may ANSWER (portfolio, the
+ * selected-project inbox; the task page joins in slice 3): a reversible
+ * option answers with one tap on the card, labeled with its own words —
+ * never a letter; an irreversible option is a LINK to the decision page,
+ * where the server-side confirm=yes guard lives. The roll-up inbox keeps
+ * its links-only cards and never renders this partial. The recommended
+ * option wears a neutral badge — recommendation is not urgency, and magenta
+ * stays on the card's outline.
+ */
+export declare function decisionAnswerCard(decision: Decision & {
+    taskId: string;
+    repo?: string | null;
+}, csrf: string, now: Date, chip: boolean, returnTo?: string | null): Html;
+/**
+ * The inline-answer enhancement (portfolio arc §2): submits a reversible
+ * option's form as the urlencoded POST the forms-only gate expects, follows
+ * the redirect, and — because an answered decision leaves the open list —
+ * replaces ONLY that card with the answered receipt parsed from the
+ * decision page's own rendering, or removes the card. Anything unexpected
+ * (auth, a page that is not the decision's) navigates instead of inserting.
+ * Nothing else on the page is touched: typed input elsewhere survives.
+ */
+export declare function decisionAnswerScript(): string;
+/** A plan is stored as inert Markdown for portability into the builder
+ * brief, but the console renders its known structure as a useful control
+ * surface. Historical free-form plans keep their safe plain-text fallback. */
+export declare const MILESTONE_STATE_WORDS: Record<MilestoneState, string>;
+export declare function milestoneStateWord(state: MilestoneState): string;
+/** Adaptive execution plans (v44): the live milestone projection a running
+ * (or finished) build has reported. A shared render used by BOTH the task
+ * page and the focused chat's live region (c2) — labeled clearly as an
+ * agent's own report, since a milestone claim is never completion proof
+ * (Priority 2's proof contract is the only thing that adjudicates "done"). */
+export declare function milestoneProgressHtml(milestones: MilestoneProgressView[] | null | undefined): Html;
+/** Adaptive execution plans (v44): the current plan revision's own reason
+ * and evidence, any revision still awaiting an operator's accept/reject,
+ * and the immutable history. A shared render used by BOTH the task page
+ * and the focused chat's live region (c2), reading a document already
+ * verified before a byte reached this function (c5). `csrf` is only a
+ * guard now: an empty one renders no forms; postForm writes the field. */
+export declare function planRevisionLedgerHtml(ledger: PlanRevisionLedgerView | null | undefined, taskId: string, csrf: string): Html;
+export declare function executionPlanHtml(document: string, compact?: boolean): Html;
+/** One plan revision, its document verified before a byte renders — the
+ * same verify-then-read discipline as `planViewOf`, just carrying the
+ * ledger row's own facts alongside the text. `id: null` marks the
+ * read-only revision-1 projection for a task with no `plan_revision` rows
+ * yet (c1). */
+export type RevisionDocView = {
+    id: number | null;
+    revision: number;
+    status: PlanRevisionStatus;
+    reason: string;
+    evidenceLink: string | null;
+    author: string;
+    kind: PlanRevisionKind;
+    authorityKind: "plan-only" | "authority-change";
+    changedFields: string[];
+    document: string;
+    sha256: string;
+    createdAt: string;
+    resolvedAt: string | null;
+    resolvedBy: string | null;
+};
+export type PlanRevisionLedgerView = {
+    current: RevisionDocView | null;
+    pending: RevisionDocView | null;
+    history: RevisionDocView[];
+};
+export type MilestoneProgressView = {
+    id: string;
+    description: string;
+    state: MilestoneState;
+    note: string | null;
+};
+/** The revision batch a task's approval screen restates, or the named reason it cannot. */
+export type RevisionView = {
+    sourceTask: string;
+    sourceRun: number;
+    /** What kind of brief this is — annotations, a CI repair, a criterion repair. */
+    kind: "annotations" | "ci-repair" | "criterion-repair";
+    comments: {
+        path: string | null;
+        line: number | null;
+        note: string;
+        author: string;
+    }[];
+    /** The lineage and ACTUAL terms (contract handoff task 2), read from
+     * the child's own rows — the same projection chat and the approval
+     * card restate. */
+    lineage: RevisionLineage | null;
+} | {
+    problem: string;
+};
+/**
+ * A revision's lineage and ACTUAL terms, in the same words on the task
+ * page, the approval card, and chat (contract handoff task 2): which
+ * source and build it revises, the ancestry to its root, the terms the
+ * child really carries (read from its own scope — never restated from the
+ * brief), what is re-resolved for THIS approval, what never inherits, and
+ * — when the task continues a repair chain — the attempts used against
+ * the signed cap.
+ */
+export declare function revisionLineageWords(lineage: RevisionLineage): string[];
+export declare function revisionLineageHtml(lineage: RevisionLineage | null): Html;
+export declare function taskBodyParts(data: {
+    /** Until the first Ready result: show the task's way there (onboarding). */
+    guide?: boolean;
+    /** What the last attempt missed and what to change, shown when the task failed. */
+    failure?: FailureExplanation | null;
+    /** Run checks in place, for a status row that offers it. */
+    runChecks?: {
+        action: string;
+        level: "quick" | "full";
+        returnTo: string;
+    } | null;
+    /** The demo database: no check runs here, and the Checks row says so. */
+    demo?: boolean;
+    assignment?: AssignmentSnapshot | null;
+    checkProgress?: CheckProgress | null;
+    rootId?: string;
+    rootTitle?: string;
+    /** Markup the caller rendered (the version history). */
+    history?: Html;
+    versionLabel?: string | null;
+    status?: DisplayStatus;
+    task: Task;
+    /** Shared read-side lifecycle answer; the atomic claim still re-proves it. */
+    dispatch?: DispatchDiagnosis | null;
+    /** v52: the exact-run Stop / Stopping / Resume control. */
+    control?: TaskControlView;
+    strikes: number;
+    /** v102: who filed it, and the project's approval rules as they bear on this task (null: none apply). */
+    filer?: {
+        name: string | null;
+        kind: string;
+    } | null;
+    budgetHold?: string | null;
+    policyHold?: string | null;
+    approvalRules?: {
+        words: string;
+        votes: string[];
+        needsTwo: boolean;
+    } | null;
+    plan: "requested" | "drafted" | null;
+    planDocument: string | null;
+    planAuto?: boolean;
+    /** Hash of the verified plan artifact currently shown. */
+    planSha?: string | null;
+    /** The drafted plan's contract record (contract handoff, task 1). */
+    planContract?: PlanContractView | null;
+    /** Adaptive execution plans (v44): the revision ledger and live milestone
+     * projection — null for a task with no plan at all. */
+    planRevisions?: PlanRevisionLedgerView | null;
+    milestoneProgress?: MilestoneProgressView[] | null;
+    /** v34: what this task delivers, and the scout's report when one exists. */
+    deliverable?: "branch" | "report";
+    report?: ReportView | null;
+    revision?: RevisionView | null;
+    /** v40: this task's own place in a bounded repair chain — computed
+     * independent of `completion` (a freshly drafted, unapproved repair has
+     * no run yet, so it must not wait for one to say so). `completion`'s own
+     * branches render it too, once a run exists; this is the fallback for
+     * the moment before that, so "awaiting approval" is never invisible. */
+    repairChain?: RepairChainRow | null;
+    publication?: Publication | null;
+    repo: string | null;
+    /** Immutable filing provenance (v12) — the approver sees which door
+     * filed this (console, cli, intake, template:<name>) at the yes. */
+    filedVia?: string | null;
+    /** Coordinator provenance when an agent filed this; null otherwise. */
+    coordinator?: {
+        label: string;
+        filedAgo: string | null;
+    } | null;
+    holds: Hold[];
+    claimed: boolean;
+    /** What this task waits for — blockers outside this console's ceiling
+     * are named but carry no state and no link. */
+    waitsFor?: {
+        id: string;
+        title: string | null;
+        state: string | null;
+        admitted: boolean;
+    }[];
+    /** Open tasks a "wait for" select may offer (this console's view only). */
+    waitCandidates?: {
+        id: string;
+        title: string;
+    }[];
+    /** The run whose lease is the CURRENT live claim — computed by the data
+     * layer; the renderer never guesses liveness from a null outcome. */
+    liveRunId?: number | null;
+    /** What the agent did last on that live run, and when (task-activity.ts). */
+    activity?: RunActivity | null;
+    /** Workers that are both alive and authorized for this task's project. */
+    worker?: {
+        answering: number;
+        registered: number;
+        totalRegistered: number;
+        lastHeard: string | null;
+    };
+    /** Unmet capabilities that keep this exact task out of dispatch. */
+    gaps?: Gap[];
+    /** Whether this serve asserted its runner — the live file view exists. */
+    peekable?: boolean;
+    /** Where the task stands in its own column, from the data layer. */
+    position?: {
+        position: number;
+        total: number;
+        column: string | null;
+    } | null;
+    /** The tracker item this task stands for, when it is external work. */
+    mirror?: ExternalMirror | null;
+    scope: Scope | null;
+    /** What the approval nonce/digest bind: scope digest, or the joint fingerprint. */
+    approvalDigest?: string | null;
+    spendDefaults?: {
+        buildPerRunMicrousd: number | null;
+    } | null;
+    /** Installation starting value for a task that has no profile yet. */
+    permissionDefault?: UnattendedPermissionMode;
+    /** Durable choice for this task, when one was explicitly made. */
+    permissionMode?: UnattendedPermissionMode | null;
+    /** Installation starting value and this task's explicit evidence depth. */
+    qualityDefault?: QualityMode;
+    qualityMode?: QualityMode | null;
+    /** The phase route (v47) and whether this session may edit it. */
+    route?: RouteView | null;
+    canEditRoute?: boolean;
+    runs: Run[];
+    /** Proof produced by the newest finished attempt. The two booleans are
+     * machine facts about immutable, hash-addressed artifacts — never inferred
+     * from the agent's prose. `proofVerdict` is the closed machine-authored
+     * verdict (Priority 2), computed once at completion and never re-derived
+     * here — null only for a run that predates the proof system. */
+    completion?: {
+        runId: number;
+        outcome: string | null;
+        hasTerminalDiff: boolean;
+        hasHandoff: boolean;
+        proofVerdict: ProofVerdict | null;
+        /** v40: the verdict BEFORE an independent reviewer's judgements were
+         * folded in — null when no review has folded (every run before this
+         * migration, and every run no review has touched). */
+        machineVerdict: ProofVerdict | null;
+        proofReasons: string[];
+        proofMatrix: CriterionMatrixRow[];
+        proofMatrixLinks: EvidenceLinkMap;
+        proofAccepted: boolean;
+        /** v51: the run's signed quality mode — the policy semantic coverage is
+         * read under (default: review optional; strict: review required). */
+        qualityMode?: "default" | "strict";
+        /** v40: this run's own place in a bounded repair chain, if any. */
+        repairChain: RepairChainRow | null;
+        /** v50: every root review attempt of this result and what the
+         * allowance still admits; null when no review was ever asked for. */
+        reviewRetry?: ReviewRetryState | null;
+        /** The same review, as the shared projection reads it (review fixes). */
+        review?: ReviewFacts | null;
+        /** Priority 2's concise, shared result package. */
+        receipt: CompletionReceiptView | null;
+    } | null;
+    /** v50: whether this session may ask for a review retry (an approver's
+     * browser session — the same standing `task review` demands). */
+    canRetryReview?: boolean;
+    decisions: Decision[];
+    incidents: Incident[];
+    /** Pending coordinator proposals on this task (mate arc v3), with the decisions their answer cards name. */
+    coordinatorProposals?: {
+        rows: CoordinatorProposal[];
+        decisions: Map<number, Decision>;
+        now: Date;
+    } | null;
+    /** Operator steering notes (arc 1), delivery state included. */
+    steering?: SteerNote[];
+    /** The publication grant the publisher would act under — from
+     * publicationGrantFor(repo) only; null when none, or no project. */
+    grant?: PublicationGrant | null;
+    /** The pull request opened through Complete (its state, link, CI and merge), or the offer to open one for a
+     * result already marked complete; null when neither applies. */
+    pullRequest?: TaskPullRequest | null;
+    /** The task's whole family (the original and its revisions) and every attempt across it, for the thread. */
+    family?: {
+        root: {
+            id: string;
+            title: string;
+            createdAt: string;
+            goal?: string | null;
+        };
+        versions: {
+            id: string;
+            title: string;
+            state: string;
+        }[];
+        runs: (Run & {
+            taskId: string;
+        })[];
+    } | null;
+    /** Degraded composition (slice 1c). "sensitive": the page carries a
+     * password ceremony, so no live poller runs, the attempt panel is a
+     * static line, and open decisions render link-only — decided by the page
+     * wrapper from the rendered body itself. "pane": the body is embedded in
+     * the workbench's selected-task pane, which carries no run pollers, so
+     * only the attempt panel degrades. */
+    degraded?: "sensitive" | "pane";
+    csrf: string;
+    nonce: string;
+    scopeDraft?: URLSearchParams;
+    /** Arrived to edit the plan (?edit=plan): the approval sheet opens its editor. */
+    editPlan?: boolean;
+    cancelDraft?: string;
+    problem: string | null;
+    now: Date;
+}): {
+    html: Html;
+    view: BrowserTaskView;
+};
+export declare function taskBody(data: Parameters<typeof taskBodyParts>[0]): Html;
+export declare function taskPage(chrome: Chrome, data: Parameters<typeof taskBody>[0]): Screen;
+/** One accessible two-choice control everywhere permissions are selected.
+ * The words describe behavior; the raw flag stays secondary detail. */
+export declare function permissionModeChoices(name: string, selected: UnattendedPermissionMode): Html;
+/** Quality selects the configured agent route; permissions remain separate. */
+export declare function qualityModeChoices(name: string, selected: QualityMode): Html;
+/**
+ * A decision's answer forms — one source of truth for the decision screen
+ * and the triage flow. The consequence reads BEFORE the button that buys
+ * it; irreversible options arm behind one deliberate tap AND the server
+ * independently requires the confirm field. `returnTo` is allow-listed by
+ * the answer handler, never an arbitrary URL. `csrf` is unused (postForm
+ * writes the field); kept for callers.
+ */
+export declare function decisionOptionForms(decision: Decision, returnTo: string | null): Html;
+export declare function decisionPage(chrome: Chrome, decision: Decision, taskId: string, artifacts: Artifact[], who: Who, now: Date, returnTo?: string | null): Screen;
+export declare function taskOf(store: Store, decision: Decision): string;