toolroll 0.9.104 → 0.9.105

package/dist/workspace-ui.d.ts

@@ -1,385 +0,0 @@
-/**
- * The workspace's ONE display projection (package 1, 2026-09-13): the
- * words, tone, and next action a task or result wears on every surface —
- * Work rows, the task page's status box, the focused chat's journey card,
- * the review cockpit's chip, and the completion receipt's heading. Pure
- * functions over facts the store already records (task state, the dispatch
- * diagnosis, the machine's proof verdict and its reasons, an operator's
- * acceptance, the publication row); nothing here is a second lifecycle,
- * and nothing here reads the agent's narrative as evidence of success.
- *
- * The vocabulary is the truthful-status contract from the workspace plan:
- * a saved result with a failed check says "Changes saved, but checks
- * failed"; a missing proof says "verification needed"; agent-reported
- * checks say so; an accepted exception stays an exception; and nothing
- * local is ever called shipped or deployed — "PR opened" and "Merge
- * observed" name observed publication records, and deployment is never
- * claimed without one.
- */
-import type { DispatchDiagnosis } from "./dispatch.js";
-import { ACCEPT_NEEDS_REASON, cantAcceptYetOf, evidenceProblemOf, type AcceptLabel, type EvidenceProblem } from "./result-acts.js";
-export { ACCEPT_NEEDS_REASON, cantAcceptYetOf, evidenceProblemOf, type EvidenceProblem };
-import { type ProofVerdict } from "./proof.js";
-import type { ReviewRetryState, TaskState } from "./store.js";
-import type { TaskControlView } from "./task-control.js";
-import { type ChecksFact } from "./task-status.js";
-import { type Html } from "./html.js";
-/** The Work destination's views — shortcuts over the same rows, never a
- * persisted state. All is the default. */
-export type WorkView = "all" | "needs-you" | "ready" | "running" | "queued" | "completed" | "archived";
-export declare const WORK_VIEWS: readonly {
-    key: WorkView;
-    label: string;
-    hint: string;
-    empty: string;
-}[];
-export declare function parseWorkView(raw: string | null): WorkView;
-/** The finished result's recorded facts, as `taskViewData`, dispatch, and
- * the completed-work query already read them. */
-export type ResultFacts = {
-    runId: number | null;
-    /** The result run's role — a scout delivers a report, not a diff. */
-    role: string | null;
-    outcome: string | null;
-    verdict: ProofVerdict | null;
-    reasons: readonly string[];
-    accepted: boolean;
-    /** A no-change conclusion's two presence facts (handoff + sealed diff);
-     * undefined when the caller did not read them. */
-    recordComplete?: boolean;
-    /** The check level this result now stands at (check-levels.ts): Off reads
-     * Ready for review, saying no check ran, until a follow-up check passes. */
-    checkLevel?: "quick" | "full" | "off" | null;
-    /** This exact run's independent review (v50 retry projection), read
-     * per run so an older selected result keeps its own words; undefined
-     * when the caller did not read it, null when never requested. */
-    review?: ReviewFacts | null;
-    /** The saved approved check as read now (assignmentChecksForRun), for `approvedCheckOf`: the words say the check
-     * passed only when this reading does. Undefined: the caller read no check (a list or dispatch read), so the words
-     * name only what the verdict recorded when the build finished. */
-    checks?: ChecksFact | null;
-};
-/** The result's review facts as `reviewRetryStateOf` records them, plus
- * the one liveness fact the words depend on. */
-export type ReviewFacts = {
-    state: ReviewRetryState["state"];
-    /** The attempt in play: the next ordinal while queued, else the live or
-     * latest attempt's. */
-    attempt: number | null;
-    cap: number;
-    attempts: number;
-    retriesRemaining: number;
-    latestReason: string | null;
-    interrupted: boolean;
-    /** Who asked for the open (queued) request, when one is open. */
-    queuedBy: string | null;
-    queuedOrigin?: "operator" | "automatic" | null;
-    /** Whether the live attempt's reviewer worker is answering. */
-    reviewerAlive: boolean;
-    /** The build's one automatic review is still pending (build-review.ts). */
-    automaticPending?: boolean;
-};
-/** The review facts from the store's bounded retry projection — the same
- * reading `diagnoseTaskDispatch` makes, so every surface starts from one
- * record. `reviewerAlive` answers for the live attempt's runner. */
-export declare function reviewFactsOf(retry: ReviewRetryState | null, reviewerAlive: (runner: string) => boolean, automaticPending?: boolean): ReviewFacts | null;
-/** The tokens a review in flight wears — the dispatch codes, unchanged. */
-export declare const REVIEW_TOKENS: ReadonlySet<string>;
-/**
- * A review that is queued, running, failed with a retry left, or
- * exhausted is the result's PRIMARY status — the machine is still
- * deciding, and every surface must say so with the same words. A review
- * never requested, or one that succeeded, adds nothing: the stored verdict
- * (folded by the review where one landed) speaks. Words and tokens are
- * the v50 dispatch contract; nothing here changes the lifecycle.
- */
-export declare function reviewStatusOf(review: ReviewFacts | null): DisplayStatus | null;
-export type PublicationFacts = {
-    state: string;
-    prNumber: number | null;
-    prUrl: string | null;
-    remoteState: string | null;
-    lastCheckState: string | null;
-} | null;
-export type StatusTone = "attention" | "problem" | "live" | "ready" | "done" | "muted" | "neutral";
-export type NextAction = {
-    label: string;
-    /** Where the act lives — the page, not a URL, so every surface can
-     * build its own link (a task page anchors, a row links out). */
-    kind: "open-result" | "open-review" | "open-task" | "open-findings" | "open-run" | "open-pr";
-};
-export type DisplayStatus = {
-    /** The stable `data-work-status` token pages and tests key off. */
-    token: string;
-    /** The main wording — the same words on every surface. */
-    label: string;
-    /** One plain sentence: the real reason when one is recorded, never an
-     * invented cause, repair, retry time, or percentage. */
-    detail: string;
-    tone: StatusTone;
-    action: NextAction | null;
-};
-/** The exit code of the failed check, when the recorded reason names one. */
-export declare function failedCheckExit(reasons: readonly string[]): number | null;
-/** The observed publication record in words. Each state is a distinct
- * fact: a pushed branch is not a PR, an open PR is not a merge, and a
- * merge is not a deployment — no record here ever says "deployed". The
- * words name what was recorded or last observed and what stays
- * unconfirmed; a missing or stale observation never proves that nothing
- * merged or deployed, and merging is never called manual-only — an
- * authorized mode may merge on green. */
-export declare function publicationStatusOf(publication: PublicationFacts): {
-    token: string;
-    label: string;
-    detail: string;
-} | null;
-/**
- * The finished result's status — the one place the done words are chosen.
- * Precedence: no record → scout report → operator acceptance → the machine
- * verdict's problems (a refuted or short verdict is never masked by a
- * no-change outcome) → a no-change conclusion, which owes no proof beyond
- * its handoff and sealed diff → agent-attested → verified, where an
- * observed publication names itself (a published but unverified result
- * keeps its evidence problem as the main wording; the publication rides
- * the detail).
- */
-export declare function resultStatusOf(result: ResultFacts | null, publication?: PublicationFacts): DisplayStatus;
-/** The completion receipt's heading: what the record actually supports.
- * Never "shipped" — local changes are saved; a PR or merge is named only
- * from its observed record. */
-export declare function receiptHeadingOf(outcome: string | null, publication: PublicationFacts, role?: string | null): string;
-/** The receipt's one-line publication fact under the heading. */
-export declare function receiptPublicationWords(publication: PublicationFacts): string;
-/** Everything one Work row needs, gathered by the server from records it
- * already reads elsewhere. */
-export type WorkFacts = {
-    id: string;
-    /** The machine runs this task's check on a prepared candidate; no agent runs (machine-check.ts). */
-    machine?: boolean;
-    title: string;
-    repo: string | null;
-    state: TaskState;
-    updatedAt: string;
-    dispatch: DispatchDiagnosis | null;
-    result: ResultFacts | null;
-    publication: PublicationFacts;
-    liveRunId: number | null;
-    /** The unfinished recorded attempt, even if its claim disappeared. */
-    unfinishedRunId?: number | null;
-    control?: TaskControlView;
-    /** An unanswered question on this exact task, read from the decision
-     * owner. An elapsed attention deadline does not close a question. */
-    openDecision?: {
-        id: number;
-        runId: number;
-        question: string;
-        overdue: boolean;
-    } | null;
-    /** Findings of this task's family that used their rounds and wait on a person (findings.ts). */
-    heldFindings?: number;
-};
-export type WorkStatus = DisplayStatus & {
-    /** Which shortcut views list this row; `all` always does. */
-    views: readonly WorkView[];
-    /** The rank All sorts by: what needs a person first, then live work,
-     * then queued and waiting, then finished, then cancelled. */
-    rank: number;
-    /** Facts that remain visible when a more useful next action leads. */
-    diagnostics?: readonly Pick<DisplayStatus, "token" | "label" | "detail" | "tone">[];
-};
-/** Needs you: the existing diagnosis semantics — waiting on a person with a
- * concrete act — never every queued task indiscriminately. */
-export declare function needsPerson(dispatch: DispatchDiagnosis | null): boolean;
-export declare function dispatchActionLabel(dispatch: DispatchDiagnosis | null): string;
-/** A finished result's display status in the shared headline's words: a
- * failed project check is Failed, a result missing its record needs a
- * person, every other saved result is Ready for review. Token and action stay. */
-/** The result's headline while its report disagrees with its saved changes. */
-export declare const MISMATCH_HEADLINE = "The report doesn't match the changes";
-/** One way the report disagrees with the saved changes, in plain words: the
- * file and lines it concerns when they are in the saved changes, or
- * `inChanges: false` for a file the report names that the changes don't have.
- * `reason` is the recorded words it says plainly. */
-export type ReportMismatch = {
-    text: string;
-    path: string | null;
-    lines: {
-        from: number;
-        to: number;
-    } | null;
-    inChanges: boolean | null;
-    /** The report's own note (1-based) the disagreement is about, when it names one. */
-    note: number | null;
-    reason: string;
-};
-/** Each recorded way a refuted report disagrees with its saved changes, said
- * plainly and tied to the changed lines it concerns. `changes` maps each
- * changed file to the lines of its first change (null when it has no line
- * changes, a binary file say). Presentation only: the verdict is unchanged. */
-export declare function reportMismatchesOf(reasons: readonly string[], criteria: readonly {
-    id: string;
-    statement: string;
-    answered: readonly {
-        kind: string;
-        ref: string;
-    }[];
-    state?: string;
-    detail?: readonly string[];
-}[], changes: ReadonlyMap<string, {
-    from: number;
-    to: number;
-} | null>): ReportMismatch[];
-/** The line a failing check ended on: the last line of its error output that
- * names an error, else the last line it printed, with its 1-based number in
- * the saved log. Null when the log printed nothing. */
-export declare function lastErrorLineOf(log: string): {
-    line: number;
-    text: string;
-} | null;
-/** The result page's own sentence when the decision is on it. */
-export declare const RESULT_DECISION_SENTENCE = "Review the change, then accept it or send it back.";
-/** What the result page's Accept says, from facts it already shows: the
- * recorded checks, the requirements not met, whether the saved proof reads,
- * and what the button posts. "Accept and finish" only when everything is met
- * and the checks passed; otherwise "Accept without checks" and one line naming
- * what. The person's own checks are the page's to add (acceptWithChecksOf).
- * `effect` says what pressing it does, in the action's own terms. */
-export type AcceptFacts = {
-    checks: "passed" | "failed" | "not-run" | "off" | "running" | "unavailable" | null;
-    unmet: number;
-    /** `complete`: accepts and finishes the exact result in one request; `accept`: records a person's acceptance only (nothing here can finish it). */
-    action: "complete" | "accept";
-    /** `pull-request`: one can be opened from the task after; `off`: publishing isn't set up; `other`: neither is said. Accept itself never publishes. */
-    publishing: "pull-request" | "off" | "other";
-    /** False when the saved proof is missing or can't be read: nothing on record says what was met. */
-    proof: boolean;
-};
-export type AcceptWords = {
-    label: AcceptLabel;
-    ready: boolean;
-    why: string | null;
-    effect: string;
-};
-export declare function acceptWordsOf(facts: AcceptFacts): AcceptWords;
-export declare function resultHeadlineOf<T extends DisplayStatus>(status: T): T;
-/** The one shared headline (task-status.ts) over the work status below: the
- * token, views, rank, action and diagnostics stay; the words and tone are
- * the eight headlines'. */
-export declare function workStatusOf(facts: WorkFacts, resultDisplay?: DisplayStatus): WorkStatus;
-/** The counts each view tab wears — from the same rows the page lists. */
-export declare function workCounts(rows: readonly {
-    views: readonly WorkView[];
-}[]): Record<WorkView, number>;
-/** The shell's three primary destinations, from the page's own active
- * key: every old page keeps its key and lights the destination it now
- * lives under. */
-export type PrimaryDestination = "chat" | "work" | "projects" | "flows" | "settings" | null;
-export declare function primaryDestinationOf(active: string): PrimaryDestination;
-/** Learning stays in Settings and a useful, closed result disclosure. `csrf` gates the management forms (a cookie
- * session has one); postForm adds the request's own CSRF field. */
-export declare function learningHtml(view: import('./project-learning.js').LearningView, csrf: string, canManage: boolean, source?: number): Html;
-/** The first signed requirement a finished attempt missed (failed or unanswered; a person's own check is not a miss),
- * with the evidence line behind it in plain words. Null when every requirement held. */
-export declare function missedRequirementOf(matrix: readonly {
-    id: string;
-    statement: string;
-    state: string;
-    detail: readonly string[];
-}[]): {
-    id: string;
-    statement: string;
-    evidence: string | null;
-} | null;
-/** One milestone of a live build's plan, as the agent last reported it; its words are null where only the recorded
- * progress was read (a list row reads no plan file). */
-export type BuildStep = {
-    description: string | null;
-    state: "pending" | "current" | "completed" | "blocked";
-    note: string | null;
-};
-/** Where a live build is, in one line: "Step 3 of 6: …", or, when a step is blocked, "Stuck on step 4 of 6: <why>" in
- * its place. `stuck` says which step and why; null while nothing is blocked. */
-export type BuildProgress = {
-    step: number;
-    total: number;
-    line: string;
-    stuck: {
-        step: number;
-        why: string | null;
-        line: string;
-    } | null;
-};
-/** A live build's progress: the step in progress (else the first one not done) as "Step N of M: <step>"; a blocked
- * step replaces it as "Stuck on step N of M: <why>" (its note, else the step itself). Null with no plan steps. */
-export declare function buildProgressOf(steps: readonly BuildStep[] | null | undefined): BuildProgress | null;
-/** Earlier attempts that stopped before the one now running, in one quiet line. */
-export declare function earlierAttemptsWords(count: number): string;
-/** One row of a task page's steps (docs/plans/task-page-steps.md): the step's label, how its marker reads, one plain
- * sentence and a time, whether it has something to open, and whether it starts open. `mark`: done (an ink disc with
- * a check), needs (waits on this person: ink), live (something runs now: blue), wait (current, waiting on nothing
- * this person does), stuck (stopped there: vermilion), skipped (a dashed ring), todo (not reached: grey). */
-export type StepRow = {
-    key: "plan" | "approve" | "build" | "checks" | "ready";
-    label: string;
-    state: "done" | "current" | "stuck" | "skipped" | "todo";
-    mark: "done" | "needs" | "live" | "wait" | "stuck" | "skipped" | "todo";
-    sentence: string;
-    /** When the step happened (ISO), shown as a clock time; null when nothing recorded says. */
-    at: string | null;
-    needsYou: boolean;
-    /** It holds something to read or do: a finished row opens on press, the current one is open. */
-    opens: boolean;
-    open: boolean;
-};
-/** What `stepRowsOf` reads: facts the task page's view already carries. */
-export type StepRowFacts = {
-    journey?: readonly {
-        key: StepRow["key"];
-        label: string;
-        state: StepRow["state"];
-        needsYou?: true;
-        say?: string;
-    }[] | null;
-    scout: boolean;
-    status: {
-        status: {
-            headline: string;
-        };
-        attempts: readonly unknown[];
-    } | null;
-    /** Builds that stopped before this one: with more than one version, the Build row's history. */
-    earlier?: {
-        attempts: readonly unknown[];
-    } | null;
-    approved?: {
-        by: string;
-        at: string;
-        automatic: boolean;
-        rule: string | null;
-    } | null;
-    approve?: {
-        heading: string;
-    } | null;
-    approval?: string;
-    progress?: {
-        line: string;
-    } | null;
-    plan?: {
-        lead: string | null;
-        by: string | null;
-        at: string | null;
-        planning: boolean;
-        updating?: boolean;
-    } | null;
-    result?: {
-        selected: unknown;
-    } | null;
-    thread?: readonly {
-        kind: string;
-        at: string;
-    }[];
-    release?: unknown;
-};
-/** The task page's rows, from its road (first-run.ts taskRoad) and the facts beside it. Null when the task has no road
- * (cancelled, or no status): the page keeps its status block then. Pure: no clock, no store. */
-export declare function stepRowsOf(view: StepRowFacts): StepRow[] | null;

package/dist/worktree-notices.d.ts

@@ -1,13 +0,0 @@
-/** One announcement for a reconciliation batch. The complete path inventory
- * stays in worktree rows and reconcile's result; this grants no reuse/deletion
- * authority and performs no filesystem or database changes. */
-export declare function worktreeAdoptionNotice(repo: string, adopted: readonly string[], now: Date): {
-    source: {
-        project: string;
-    };
-    dedupeKey: string;
-    kind: string;
-    subject: string;
-    body: string;
-    link: string;
-} | null;