toolroll 0.9.103 → 0.9.105

package/dist/contracts/project-skills.d.ts

@@ -1,120 +0,0 @@
-/**
- * Project skills (project-skills.ts): one schema for a skill package (`skill_package`), a project's selection of
- * versions (`project_skill_change`), and the versions a run is pinned to (`skill_snapshot`, and the snapshot a reviewer
- * reads). The rules JSON Schema cannot state — UTF-8 byte limits, base64, path safety, YAML metadata, secrets, the
- * selection's total size — run in plain code (`validateSkill`, `changeSkills`) when a skill is imported or chosen.
- *
- * Two payloads carry no envelope, on purpose. A package is content-addressed: its digest is its version, so the same
- * folder imported before and after this contract is the same version. A selection maps skill names to versions, and
- * `version` is itself a valid skill name, so a key there would collide with one; an older runtime also reads every
- * value in it as a choice. Both are read exactly as they have always been written.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-/** How many files a package holds, how many versions a project enables and a person's library keeps. Text limits live
- * in TEXT_LIMITS. */
-export declare const SKILL_COUNTS: {
-    readonly files: 64;
-    readonly enabled: 8;
-    readonly library: 100;
-};
-/** Every skill limit by its long-standing name: the counts above and the byte limits from TEXT_LIMITS. */
-export declare const SKILL_LIMITS: {
-    readonly files: 64;
-    readonly packageBytes: number;
-    readonly fileBytes: number;
-    readonly bodyBytes: number;
-    readonly enabled: 8;
-    readonly selectionBytes: number;
-};
-/** A skill name: lowercase words joined by hyphens. */
-export declare const SKILL_NAME: RegExp;
-export declare const skillFileSchema: z.ZodObject<{
-    path: z.ZodString;
-    base64: z.ZodString;
-}, z.core.$strict>;
-/** A package as it is imported. */
-export declare const skillPackageSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodString;
-    source: z.ZodString;
-    requirements: z.ZodString;
-    warnings: z.ZodArray<z.ZodString>;
-    files: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        base64: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-/** A package as it is read back. */
-export declare const savedSkillPackageSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodString;
-    source: z.ZodString;
-    requirements: z.ZodString;
-    warnings: z.ZodArray<z.ZodString>;
-    files: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        base64: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-/** A package with its version (the digest of its bytes). */
-export declare const savedSkillSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodString;
-    source: z.ZodString;
-    requirements: z.ZodString;
-    warnings: z.ZodArray<z.ZodString>;
-    files: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        base64: z.ZodString;
-    }, z.core.$strict>>;
-    sha: z.ZodString;
-}, z.core.$strict>;
-export type SkillFile = z.infer<typeof skillFileSchema>;
-export type SkillPackage = z.infer<typeof skillPackageSchema>;
-export type SavedSkill = z.infer<typeof savedSkillSchema>;
-/** One skill's chosen version, and whether it is on. */
-export declare const skillChoiceSchema: z.ZodObject<{
-    sha: z.ZodString;
-    enabled: z.ZodBoolean;
-}, z.core.$strict>;
-/** A project's selection: each skill name and its chosen version. */
-export declare const skillSelectionSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
-    sha: z.ZodString;
-    enabled: z.ZodBoolean;
-}, z.core.$strict>>;
-export type SkillSelection = z.infer<typeof skillSelectionSchema>;
-export declare const SKILLS_SNAPSHOT_VERSION = 1;
-/** The versions a run is pinned to, as frozen: the packages by digest. */
-export declare const savedSkillsSnapshotSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    revision: z.ZodInt;
-    identity: z.ZodString;
-    inheritedFrom: z.ZodNullable<z.ZodInt>;
-    test: z.ZodBoolean;
-    packageShas: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-/** The same snapshot with each package read, as a run and its reviewer get it. */
-export declare const skillsSnapshotSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    revision: z.ZodInt;
-    identity: z.ZodString;
-    inheritedFrom: z.ZodNullable<z.ZodInt>;
-    test: z.ZodBoolean;
-    packages: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        description: z.ZodString;
-        source: z.ZodString;
-        requirements: z.ZodString;
-        warnings: z.ZodArray<z.ZodString>;
-        files: z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            base64: z.ZodString;
-        }, z.core.$strict>>;
-        sha: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type SavedSkillsSnapshot = z.infer<typeof savedSkillsSnapshotSchema>;
-export type SkillsSnapshot = z.infer<typeof skillsSnapshotSchema>;
-/** Read a frozen snapshot: version 1 (every snapshot ever frozen) as itself, a newer one refused plainly. */
-export declare function readSkillsSnapshotPayload(input: unknown): ContractResult<SavedSkillsSnapshot>;

package/dist/contracts/proof.d.ts

@@ -1,136 +0,0 @@
-/**
- * The builder's proof: one schema for the file a builder writes (the proof manifest), the `proof.json` the machine
- * stores, and the reader that reads both back (`parseProof` in proof.ts). The rules JSON Schema cannot state — UTF-8
- * byte limits, blank text, control characters, relative screenshot paths and duplicate ids or paths — run in plain
- * code after parsing, each with a path-named error.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-/** How many entries each proof list may hold. Text limits live in TEXT_LIMITS. */
-export declare const PROOF_COUNTS: {
-    readonly criteria: 12;
-    readonly evidencePerCriterion: 4;
-    readonly checks: 12;
-    readonly changed: 64;
-    readonly caveats: 8;
-    readonly screenshots: 8;
-};
-/** Every proof limit by its long-standing name: the counts above and the byte limits from TEXT_LIMITS. */
-export declare const PROOF_LIMITS: {
-    readonly criteria: 12;
-    readonly evidencePerCriterion: 4;
-    readonly checks: 12;
-    readonly changed: 64;
-    readonly caveats: 8;
-    readonly screenshots: 8;
-    readonly payload: number;
-    readonly criterionId: 40;
-    readonly criterionStatement: 300;
-    readonly criterionHow: 500;
-    readonly evidenceRef: 300;
-    readonly checkCommand: 300;
-    readonly checkSummary: 300;
-    readonly changedPath: 300;
-    readonly caveat: 300;
-    readonly screenshotPath: 300;
-    readonly screenshotCaption: 300;
-};
-export declare const CRITERION_VERDICTS: readonly ["met", "not-met", "not-checked", "pending-verification"];
-/** One typed reference a criterion cites: an existing check's command, screenshot's path, a path in `changed`, or
- * (kind `manual-review`) free text pointing at nothing machine-checkable. */
-export declare const criterionEvidenceSchema: z.ZodObject<{
-    kind: z.ZodEnum<{
-        "changed-path": "changed-path";
-        check: "check";
-        "manual-review": "manual-review";
-        screenshot: "screenshot";
-    }>;
-    ref: z.ZodString;
-}, z.core.$strict>;
-/** One criterion the proof answers. `pending-verification` asserts all agent-owned work is met and only the
- * machine-owned final check remains. */
-export declare const proofCriterionSchema: z.ZodObject<{
-    id: z.ZodString;
-    statement: z.ZodString;
-    how: z.ZodString;
-    verdict: z.ZodEnum<{
-        met: "met";
-        "not-checked": "not-checked";
-        "not-met": "not-met";
-        "pending-verification": "pending-verification";
-    }>;
-    evidence: z.ZodArray<z.ZodObject<{
-        kind: z.ZodEnum<{
-            "changed-path": "changed-path";
-            check: "check";
-            "manual-review": "manual-review";
-            screenshot: "screenshot";
-        }>;
-        ref: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const proofCheckSchema: z.ZodObject<{
-    command: z.ZodString;
-    summary: z.ZodString;
-    exitCode: z.ZodInt;
-}, z.core.$strict>;
-/** A screenshot the proof claims; its path is where the file lived in the worktree, its bytes are checked by the
- * caller. */
-export declare const proofScreenshotSchema: z.ZodObject<{
-    path: z.ZodString;
-    caption: z.ZodString;
-}, z.core.$strict>;
-export declare const PROOF_VERSION = 2;
-/** The proof as stored and as every reader returns it: every list present, nothing unknown. */
-export declare const proofSchema: z.ZodObject<{
-    version: z.ZodLiteral<2>;
-    criteria: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        statement: z.ZodString;
-        how: z.ZodString;
-        verdict: z.ZodEnum<{
-            met: "met";
-            "not-checked": "not-checked";
-            "not-met": "not-met";
-            "pending-verification": "pending-verification";
-        }>;
-        evidence: z.ZodArray<z.ZodObject<{
-            kind: z.ZodEnum<{
-                "changed-path": "changed-path";
-                check: "check";
-                "manual-review": "manual-review";
-                screenshot: "screenshot";
-            }>;
-            ref: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    checks: z.ZodArray<z.ZodObject<{
-        command: z.ZodString;
-        summary: z.ZodString;
-        exitCode: z.ZodInt;
-    }, z.core.$strict>>;
-    changed: z.ZodArray<z.ZodString>;
-    caveats: z.ZodArray<z.ZodString>;
-    screenshots: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        caption: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type ParsedProof = z.infer<typeof proofSchema>;
-export type ParsedCriterion = z.infer<typeof proofCriterionSchema>;
-export type CriterionEvidenceRef = z.infer<typeof criterionEvidenceSchema>;
-export type ParsedCheck = z.infer<typeof proofCheckSchema>;
-export type ParsedScreenshot = z.infer<typeof proofScreenshotSchema>;
-/**
- * A version 1 proof — what a builder writes (`{ "version": 1, "screenshots": [...] }`) and every proof stored through
- * 0.9.34 — as version 2. Version 1 read only the fields it knew and ignored any others, and read a missing or null
- * list (a criterion's `evidence` too) as empty; this keeps exactly that. Values themselves are never rewritten.
- */
-export declare function upgradeProofV1(body: Record<string, unknown>): Record<string, unknown>;
-export declare const PROOF_UPGRADES: {
-    readonly 1: typeof upgradeProofV1;
-};
-/** The payload as version 2 (upgraded from version 1 when needed), for the plain-code rules; null for a non-object. */
-export declare function proofPayloadBody(input: unknown): Record<string, unknown> | null;
-/** Read a proof payload: version 2 as itself, version 1 upgraded, a newer one refused plainly. */
-export declare function readProofPayload(input: unknown): ContractResult<ParsedProof>;

package/dist/contracts/provider.d.ts

@@ -1,40 +0,0 @@
-/**
- * Which harness runs, on which model (provider.ts `AgentSpec`): a provider id and a model id, null for the harness's
- * default. One schema for the pair; `ProviderId` and `AgentSpec` are derived from it. Model ids cross providers
- * ("anthropic/claude-sonnet-4.5", "gpt-5-codex", "opus"): bounded and printable, never leading with a dash (argv
- * safety), and no TOML-hostile characters. That OpenRouter and Gemini need an explicit model runs after parsing.
- *
- * A refusal names its field and never repeats the value it was given: a provider or model field is where a pasted
- * credential would land, and a refusal is shown, logged and sent on.
- */
-import { z } from "zod";
-export declare const PROVIDER_ID_VALUES: readonly ["claude", "codex", "openrouter", "gemini", "opencode", "cursor", "cline", "qwen", "goose"];
-export declare const providerIdSchema: z.ZodEnum<{
-    claude: "claude";
-    cline: "cline";
-    codex: "codex";
-    cursor: "cursor";
-    gemini: "gemini";
-    goose: "goose";
-    opencode: "opencode";
-    openrouter: "openrouter";
-    qwen: "qwen";
-}>;
-export declare const MODEL_ID: RegExp;
-export declare const modelIdSchema: z.ZodString;
-export declare const agentSpecSchema: z.ZodObject<{
-    provider: z.ZodEnum<{
-        claude: "claude";
-        cline: "cline";
-        codex: "codex";
-        cursor: "cursor";
-        gemini: "gemini";
-        goose: "goose";
-        opencode: "opencode";
-        openrouter: "openrouter";
-        qwen: "qwen";
-    }>;
-    model: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>;
-export type ProviderId = z.infer<typeof providerIdSchema>;
-export type AgentSpec = z.infer<typeof agentSpecSchema>;

package/dist/contracts/recipes.d.ts

@@ -1,166 +0,0 @@
-/**
- * A recipe document (recipes.ts): reusable work a person imports, exports, previews and saves. One schema for both
- * versions, a discriminated union on `version` — version 1 is fixed work, version 2 adds questions whose answers fill
- * `{{key}}` placeholders. Recipes are strict and always were: every key is required, and an unknown one (an approval,
- * provider or credential setting smuggled in) is refused by name.
- *
- * A success check is the scope's own saved criterion (src/contracts/scope.ts), strict about its keys. The reader fills
- * an absent or empty `how` with null before parsing, as the scope reader always has. What JSON Schema can't say runs
- * in recipes.ts after parsing, each refusal naming its field: the 32 KB size, text and placeholder rules, schedules,
- * the budget/schedule/deliverable/planning combinations, question keys and the scope reader's byte, control-character
- * and duplicate checks. Saved recipes and previews keep their exact bytes, so their digests still match.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-export declare const RECIPE_FORMAT = "standing-orders-recipe";
-/** Numbers the recipe rules use, in plain code after parsing (bytes of the whole document, characters of a field). */
-export declare const RECIPE_LIMITS: {
-    readonly documentBytes: 32768;
-    readonly description: 400;
-    readonly inputs: 8;
-    readonly label: 80;
-    readonly answer: 500;
-};
-/** A question a version 2 recipe asks: its key, its label and an optional default answer (null for none). */
-export declare const recipeInputSchema: z.ZodObject<{
-    key: z.ZodString;
-    label: z.ZodString;
-    defaultValue: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
-export declare const recipeV1Schema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    format: z.ZodLiteral<"standing-orders-recipe">;
-    name: z.ZodString;
-    description: z.ZodString;
-    goal: z.ZodString;
-    outOfScope: z.ZodNullable<z.ZodString>;
-    touches: z.ZodArray<z.ZodString>;
-    acceptance: z.ZodArray<z.ZodLazy<z.ZodObject<{
-        id: z.ZodString;
-        statement: z.ZodString;
-        evidence: z.ZodArray<z.ZodEnum<{
-            "changed-path": "changed-path";
-            check: "check";
-            "manual-review": "manual-review";
-            screenshot: "screenshot";
-        }>>;
-        how: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>>;
-    planning: z.ZodEnum<{
-        auto: "auto";
-        required: "required";
-        skip: "skip";
-    }>;
-    deliverable: z.ZodEnum<{
-        branch: "branch";
-        report: "report";
-    }>;
-    schedule: z.ZodNullable<z.ZodString>;
-    costCeilingUsd: z.ZodNullable<z.ZodNumber>;
-}, z.core.$strict>;
-export declare const recipeV2Schema: z.ZodObject<{
-    version: z.ZodLiteral<2>;
-    format: z.ZodLiteral<"standing-orders-recipe">;
-    name: z.ZodString;
-    description: z.ZodString;
-    goal: z.ZodString;
-    outOfScope: z.ZodNullable<z.ZodString>;
-    touches: z.ZodArray<z.ZodString>;
-    acceptance: z.ZodArray<z.ZodLazy<z.ZodObject<{
-        id: z.ZodString;
-        statement: z.ZodString;
-        evidence: z.ZodArray<z.ZodEnum<{
-            "changed-path": "changed-path";
-            check: "check";
-            "manual-review": "manual-review";
-            screenshot: "screenshot";
-        }>>;
-        how: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>>;
-    planning: z.ZodEnum<{
-        auto: "auto";
-        required: "required";
-        skip: "skip";
-    }>;
-    deliverable: z.ZodEnum<{
-        branch: "branch";
-        report: "report";
-    }>;
-    schedule: z.ZodNullable<z.ZodString>;
-    costCeilingUsd: z.ZodNullable<z.ZodNumber>;
-    inputs: z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        label: z.ZodString;
-        defaultValue: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const recipeDocumentSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    format: z.ZodLiteral<"standing-orders-recipe">;
-    name: z.ZodString;
-    description: z.ZodString;
-    goal: z.ZodString;
-    outOfScope: z.ZodNullable<z.ZodString>;
-    touches: z.ZodArray<z.ZodString>;
-    acceptance: z.ZodArray<z.ZodLazy<z.ZodObject<{
-        id: z.ZodString;
-        statement: z.ZodString;
-        evidence: z.ZodArray<z.ZodEnum<{
-            "changed-path": "changed-path";
-            check: "check";
-            "manual-review": "manual-review";
-            screenshot: "screenshot";
-        }>>;
-        how: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>>;
-    planning: z.ZodEnum<{
-        auto: "auto";
-        required: "required";
-        skip: "skip";
-    }>;
-    deliverable: z.ZodEnum<{
-        branch: "branch";
-        report: "report";
-    }>;
-    schedule: z.ZodNullable<z.ZodString>;
-    costCeilingUsd: z.ZodNullable<z.ZodNumber>;
-}, z.core.$strict>, z.ZodObject<{
-    version: z.ZodLiteral<2>;
-    format: z.ZodLiteral<"standing-orders-recipe">;
-    name: z.ZodString;
-    description: z.ZodString;
-    goal: z.ZodString;
-    outOfScope: z.ZodNullable<z.ZodString>;
-    touches: z.ZodArray<z.ZodString>;
-    acceptance: z.ZodArray<z.ZodLazy<z.ZodObject<{
-        id: z.ZodString;
-        statement: z.ZodString;
-        evidence: z.ZodArray<z.ZodEnum<{
-            "changed-path": "changed-path";
-            check: "check";
-            "manual-review": "manual-review";
-            screenshot: "screenshot";
-        }>>;
-        how: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>>;
-    planning: z.ZodEnum<{
-        auto: "auto";
-        required: "required";
-        skip: "skip";
-    }>;
-    deliverable: z.ZodEnum<{
-        branch: "branch";
-        report: "report";
-    }>;
-    schedule: z.ZodNullable<z.ZodString>;
-    costCeilingUsd: z.ZodNullable<z.ZodNumber>;
-    inputs: z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        label: z.ZodString;
-        defaultValue: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>], "version">;
-export type RecipeDocument = z.infer<typeof recipeDocumentSchema>;
-export type RecipeInput = z.infer<typeof recipeInputSchema>;
-/** Read a recipe's structure (format and version already checked): every refusal is a path-named issue. */
-export declare function readRecipeDocument(input: Record<string, unknown>): ContractResult<RecipeDocument>;