toolroll 0.9.103 → 0.9.105

package/dist/result-acts.d.ts

@@ -1,112 +0,0 @@
-/** The result page's acts (2026-10-02; docs/plans/plain-toolroll.md P1.3), chosen in one place: three verbs, each a
- * relabel over the post it has always made. Exactly one ink act at most, the one that resolves the result's state,
- * and never navigation; at most one outline act beside it. A result that can't be accepted says why in one line
- * before them. Run checks stays in the Checks row, and a person's own checks in the Checks list: neither is an act here.
- *
- *   everything met                      → Accept
- *   a "You check this one" unanswered   → (the check itself, above), then Accept without your check
- *   a check you marked Not right        → Send back, then Accept anyway
- *   checks queued or running            → (Checks running, in its row), then Accept without checks
- *   checks didn't run, a check exists   → (Run checks, in its row), then Accept without checks
- *   report and changes disagree,
- *   or the proof is refuted             → Send back, then Accept (as allowed);
- *                                         never Accept as ink, even with no form here
- *   a Needs you form resolves it        → that form (Retry: Build again; Check again)
- *   saved notes or a failing PR         → Send back (the revision from the notes, or the repair of the PR)
- *   a failed build                      → Retry (its note starts with what to change); never Accept: a failed build
- *                                         is not a result to accept
- *   a failed task's delivered result    → Retry, then Accept anyway (in outline, with a reason) where it may be
- *                                         accepted
- *
- * Accepting finishes the task in one request: the person's acceptance, when one is owed, and the completion
- * together. This only decides which act is ink; the page recomputes it as the person answers each check. */
-import type { ProofVerdict } from "./proof.js";
-/** The words over the reason field an Accept of a refuted result requires. */
-export declare const ACCEPT_NEEDS_REASON = "Accepting needs a reason";
-/** What kind of evidence problem a verdict records: a check the machine
- * actually ran and saw fail, evidence that contradicts the sealed record
- * (a mismatched changed-path claim, an altered criterion, a caveat that
- * contradicts a met verdict), or evidence that is simply absent. A generic
- * refuted verdict is NOT a failed test claim — only the verify-command
- * reasons say a check failed. */
-export type EvidenceProblem = "checks-failed" | "mismatched" | "missing" | "none";
-export declare const FAILED_CHECK: RegExp;
-export declare function evidenceProblemOf(verdict: ProofVerdict | null, reasons: readonly string[]): EvidenceProblem;
-/** Why a result can't be accepted as it stands, in one plain line, or null
- * when nothing refutes it (a person's acceptance settles it). The result page
- * shows it before Request changes, its one ink act. */
-export declare function cantAcceptYetOf(verdict: ProofVerdict | null, reasons: readonly string[], accepted: boolean): string | null;
-export type ResultActKind = "retry" | "accept" | "accept-anyway" | "next-check" | "checks-running" | "run-checks" | "request-changes" | "rebuild" | "recheck-stopped" | "revise" | "draft-repair";
-export type ResultActFacts = {
-    /** An Accept this page can post (Accept and finish, or the person's acceptance alone); `ready`: every requirement met and checks passed. */
-    accept: {
-        ready: boolean;
-    } | null;
-    /** The checks didn't run, the project has one, and this person may run it. */
-    runChecks: boolean;
-    /** Checks on this result are queued or running. */
-    checksRunning: boolean;
-    /** Why it can't be accepted yet (cantAcceptYetOf), or null. */
-    blocked: string | null;
-    /** The feedback form is on this page. */
-    canRequest: boolean;
-    /** A Needs you form that resolves it here. */
-    need: "rebuild" | "recheck-stopped" | null;
-    /** Saved notes ready to become a revision, or a failing pull request's repair. */
-    next: "revise" | "draft-repair" | null;
-    /** A failed build: `retry` when the task can be retried from here; `acceptAnyway` when it delivered a result that
-     * may still be accepted, with a reason. */
-    failed?: {
-        retry: boolean;
-        acceptAnyway?: boolean;
-    } | null;
-    /** "You check this one" items not answered yet on this page. */
-    unanswered?: number;
-    /** Items the person marked Not right. */
-    notRight?: number;
-};
-export type ResultActs = {
-    /** The one ink act, or null when nothing waits on the person. */
-    primary: ResultActKind | null;
-    /** The one outline act beside it. */
-    secondary: ResultActKind | null;
-    /** The one line before the acts: why it can't be accepted yet. */
-    line: string | null;
-};
-/** The three verbs, and the posts each one makes (docs/plans/plain-toolroll.md P1.3): Accept is today's Accept (and
- * finish), or Accept anyway with a reason; Send back is today's request for changes and its revision from saved notes
- * for an unpublished result, or the repair of a published one; Retry is today's Retry, or Build again. Check again
- * keeps its own words (its act stands on the build, not on the result). */
-export type ResultVerb = "Accept" | "Send back" | "Retry";
-export declare const RESULT_VERB: Readonly<Record<ResultActKind, ResultVerb | null>>;
-/** What Send back does, said on its own confirm line: the rule is fixed by whether the result is already published. */
-export declare const SEND_BACK_UNPUBLISHED = "Sends it back with your notes. The same task builds again once you approve the revision.";
-export declare const SEND_BACK_PUBLISHED = "It's already published, so this files a fix as a new version for you to approve.";
-export declare function resultActsOf(facts: ResultActFacts): ResultActs;
-/** The words a result's Accept wears and the one line before it, given the
- * server's words for everything but the person's own checks (`base`) and how
- * those stand on this page: an unanswered check names itself; a check marked
- * Not right says so; otherwise the base words stand. */
-export type AcceptLabel = "Accept" | "Accept without checks" | "Accept without your check" | "Accept anyway";
-export declare function acceptWithChecksOf(base: {
-    label: AcceptLabel;
-    ready: boolean;
-    why: string | null;
-}, checks: {
-    unanswered: readonly string[];
-    notRight: readonly string[];
-}): {
-    label: AcceptLabel;
-    ready: boolean;
-    why: string | null;
-};
-/** The Requirements row as the person answers their checks: each Looks right is met, each answer leaves "You check". */
-export declare function requirementsWordsOf(req: {
-    met: number;
-    total: number;
-    yours: number;
-}, looked: number, notRight: number): {
-    text: string;
-    done: boolean;
-    short: boolean;
-};

package/dist/result-completion.d.ts

@@ -1,35 +0,0 @@
-/**
- * v102: what a result actually changed, read from the build's sealed diff
- * inventory, and whether a result that changed protected files may go out.
- * Completion and publication share this so neither can be the gap.
- */
-import type { Store } from "./store.js";
-/** The ledger action a person's (or lead's) completion of a result writes. */
-export declare const COMPLETION_ACTION = "assignment handoff checked";
-/** The actor of an automatic completion: the result's work already landed (landed-cleanup.ts). Its ledger detail is
- * the plain-English reason ("its pull request merged"), the one place every surface reads it from. */
-export declare const LANDED_ACTOR = "system:landed";
-/** Who may complete a result, as a completion's ledger actor: a person, a lead, or Toolroll when the work landed. */
-export declare const COMPLETER_ACTOR: RegExp;
-/** Why Toolroll marked a result complete, from its completion's actor and detail; null for a person's completion. */
-export declare function landedReasonOf(actor: string | null | undefined, detail: string | null | undefined): string | null;
-/** Whether a task's family is marked complete. Completion is recorded on the
- * family's root against its current version's latest result, so the root, a
- * superseded revision and the current version all read Complete together. */
-export declare function familyCompleted(store: Store, taskId: string): boolean;
-/** The files a build changed, renames on both sides; null when the inventory can't be read whole. */
-export declare function changedFilesOf(store: Store, runId: number, root: string): string[] | null;
-/** Everything a result's branch carries: this build's changes and every build of every task it revises (a
- * revision builds on its source's head, so its branch holds the source's commits too). null when any of
- * them can't be read whole. */
-export declare function familyChangedFiles(store: Store, taskId: string, runId: number, root: string): string[] | null;
-/** Why a build's branch must wait before it's pushed (and so before any PR or merge): it (or a task it
- * revises) changed protected files on a one-person approval, and nobody but its approver and requesters
- * has marked it complete. */
-export declare function protectedPublicationHold(store: Store, runId: number, root: string): string | null;
-/** A completion's mark (v134, approval policy §1.7a): whether a person or a machine credential made it. */
-export declare const COMPLETION_BY_PERSON = "proof person";
-export declare const COMPLETION_BY_MACHINE = "proof machine";
-/** Whether this person completing an already-complete result would release a protected publication hold: protected
- * work needs someone other than its approver, no person's completion on record provides it, and this person can. */
-export declare function personCompletionOwed(store: Store, taskId: string, runId: number, receiptDigest: string, person: string, root: string): boolean;

package/dist/result-evidence-readers.d.ts

@@ -1,42 +0,0 @@
-/** Shared verified readers for result screens and the compact CLI review. */
-import type { Artifact } from "./store.js";
-export declare const SCREENSHOT_CAPTURE: RegExp;
-/** What the run page shows of the terminal diff — verified bytes or a named problem, never silence. */
-export type TerminalDiffView = {
-    patch: {
-        text: string;
-        truncated: boolean;
-        artifactId: number;
-    } | {
-        problem: string;
-    } | null;
-    stat: {
-        base: string;
-        head: string;
-        fileCount: number;
-        additions: number;
-        deletions: number;
-        binaryCount: number;
-        filesTruncated: boolean;
-        files: {
-            path: string;
-            additions: number | null;
-            deletions: number | null;
-            renamedFrom?: string;
-        }[];
-    } | {
-        problem: string;
-    } | null;
-};
-/** A compact, typed view of the agent-authored handoff. Older v1
- * artifacts simply have no lists, while v2 can present the useful answer
- * before the raw diff and evidence below it. */
-export type StructuredHandoffView = {
-    conclusion: string;
-    changes: string[];
-    verification: string[];
-    followUps: string[];
-};
-export declare function structuredHandoffView(artifacts: Artifact[], root: string, displayText?: (text: string) => string): StructuredHandoffView | null;
-/** A failed capture or unverifiable bytes keep their problem; absence returns null. */
-export declare function terminalDiffView(artifacts: Artifact[], root: string): TerminalDiffView | null;

package/dist/result-follow-ups.d.ts

@@ -1,118 +0,0 @@
-import type { Runner } from "./backend.js";
-import type { Store } from "./store.js";
-import { type CheckLevel } from "./check-levels.js";
-export declare const CHECKS_REQUESTED = "checks requested";
-export declare const CHECKS_STARTED = "checks started";
-export declare const CHECKS_FINISHED = "checks finished";
-export declare const FOLLOW_UP_LOG = "follow-up check log v1";
-export declare const FOLLOW_UP_RECEIPT = "follow-up check receipt v1";
-export declare const ADD_TESTS_ACTION = "tests task filed";
-export type RunLevel = Exclude<CheckLevel, "off">;
-/** How a batch check (batch-checks.ts) reached this result's outcome. `together`: one check on a temporary
- * merge of `members`; `split`: its batch failed, so it was checked on its own; `conflict`: it couldn't be merged
- * with the others, so it was checked on its own; `alone`: nothing joined it within the window. */
-export type BatchFacts = {
-    mode: "together" | "split" | "conflict" | "alone";
-    tested: string;
-    base: string | null;
-    members: {
-        task: string;
-        run: number;
-        head: string;
-    }[];
-};
-export type FollowUpCheck = {
-    request: number;
-    runId: number;
-    level: RunLevel;
-    head: string;
-    actor: string;
-    at: string;
-    why: "person" | "pull-request" | "batch" | "recheck";
-    /** The approved command's digest when checks were asked for: only that exact command runs. */
-    digest: string;
-    state: "waiting" | "running" | "passed" | "failed" | "not-run";
-    exitCode: number | null;
-    logArtifactId: number | null;
-    note: string | null;
-    /** A batch request: the project base it is merged onto. */
-    base?: string | null;
-    /** The commit the check actually ran on: the result's own, or a temporary batch commit. Null until it ran. */
-    tested?: string | null;
-    /** From the sealed receipt of a batch check. */
-    batch?: BatchFacts | null;
-};
-type Refusal = {
-    ok: false;
-    reason: string;
-    message: string;
-};
-/** Every follow-up check a result has had, oldest first, as the ledger and its sealed receipts say. */
-export declare function followUpChecksOf(store: Store, runId: number, now?: Date, root?: string): FollowUpCheck[];
-/** Ask for checks on a result's exact commit. Asking twice while one is waiting
- * or running returns the same request; a worker runs it once. */
-export declare function requestFollowUpChecks(store: Store, input: {
-    runId: number;
-    level: RunLevel;
-    actor: string;
-    why?: "person" | "pull-request" | "recheck";
-}, now: Date): {
-    ok: true;
-    request: number;
-    level: RunLevel;
-    existing: boolean;
-} | Refusal;
-/** Requests nobody has started yet, oldest first. Batch requests wait for the batch pass (batch-checks.ts). */
-export declare function waitingCheckRequests(store: Store, now: Date): FollowUpCheck[];
-export declare function waitingRequestsOfAnyKind(store: Store, now: Date): FollowUpCheck[];
-export type CheckRunDeps = {
-    runner?: Runner;
-    git?: Runner;
-    now?: () => Date;
-    scratch?: string;
-};
-/** Run one waiting request: claim it, check out its commit, run the approved
- * setup (when the project has one) and the check, seal the log and receipt. */
-export declare function runFollowUpCheck(store: Store, root: string, request: number, deps?: CheckRunDeps): Promise<FollowUpCheck | null>;
-/** The worker's pass: run every waiting request, one at a time. */
-export declare function runWaitingChecks(store: Store, root: string, deps?: CheckRunDeps & {
-    shouldStop?: () => boolean;
-}): Promise<number>;
-export type CheckReading = {
-    status: "passed" | "failed" | "not-run" | "unavailable";
-    level: CheckLevel | null;
-    exitCode: number | null;
-    head: string | null;
-};
-/** The build's own check, then each finished follow-up in order on the same
- * commit: a pass upgrades (a quick pass never replaces a full one), a failure
- * is shown as it is. A follow-up that couldn't run changes nothing. */
-export declare function withFollowUps(original: CheckReading, followUps: readonly Pick<FollowUpCheck, "level" | "state" | "head" | "exitCode">[]): CheckReading & {
-    running: RunLevel | null;
-};
-/** The level a result's checks stand at now: the build's own level, raised by
- * a follow-up that passed on the same commit. null for results from before levels. */
-export declare function resultCheckLevel(store: Store, runId: number, now: Date): CheckLevel | null;
-/** Before a Quick or Off result merges: the project's full check on its exact
- * commit. Clear when the build already ran the full check, when the project has
- * no full command (its CI covers it), or when a follow-up full check passed. */
-export type FullCheckGate = {
-    state: "clear";
-} | {
-    state: "not-requested" | "waiting" | "failed" | "not-run";
-    message: string;
-};
-export declare function fullCheckGate(store: Store, runId: number, now: Date): FullCheckGate;
-/** File a small task to write tests for a result's change. It is filed like any
- * other task: nothing runs until a person approves it. */
-export declare function fileAddTestsTask(store: Store, root: string | null, input: {
-    runId: number;
-    actor: string;
-    filedVia: string;
-    admittedRepos?: readonly string[];
-}, now: Date): {
-    ok: true;
-    id: string;
-    existing: boolean;
-} | Refusal;
-export {};

package/dist/result-review.d.ts

@@ -1,220 +0,0 @@
-/** Result-first review (workspace package 3, 2026-09-13): the pure parts
- * of ONE result presentation shared by the task chat receipt, the run
- * page, the review cockpit, and the chat's result detail.
- *
- * Nothing here reads a database or renders a full page. The server
- * assembles the same verified records it already reads (handoff, proof,
- * diff, matrix, publication, report) into `SharedResultFacts`; every
- * surface prints those facts through `resultFactsAttributeMap` (as html attributes), so a test —
- * or a person — can check that chat, run detail, and review agree on the
- * run, its head, its checks, its caveats, and its publication.
- *
- * The presentation leads with the deliverable itself: validated
- * screenshots for UI work, the escaped report for an investigation, a
- * concise change summary for code. Missing, corrupt, or truncated
- * evidence is named in `evidenceProblemsOf` and is never described as
- * validated. Three local views — Summary, Changes, Checks — are anchor
- * links (`?tab=`) the server honours, enhanced in the browser by
- * `RESULT_REVIEW_SCRIPT`, which also keeps a bounded review draft, the
- * selected tab, and the reading position in this tab's sessionStorage,
- * keyed by the server-named account, the task, and the run. */
-import { type ResultFacts, type PublicationFacts, type DisplayStatus } from "./workspace-ui.js";
-/** Optional context for feedback. The sealed diff remains the revision authority. */
-export type FeedbackImage = {
-    run: number;
-    artifact: number;
-    sha256: string;
-};
-export declare function parseFeedbackImage(value: unknown): FeedbackImage | null | false;
-export declare function sameFeedbackImage(a: FeedbackImage | null | undefined, b: FeedbackImage | null | undefined): boolean;
-/** Add re-read evidence health to the existing result/review projection.
- * This is presentation only: the recorded verdict and acceptance stay intact. */
-export declare function evidenceResultStatusOf(result: ResultFacts, publication: PublicationFacts, evidence: EvidenceHealth): DisplayStatus;
-export declare function evidenceShortenedWords(evidence: EvidenceHealth): string;
-export type ResultTab = "summary" | "changes" | "checks";
-export declare const RESULT_TABS: readonly {
-    key: ResultTab;
-    label: string;
-}[];
-/** The requested local view; anything unknown reads as Summary. */
-export declare function parseResultTab(raw: string | null | undefined): ResultTab;
-/** What leads the Summary view — decided from the records present, never
- * from the outcome word: a scout's report leads even when a diff exists;
- * validated screenshots lead UI work; a sealed diff leads code; the
- * handoff alone leads when nothing else was captured. */
-export type ResultLead = "report" | "screenshots" | "changes" | "summary";
-export declare function resultLeadOf(input: {
-    role: string;
-    report: boolean;
-    screenshots: number;
-    diff: boolean;
-}): ResultLead;
-/** One validated screenshot as the page will show it, or the reason it
- * cannot be shown. `problem` is set when the stored bytes no longer verify
- * against their record; such a shot is counted as unavailable and is
- * never rendered as an image or described as validated. */
-export type ResultScreenshot = {
-    path: string;
-    caption: string;
-    artifactId: number;
-    sha256?: string;
-    problem: string | null;
-};
-export type ResultEvidenceInput = {
-    /** The proof artifact exists but cannot be shown (corrupt, unparseable). */
-    proofProblem: string | null;
-    /** The sealed diff's health: absent, unverifiable, or fine. */
-    diff: {
-        problem: string;
-    } | {
-        truncated: boolean;
-    } | null;
-    stat: {
-        problem: string;
-    } | {
-        filesTruncated: boolean;
-    } | null;
-    /** The check log: absent, no longer verifying (`problem`), or stored
-     * whole or shortened. */
-    checkLog: {
-        problem: string;
-    } | {
-        truncated: boolean;
-    } | null;
-    screenshots: readonly ResultScreenshot[];
-    /** Screenshot paths the proof cites that no stored artifact answers. */
-    uncapturedScreenshots: readonly string[];
-    /** A scout's report record: absent, unverifiable, or fine (possibly
-     * shortened when it was stored). */
-    report: {
-        problem: string;
-    } | {
-        ok: true;
-        truncated?: boolean;
-    } | null;
-    /** Whether a report is owed (a scout's run) — absence is then a problem. */
-    reportExpected: boolean;
-    /** The handoff record: a no-change conclusion owes one. */
-    handoffPresent: boolean;
-    outcome: string | null;
-};
-/** What kind of evidence problem a record has (repair 2026-09-14):
- * `damaged` — the stored bytes no longer verify, cannot be read, or the
- * capture itself failed, so nothing can be shown for that record;
- * `shortened` — the record was cut at its storage cap, so its download is
- * the stored part only, never the full bytes; `missing` — a record the
- * result owes was never stored. */
-export type EvidenceProblemKind = "damaged" | "shortened" | "missing";
-export type EvidenceProblem = {
-    kind: EvidenceProblemKind;
-    words: string;
-};
-/** Every evidence problem, classified, in a stable order. Empty means
- * every record this result cites is present, whole, and verifies. */
-export declare function evidenceProblemDetailsOf(input: ResultEvidenceInput): EvidenceProblem[];
-/** Every evidence problem in plain words, in a stable order. */
-export declare function evidenceProblemsOf(input: ResultEvidenceInput): string[];
-/** The counts the shared status reads: how many records are damaged,
- * shortened, or missing. A status is truthful only when it knows these. */
-export type EvidenceHealth = {
-    damaged: number;
-    shortened: number;
-    missing: number;
-};
-export declare function evidenceHealthOf(problems: readonly EvidenceProblem[]): EvidenceHealth;
-/** The facts every result surface must agree on. */
-export type SharedResultFacts = {
-    runId: number;
-    /** The exact commits, from the sealed diff summary when it verifies,
-     * else from the run record — `headSource` says which. */
-    base: string | null;
-    head: string | null;
-    headSource: "saved diff" | "build record" | null;
-    /** Signed criteria passed, from the machine's matrix; null = no rubric. */
-    checks: {
-        passed: number;
-        total: number;
-    } | null;
-    caveats: readonly string[];
-    evidenceProblems: readonly string[];
-    /** How many of the problems above are damaged, shortened, or missing
-     * records — what the shared status reads (repair 2026-09-14). */
-    evidenceHealth: EvidenceHealth;
-    /** The observed publication state, "none" when nothing was intended. */
-    publicationState: string;
-    publicationWords: string;
-};
-/** The `data-result-*` attributes every surface stamps on its result
- * element. Values are short, escaped, and deterministic for one run, so
- * two surfaces rendering the same result carry byte-identical attributes. */
-/** The shared facts as the panel's data attributes, unescaped (the rebuilt
- * result page sets them through React). */
-export declare function resultFactsAttributeMap(facts: SharedResultFacts): Record<string, string>;
-/** The shared fact names, in the order `resultFactsAttributeMap` lists them. */
-export declare const RESULT_FACT_KEYS: readonly ["run", "head", "base", "head-source", "checks", "caveats", "evidence", "publication"];
-/** Parse the shared facts back — the test-side and proof-side reader.
- * Only the shared keys are read; a panel's own presentation attributes
- * (place, lead, task, user) are not facts and are left out. */
-export declare function resultFactsFromHtml(html: string): Record<string, string>[];
-/** Where a result form may send its reader back: the review cockpit's
- * own deep link, the chat's result detail, the page of a task named in
- * `tasks` (the run's own) or its Result tab at this run, or the run page. Anything else lands on the run
- * page. Matched exactly — never a bare open redirect. */
-export declare function resultReturnTarget(raw: string | null | undefined, runId: number, tasks?: readonly string[]): string;
-/** A form's own request token, minted per render — the same shape the
- * chat composer uses. A replayed submission carries the same token, so
- * the server can recognise it and mint nothing twice. */
-export declare const REQUEST_TOKEN: RegExp;
-/** The dedupe key a review note is stored under when the form carried a
- * request token: bound to the account and the token, never to the words,
- * so the same person saying the same thing twice on purpose still lands. */
-export declare function commentSourceKey(user: string, request: string | null | undefined): string | undefined;
-/** The revision form's exact batch (repair 2026-09-14): the ids of the
- * live notes the page DISPLAYED, oldest first, joined by commas, plus the
- * source scope digest the page rendered against ("none" when the task has
- * no scope). A seal binds to exactly these — never to "whatever is live
- * when the POST arrives" — so a replayed or second-tab submission can
- * only ever consume the notes its own reader saw. */
-export declare function revisionBatchOf(comments: readonly {
-    id: number;
-}[]): string;
-/** User feedback requests work; a reviewer's observations only do so when
- * they are problems. The original findings always remain on record. */
-export declare function isRevisionFeedback(comment: {
-    reviewerRun: number | null;
-    severity: string | null;
-}): boolean;
-export declare const REVISION_BATCH_CAP = 500;
-/** Parse a posted batch back into distinct positive ids, or null when the
- * field is absent or malformed (an out-of-date form, a hand-built POST). */
-export declare function parseRevisionBatch(raw: string | null | undefined): number[] | null;
-/** The source binding the revision form carries: the scope digest the
- * page was rendered against, or "none". */
-export declare function revisionSourceOf(scopeDigest: string | null): string;
-/** The in-page half of the result presentation. Everything it does is
- * presentational or a bounded draft: no fetch, no endpoint, no submit.
- *
- * - Tabs: the anchor links switch the visible view in place and record
- *   `?tab=` with replaceState, so refresh and Back land on the same view
- *   the server would render for that URL.
- * - Diff modes: View hides the line pins; Annotate shows them. A pin or a
- *   file button copies its target into the Request changes form, opens
- *   the pin disclosure, and focuses the note.
- * - Review draft: the note, file, and line are kept in sessionStorage
- *   under the account, task, and run the form names, for at most a day,
- *   and restored on load. The draft clears only when the page carries the
- *   receipt for THIS draft's request token (`?noted=<token>`); a refused
- *   submission leaves it in place. Other accounts' drafts on this tab are
- *   dropped, never restored.
- * - Request identity (repair 2026-09-14): the form's request token is
- *   bound to the exact note, file, and line last displayed, even when
- *   FormData is sent directly. An unchanged retry keeps the token, so the server
- *   records it once; editing any of the three after a submission mints a
- *   fresh token, so the edited words are a new note and can never be
- *   swallowed by the earlier one's receipt. A refusal that comes back with
- *   `?conflict=<token>` rotates that token too, keeping the words.
- * - Reading position: the page's scroll offset is kept under the same
- *   account/task and the URL's own result and tab, and restored on load
- *   when the URL carries no hash, so Back to chat and refresh return the
- *   reader to where they were. */
-export declare const RESULT_REVIEW_SCRIPT: string;

package/dist/result-shots.d.ts

@@ -1,59 +0,0 @@
-import { type Notification, type ResultScreenshots, type Store } from "./store.js";
-import { type ChatContent, type ChatState } from "./chat-delivery-state.js";
-/** "Up to 4": the most screenshots one result ever sends. */
-export declare const RESULT_SHOTS_MAX = 4;
-/** The choices in the order Settings and the CLI show them. */
-export declare const RESULT_SHOT_CHOICES: readonly (readonly [ResultScreenshots, string])[];
-export declare function resultShotLimit(choice: ResultScreenshots): number;
-export type ResultShot = {
-    artifact: number;
-    sha256: string;
-    bytes: Buffer;
-    format: "png" | "jpeg";
-    fileName: string;
-    /** Plain words: the first screenshot's carry the task ("Is the site current? · the home page on a phone"). */
-    caption: string;
-    /** Within Telegram's photo limits, so it shows an inline preview. */
-    photo: boolean;
-    /** Captioned with its item's number (flow-items.ts): an album shows it on this photo, not only on the first. */
-    numbered?: true;
-};
-export type ResultShotsPlan = 
-/** Nothing to send and nothing to say: off, pruned by retention, none saved, or all already sent. */
-{
-    kind: "none";
-    why: "off" | "pruned" | "none" | "sent";
-}
-/** One plain line instead of any screenshot. */
- | {
-    kind: "line";
-    text: string;
-} | {
-    kind: "send";
-    taskId: string;
-    run: number;
-    shots: ResultShot[];
-};
-/**
- * What one person's screenshots row may send now, to a chat that reaches
- * `repos`. `sent`: screenshots this destination already has, never sent again.
- * Every byte returned was verified this instant; a channel uploads them with
- * no wait in between, or asks again.
- */
-export declare function resultShotsFor(store: Store, evidenceRoot: string | undefined, repos: readonly string[], row: Pick<Notification, "kind" | "recipient" | "taskId" | "taskRef" | "run"> & {
-    dedupeKey?: string;
-}, sent?: ReadonlySet<number>): ResultShotsPlan;
-/** A row that carries a result's screenshots: one a person asked for with results, or one a flow sends them. */
-export declare function isShotsKind(kind: string): boolean;
-/** A screenshot whose result message is not posted yet waits for that message's own next try (at least a second). */
-export declare function shotWaitsUntil(resultNextAt: unknown, now: Date): string;
-/** Retention removed this result's files: its screenshots go quietly, never as a complaint. */
-export declare function resultShotsPruned(evidenceRoot: string, run: number): boolean;
-/**
- * The chat app refused the upload (no file permission there): this part becomes one plain line and the result's
- * other screenshots in the same message are dropped, so the person reads one line, not one per screenshot.
- */
-export declare function refuseResultShots(state: Pick<ChatState, "prepare">, store: Store, part: {
-    id: number;
-    event: string;
-}, content: ChatContent, app: string, now: Date): void;

package/dist/retention-ui.d.ts

@@ -1,21 +0,0 @@
-/**
- * Settings → Retention (v105): how long each kind of data is kept, and what
- * the next daily sweep would remove. An instance operator's page; changes
- * take a step-up. Built from the revamp kit; the Settings frame adds the title.
- */
-import { type Html } from "./html.js";
-import { type RetentionCount, type RetentionKind, type RetentionPeriods } from "./retention.js";
-/** The page is kit pieces now; nothing of the old look is left. Kept as an export for the shared stylesheet. */
-export declare const RETENTION_CSS = "";
-/** `chosen`: the kinds someone chose a period for; the rest keep their default. */
-export type RetentionView = {
-    periods: RetentionPeriods;
-    chosen: readonly RetentionKind[];
-    next: RetentionCount[];
-    lastSweep: string | null;
-    csrf: string;
-};
-export declare function retentionHtml(view: RetentionView, said: {
-    said?: string | null;
-    problem?: string | null;
-}): Html;