toolroll 0.9.104 → 0.9.105

package/dist/fast-start.d.ts

@@ -1,213 +0,0 @@
-import { type ApprovalPasswordFacts } from "./approval-password.js";
-import type { ChatApprovalLimits } from "./chat-approval.js";
-import { type TaskSizing } from "./phase-routing.js";
-import { type ApproveResult, type Scope } from "./scope.js";
-import { type Store } from "./store.js";
-/** The constants, in one place, versioned together in every marker. */
-export declare const FAST_START_RULE = "small-v1";
-export declare const FAST_WINDOW_MS: number;
-export declare const FAST_MAX_FILES = 3;
-export declare const FAST_MAX_LINES = 150;
-/** How long a rendered form may still be pressed. */
-export declare const FAST_PREVIEW_MS: number;
-/** Which person surface is filing. `chat` is a Start card a person taps or answers yes to (one-step-chat.md); a flow, a
- * token or an agent has no entry here. */
-export type FastVia = "console" | "terminal-ui" | "cli" | "chat";
-export type FastRefusal = "setting" | "size" | "classifier" | "plan" | "quality" | "rules" | "protected" | "password" | "release" | "trial" | "chain" | "monthly" | "policy" | "agents" | "machine" | "mode" | "limit";
-export declare const fastRefusalWords: (reason: FastRefusal) => string;
-/** Small tasks start right away: a project's own choice, else on for single-approver installs and off once there's more
- * than one approver. */
-export declare function fastStartOn(store: Store, repo: string): boolean;
-/** A person's logged settings act. */
-export declare function setFastStart(store: Store, repo: string, on: boolean, by: string, now: Date): boolean;
-/** Filed this way, the plan's words are the person's words, and they inspect the result. */
-export declare const fastAcceptance: (title: string) => {
-    id: string;
-    statement: string;
-    how: null;
-    evidence: ["manual-review"];
-}[];
-export type FastInput = {
-    actor: string;
-    repo: string;
-    title: string;
-    permissionMode?: "auto" | "bypassPermissions" | undefined;
-};
-export type PasswordFacts = Pick<ApprovalPasswordFacts, "passwordless" | "localOwner" | "freshAt" | "returnTo">;
-/** How the person is proved at the one step that differs by surface: the password rule the form reads, or (a chat
- * start) the person's own chat approval limits. */
-export type FastProof = {
-    password: PasswordFacts;
-} | {
-    chat: ChatApprovalLimits;
-};
-/** Every person surface's eligibility: the rules, then a machine is refused. */
-export declare function fastStartEligible(store: Store, input: FastInput & {
-    taskId: string;
-    sizing: TaskSizing;
-} & ({
-    password: PasswordFacts;
-} | {
-    proof: FastProof;
-}), now: Date): {
-    ok: true;
-    scope: Scope;
-} | {
-    ok: false;
-    reason: FastRefusal;
-};
-/** The rules alone, the same for every surface: only the person-proof step has two forms (FastProof). A preview reads
- * these as any caller; Build reads them again behind the machine check (fastStartEligible). */
-export declare function fastStartRules(store: Store, input: FastInput & {
-    taskId: string;
-    sizing: TaskSizing;
-    proof: FastProof;
-}, now: Date): {
-    ok: true;
-    scope: Scope;
-} | {
-    ok: false;
-    reason: FastRefusal;
-};
-export type FastPreview = {
-    eligible: true;
-    preview: string;
-    digest: string;
-    scope: Scope;
-    taskId: string;
-} | {
-    eligible: false;
-    reason: FastRefusal;
-};
-/**
- * What the form renders: the classifier asked (at most its budget), then the same proposal the plan step would seal, in a
- * transaction that's rolled back. The filing's words and the classifier's answer are kept (fast_preview), so Build
- * files exactly this, whatever is posted.
- */
-export declare function prepareFastStart(store: Store, input: FastInput & {
-    via: Exclude<FastVia, "chat">;
-    password: PasswordFacts;
-}, now: Date): Promise<FastPreview>;
-export type FastBuild = {
-    ok: true;
-    taskId: string;
-} | {
-    ok: false;
-    reason: "gone" | "changed" | FastRefusal;
-    message: string;
-};
-/** Approve inside the filing: `approveNow` is the surface's own call to approve() (web: its freshness and re-check). */
-export type FastApprove = (taskId: string, sawDigest: string, fast: {
-    rule: string;
-    at: string;
-}) => ApproveResult;
-/**
- * Build: file and approve in one transaction. Every check is made here, on the rows written here; anything refused
- * rolls the filing back, so a refusal leaves nothing behind.
- */
-export declare function fastStartBuild(store: Store, input: {
-    preview: string;
-    digest: string;
-    actor: string;
-    via: FastVia;
-    approveNow: FastApprove;
-    /** A chat start: the lead turn its card was drafted in. Its preview must have been prepared in that same turn. */
-    turn?: number;
-} & ({
-    password: PasswordFacts;
-} | {
-    proof: FastProof;
-}), now: Date): FastBuild;
-/**
- * A fast start that didn't start in time: its seal is cleared, in a logged transaction, and the task shows the ordinary
- * Approve plan. A task with a build running or a result to read is left to that.
- */
-export declare function expireFastStarts(store: Store, now: Date): number;
-export type VerifiedChange = {
-    ok: true;
-    base: string;
-    head: string;
-    files: {
-        path: string;
-        added: number;
-        removed: number;
-    }[];
-    lines: number;
-} | {
-    ok: false;
-    problem: string;
-};
-/**
- * The whole change a result carries, verified: every version of the task (any ancestry problem refuses), from the base in
- * Toolroll's own records to the head on the run record, every contributing build's saved diff present, and every file
- * countable through the hardened git. Null-like answers refuse: nothing here is ever a guess.
- */
-export declare function verifiedChange(store: Store, taskId: string, runId: number): VerifiedChange;
-/** Whether any version of this task started fast. An unreadable history counts: it fails closed below. */
-export declare function fastStarted(store: Store, taskId: string): boolean;
-/** The one sentence over every over-the-caps refusal; the road on is the approval of the expanded commit (keepGrownChange). */
-export declare const GREW_WORDS = "This grew beyond a small change. Approve it to keep it.";
-/** Why this exact result can't go further as a small change, or null. */
-export declare function fastChangeProblem(store: Store, taskId: string, runId: number): string | null;
-/** Completion: a person only, and only a change the measure accepts. */
-export declare function fastCompletionProblem(store: Store, taskId: string, runId: number, person: string | null): string | null;
-/** Publication and merge: nothing leaves until a person accepted this exact build, and the measure still accepts it. */
-export declare function fastPublishProblem(store: Store, taskId: string, runId: number): string | null;
-/**
- * "Approve it to keep it": a plan for the actual expanded commit, proposed the way a rerun proposes one (dispose.ts
- * regateTask): the same terms with `candidate` set to the exact head. It seals nothing; the person approves it on the
- * ordinary ceremony, Toolroll checks that commit out with no agent, and only that attempt's result goes further.
- */
-export declare function keepGrownChange(store: Store, taskId: string, now: Date): {
-    ok: true;
-    digest: string;
-} | {
-    ok: false;
-    message: string;
-};
-/** What a chat start's preview is for: who asked, where, the lead's one-line title, and the lead turn it is prepared in. */
-export type ChatStartInput = {
-    actor: string;
-    repo: string;
-    title: string;
-    turn: number;
-};
-/**
- * A chat start's preview, prepared by the lead's turn loop before the Start card is drafted: the classifier asked (at
- * most its budget), the filing dry-run, and the rules read. It refuses no machine caller, because a preview grants
- * nothing (the lead's turn runs as the lead): Build refuses a machine (fastStartBuild), and only a person's own tap or
- * typed yes reaches Build. The row is bound to the person, `via = 'chat'` and the turn; a preview without a turn is
- * unusable. The person's own chat limits are read again at the tap, for the chat it comes from; here only the loosest
- * limit that still means something applies (no full access, no cap), so a card is never drafted for terms no chat
- * approval could allow.
- */
-export declare function prepareChatStart(store: Store, input: ChatStartInput, now: Date): Promise<FastPreview>;
-/** A chat start's preview, as the Start card reads it again: this person's, `via = 'chat'`, prepared in this turn,
- * unexpired and unused. Null otherwise. */
-export declare function chatStartPreview(store: Store, preview: string, actor: string, turn: number, now: Date): {
-    taskId: string;
-    repo: string;
-    title: string;
-    sizing: TaskSizing;
-    digest: string;
-} | null;
-/** A dismissed Start card's preview can't be used: consumed, in the dismissal's transaction. */
-export declare function consumeChatStartPreview(store: Store, preview: string, now: Date): void;
-/**
- * A chat start's filing dry-run, for its card: the scope filing would make, read in a savepoint that is always rolled
- * back, with the rules read on it (any proof form; the card shows the terms, the tap proves the person). The card is made
- * from these words; the tap files again and compares.
- */
-export declare function chatStartDryRun(store: Store, input: {
-    actor: string;
-    repo: string;
-    title: string;
-    taskId: string;
-    sizing: TaskSizing;
-}, now: Date): {
-    ok: true;
-    scope: Scope;
-} | {
-    ok: false;
-    reason: FastRefusal;
-};

package/dist/fast-terms.d.ts

@@ -1,9 +0,0 @@
-/** A fast start's terms, the words a yes agrees to (scope.ts describeScope, the lines every plan approval reads), plus the
- * project tools its seal will carry. The same lines on the New task form, in the terminal UI and in `task new`. The
- * plan version and approval state rows say nothing yet: nothing is approved. */
-import { type Scope } from "./scope.js";
-import type { Store } from "./store.js";
-export declare function fastTermsLines(store: Store, scope: Scope, repo: string): {
-    label: string;
-    words: string;
-}[];

package/dist/fenced-check-coverage.d.ts

@@ -1,62 +0,0 @@
-/**
- * What a sandboxed Full check must show for what it couldn't run (docs/plans/trusted-release-reports.md, H3). Inside a
- * fence some cases skip: a test that makes a sandbox, or a keychain. A skipped case counts as covered only if the SAME
- * case passed in the macOS CI of that exact commit, or it is on the short reviewed list below. Being in the same file
- * isn't enough: a file is in the macOS lane even when its case is skipped there (Codex round 1, finding 6).
- *
- * This reads nothing on an unsandboxed check, which skips nothing for this reason: Toolroll's own releases, today. It
- * guards a release only once a person has narrowed that project's check access, and scripts/fenced-run.mjs has measured
- * it first. Reports are the candidate's own words (R1): this keeps an accident from passing unseen, not a hostile test.
- *
- * The fallback: when a sandboxed check can't cover everything, the release scope seals the wider level the measurement
- * shows it needs. That is an operator's widening, with a password, and a new approval whose card says so: nothing here
- * widens anything, and a release can always go out at the level a person approves.
- */
-import type { CheckAccess } from "./check-access.js";
-import type { CheckReport } from "./contracts/release-check.js";
-/** Cases that may stay skipped with no CI case behind them, each with why. Product code, reviewed like it: never a file a
- * release's commits could carry. Empty until a measured run gives a reason. */
-export declare const FENCED_SKIP_EXEMPTIONS: readonly {
-    identity: string;
-    why: string;
-}[];
-export declare const unitCaseIdentity: (file: string, name: string) => string;
-type VitestAssertion = {
-    title?: unknown;
-    ancestorTitles?: unknown;
-    status?: unknown;
-};
-type VitestReport = {
-    testResults?: {
-        name?: unknown;
-        assertionResults?: VitestAssertion[];
-    }[];
-};
-/**
- * Every case in the macOS CI's reports, by the identity the release check's own reporter gives it (test/release-reporter.ts:
- * `suite > test`; Vitest's JSON `fullName` joins with spaces, so it can't be matched as it stands). A name twice in a file
- * passes only if every one of them did. `root` is the checkout the reports name files under.
- */
-export declare function macosCases(reports: readonly VitestReport[], root: string): Map<string, boolean>;
-/** Every case a check's report says it skipped: unit cases and journeys alike. */
-export declare function skippedCases(report: CheckReport): string[];
-export type SkipCoverage = {
-    covered: string[];
-    exempt: string[];
-    uncovered: string[];
-};
-/** Each skipped case: passed in that commit's macOS CI, reviewed as exempt, or not covered. */
-export declare function skipCoverage(skipped: readonly string[], macos: ReadonlyMap<string, boolean>, exemptions?: readonly {
-    identity: string;
-}[]): SkipCoverage;
-/** A measurement's verdict on one level (scripts/fenced-run.mjs): whether the check passed there, and what it left uncovered. */
-export type LevelMeasurement = {
-    level: CheckAccess;
-    passed: boolean;
-    uncovered: number;
-};
-/** The narrowest level a measured check fully covers. No level covered: `unsandboxed`, as today, with a person's yes. */
-export declare function measuredLevel(measurements: readonly LevelMeasurement[]): CheckAccess;
-/** Why a sandboxed check can't stand for this release, in words a person can act on. */
-export declare function uncoveredWords(uncovered: readonly string[]): string;
-export {};

package/dist/findings.d.ts

@@ -1,224 +0,0 @@
-/**
- * Findings sent to the task that owns the code (docs/plans/fleet-follow-through.md, part 1).
- *
- * A finding asks the owner for an answer: accepted, with what changed, or rejected, with a reason against the code.
- * Reading one closes nothing. It stays open, and visible, until an answer counts or a person closes it, and a reviewer
- * and an implementer get FINDING_ROUND_LIMIT rounds before it goes to a person.
- *
- * Trust: summary, action, excerpt and every answer can hold model output or repository text. They are data wherever
- * they are read: quoted with `fence` for an agent, and they decide nothing. An answer ends this finding and touches no
- * proof, check or approval, and only a signed-in person (the caller proves it) closes one.
- */
-import { z } from "zod";
-import type { BuildFinding } from "./contracts/review-findings.js";
-import type { Store } from "./store.js";
-/** A first send and one more: then a person decides. */
-export declare const FINDING_ROUND_LIMIT = 2;
-export declare const FINDING_TEXT_LIMIT = 1000;
-export declare const FINDING_ACTION_LIMIT = 300;
-export declare const FINDING_EXCERPT_LIMIT = 2000;
-export declare const ANSWER_TEXT_LIMIT = 1000;
-export declare const ANSWER_FILE_BYTES: number;
-export declare const REVIEW_ACTION = "Check this against the code. Fix it and say what changed, or reject it with a reason that names the file.";
-export declare const CHECK_ACTION = "Find the cause of this failed check. Fix it and say what changed, or reject it with a reason that names the file.";
-/** `lead`: words the lead (a model) drafted, sent only once a person confirmed them; `sent_by` is that person. They are
- * never recorded as the person's own words. */
-export type FindingSource = "build-review" | "person" | "lead" | "check-failure";
-export type FindingState = "open" | "accepted" | "rejected" | "with-person" | "closed";
-export type FindingAnswer = {
-    round: number;
-    run: number;
-    answer: "accepted" | "rejected";
-    detail: string;
-    file: string | null;
-    line: number | null;
-    revision: string | null;
-    state: "saved" | "counted" | "refused";
-    problem: string | null;
-    at: string;
-};
-export type Finding = {
-    id: number;
-    familyRoot: string;
-    taskId: string;
-    repo: string | null;
-    source: FindingSource;
-    sourceRun: number | null;
-    severity: "HIGH" | "MEDIUM" | "LOW" | null;
-    file: string | null;
-    line: number | null;
-    summary: string;
-    action: string;
-    excerpt: string | null;
-    revision: string | null;
-    state: FindingState;
-    rounds: number;
-    sentBy: string;
-    sentAt: string;
-    deliveredRun: number | null;
-    deliveredHow: "mailbox" | "brief" | null;
-    readAt: string | null;
-    closedBy: string | null;
-    closedNote: string | null;
-    closedAt: string | null;
-    /** The newest answer of any standing, or null. */
-    answer: FindingAnswer | null;
-};
-export declare const findingSourceWords: (source: FindingSource) => string;
-/** Who a finding's words are from, naming the person who confirmed the lead's draft: never the person as its author. */
-export declare const findingFromWords: (finding: Pick<Finding, "source" | "sentBy">) => string;
-/** The family a task belongs to: a broken history keeps the finding on the task it named. */
-export declare function familyRootOf(store: Store, taskId: string): string;
-/** One line of quotable text: controls gone, secrets gone, inside its limit. */
-export declare function cleanFindingText(text: string, limit: number): string;
-export declare function getFinding(store: Store, id: number): Finding | null;
-/** Every finding of a task's family, newest first. */
-export declare function findingsOfTask(store: Store, taskId: string): Finding[];
-/** How many of this task's family's findings used their rounds and wait on a person; none on a database not yet migrated. */
-export declare const heldFindingCount: (store: Store, taskId: string) => number;
-/** The findings still waiting on someone, across a project or everywhere. */
-export declare function waitingFindings(store: Store, repos: readonly string[] | null): Finding[];
-/** Who is reading or sending: the projects this chat reaches, and the person they must reach them as. */
-export type FindingReader = {
-    name: string;
-    repos: readonly string[];
-};
-/** Every project a task's family reaches, or null unless this person reaches all of them: one gate for every chat road to
- * a family's findings and handover. A task with no project is out of reach. */
-export declare function familyInReach(store: Store, who: FindingReader, task: string): readonly string[] | null;
-/** The findings this person may see: a task's, only if its whole family is in reach, else those waiting in `repos`. Null
- * for a task out of reach. A finding with no project, or one out of reach, is left out. */
-export declare function findingsInReach(store: Store, who: FindingReader, query: {
-    task?: string;
-    repos: readonly string[];
-}): Finding[] | null;
-/** The same finding, in another reviewer's words: the same file, and the same opening words or nearly the same line. */
-export declare function sameFinding(a: {
-    file: string | null;
-    line: number | null;
-    summary: string;
-}, b: {
-    file: string | null;
-    line: number | null;
-    summary: string;
-}): boolean;
-export type SendInput = {
-    taskId: string;
-    source: FindingSource;
-    by: string;
-    summary: string;
-    action?: string;
-    file?: string | null;
-    line?: number | null;
-    severity?: Finding["severity"];
-    run?: number | null;
-    excerpt?: string | null;
-    revision?: string | null;
-    /** The source's own identity: a repeat of the same key is the same finding. */
-    key?: string | null;
-};
-export type SendAnswer = {
-    ok: true;
-    id: number;
-    standing: "running" | "next-attempt" | "with-person" | "already-sent";
-    round: number;
-} | {
-    ok: false;
-    reason: "unknown-task" | "invalid" | "closed";
-    message: string;
-};
-/** Send a finding, or count a repeat of one already sent as another round. The caller proves who is sending. */
-export declare function sendFinding(store: Store, input: SendInput, now: Date): SendAnswer;
-/** Send an answered finding back to its owner: one more round, or to a person once the rounds are used. */
-export declare function resendFinding(store: Store, id: number, now: Date): SendAnswer;
-/** A person's decision on a finding. The caller has proved the person. */
-export declare function closeFinding(store: Store, id: number, by: string, note: string, now: Date): {
-    ok: true;
-} | {
-    ok: false;
-    message: string;
-};
-/** The open findings of a run's family it has not been given yet. */
-export declare function undeliveredFindings(store: Store, taskRef: number, runId: number): Finding[];
-/** Recorded only after the file reached the run, or the brief named it: a pending delivery is never counted as read. */
-export declare function markFindingDelivered(store: Store, id: number, runId: number, how: "mailbox" | "brief", now: Date): boolean;
-/** The findings a fresh attempt's brief quotes, recorded as reaching it. Bounded by the caller's brief. */
-export declare function attachFindings(store: Store, taskRef: number, runId: number, now: Date): Finding[];
-/** The agent moved the file to handled/: it read it. That closes nothing. */
-export declare function markFindingRead(store: Store, id: number, runId: number, now: Date): void;
-/** An answer as an agent writes it. Its `key` proves the attempt's own folder wrote it, nothing more. */
-export declare const findingAnswerSchema: z.ZodObject<{
-    key: z.ZodString;
-    finding: z.ZodNumber;
-    answer: z.ZodEnum<{
-        accepted: "accepted";
-        rejected: "rejected";
-    }>;
-    detail: z.ZodString;
-    file: z.ZodOptional<z.ZodString>;
-    line: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
-export type FindingAnswerFile = z.infer<typeof findingAnswerSchema>;
-/** Save what an attempt answered. It counts only when that attempt settles (settleFindingAnswers). A finding this run
- * was not given, or one no longer open, takes no answer. */
-export declare function saveFindingAnswer(store: Store, runId: number, answer: FindingAnswerFile, now: Date): boolean;
-/**
- * The attempt has settled: each answer it saved counts or is refused, against what the machine saw, not what it said.
- * Accepted needs a commit past the revision the finding was sent about. Rejected needs a file that exists at the run's
- * commit. A refused answer leaves the finding open, and the next attempt gets it again.
- */
-export declare function settleFindingAnswers(store: Store, runId: number, worktree: string, now: Date): number;
-/**
- * A finished review's HIGH findings. Sent back: each becomes a finding its revision must answer. Not sent back (a family
- * gets one automatic send-back): a HIGH that repeats an answered finding is that finding's next round, and any other
- * stays where it is, for the person to decide. Never at the review's expense.
- */
-export declare function recordReviewFindings(store: Store, input: {
-    run: number;
-    taskId: string;
-    sentBackAs: string | null;
-    high: readonly BuildFinding[];
-}, now: Date): void;
-export declare const NOT_ON_TASK = "That result isn't on this task.";
-/** Whether a run belongs to this task's family. Admission proves the task named, never a run a form or flag names beside
- * it, so every act that takes a run checks it here: no finding's text crosses a task or a project. */
-export declare function runOnTask(store: Store, runId: number, taskId: string): boolean;
-/** Send one of a result's review findings: `<run>:<number>`, counted from 1 as the result lists them. */
-export declare function sendReviewFinding(store: Store, taskId: string, pointer: string, by: string, now: Date): SendAnswer;
-/** The review finding `<run>:<number>` names, on this task's family: what a send would quote, read once for both. */
-export declare function reviewFindingAt(store: Store, taskId: string, pointer: string): {
-    ok: true;
-    run: number;
-    finding: BuildFinding;
-} | {
-    ok: false;
-    message: string;
-};
-/** Send a result's failed check, with the end of its sealed log as the evidence. The summary is Toolroll's own words. */
-export declare function sendCheckFinding(store: Store, root: string, taskId: string, runId: number, by: string, now: Date): SendAnswer;
-/** A failed check as a send would quote it. */
-export declare function checkFindingAt(store: Store, root: string, taskId: string, runId: number): {
-    ok: true;
-    summary: string;
-    head: string | null;
-    excerpt: string;
-} | {
-    ok: false;
-    message: string;
-};
-/** The folder an attempt's answers go in, and what the brief says about writing one. Trusted words: nothing here is quoted. */
-export declare function findingAnswerRule(folder: string, key: string): string[];
-/** The findings a fresh attempt starts with, quoted as data. `answer` is the folder and key, when this attempt has one. */
-export declare function findingsBriefLines(findings: readonly Finding[], answer: {
-    folder: string;
-    key: string;
-} | null): string[];
-/** How a finding stands, for a person, in one sentence. Text after a colon is the agent's. */
-export declare function findingStandingWords(finding: Finding): string;
-/** Plain lines for `task show`, `finding list` and the handover note. */
-export declare function findingLine(finding: Finding): string;
-/** The web's door to the same gate as chat (familyInReach): the projects this person reaches are those the page can
- * see and their account may access, and every project in the task's family must be one of them. Null: out of reach. */
-export declare function familyInWebReach(store: Store, who: {
-    name: string;
-}, task: string, visible: (repo: string | null) => boolean): readonly string[] | null;