toolroll 0.9.54 → 0.9.55

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

@@ -0,0 +1,744 @@
+import { type AssignmentSnapshot } from "../assignment.js";
+import { type BrowserCheckItem, type BrowserNeedAction, type BrowserResultPanel, type BrowserResultView } from "../browser-workspace.js";
+import { type ReportShot } from "../evidence.js";
+import { type FailureExplanation } from "../needs-you.js";
+import { type RouteStamp } from "../phase-routing.js";
+import { type CriterionMatrixRow, type ProofVerdict } from "../proof.js";
+import { type PullRequestView } from "../pull-request-flow.js";
+import { type StructuredHandoffView, type TerminalDiffView } from "../result-evidence-readers.js";
+import { type FollowUpCheck } from "../result-follow-ups.js";
+import { type ResultScreenshot, type ResultTab, type SharedResultFacts } from "../result-review.js";
+import { type BuildReviewView } from "../review-switch.js";
+import { type AcceptanceCriterion, type approvalOf } from "../scope.js";
+import { type ReportItem } from "../scout-report.js";
+import { type Artifact, type DiffComment, type Publication, type RepairChainRow, type ReviewRetryState, type Run, type Store, type TaskState } from "../store.js";
+import { type PullRequestFact, type TaskStatus } from "../task-status.js";
+import { type DisplayStatus, type PublicationFacts, type ReviewFacts } from "../workspace-ui.js";
+import { type Chrome, type Screen } from "./chrome.js";
+import { type Html } from "../html.js";
+export declare const RUNS_PAGE = 50;
+/**
+ * A vscode://file href, or null (arc 6, finding 2): the link exists only
+ * when every part is provably tame — an absolute, control-free worktree;
+ * a relative, single-line path whose segments contain no empty, dot,
+ * dot-dot, or backslash components (so lexical resolution stays below the
+ * worktree); a line inside the same 1..1,000,000 range the comment form
+ * enforces. Encoding failures return null — a file row degrades to plain
+ * text, never to a 500. The scheme is a constant, never data.
+ */
+export declare function editorFileHref(worktree: string, path: string, line?: number | null): string | null;
+/** The execution profile in plain words (v24): what the password signs
+ * says WHAT RUNS — provider, exact model, permissions, and the real
+ * bounds — or says honestly that it cannot yet. */
+/** The state badges the criterion-to-evidence matrix renders with — one
+ * shared vocabulary, so a "failed" row reads the same shade of trouble on
+ * the task page, the run page, the board, done, builds, the inbox, and
+ * chat (v39, extending Priority 2's "one surface, six places" rule from
+ * the verdict word to the per-criterion state). */
+export declare function matrixStateBadge(state: CriterionMatrixRow["state"]): Html;
+/** v40: the bounded repair chain's own line — presented as the user-facing
+ * recovery it represents, without exposing the internal workflow name.
+ * Renders on the task page and the run page identically. */
+export declare function repairChainHtml(chain: RepairChainRow | null): Html;
+/**
+ * The bounded review-retry panel (v50), shared by the task page and the
+ * result cockpit so both say the same thing: which attempt is running or
+ * queued, how the latest one ended, every root attempt on record, and the
+ * ONE explicit act — a Retry review form — rendered only while the store's
+ * allowance admits it and this session may ask (an approver's cookie
+ * session). Every other state shows the same control disabled, in words,
+ * so a person always sees why nothing more will happen by itself. Empty
+ * when no review was ever asked for.
+ */
+export declare function reviewRetryPanel(_taskId: string, _sourceRun: number, retry: ReviewRetryState | null, _options: {
+    csrf: string;
+    canAct: boolean;
+    returnTo: string | null;
+}): Html;
+/** A one-line summary of the matrix for list rows too dense for the full
+ * table (done, builds, board, inbox) — "2/3 criteria", plus a worst-state
+ * badge so trouble is visible without opening the row. `[]` renders
+ * nothing. */
+export declare function criterionMatrixSummary(matrix: readonly CriterionMatrixRow[]): Html;
+/** Where a criterion's own typed evidence ref resolves to a stored
+ * artifact, keyed `${kind}:${ref}` — built once per run from its
+ * artifacts (v39 review finding: "link artifacts where possible"). A
+ * `changed-path` ref never gets its own per-file artifact, so every one of
+ * those shares the single terminal-diff patch, under the wildcard key. A
+ * `manual-review` ref never resolves — it names nothing machine-checkable. */
+export type EvidenceLinkMap = ReadonlyMap<string, number>;
+export declare const CHECK_LOG_CAPTURE: RegExp;
+export declare function evidenceLinksFor(artifacts: readonly Artifact[]): EvidenceLinkMap;
+/** Read the approved requirement first; inspect its saved evidence on demand.
+ * Machine results, reviewer judgements and missing context remain separate.
+ * Warnings stay outside the disclosure, including on compact surfaces. */
+export declare function criterionMatrixHtml(matrix: readonly CriterionMatrixRow[], options?: {
+    compact?: boolean;
+    runId?: number;
+    links?: EvidenceLinkMap;
+    fileAnchors?: ReadonlyMap<string, string>;
+    verdict?: string | null;
+}): Html;
+/** One policy summary beneath the requirements. Per-requirement concerns
+ * are already visible in the matrix; do not repeat their full text here. */
+export declare function semanticCoverageHtml(matrix: readonly CriterionMatrixRow[], qualityMode: "default" | "strict"): Html;
+/** A same-site path or "/": never a scheme, a host, or a protocol-relative road. */
+/** The words a result page shows for a refusal its own form led to, by the fixed code a redirect carries. */
+export declare const ACCEPT_ANYWAY_NEEDS_REASON = "Accepting anyway needs a reason.";
+export declare const RESULT_REFUSALS: Record<string, string>;
+/** A same-site page address with a refusal code added, before any fragment. */
+export declare function withRefusal(href: string, code: keyof typeof RESULT_REFUSALS): string;
+/** The queue reads at most this many completed tasks — the store's own
+ * page ceiling, admission bound before it. */
+export declare const REVIEW_QUEUE_CAP = 100;
+/** The one return road the comment endpoint honors besides its own run
+ * page: the cockpit's selected-result link, exactly. */
+export declare const REVIEW_RETURN: RegExp;
+/** Review priority: a deterministic, LABELED presentation aid over facts
+ * the done list already carries. Band 0 goes first; the words name why.
+ * It is never a verdict — the stored proof verdict stays the authority,
+ * and an operator's acceptance lowers a band without touching it. */
+export type ReviewPriority = {
+    band: 0 | 1 | 2;
+    label: "needs action" | "review" | "no flags";
+    reasons: string[];
+};
+export type ReviewQueueFacts = {
+    /** Only an exact current task/run match carries the assignment status. */
+    assignment?: AssignmentSnapshot | null;
+    proofReasons?: readonly string[];
+    runId: number | null;
+    outcome: string | null;
+    proofVerdict: ProofVerdict | null;
+    proofAccepted: boolean;
+    proofMatrix: readonly CriterionMatrixRow[];
+    ciFailing: boolean;
+    publicationState: string | null;
+};
+export declare const PRIORITY_LABELS: Record<ReviewPriority["band"], ReviewPriority["label"]>;
+export declare function reviewPriorityOf(row: ReviewQueueFacts): ReviewPriority;
+/** Ranked, stable: band first, then newest completion, then task id — the
+ * same input always yields the same queue, whoever loads it. */
+export declare function rankReviewQueue<T extends ReviewQueueFacts & {
+    completedAt: string;
+    taskId: string;
+}>(rows: readonly T[]): (T & {
+    priority: ReviewPriority;
+})[];
+/** Whether a changed path sits inside the scope's signed "touches" — an
+ * exact file, a directory prefix (with or without its slash), or a plain
+ * `*` / `**` glob. Touches are advisory in the scope; here they only
+ * decide which files wear the "outside the signed touches" flag. */
+export declare function withinSignedTouches(path: string, touches: readonly string[]): boolean;
+/** A signed touch's glob as a regular expression, gitignore-style: `*`
+ * stays inside one segment; `**` followed by `/` spans zero or more
+ * directories, so `src/**` followed by `/*.ts` matches `src/a.ts` as well
+ * as `src/nested/a.ts` (v2 review, comment 2); a bare `**` spans anything.
+ * Whatever the glob names, its contents are inside it too. */
+export declare function touchGlob(raw: string): RegExp;
+/** A stable, attribute-safe anchor for one file of the sealed patch —
+ * derived from the path's bytes, never from the path's characters, so a
+ * hostile file name can neither break the id nor escape the attribute. */
+export declare function diffFileAnchor(path: string): string;
+export type ReviewFileRow = {
+    path: string;
+    additions: number | null;
+    deletions: number | null;
+    renamedFrom: string | null;
+    anchor: string | null;
+    outsideTouches: boolean;
+    cited: boolean;
+};
+/** Paths whose churn a reviewer reads first — dependency manifests and
+ * locks, CI workflows, container and schema definitions, migrations, the
+ * environment files secrets live in, and files NAMED for credentials.
+ * The credential words match only as whole `-`/`_`/`.`-delimited pieces
+ * of the file name (v2 review, comment 4): `auth.ts`, `api-token.ts`,
+ * `secrets.json` count; `author.ts`, `tokenizer.ts`, and `.envelope.ts`
+ * are ordinary names and do not. `permission` is not a credential word
+ * at all — `permissions-ui.tsx` is a screen, not a secret. */
+export declare const SENSITIVE_PATH: RegExp;
+export declare const LARGE_CHANGE_LINES = 200;
+/** The changed-file list's own review priority: outside the signed
+ * touches first, then files a machine cannot diff or a criterion never
+ * cited, then the rest by churn. Presentation only — the sealed patch
+ * keeps its own order beneath, byte for byte. */
+export declare function reviewFilePriority(file: ReviewFileRow, proofCitesPaths: boolean): ReviewPriority;
+export declare function orderChangedFiles(files: readonly ReviewFileRow[], proofCitesPaths: boolean): (ReviewFileRow & {
+    priority: ReviewPriority;
+})[];
+export type CompletedWorkRow = ReturnType<Store["listCompletedWorkScoped"]>[number] & {
+    historyProblem?: string | null;
+};
+export type RankedReviewRow = CompletedWorkRow & {
+    ciFailing: boolean;
+    priority: ReviewPriority;
+    assignment?: AssignmentSnapshot | null;
+};
+/** What the cockpit shows of one selected result — a projection of the
+ * scope, plan, run, artifact, verdict, and publication records,
+ * each read through the verifier the run page already uses. */
+export type ReviewCockpitView = {
+    taskId: string;
+    title: string;
+    repo: string | null;
+    completedAt: string;
+    historyProblem: string | null;
+    priority: ReviewPriority;
+    assignment: AssignmentSnapshot | null;
+    /** null = no scope was ever filed (a task marked done by hand). */
+    intent: {
+        goal: string;
+        outOfScope: string | null;
+        touches: string[];
+        acceptance: AcceptanceCriterion[];
+        approval: ReturnType<typeof approvalOf>;
+        approvedBy: string | null;
+    } | null;
+    plan: {
+        revision: number;
+        sha256: string;
+        approach: string | null;
+    } | null;
+    /** null = the task is done with no finished build attempt on record. */
+    run: {
+        id: number;
+        role: string;
+        outcome: string | null;
+        runner: string;
+        provider: string;
+        model: string | null;
+        finishedAt: string | null;
+        branch: string | null;
+        headRevision: string | null;
+        ranMinutes: number | null;
+        cost: string;
+        summary: string | null;
+    } | null;
+    /** The shared result detail (package 3) — the same records, the same
+     * panel, as the run page and the chat's result view. */
+    detail: ResultDetail | null;
+    /** v50: the result's bounded review-retry history, null when never asked. */
+    reviewRetry: ReviewRetryState | null;
+    /** The same history as the shared projection's facts (review fixes). */
+    review: ReviewFacts | null;
+    notes: {
+        id: number;
+        author: string;
+        note: string;
+        createdAt: string;
+    }[];
+    /** The demo database: no check runs here, and the Checks row says so. */
+    demo?: boolean;
+    /** A build that didn't deliver a result: what it missed, the suggestion, and Retry when the task can be retried here. */
+    failure?: (FailureExplanation & {
+        retry: {
+            action: string;
+            note: string;
+        } | null;
+        acceptAnyway?: {
+            action: string;
+            run: number;
+        } | null;
+    }) | null;
+};
+/** The receipt's own proof-state word, so the cockpit and the task page
+ * never disagree on the state's name or its precedence: the stored
+ * verdict decides, whatever the run's outcome — a no-change run with a
+ * refuted proof reads as refuted, never as "no change needed". The one
+ * word the receipt never needs is "No build record": a manual completion
+ * has no receipt to share it with. */
+/** The cockpit's headline status: the shared projection over the same
+ * verdict, acceptance, and publication rows the task page reads. */
+export declare function cockpitStatusOf(view: ReviewCockpitView): DisplayStatus;
+/** Turn verifier records into one sentence a project owner can act on.
+ * A command-not-found result means the check could not start, not that the
+ * product itself failed. The stored record remains unchanged. */
+export declare function verificationExplanation(verdict: ProofVerdict | null, reasons: readonly string[]): string;
+export declare function verificationRecovered(reasons: readonly string[]): boolean;
+/** Whether a reviewer can annotate this result's diff here: the shared
+ * detail's own answer (a verified, non-empty sealed patch read by a
+ * session that holds a CSRF token) — decided once, in `resultDetailOf`. */
+export declare function canAnnotateDiff(view: ReviewCockpitView | null, csrf: string): boolean;
+export declare function reviewCockpitPage(chrome: Chrome, data: {
+    queue: readonly RankedReviewRow[];
+    /** The queue's ceiling — printed when the queue reaches it. */
+    queueCap: number;
+    selected: ReviewCockpitView | null;
+    /** The deep link resolved a completion older than the queue shows. */
+    beyondQueue: boolean;
+    missing: string | null;
+    csrf: string;
+    /** v50: an approver's session may ask for a review retry here. */
+    canRetryReview: boolean;
+    noted: boolean;
+    /** What this person's last post from this page was refused for, in words (`refused=` on the address). */
+    refusal?: string | null;
+    /** Package 3: the selected local result view and the panel's draft keys. */
+    tab: ResultTab;
+    user: string;
+    now: Date;
+}): Screen;
+/** The selected result: intent → proof → changes → publication → acts,
+ * one scan path, every fact labeled by its source. */
+export declare function reviewCockpitDetail(view: ReviewCockpitView, csrf: string, noted: boolean, canRetryReview?: boolean, tab?: ResultTab, user?: string): Html;
+/** The selected result's HTML and, for the rebuilt page, the same result
+ * as data: every form and panel body is the one the HTML carries. */
+export declare function reviewCockpitDetailParts(view: ReviewCockpitView, csrf: string, noted: boolean, canRetryReview: boolean, tab: ResultTab, user: string): {
+    html: Html;
+    selected: NonNullable<BrowserResultView["selected"]>;
+};
+/** What Accept and finish owes before it completes, as the form asks for it: the server's own rule
+ * (owedAcceptance), so the form asks for exactly what the completion requires. */
+export declare function owedAcceptanceOf(receipt: AssignmentSnapshot["receipt"]): {
+    note: string | null;
+} | null;
+export declare function completionForm(taskId: string, runId: number, digest: string, pullRequestTo?: string | null, accept?: {
+    note: string | null;
+} | null): Html;
+/** What the task page shows about a result's pull request: the view, or the offer to open one. */
+export type TaskPullRequest = {
+    taskId: string;
+    view: PullRequestView | null;
+    offer: {
+        taskId: string;
+        runId: number;
+        digest: string;
+    } | null;
+    target: string | null;
+    /** The same pull request as the shared status's detail row reads it. */
+    fact?: PullRequestFact | null;
+};
+/** The pull request, in one card: its state and link, one line of detail, and the one action it needs — Merge
+ * behind the password when checks passed, or Open a pull request for a result completed without one. */
+export declare function pullRequestCardHtml(pr: TaskPullRequest, csrf: string): Html;
+/** Exactly one primary road per result, chosen from its state; the
+ * others stay reachable from their own sections. Every form posts to the
+ * endpoint that already owns the act, with the session's CSRF token; a
+ * bearer session (no token) sees the road named, never a form. */
+export declare function reviewNextAction(view: ReviewCockpitView, csrf: string, _accepted: boolean, _canAnnotate: boolean): Html;
+/** The next action for the browser workspace's JSON: its control as markup text. */
+export declare function reviewNextActionOf(view: ReviewCockpitView, csrf: string): {
+    kind: string;
+    title: string;
+    detail: string;
+    control: string;
+} | null;
+/**
+ * Plain words for the machine's own vocabulary — no internal token ever
+ * reaches a page. Every map here has a generic fallback: a kind a newer
+ * daemon invents degrades to honest generic prose, never to its raw name.
+ */
+export declare const PHASE_WORDS: Record<string, string>;
+/** An agent's phase on the home card, from the machine's own vocabulary. */
+export declare function homePhaseWords(run: Pick<Run, "role" | "phase">): string;
+export declare function phaseWords(phase: string): string;
+/** A recorded reason in one plain line; machine output (a stack trace, a path, "Error:" text) waits on the run record. */
+export declare function reasonWords(reason: string): string;
+export declare const INCIDENT_WORDS: Record<string, string>;
+export declare function incidentWords(kind: string): string;
+export declare const EVIDENCE_WORDS: Record<string, string>;
+/** Byte counts as people read them. */
+export declare function humanBytes(bytes: number): string;
+export declare function evidenceWords(kind: string): string;
+/** The badge for a run's outcome. A null outcome reads "running" ONLY when
+ * the caller proved the run's lease is the task's current live claim — an
+ * orphaned run keeps saying what actually became of it. */
+export declare function runOutcomeBadge(run: Run, live: boolean): Html;
+export declare const runNoun: (run: Pick<Run, "role">) => string;
+export declare function runsPage(chrome: Chrome, rows: (Run & {
+    taskId: string;
+})[], liveIds: ReadonlySet<number>, nextCursor: number | null, verdicts?: Map<number, {
+    verdict: ProofVerdict;
+    matrix?: CriterionMatrixRow[];
+}>, accepted?: ReadonlySet<number>): Screen;
+/** The evidence bundle (Priority 2): the closed machine-authored verdict,
+ * the agent's proof (or why it cannot be shown), the plane's own re-run
+ * check, and every validated screenshot — each row labeled by source so
+ * "the agent said" and "the machine proved" never blur together. */
+export type ProofBundleView = {
+    verdict: ProofVerdict | null;
+    reasons: string[];
+    accepted: {
+        by: string;
+        note: string | null;
+        at: string;
+    } | null;
+    proof: {
+        criteria: {
+            statement: string;
+            verdict: string;
+            how: string;
+        }[];
+        checks: {
+            command: string;
+            exitCode: number;
+            summary: string;
+        }[];
+        caveats: string[];
+    } | null;
+    proofProblem: string | null;
+    /** The check log as stored: its text when the bytes verify, else the
+     * `problem` (repair 2026-09-14) — a log that no longer verifies shows no
+     * text and offers no download. `bytesOriginal`/`bytesStored` let a
+     * shortened log's download be described as the stored part only. */
+    checkLog: {
+        text: string;
+        artifactId: number;
+        truncated: boolean;
+        problem: string | null;
+        bytesOriginal: number;
+        bytesStored: number;
+    } | null;
+    /** Every stored screenshot artifact; one whose bytes no longer verify
+     * carries its `problem` and is never rendered or called validated
+     * (workspace package 3). */
+    screenshots: ResultScreenshot[];
+    /** Screenshot paths the proof cites that no stored artifact answers. */
+    uncapturedScreenshots: string[];
+    /** v39: the criterion-to-evidence matrix, one row per signed criterion —
+     * `[]` when the scope this run built against signed no rubric. */
+    matrix: CriterionMatrixRow[];
+    /** v39 review finding: where a row's answered evidence ref resolves to a
+     * stored artifact, for `criterionMatrixHtml` to link. */
+    matrixLinks: EvidenceLinkMap;
+    /** v40: the verdict BEFORE an independent reviewer's judgements were
+     * folded in — null when no review has folded. */
+    machineVerdict: ProofVerdict | null;
+    /** v40: this run's own place in a bounded repair chain, if any. */
+    repairChain: RepairChainRow | null;
+    /** v51: the policy semantic coverage is read under. */
+    qualityMode: "default" | "strict";
+};
+/** The smallest complete answer to "what did this task deliver?". It is a
+ * projection of the same sealed handoff, proof, screenshot, and diff records
+ * used by the run page—not a new persistence layer or another verdict. */
+export type CompletionReceiptView = {
+    runId: number;
+    /** The run's role — a scout's receipt is a report, not a diff. */
+    role: string;
+    outcome: string | null;
+    summary: string | null;
+    verdict: ProofVerdict | null;
+    /** The verdict's recorded reasons — what tells a failed check from
+     * mismatched evidence (package 1). */
+    reasons: string[];
+    accepted: boolean;
+    /** A no-change conclusion's two records — handoff and sealed diff. */
+    recordComplete: boolean;
+    /** The run's own publication record, when one exists: the heading names
+     * a PR or a merge only from this, never from the outcome. */
+    publication: PublicationFacts;
+    /** This run's independent review, when one was asked (review fixes). */
+    review: ReviewFacts | null;
+    matrix: CriterionMatrixRow[];
+    /** v51: the semantic-coverage lines (`coverageWords`) — independent
+     * review standing under the run's policy, plus every named context gap.
+     * Rendered beside the machine verdict on the task and chat receipts. */
+    coverage: string[];
+    /** Concise pass (2026-09-13): the coverage lines are secondary — behind a
+     * disclosure — only while nothing is owed: review optional and not yet
+     * settled, or satisfied. A strict-quality shortfall, a strict review
+     * still pending, or a named context gap stays in the open. */
+    coverageSecondary: boolean;
+    diff: {
+        fileCount: number;
+        additions: number;
+        deletions: number;
+        binaryCount: number;
+        filesTruncated: boolean;
+    } | {
+        problem: string;
+    } | null;
+    screenshots: ResultScreenshot[];
+    caveats: string[];
+    /** The run's own report artifact (a scout's deliverable), verified at
+     * render — the investigation's result leads with it (package 3). */
+    report: RunReportView | null;
+    /** The facts every result surface prints identically (package 3). */
+    facts: SharedResultFacts;
+};
+/** A scout run's report as this run stored it: verified and parsed, or
+ * the reason it cannot be shown. The download link serves the exact
+ * stored bytes as text — never as a page. */
+export type RunReportView = {
+    ok: true;
+    artifactId: number;
+    title: string;
+    summary: string;
+    document: string;
+    followUps: number;
+    truncated: boolean;
+    items: ReportItem[];
+    shots: ReportShot[];
+} | {
+    ok: false;
+    artifactId: number;
+    problem: string;
+};
+/** What a scout found, each with its link and picture, then any screenshot no item shows. Every link is the cited
+ * http(s) address the report parser admitted; every picture is served from verified evidence. */
+export declare function reportItemsHtml(items: readonly ReportItem[], shots: readonly ReportShot[], runId: number): Html;
+export declare function runReportView(artifacts: Artifact[], root: string): RunReportView | null;
+/** The shared facts (package 3), computed ONCE from the same verified
+ * records every surface reads: the head from the sealed diff summary when
+ * it verifies (else the run record, and the source is named), the signed
+ * criteria passed from the machine's matrix, the proof's caveats, every
+ * evidence problem in words, and the observed publication state. */
+export declare function sharedResultFactsOf(run: Run, proof: ProofBundleView | null, terminal: TerminalDiffView | null, handoff: StructuredHandoffView | null, report: RunReportView | null, publication: PublicationFacts): SharedResultFacts;
+export declare function proofBundleView(store: Store, run: Run, artifacts: Artifact[], root: string): ProofBundleView | null;
+export declare function completionReceiptView(store: Store, run: Run, artifacts: Artifact[], root: string, review?: ReviewFacts | null): CompletionReceiptView;
+export type ReviewDiffLine = {
+    kind: "context" | "addition" | "deletion" | "meta";
+    text: string;
+    oldLine: number | null;
+    newLine: number | null;
+};
+export type ReviewDiffHunk = {
+    header: string;
+    lines: ReviewDiffLine[];
+};
+export type ReviewDiffFile = {
+    path: string;
+    oldPath: string | null;
+    meta: string[];
+    hunks: ReviewDiffHunk[];
+};
+export type ReviewDiff = {
+    files: ReviewDiffFile[];
+    linesTruncated: boolean;
+};
+export declare const REVIEW_DIFF_LINE_CAP = 4000;
+/** Parse only the stable structure Git's unified patch format guarantees.
+ * Unknown metadata remains visible, and a patch that cannot be structured
+ * falls back to the sealed raw record—presentation never becomes proof. */
+export declare function parseReviewDiff(text: string): ReviewDiff;
+export declare function reviewDiffHtml(patch: {
+    text: string;
+    truncated: boolean;
+    artifactId: number;
+}, stat: TerminalDiffView["stat"], runId: number, commentable: boolean, anchors?: ReadonlyMap<string, string>): Html;
+/** The check log as stored (repair 2026-09-14): its output behind a
+ * disclosure when the bytes verify — a shortened log says so in the
+ * summary and its download is the stored part; a log that no longer
+ * verifies is a named problem with no output and no download. */
+export declare function checkLogHtml(log: NonNullable<ProofBundleView["checkLog"]>, runId: number, extra: Html): Html;
+/** The download link for a stored record (repair 2026-09-14): a shortened
+ * record's link says it holds the stored part only — never "the full"
+ * bytes that were cut at storage and exist nowhere. */
+export declare function storedDownloadLink(runId: number, artifactId: number, what: string, truncated: boolean): Html;
+/** Render the terminal diff card: stat and capture health first, the bounded
+ * patch beneath a fold. `editor` (arc 6) links file rows to vscode:// on the
+ * reviewing device; `commentable` adds a per-file "comment" button the
+ * page's prefill script reads — a real button, keyboard-reachable, separate
+ * from the link so the two never fight over one click (finding 4). */
+export declare function terminalDiffCard(view: TerminalDiffView, runId: number, editor?: {
+    worktree: string;
+} | null, commentable?: boolean): Html;
+/**
+ * The evidence bundle (Priority 2): the closed verdict first — the one
+ * sentence every other surface agrees with — then criteria, the agent's
+ * declared checks, the plane's own re-run (labeled "re-run here", never
+ * confused with the agent's own claim), caveats, and every validated
+ * screenshot as a thumbnail linking to the full image. Renders nothing
+ * when the run predates the proof system.
+ */
+export declare function evidenceBundleCard(view: ProofBundleView | null, run: Pick<Run, "id" | "role" | "outcome">, publication?: PublicationFacts, review?: ReviewFacts | null): Html;
+/** A calm, scan-first result receipt for the task and its focused chat.
+ * The full ledger remains one click away; this card carries only the facts
+ * needed to decide whether to inspect, discuss, or move on. */
+/** The receipt's proof-state word and tone, from the stored verdict and
+ * the operator's acceptance alone — shared with the review cockpit's
+ * header chip so the two surfaces never name one state differently. */
+/** The receipt's facts as the shared projection reads them. */
+/** A result's follow-ups: checks run on its commit since it finished, and its tests task. */
+export declare function followUpsFor(store: Store, evidenceRoot: string, run: Run, now: Date): NonNullable<ResultDetail["followUps"]> | null;
+export declare const FOLLOW_UP_WORDS: Record<FollowUpCheck["state"], string>;
+/** Run checks and Add tests, under the result's Checks: what ran since, then the two acts. */
+export declare function followUpsHtml(followUps: NonNullable<ResultDetail["followUps"]>, runId: number, o: ResultPanelOptions): Html;
+export declare function receiptStatusOf(view: CompletionReceiptView, review?: ReviewFacts | null): DisplayStatus;
+export declare function completionReceiptCard(view: CompletionReceiptView, taskId: string, place: "task" | "chat", standing?: DisplayStatus, assignment?: AssignmentSnapshot | null, headline?: boolean): Html;
+/**
+ * ONE result presentation (workspace package 3) for the run page, the
+ * review cockpit, and the chat's result detail. Every fact here comes
+ * from the same verified records the receipt reads; the surfaces differ
+ * only in where the panel sits and which links lead away from it.
+ */
+export type ResultDetail = {
+    /** Where "Complete and open a pull request" opens one; null when only "Mark complete" is offered. */
+    pullRequestTo?: string | null;
+    /** Where publishing stands: a pull request can be opened, publishing isn't set up, or neither said. Accept never publishes. */
+    publishing?: "pull-request" | "off" | "other";
+    learning?: Html;
+    skillTest?: boolean;
+    rootId?: string;
+    history?: Html;
+    taskId: string;
+    run: Run;
+    receipt: CompletionReceiptView;
+    assignment?: AssignmentSnapshot | null;
+    handoff: StructuredHandoffView | null;
+    proof: ProofBundleView | null;
+    terminal: TerminalDiffView | null;
+    publication: Publication | null;
+    ciFailing: boolean;
+    files: (ReviewFileRow & {
+        priority: ReviewPriority;
+    })[];
+    outsideTouches: string[];
+    fileAnchors: ReadonlyMap<string, string>;
+    comments: DiffComment[];
+    pastComments?: DiffComment[];
+    reviewerFindings: DiffComment[];
+    /** The build's one automatic review, when its project had review on. */
+    automaticReview?: BuildReviewView | null;
+    /** Revisions already sealed from this run — the forward link. Each
+     * carries the shared status projection's own words for the child
+     * (repair 2026-09-14): CURRENT exact approval and actual activity, so
+     * held or paused work is never called building because it was once
+     * approved, and a rescoped child reads as needing approval again. */
+    revisions: {
+        id: string;
+        title: string;
+        state: TaskState;
+        approved: boolean;
+        standing: string;
+        tone: string;
+    }[];
+    /** The source scope digest the panel was rendered against (null = no
+     * scope) — the revision form's source binding. */
+    sourceDigest: string | null;
+    route: RouteStamp | null;
+    editor: {
+        worktree: string;
+    } | null;
+    /** Signed criteria on the scope this run built against. */
+    signedCriteria: number;
+    /** Whether a reviewer can annotate here (sealed non-empty patch verifies, cookie session). */
+    canAnnotate: boolean;
+    /** Follow-ups on this result (result-follow-ups.ts): checks run since, the tests task, and what can run. */
+    followUps?: {
+        repo: string | null;
+        checks: FollowUpCheck[];
+        testsTask: string | null;
+        quick: boolean;
+        full: boolean;
+    } | null;
+};
+export type ResultPanelOptions = {
+    place: "run" | "review" | "chat";
+    tab: ResultTab;
+    csrf: string;
+    /** The server-named account, for the browser's bounded draft keys. */
+    user: string;
+    /** The page carries a receipt for a just-posted note: focus the box. */
+    noted: boolean;
+    /** This render's request token for the note form (replay dedupe). */
+    requestToken: string;
+    hrefFor: (tab: ResultTab) => string;
+    /** Where the forms send the reader back (validated server-side too). */
+    returnTo: string;
+    back: {
+        href: string;
+        label: string;
+    } | null;
+    /** Surface-specific acts that belong under Checks (the cockpit's review
+     * retry panel and its accept-with-exception form). */
+    extraChecks?: Html;
+    /** The cockpit's header already carries the status chip: said once. */
+    headStatus?: boolean;
+    /** The cockpit renders its own next-action card: no panel action. */
+    action?: boolean;
+    /** Accept and finish sits beside the panel: it records the person's own checks too, so the panel offers no separate Accept. */
+    finishes?: boolean;
+};
+/** The revision form's binding (repair 2026-09-14): the exact ids of the
+ * notes this page displays and the source terms it was rendered against.
+ * The server seals these ids and no others. */
+export declare function revisionSealFields(comments: readonly {
+    id: number;
+}[], sourceDigest: string | null): Html;
+/** Older machine-checked results saved a mechanical sentence; say the same
+ * facts in plain words (the version id stays, shortened). */
+export declare function plainConclusionOf(conclusion: string): string;
+export declare function resultPanelHtml(detail: ResultDetail, o: ResultPanelOptions): Html;
+/** The panel's HTML and the same panel in parts, for the rebuilt result page. */
+export declare function resultPanelParts(detail: ResultDetail, o: ResultPanelOptions): {
+    html: Html;
+    panel: BrowserResultPanel;
+};
+/** Changed lines shown beside one "You check this one" item: at most this many per file, three files. */
+export declare const CHECK_EXCERPT_LINES = 12;
+/** Each requirement only a person can confirm, with the evidence to judge
+ * it by, inline: the changed lines in the files it cites (citing none, the
+ * change's first file, labelled as not cited), the screenshots it cites
+ * (none cited: every validated one), and the agent's own note. */
+export declare function personCheckItems(proof: ProofBundleView, patchText: string | null, shots: readonly ResultScreenshot[], runId: number): BrowserCheckItem[];
+/** A Needs you result's one action (needs-you.ts): a link to the act that resolves it, or Confirm it
+ * stopped behind the password. Null under every other headline. */
+export declare function needActionOf(assignment: AssignmentSnapshot | null, status: TaskStatus | null, csrf: string, returnTo: string, result?: {
+    accepted: boolean;
+    humanReview: boolean;
+    run: number;
+    action: string;
+    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
+ * first sentence, cut at a word when it runs past 180 characters. The
+ * full conclusion stays available behind the Summary's disclosure. */
+export declare function conciseOutcomeOf(conclusion: string): string;
+/** Exactly one primary act for the result (repair 2026-09-14), chosen from
+ * its state: draft the CI repair, create the revision the notes are
+ * waiting for, open the pull request, or request changes. A bearer session
+ * (no token) gets no control; the cockpit renders its own next-action
+ * card instead (`action: false`). */
+export declare function resultPrimaryAction(detail: ResultDetail, o: ResultPanelOptions, prUrl: string | null): Html;
+/** The run's facts as rows — one renderer for the page and its live
+ * fragment (A4). Elapsed ticks client-side while the run is open. */
+/** The run's route provenance in plain words (v47): the exact agent it
+ * spent as, in which role, and how that agent was chosen. */
+export declare function runAgentWords(route: RouteStamp | null | undefined): string | null;
+export declare function runFactsRows(run: Run, taskId: string, live: boolean, route?: RouteStamp | null): Html;
+export declare function runPage(chrome: Chrome, run: Run, taskId: string, artifacts: Artifact[], terminal?: TerminalDiffView | null, notes?: {
+    id: number;
+    author: string;
+    note: string;
+    createdAt: string;
+}[], csrf?: string, comments?: DiffComment[], ciRepair?: {
+    pr: number;
+} | null, liveScript?: string, peekable?: boolean, running?: boolean, editor?: {
+    worktree: string;
+} | null, editorToggle?: {
+    on: boolean;
+} | null, noted?: boolean, structuredHandoff?: StructuredHandoffView | null, proofBundle?: ProofBundleView | null, route?: RouteStamp | null, publicationRow?: Publication | null, review?: ReviewFacts | null, result?: {
+    detail: ResultDetail;
+    tab: ResultTab;
+    user: string;
+    requestToken: string;
+} | null, sourceDigest?: string | null): Screen;
+/**
+ * Click-to-prefill (arc 6, finding 4): client-side FORM mutation, named as
+ * such — normal viewing stays the default; "Annotate" reveals line pins.
+ * A pin or file button copies its target into the comment form and focuses
+ * the note field. No fetch, endpoint, or submit: comments still leave
+ * through the same CSRF'd form POST. Reads data attributes, writes input
+ * values, and flips presentational state — never markup. The note counter
+ * (follow-up on build 1540) reads the textarea's own maxlength — the
+ * server's LIMITS.note — into the helper text, so the two cannot drift.
+ */
+export declare function prefillScript(): string;
+/** The primary review act opens the Checks view it names. The anchor
+ * still lands on the result without JavaScript (the server honours
+ * `?tab=checks`); this only removes the reload. */
+export declare function reviewEvidenceScript(): string;
+/** The facts region alone, for the open-run poll (A4). A finished run's
+ * fragment says so instead of quietly growing forms (finding 5), and a run
+ * that stopped being the task's live claim says so too — both carry the
+ * stop marker, so an open tab quits refetching a dead build (round-4
+ * finding 15). */
+export declare function runFactsFragment(run: Run, taskId: string, live: boolean, route?: RouteStamp | null): Html;