toolroll 0.9.103 → 0.9.105

package/dist/contracts/verification-receipt.d.ts

@@ -1,200 +0,0 @@
-/**
- * The machine verification receipt (`verification-receipt.json`): one schema for what `sealVerificationReceipt`
- * writes and what `verificationEvidence` reads back. Only the machine writes it, from typed values, so every receipt
- * ever sealed already has exactly this shape; the bindings that need the store — the run, its candidate, the approved
- * command, the retained log and a reused gate's source — are checked in plain code after parsing.
- *
- * Version 1 is a gate executed in its own run. Version 2 added `reusedFrom` and `executedHere: false` for a gate
- * reused by an unchanged observation follow-up. Version 3 (docs/plans/release-once.md) is a release check: it keeps
- * the raw exit (`result`) apart from `coverage` — `full`, `composed` (a targeted run composed with the full check A),
- * `partial` (never passes) or `identity-removed` (a required test went away; asks again) — names the sealed check
- * artifacts, and for a composed check every link its reader proves again. A direct receipt is still sealed as version 1,
- * so its bytes (and the digests bound to them) read the same in every Toolroll that reads receipts.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-export declare const VERIFICATION_FAILURES: readonly ["spawn-failed", "timed-out", "dependency-missing", "setup-stale", "setup-failed", "own-install-failed", "tracked-files-changed", "setup-changed-files", "checkout-moved", "cleanliness-unavailable", "dependency-still-missing", "retry-spawn-failed", "retry-timed-out", "custody-lost", "coverage-incomplete", "no-result", "stopped-by-toolroll", "baseline-unverifiable"];
-/**
- * What the repository's approved verification command did: not configured; configured but the run could not attempt
- * it (`attemptFailed`, which downgrades to `short` rather than `refuted`: "we could not check" is not "the claim is
- * false"); or ran, with its exit code.
- */
-export declare const verifyCommandFactsSchema: z.ZodUnion<readonly [z.ZodObject<{
-    configured: z.ZodLiteral<false>;
-}, z.core.$strict>, z.ZodObject<{
-    configured: z.ZodLiteral<true>;
-    ran: z.ZodLiteral<false>;
-    attemptFailed: z.ZodLiteral<true>;
-    failure: z.ZodOptional<z.ZodEnum<{
-        "baseline-unverifiable": "baseline-unverifiable";
-        "checkout-moved": "checkout-moved";
-        "cleanliness-unavailable": "cleanliness-unavailable";
-        "coverage-incomplete": "coverage-incomplete";
-        "custody-lost": "custody-lost";
-        "dependency-missing": "dependency-missing";
-        "dependency-still-missing": "dependency-still-missing";
-        "no-result": "no-result";
-        "own-install-failed": "own-install-failed";
-        "retry-spawn-failed": "retry-spawn-failed";
-        "retry-timed-out": "retry-timed-out";
-        "setup-changed-files": "setup-changed-files";
-        "setup-failed": "setup-failed";
-        "setup-stale": "setup-stale";
-        "spawn-failed": "spawn-failed";
-        "stopped-by-toolroll": "stopped-by-toolroll";
-        "timed-out": "timed-out";
-        "tracked-files-changed": "tracked-files-changed";
-    }>>;
-}, z.core.$strict>, z.ZodObject<{
-    configured: z.ZodLiteral<true>;
-    ran: z.ZodLiteral<true>;
-    exitCode: z.ZodInt;
-    setupReplayed: z.ZodOptional<z.ZodLiteral<true>>;
-    firstAttempt: z.ZodOptional<z.ZodObject<{
-        class: z.ZodLiteral<"launch">;
-        program: z.ZodString;
-        exitCode: z.ZodInt;
-    }, z.core.$strict>>;
-}, z.core.$strict>]>;
-export type VerifyCommandFacts = z.infer<typeof verifyCommandFactsSchema>;
-/** The approved verification grant the gate ran, exactly as the store held it. */
-export declare const receiptCommandSchema: z.ZodObject<{
-    id: z.ZodInt;
-    repo: z.ZodString;
-    command: z.ZodString;
-    timeoutMs: z.ZodInt;
-    digest: z.ZodString;
-    recoverySetupDigest: z.ZodNullable<z.ZodString>;
-    approvedBy: z.ZodString;
-    approvedAt: z.ZodString;
-    revokedAt: z.ZodNullable<z.ZodString>;
-    revokedBy: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
-/** The retained check log the receipt binds, by artifact id and content. */
-export declare const receiptLogSchema: z.ZodObject<{
-    artifactId: z.ZodInt;
-    sha256: z.ZodString;
-    bytesStored: z.ZodInt;
-    bytesOriginal: z.ZodInt;
-    truncated: z.ZodBoolean;
-    redacted: z.ZodBoolean;
-    captureStatus: z.ZodNullable<z.ZodEnum<{
-        failed: "failed";
-        ok: "ok";
-    }>>;
-}, z.core.$strict>;
-export declare const RECEIPT_VERSION = 3;
-export declare const RECEIPT_COVERAGES: readonly ["full", "composed", "partial", "identity-removed", "no-result"];
-export type ReceiptCoverage = typeof RECEIPT_COVERAGES[number];
-/** The receipt as read: a reused gate names its source run and digest; a direct one names neither. */
-export declare const verificationReceiptSchema: z.ZodObject<{
-    version: z.ZodLiteral<3>;
-    run: z.ZodInt;
-    head: z.ZodString;
-    base: z.ZodNullable<z.ZodString>;
-    scopeDigest: z.ZodNullable<z.ZodString>;
-    reusedFrom: z.ZodOptional<z.ZodObject<{
-        run: z.ZodInt;
-        digest: z.ZodString;
-    }, z.core.$strict>>;
-    executedHere: z.ZodOptional<z.ZodLiteral<false>>;
-    command: z.ZodObject<{
-        id: z.ZodInt;
-        repo: z.ZodString;
-        command: z.ZodString;
-        timeoutMs: z.ZodInt;
-        digest: z.ZodString;
-        recoverySetupDigest: z.ZodNullable<z.ZodString>;
-        approvedBy: z.ZodString;
-        approvedAt: z.ZodString;
-        revokedAt: z.ZodNullable<z.ZodString>;
-        revokedBy: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>;
-    result: z.ZodUnion<readonly [z.ZodObject<{
-        configured: z.ZodLiteral<false>;
-    }, z.core.$strict>, z.ZodObject<{
-        configured: z.ZodLiteral<true>;
-        ran: z.ZodLiteral<false>;
-        attemptFailed: z.ZodLiteral<true>;
-        failure: z.ZodOptional<z.ZodEnum<{
-            "baseline-unverifiable": "baseline-unverifiable";
-            "checkout-moved": "checkout-moved";
-            "cleanliness-unavailable": "cleanliness-unavailable";
-            "coverage-incomplete": "coverage-incomplete";
-            "custody-lost": "custody-lost";
-            "dependency-missing": "dependency-missing";
-            "dependency-still-missing": "dependency-still-missing";
-            "no-result": "no-result";
-            "own-install-failed": "own-install-failed";
-            "retry-spawn-failed": "retry-spawn-failed";
-            "retry-timed-out": "retry-timed-out";
-            "setup-changed-files": "setup-changed-files";
-            "setup-failed": "setup-failed";
-            "setup-stale": "setup-stale";
-            "spawn-failed": "spawn-failed";
-            "stopped-by-toolroll": "stopped-by-toolroll";
-            "timed-out": "timed-out";
-            "tracked-files-changed": "tracked-files-changed";
-        }>>;
-    }, z.core.$strict>, z.ZodObject<{
-        configured: z.ZodLiteral<true>;
-        ran: z.ZodLiteral<true>;
-        exitCode: z.ZodInt;
-        setupReplayed: z.ZodOptional<z.ZodLiteral<true>>;
-        firstAttempt: z.ZodOptional<z.ZodObject<{
-            class: z.ZodLiteral<"launch">;
-            program: z.ZodString;
-            exitCode: z.ZodInt;
-        }, z.core.$strict>>;
-    }, z.core.$strict>]>;
-    log: z.ZodObject<{
-        artifactId: z.ZodInt;
-        sha256: z.ZodString;
-        bytesStored: z.ZodInt;
-        bytesOriginal: z.ZodInt;
-        truncated: z.ZodBoolean;
-        redacted: z.ZodBoolean;
-        captureStatus: z.ZodNullable<z.ZodEnum<{
-            failed: "failed";
-            ok: "ok";
-        }>>;
-    }, z.core.$strict>;
-    coverage: z.ZodOptional<z.ZodEnum<{
-        composed: "composed";
-        full: "full";
-        "identity-removed": "identity-removed";
-        "no-result": "no-result";
-        partial: "partial";
-    }>>;
-    check: z.ZodOptional<z.ZodObject<{
-        attempt: z.ZodEnum<{
-            full: "full";
-            targeted: "targeted";
-        }>;
-        report: z.ZodNullable<z.ZodString>;
-        inventory: z.ZodNullable<z.ZodString>;
-        exitCode: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
-        retried: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strict>>;
-    composed: z.ZodOptional<z.ZodObject<{
-        base: z.ZodInt;
-        baseReceipt: z.ZodString;
-        baseReport: z.ZodString;
-        authority: z.ZodInt;
-        carries: z.ZodArray<z.ZodInt>;
-        artifacts: z.ZodString;
-        plan: z.ZodString;
-        snapshot: z.ZodString;
-        report: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type VerificationReceipt = z.infer<typeof verificationReceiptSchema>;
-/** A version 1 or 2 receipt read as version 3: the same fields. Reuse is a version 2 field and coverage a version 3
- * one; a receipt naming a field newer than it was sealed as is refused by its reader, which still knows the version. */
-export declare function upgradeDirectReceipt(body: Record<string, unknown>): Record<string, unknown>;
-export declare const RECEIPT_UPGRADES: {
-    readonly 1: typeof upgradeDirectReceipt;
-    readonly 2: typeof upgradeDirectReceipt;
-};
-/** Read a receipt: version 3 as itself, 1 and 2 upgraded, a newer one refused plainly. */
-export declare function readVerificationReceipt(input: unknown): ContractResult<VerificationReceipt>;

package/dist/contracts/verification-view.d.ts

@@ -1,102 +0,0 @@
-/**
- * The gate view `verificationEvidence` returns as `bytes`: a sealed receipt exactly as sealed (either version), or,
- * for a run from before receipts, the view of its legacy machine log header. Reused gates, failed-check repair and
- * saved assessments read a view back through `readVerificationView`.
- *
- * A legacy view is built by Toolroll from the run's single-attempt log header (the "check log metadata"), its
- * approved command and its candidate inventory; it is never saved, so its schema is strict. A sealed receipt is read
- * by the receipt's own contract.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-import { type VerificationReceipt } from "./verification-receipt.js";
-export declare const LEGACY_GATE_SOURCE = "legacy machine log header";
-export declare const legacyGateViewSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    source: z.ZodLiteral<"legacy machine log header">;
-    run: z.ZodInt;
-    head: z.ZodString;
-    base: z.ZodNullable<z.ZodString>;
-    scopeDigest: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    command: z.ZodObject<{
-        id: z.ZodInt;
-        repo: z.ZodString;
-        command: z.ZodString;
-        timeoutMs: z.ZodInt;
-        digest: z.ZodString;
-        recoverySetupDigest: z.ZodNullable<z.ZodString>;
-        approvedBy: z.ZodString;
-        approvedAt: z.ZodString;
-        revokedAt: z.ZodNullable<z.ZodString>;
-        revokedBy: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>;
-    result: z.ZodUnion<readonly [z.ZodObject<{
-        configured: z.ZodLiteral<false>;
-    }, z.core.$strict>, z.ZodObject<{
-        configured: z.ZodLiteral<true>;
-        ran: z.ZodLiteral<false>;
-        attemptFailed: z.ZodLiteral<true>;
-        failure: z.ZodOptional<z.ZodEnum<{
-            "baseline-unverifiable": "baseline-unverifiable";
-            "checkout-moved": "checkout-moved";
-            "cleanliness-unavailable": "cleanliness-unavailable";
-            "coverage-incomplete": "coverage-incomplete";
-            "custody-lost": "custody-lost";
-            "dependency-missing": "dependency-missing";
-            "dependency-still-missing": "dependency-still-missing";
-            "no-result": "no-result";
-            "own-install-failed": "own-install-failed";
-            "retry-spawn-failed": "retry-spawn-failed";
-            "retry-timed-out": "retry-timed-out";
-            "setup-changed-files": "setup-changed-files";
-            "setup-failed": "setup-failed";
-            "setup-stale": "setup-stale";
-            "spawn-failed": "spawn-failed";
-            "stopped-by-toolroll": "stopped-by-toolroll";
-            "timed-out": "timed-out";
-            "tracked-files-changed": "tracked-files-changed";
-        }>>;
-    }, z.core.$strict>, z.ZodObject<{
-        configured: z.ZodLiteral<true>;
-        ran: z.ZodLiteral<true>;
-        exitCode: z.ZodInt;
-        setupReplayed: z.ZodOptional<z.ZodLiteral<true>>;
-        firstAttempt: z.ZodOptional<z.ZodObject<{
-            class: z.ZodLiteral<"launch">;
-            program: z.ZodString;
-            exitCode: z.ZodInt;
-        }, z.core.$strict>>;
-    }, z.core.$strict>]>;
-    log: z.ZodObject<{
-        artifactId: z.ZodInt;
-        sha256: z.ZodString;
-        bytesStored: z.ZodInt;
-        bytesOriginal: z.ZodInt;
-        truncated: z.ZodBoolean;
-        redacted: z.ZodBoolean;
-        captureStatus: z.ZodNullable<z.ZodEnum<{
-            failed: "failed";
-            ok: "ok";
-        }>>;
-    }, z.core.$strict>;
-    candidate: z.ZodObject<{
-        artifactId: z.ZodInt;
-        sha256: z.ZodString;
-        bytesStored: z.ZodInt;
-        bytesOriginal: z.ZodInt;
-        truncated: z.ZodBoolean;
-        redacted: z.ZodBoolean;
-        captureStatus: z.ZodNullable<z.ZodEnum<{
-            failed: "failed";
-            ok: "ok";
-        }>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type LegacyGateView = z.infer<typeof legacyGateViewSchema>;
-/** What every view carries. */
-export type VerificationView = Pick<VerificationReceipt, "run" | "head" | "base" | "scopeDigest" | "command" | "result" | "log">;
-/**
- * Read a view's bytes. The value is the object as written, once its shape is checked: its key order is part of what a
- * reused gate compares and seals again.
- */
-export declare function readVerificationView(bytes: string): ContractResult<VerificationView>;

package/dist/contracts/youiyoux-request.d.ts

@@ -1,248 +0,0 @@
-/**
- * A youiyoux request as Toolroll reads it (youiyoux-intake.ts): the published `youi.request/v1` schema (youiyoux's
- * schema/youi.request.schema.json), held to its own limits, and the `youi.proposal/v1` options file an options request's
- * agent writes (schema/youi.proposal.schema.json). Unknown keys are allowed, as the published schemas allow them;
- * everything Toolroll reads is checked here, and every string is outside text all the same.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-export declare const REQUEST_ID: RegExp;
-/** An options file's id: `p-` and the same 10 hex as the options request it answers. */
-export declare const PROPOSAL_ID: RegExp;
-/** The provenance every task filed from a request carries (task_ref.filed_via): immutable, and the seal reads it. */
-export declare const YOUIYOUX_FILED_VIA = "youiyoux";
-/** The one chat card a pass's filings make for a project (youiyoux-intake.ts), drawn by chat-decide.ts: the new tasks,
- * Approve all and each one's own Approve and Open. */
-export declare const YOUIYOUX_CARD_KIND = "youiyoux-requests";
-/** Where a person sees and approves everything waiting on them in the console (flow-triggers.ts NEEDS_YOU_HREF). */
-export declare const YOUIYOUX_HOME_PATH = "/tasks?view=needs-you";
-export declare const YOUIYOUX_EVIDENCE: readonly ["screenshot", "check", "changed-path", "manual-review"];
-/** What an options request offers its agent: the one file to write (`.youi/proposals/<proposal>.json`), the props an
- * option may set (enum values from `values`), and whether it may give the component new text. */
-export declare const youiyouxOfferSchema: z.ZodObject<{
-    proposal: z.ZodString;
-    file: z.ZodString;
-    choices: z.ZodRecord<z.ZodString, z.ZodObject<{
-        type: z.ZodEnum<{
-            boolean: "boolean";
-            enum: "enum";
-            number: "number";
-            string: "string";
-        }>;
-        values: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
-    }, z.core.$strip>>;
-    text: z.ZodBoolean;
-}, z.core.$strip>;
-export type YouiyouxOffer = z.infer<typeof youiyouxOfferSchema>;
-export declare const youiyouxTaskSchema: z.ZodObject<{
-    title: z.ZodString;
-    goal: z.ZodString;
-    touches: z.ZodArray<z.ZodString>;
-    touchesKnown: z.ZodBoolean;
-    why: z.ZodOptional<z.ZodString>;
-    not: z.ZodArray<z.ZodString>;
-    acceptance: z.ZodArray<z.ZodObject<{
-        statement: z.ZodString;
-        evidence: z.ZodArray<z.ZodEnum<{
-            "changed-path": "changed-path";
-            check: "check";
-            "manual-review": "manual-review";
-            screenshot: "screenshot";
-        }>>;
-    }, z.core.$strip>>;
-    offer: z.ZodOptional<z.ZodObject<{
-        proposal: z.ZodString;
-        file: z.ZodString;
-        choices: z.ZodRecord<z.ZodString, z.ZodObject<{
-            type: z.ZodEnum<{
-                boolean: "boolean";
-                enum: "enum";
-                number: "number";
-                string: "string";
-            }>;
-            values: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
-        }, z.core.$strip>>;
-        text: z.ZodBoolean;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const youiyouxRequestSchema: z.ZodObject<{
-    schema: z.ZodLiteral<"youi.request/v1">;
-    id: z.ZodString;
-    project: z.ZodString;
-    kind: z.ZodEnum<{
-        change: "change";
-        comment: "comment";
-        options: "options";
-    }>;
-    status: z.ZodEnum<{
-        addressed: "addressed";
-        closed: "closed";
-        open: "open";
-    }>;
-    body: z.ZodString;
-    author: z.ZodObject<{
-        kind: z.ZodEnum<{
-            agent: "agent";
-            person: "person";
-        }>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-    target: z.ZodObject<{
-        route: z.ZodString;
-        scope: z.ZodEnum<{
-            element: "element";
-            here: "here";
-        }>;
-        name: z.ZodString;
-        file: z.ZodOptional<z.ZodString>;
-        line: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strip>;
-    task: z.ZodOptional<z.ZodObject<{
-        title: z.ZodString;
-        goal: z.ZodString;
-        touches: z.ZodArray<z.ZodString>;
-        touchesKnown: z.ZodBoolean;
-        why: z.ZodOptional<z.ZodString>;
-        not: z.ZodArray<z.ZodString>;
-        acceptance: z.ZodArray<z.ZodObject<{
-            statement: z.ZodString;
-            evidence: z.ZodArray<z.ZodEnum<{
-                "changed-path": "changed-path";
-                check: "check";
-                "manual-review": "manual-review";
-                screenshot: "screenshot";
-            }>>;
-        }, z.core.$strip>>;
-        offer: z.ZodOptional<z.ZodObject<{
-            proposal: z.ZodString;
-            file: z.ZodString;
-            choices: z.ZodRecord<z.ZodString, z.ZodObject<{
-                type: z.ZodEnum<{
-                    boolean: "boolean";
-                    enum: "enum";
-                    number: "number";
-                    string: "string";
-                }>;
-                values: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
-            }, z.core.$strip>>;
-            text: z.ZodBoolean;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    thread: z.ZodArray<z.ZodUnknown>;
-}, z.core.$strip>;
-export type YouiyouxRequest = z.infer<typeof youiyouxRequestSchema>;
-export type YouiyouxTask = z.infer<typeof youiyouxTaskSchema>;
-export declare function readYouiyouxRequest(raw: unknown): ContractResult<YouiyouxRequest>;
-/** The one file an options request's agent may write: `.youi/proposals/p-<the request's hex>.json`. */
-export declare const proposalIdOf: (request: string) => string;
-export declare const proposalFileOf: (proposal: string) => string;
-/** Why an options request can't be filed as youiyoux's contract has it, or null: it carries a task with an offer whose
- * proposal is `p-<its own hex>`, whose file is that proposal's, and the task may touch that one file and nothing else. */
-export declare function optionsProblem(request: YouiyouxRequest): string | null;
-export declare const PROPOSAL_STATUSES: readonly ["open", "chosen", "dismissed"];
-export declare const youiyouxProposalSchema: z.ZodObject<{
-    $schema: z.ZodOptional<z.ZodString>;
-    schema: z.ZodLiteral<"youi.proposal/v1">;
-    id: z.ZodString;
-    project: z.ZodString;
-    route: z.ZodString;
-    target: z.ZodObject<{
-        name: z.ZodString;
-        element: z.ZodOptional<z.ZodString>;
-        file: z.ZodOptional<z.ZodString>;
-        line: z.ZodOptional<z.ZodInt>;
-        column: z.ZodOptional<z.ZodInt>;
-        box: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-        }, z.core.$strip>;
-        page: z.ZodOptional<z.ZodObject<{
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-    ask: z.ZodString;
-    author: z.ZodObject<{
-        kind: z.ZodEnum<{
-            agent: "agent";
-            person: "person";
-        }>;
-        name: z.ZodString;
-    }, z.core.$strip>;
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-    options: z.ZodArray<z.ZodObject<{
-        id: z.ZodEnum<{
-            a: "a";
-            b: "b";
-            c: "c";
-            d: "d";
-        }>;
-        label: z.ZodString;
-        why: z.ZodString;
-        set: z.ZodArray<z.ZodObject<{
-            prop: z.ZodString;
-            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
-        }, z.core.$strip>>;
-        text: z.ZodNullable<z.ZodString>;
-    }, z.core.$strip>>;
-    status: z.ZodEnum<{
-        chosen: "chosen";
-        dismissed: "dismissed";
-        open: "open";
-    }>;
-    choice: z.ZodOptional<z.ZodEnum<{
-        a: "a";
-        b: "b";
-        c: "c";
-        d: "d";
-    }>>;
-    decidedBy: z.ZodOptional<z.ZodObject<{
-        kind: z.ZodEnum<{
-            agent: "agent";
-            person: "person";
-        }>;
-        name: z.ZodString;
-    }, z.core.$strip>>;
-    decidedAt: z.ZodOptional<z.ZodString>;
-    request: z.ZodOptional<z.ZodString>;
-    for: z.ZodString;
-}, z.core.$strip>;
-export type YouiyouxProposal = z.infer<typeof youiyouxProposalSchema>;
-export declare function readYouiyouxProposal(raw: unknown): ContractResult<YouiyouxProposal>;
-/** What Toolroll writes beside a request (`youi.request-task/v1`): the task it became, how that task stands, and, when
- * the console has an address, the task's link and `home`, where a person sees and approves all waiting work. */
-export declare const YOUIYOUX_TASK_STATUSES: readonly ["queued", "needs-you", "building", "ready", "done", "failed", "stopped"];
-export type YouiyouxTaskStatus = (typeof YOUIYOUX_TASK_STATUSES)[number];
-/** A link youiyoux opens: http or https, at most 2,000 characters, with no user name or password in it. */
-export declare const youiyouxLinkSchema: z.ZodString;
-export declare const youiyouxRequestTaskSchema: z.ZodObject<{
-    schema: z.ZodLiteral<"youi.request-task/v1">;
-    request: z.ZodString;
-    runner: z.ZodLiteral<"Toolroll">;
-    task: z.ZodObject<{
-        id: z.ZodString;
-        url: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>;
-    home: z.ZodOptional<z.ZodString>;
-    status: z.ZodEnum<{
-        building: "building";
-        done: "done";
-        failed: "failed";
-        "needs-you": "needs-you";
-        queued: "queued";
-        ready: "ready";
-        stopped: "stopped";
-    }>;
-    detail: z.ZodString;
-    updatedAt: z.ZodString;
-}, z.core.$strict>;
-export type YouiyouxRequestTask = z.infer<typeof youiyouxRequestTaskSchema>;
-export declare function readYouiyouxRequestTask(raw: unknown): ContractResult<YouiyouxRequestTask>;

package/dist/control-setup.d.ts

@@ -1,44 +0,0 @@
-import type { Store } from "./store.js";
-export type SetupInputs = {
-    provider: string;
-    model: string;
-    command: string;
-    seconds: string;
-};
-export declare function previewSetup(store: Store, repo: string, inputs: SetupInputs): {
-    ok: false;
-    message: string;
-    fingerprint?: never;
-    command?: never;
-    seconds?: never;
-    provider?: never;
-    model?: never;
-    models?: never;
-} | {
-    message?: never;
-    ok: true;
-    fingerprint: string;
-    command: string;
-    seconds: number;
-    provider: "claude" | "cline" | "codex" | "cursor" | "gemini" | "goose" | "opencode" | "openrouter" | "qwen";
-    model: string;
-    models: {
-        rows: (import("./model-choices.js").DiffRow & {
-            inherited: import("./model-choices.js").Pair | null;
-        })[];
-        state: string;
-        change: string;
-    } | null;
-};
-export declare function approveSetup(store: Store, repo: string, inputs: SetupInputs, fingerprint: string, by: string, token: string, now: Date): {
-    ok: false;
-    message: string;
-    fingerprint?: never;
-    command?: never;
-    seconds?: never;
-    provider?: never;
-    model?: never;
-    models?: never;
-} | {
-    ok: true;
-};

package/dist/control-ui.d.ts

@@ -1,37 +0,0 @@
-/** Shared setup views over the existing project configuration and approval doors. */
-import { type Html } from "./html.js";
-import type { ProviderId } from "./provider.js";
-import type { ProviderConnection } from "./provider-connection.js";
-import { type ModelChoice } from "./setup-guide.js";
-import type { SetupInputs } from "./control-setup.js";
-import { type OpenRouterModels } from "./openrouter-models.js";
-export declare function connectionWords(connection: ProviderConnection): string;
-/** The last sign-in check (null: none yet). Check again posts: a page never runs a check (docs/plans/get-side-effects.md). */
-export declare function connectionHtml(provider: ProviderId, connection: ProviderConnection | null, task?: string): Html;
-export declare function controlSetupHtml(data: {
-    repo: string;
-    csrf: string;
-    provider: ProviderId;
-    inputs: SetupInputs;
-    models: ModelChoice[];
-    connection: ProviderConnection | null;
-    catalog: OpenRouterModels | null;
-    task?: string;
-    preparation: {
-        command: string;
-        label: string;
-        evidence: string;
-    } | null;
-    instructions: {
-        installed: boolean;
-        message?: string;
-    };
-}): Html;
-/** `fields` may still carry the session's csrf (a caller's habit): postForm writes the one CSRF field. */
-export declare function setupPreviewHtml(inputs: SetupInputs, fields: Record<string, string>, models?: {
-    label: string;
-    rows: {
-        role: string;
-        model: string;
-    }[];
-} | null): Html;

package/dist/controller-service.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/controller-supervisor.d.ts

@@ -1,38 +0,0 @@
-import { type ChildProcess } from "node:child_process";
-export type ControllerState = {
-    phase: "starting" | "running" | "backoff" | "stopped";
-    generation: number;
-    controllerPid: number | null;
-    exit?: {
-        code: number | null;
-        signal: NodeJS.Signals | null;
-    };
-    retryMs?: number;
-};
-/** A service process supervises exactly one controller. It knows nothing
- * about tasks, credentials, claims, or retries: those remain in `up`.
- *
- * This closes a Node-controller crash without depending on launchd starting
- * another process. It does not claim to survive its own SIGKILL or bypass an
- * OS policy that defers a LaunchAgent. Children share the service's process
- * group so launchd can also clean up the controller when this process dies.
- */
-export declare function superviseController(args: {
-    file: string;
-    argv: readonly string[];
-    signal: AbortSignal;
-    cwd?: string;
-    env?: NodeJS.ProcessEnv;
-    onState?: (state: ControllerState) => void;
-    retryMs?: number;
-    maxRetryMs?: number;
-    stableMs?: number;
-    shutdownMs?: number;
-    /** An IPC channel to each controller (fd 3), for a parent that speaks to it (`toolroll up`'s console and worker). */
-    ipc?: boolean;
-    /** Prefix every line the controller writes, sent to this process's stderr: two controllers' logs stay apart. An
-     * empty label sends its lines there unprefixed (a JSON log keeps one object a line). */
-    label?: string;
-    /** Each spawned controller's handle, before it runs: the caller listens to its messages and may signal it. */
-    onSpawn?: (child: ChildProcess, generation: number) => void;
-}): Promise<void>;