toolroll 0.9.103 → 0.9.105

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

@@ -1,754 +0,0 @@
-/** Results and runs: the review cockpit, evidence, receipts, diffs and the result panel. */
-import type { CheckAccess } from "../check-access.js";
-import type { RunNetworkRecord } from "../egress.js";
-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 { RunEfficiency } from "../run-efficiency.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 ChecksFact, type ReleaseState, 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;
-    release?: ReleaseState | undefined;
-}): 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;
-/** 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 = {
-    /** How the result's run went (docs/plans/run-efficiency.md): display only, its sources and their gaps said. */
-    efficiency?: RunEfficiency | null;
-    /** What the run's network was and what its proxy saw (egress.ts): display only. */
-    network?: RunNetworkRecord | null;
-    /** Where the time went (latency-timeline.ts): its release check's parts and the task's deploys, display only. */
-    timing?: import("../latency-timeline.js").TimingView | null;
-    /** How far its checks reached (check-access.ts): shown only when wider than sandboxed. */
-    checkAccess?: CheckAccess;
-    /** How the checks ran, from their execution stamp (check-stamp.ts ranWords); null: nothing to say. */
-    checkRan?: string | null;
-    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's HTML and, for the rebuilt page, the same result
- * as data: every form and panel body is the one the HTML carries. */
-/** Where a result is shown: its own page (/review), or the Result tab of its task's page (docs/plans/one-page-task-and-agent.md),
- * whose address is `base` (the task page with tab=result, and its version when not the current one). The result's own
- * view (Summary / Changes / Checks) rides `section=` there, so it never fights the task page's `tab`. */
-export type ResultHost = {
-    kind: "review";
-} | {
-    kind: "task";
-    base: string;
-};
-export declare function reviewCockpitDetailParts(view: ReviewCockpitView, csrf: string, noted: boolean, canRetryReview: boolean, tab: ResultTab, user: string, host?: ResultHost): {
-    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, back?: 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;
-/** 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 saved approved check read now (task-status.ts approvedCheckOf), for a finished build; absent otherwise, and
-     * then no words here claim the check passed. */
-    checks?: ChecksFact | null;
-};
-/** 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;
-    /** The saved approved check as read now (the receipt and any follow-up on the same commit), so the status words
-     * read the same answer as the Project checks row (task-status.ts approvedCheckOf). Absent on a scout's report. */
-    checks?: ChecksFact | null;
-};
-/** 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;
-/** What the verdict recorded when the build finished, said beside what holds now: a recorded pass is restated only
- * when the check read now passed; unread, it points to the result; unreadable or failed since, it says so. */
-export declare function completionWords(verdict: ProofVerdict | null, reasons: readonly string[], checks: ChecksFact | null | undefined): string;
-export declare function completionReceiptView(store: Store, run: Run, artifacts: Artifact[], root: string, review?: ReviewFacts | null, now?: Date): 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[];
-    /** Live saved notes whose screenshot would be refused now (result-actions.ts feedbackImageProblem). */
-    unusableImageNotes?: readonly number[];
-    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[];
-/** The completion blocker no acceptance resolves (a failed check, an unresolved HIGH finding), in words, or null. */
-export declare function hardBlockerOf(assignment: AssignmentSnapshot | null | undefined): string | null;
-/** 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;
-/** 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;
-/** A run's outcome in the kit's tones: built or no change finished, failed or refused failed, anything else neutral. */
-export declare function runOutcomeChip(run: Pick<Run, "outcome" | "reason" | "role">, live: boolean): Html;
-/** A run's facts as the kit's facts list: how it ended, who ran it where, when, what it cost and where it ended. The
- * live poll (`?fragment=facts`) swaps the same list in place. (The page's header names the run and its task.) */
-export declare function runFactsRows(run: Run, _taskId: string, live: boolean, route?: RouteStamp | null): Html;
-/**
- * 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;