toolroll 0.9.104 → 0.9.105

package/dist/contracts/scope.d.ts

@@ -1,105 +0,0 @@
-/**
- * A task's scope: its goal, what is out of it, the paths it expects to touch and the acceptance rubric an operator
- * signs. One schema for the terms and one for a criterion, both made from the plan contract's own fields
- * (src/contracts/plan.ts) rather than restated; a scope may name 50 paths where a plan names 32. The rules JSON Schema
- * cannot state — UTF-8 byte limits, control characters, duplicate criterion ids and evidence kinds — run in plain code
- * after parsing, each with a path-named error.
- *
- * Reading keeps what every release accepted: a criterion's unknown keys are ignored, a null or empty `how` reads as
- * null, and an absent or empty rubric reads as none (whether that is allowed is the caller's question). The digest
- * (scope.ts `digestOf`) reads the parsed values, so a saved scope's digest is what it always was.
- *
- * The schemas are built lazily: plan.ts reads the evidence kinds through scope.ts, which reads this module, so in
- * either load order plan.ts may still be loading when this module is.
- */
-import { z } from "zod";
-import { type ContractProblem } from "./contract.js";
-/** A criterion as saved and as every reader returns it: the plan's criterion with `how` always present (null for none). */
-export declare const savedCriterionSchema: 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>>;
-export type AcceptanceCriterion = z.infer<typeof savedCriterionSchema>;
-/** A rubric as saved: at most twelve criteria (an empty one is a scope filed before rubrics, or by a road with none). */
-export declare const rubricSchema: z.ZodLazy<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>>>>;
-/** A rubric as a row stores it: exactly the keys this code writes (`how` may be absent on an older row). */
-export declare const storedRubricSchema: z.ZodLazy<z.ZodArray<z.ZodObject<{
-    id: z.ZodString;
-    statement: z.ZodString;
-    how: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    evidence: z.ZodArray<z.ZodEnum<{
-        "changed-path": "changed-path";
-        check: "check";
-        "manual-review": "manual-review";
-        screenshot: "screenshot";
-    }>>;
-}, z.core.$strict>>>;
-/** What a model drafts as a rubric (the lead's proposals): the plan's criteria, one to twelve. */
-export declare const rubricInputSchema: z.ZodLazy<z.ZodArray<z.ZodObject<{
-    id: z.ZodString;
-    statement: z.ZodString;
-    how: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    evidence: z.ZodArray<z.ZodEnum<{
-        "changed-path": "changed-path";
-        check: "check";
-        "manual-review": "manual-review";
-        screenshot: "screenshot";
-    }>>;
-}, z.core.$strict>>>;
-/** A scope's terms as filed: the plan's goal, out-of-scope text and touch paths (up to 50), and its rubric. */
-export declare const scopeTermsSchema: z.ZodLazy<z.ZodObject<{
-    goal: z.ZodString;
-    outOfScope: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    touches: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    acceptance: z.ZodOptional<z.ZodLazy<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>>>>>;
-}, z.core.$strict>>;
-export type ScopeTerms = z.infer<typeof scopeTermsSchema>;
-export type AcceptanceProblem = ContractProblem;
-/**
- * Read a rubric from already-JSON-parsed input (a console form, the CLI, a routine or template, a model's proposal,
- * a saved row): every problem at once, each naming its path. Absent or empty is `[]` with no problems. A criterion
- * that reads cleanly is kept even when another does not, as before; any problem means the rubric is refused.
- */
-export declare function readAcceptance(value: unknown): {
-    criteria: AcceptanceCriterion[];
-    problems: AcceptanceProblem[];
-};
-export type ScopeTermsResult = {
-    ok: true;
-    terms: Omit<ScopeTerms, "acceptance"> & {
-        acceptance: AcceptanceCriterion[];
-    };
-} | {
-    ok: false;
-    field: "goal" | "outOfScope" | "touches" | "acceptance" | "payload";
-    problems: AcceptanceProblem[];
-};
-/** Read a scope's terms as a person or a model files them; the first field refused names the refusal. */
-export declare function readScopeTerms(input: unknown): ScopeTermsResult;

package/dist/contracts/scout-report.d.ts

@@ -1,234 +0,0 @@
-/**
- * The scout's report: one schema for the report a scout writes (its report file, or Claude's structured output), the
- * JSON Schema a Claude scout is given (`--json-schema`, `SCOUT_OUTPUT_JSON_SCHEMA`) and the reader that takes it back
- * (`parseReport` in scout-report.ts), which also reads every report already kept as evidence. The rules JSON Schema
- * cannot state — UTF-8 byte limits, blank text, control characters, one-line titles, a one-paragraph summary, safe
- * links, duplicate screenshots and items naming them — run in plain code after parsing, each with a path-named error.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-/** How many follow-ups, items and screenshots a report may carry. */
-export declare const REPORT_COUNTS: {
-    readonly followUps: 5;
-    readonly items: 6;
-    readonly images: 8;
-};
-/** Caps are BYTES of UTF-8 (v4 review, finding 11): a 64 KiB report is 64 KiB whatever script it is written in. They
- * hold what a scout writes; a stored report is read without them (`storedReportSchema`). */
-export declare const REPORT_LIMITS: {
-    readonly payload: number;
-    readonly title: 200;
-    readonly summary: 2500;
-    readonly document: number;
-    readonly followUps: 5;
-    readonly followUpTitle: 200;
-    /** A follow-up files as a task: its goal is held to the task goal limit, in bytes of the same count. */
-    readonly followUpGoal: 8000;
-    readonly items: 6;
-    readonly itemTitle: 200;
-    readonly itemWhy: 1000;
-    readonly url: 2000;
-    readonly images: 8;
-    readonly caption: 300;
-};
-/** A screenshot's name in the scout's output folder: one plain file name, PNG or JPEG, never a path. */
-export declare const REPORT_IMAGE_FILE: RegExp;
-/** Each text field, the limit it is written within, and whether it is one line or a web address. */
-export declare const REPORT_TEXT_FIELDS: {
-    readonly title: {
-        readonly limit: "reportTitleBytes";
-        readonly oneLine: true;
-    };
-    readonly summary: {
-        readonly limit: "reportSummary";
-    };
-    readonly report: {
-        readonly limit: "reportDocumentBytes";
-    };
-};
-export declare const FOLLOW_UP_TEXT_FIELDS: {
-    readonly title: {
-        readonly limit: "reportTitleBytes";
-        readonly oneLine: true;
-    };
-    readonly goal: {
-        readonly limit: "goal";
-    };
-};
-export declare const ITEM_TEXT_FIELDS: {
-    readonly title: {
-        readonly limit: "reportTitleBytes";
-        readonly oneLine: true;
-    };
-    readonly why: {
-        readonly limit: "reportWhyBytes";
-    };
-    readonly url: {
-        readonly limit: "reportUrlBytes";
-        readonly link: true;
-    };
-};
-export declare const IMAGE_TEXT_FIELDS: {
-    readonly file: {
-        readonly limit: "reportCaptionBytes";
-        readonly oneLine: true;
-    };
-    readonly caption: {
-        readonly limit: "reportCaptionBytes";
-        readonly oneLine: true;
-    };
-    readonly url: {
-        readonly limit: "reportUrlBytes";
-        readonly link: true;
-    };
-};
-export declare const REPORT_VERSION = 1;
-/** A report as a scout writes it now. */
-export declare const scoutReportSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    title: z.ZodString;
-    summary: z.ZodString;
-    report: z.ZodString;
-    followUps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        title: z.ZodString;
-        goal: z.ZodString;
-    }, z.core.$strict>>>;
-    items: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        title: z.ZodString;
-        why: z.ZodString;
-        url: z.ZodString;
-        image: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strict>>>;
-    images: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        file: z.ZodString;
-        caption: z.ZodString;
-        url: z.ZodString;
-        sha256: z.ZodOptional<z.ZodString>;
-        artifact: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
-/** A report kept as evidence: the same, except text keeps the length it was stored with. */
-export declare const storedReportSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    title: z.ZodString;
-    summary: z.ZodString;
-    report: z.ZodString;
-    followUps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        title: z.ZodString;
-        goal: z.ZodString;
-    }, z.core.$strict>>>;
-    items: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        title: z.ZodString;
-        why: z.ZodString;
-        url: z.ZodString;
-        image: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strict>>>;
-    images: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        file: z.ZodString;
-        caption: z.ZodString;
-        url: z.ZodString;
-        sha256: z.ZodOptional<z.ZodString>;
-        artifact: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
-export type ScoutReportPayload = z.infer<typeof scoutReportSchema>;
-type FollowUp = NonNullable<ScoutReportPayload["followUps"]>[number];
-type Item = NonNullable<ScoutReportPayload["items"]>[number];
-type Image = NonNullable<ScoutReportPayload["images"]>[number];
-/** One finding later steps read: it cites its URL, and may show one of the report's images (null when none). */
-export type ReportItem = Omit<Item, "image"> & {
-    image: string | null;
-};
-/** A screenshot the scout saved. From the scout, `file` names a file in its output folder; once stored, the runner
- * adds the bytes' sha256 and the evidence row that holds them. */
-export type ReportImage = Image;
-/** A report as read: the payload without its envelope, every list present (empty when the scout gave none). */
-export type ParsedReport = {
-    title: string;
-    summary: string;
-    /** The report document, markdown, rendered fenced-inert everywhere. */
-    report: string;
-    /** Proposed follow-ups: each files as a task in the same repository. */
-    followUps: FollowUp[];
-    items: ReportItem[];
-    images: ReportImage[];
-};
-/** The park mailbox's decision as a scout hands it back: the same fields `parseDecision` reads, which stays its
- * validator until the decision contract (docs/plans/zod-revamp.md, item 7) gives it one schema. */
-export declare const scoutDecisionSchema: z.ZodObject<{
-    urgency: z.ZodLiteral<"blocking">;
-    recap: z.ZodString;
-    question: z.ZodString;
-    options: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        label: z.ZodString;
-        consequence: z.ZodString;
-        reversible: z.ZodBoolean;
-    }, z.core.$strict>>;
-    recommendation: z.ZodString;
-}, z.core.$strict>;
-/**
- * The scout's handback for Claude's `--json-schema` (run 2334's fix): plan mode only lets a session write its own plan
- * file, so a Claude scout returns a report — or a question for the operator — as structured output on the terminal
- * result event. The report branch is the report schema itself; the byte limits and rules JSON Schema cannot state are
- * `parseReport`'s (and `parseDecision`'s), applied to the branch as handed back.
- */
-export declare const scoutHandbackSchema: z.ZodObject<{
-    kind: z.ZodEnum<{
-        question: "question";
-        report: "report";
-    }>;
-    report: z.ZodOptional<z.ZodObject<{
-        version: z.ZodLiteral<1>;
-        title: z.ZodString;
-        summary: z.ZodString;
-        report: z.ZodString;
-        followUps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            title: z.ZodString;
-            goal: z.ZodString;
-        }, z.core.$strict>>>;
-        items: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            title: z.ZodString;
-            why: z.ZodString;
-            url: z.ZodString;
-            image: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strict>>>;
-        images: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            file: z.ZodString;
-            caption: z.ZodString;
-            url: z.ZodString;
-            sha256: z.ZodOptional<z.ZodString>;
-            artifact: z.ZodOptional<z.ZodInt>;
-        }, z.core.$strict>>>;
-    }, z.core.$strict>>;
-    decision: z.ZodOptional<z.ZodObject<{
-        urgency: z.ZodLiteral<"blocking">;
-        recap: z.ZodString;
-        question: z.ZodString;
-        options: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            label: z.ZodString;
-            consequence: z.ZodString;
-            reversible: z.ZodBoolean;
-        }, z.core.$strict>>;
-        recommendation: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const SCOUT_OUTPUT_JSON_SCHEMA: Readonly<Record<string, unknown>>;
-/**
- * Known reports keep the old parser's field-picking, whether unversioned (including `version: null`) or version 1:
- * unknown fields in the report, follow-ups, items and images are ignored, and a null list means none. Known field
- * values are never rewritten, and anything that is not an object is left for the schema to refuse by path.
- */
-declare function normalizeReportV1(body: Record<string, unknown>): Record<string, unknown>;
-export declare const REPORT_UPGRADES: {
-    readonly 0: typeof normalizeReportV1;
-};
-/** Normalize current and unversioned reports; leave other versions for readVersioned to check. */
-export declare function reportPayloadBody(input: unknown): Record<string, unknown> | null;
-/** Read current and unversioned reports with the same field-picking, then the strict schema; refuse newer versions
- * plainly. `stored`: one kept as evidence, read without the length limits. */
-export declare function readReportPayload(input: unknown, options?: {
-    stored?: boolean;
-}): ContractResult<ScoutReportPayload>;
-export {};

package/dist/contracts/slack-callback.d.ts

@@ -1,43 +0,0 @@
-/**
- * A Slack button tap (slack-chat.ts `receiveSlack`): the `block_actions` interaction Slack sends, and the button data
- * Toolroll put on it. The interaction is Slack's, so fields Toolroll doesn't read are ignored; the button (its
- * `action_id` and one-time token `value`) is Toolroll's. A tap from the paired person whose button can't be read is
- * answered with why (`actions[0].value: must be a Toolroll button token`), and nothing is done.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-/** Toolroll's buttons: toolroll_* since the rename; standing_orders_* buttons on older messages still work. */
-export declare const SLACK_BUTTON_ACTION: RegExp;
-/** A link button opens its page in Slack's own client; Slack still reports the tap, and there is nothing to do. */
-export declare const SLACK_LINK_ACTION: RegExp;
-/** The interaction around a tap: who, and the message the button is on. */
-export declare const slackBlockActionsSchema: z.ZodObject<{
-    type: z.ZodLiteral<"block_actions">;
-    user: z.ZodObject<{
-        id: z.ZodString;
-    }, z.core.$strip>;
-    container: z.ZodObject<{
-        type: z.ZodString;
-        channel_id: z.ZodOptional<z.ZodString>;
-        message_ts: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    message: z.ZodOptional<z.ZodObject<{
-        thread_ts: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    actions: z.ZodArray<z.ZodObject<{
-        action_id: z.ZodOptional<z.ZodString>;
-        value: z.ZodOptional<z.ZodString>;
-        action_ts: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type SlackBlockActions = z.infer<typeof slackBlockActionsSchema>;
-/** The one tapped button, as Toolroll made it. */
-export declare const slackButtonSchema: z.ZodObject<{
-    action_id: z.ZodString;
-    value: z.ZodString;
-    action_ts: z.ZodString;
-}, z.core.$strip>;
-export type SlackButton = z.infer<typeof slackButtonSchema>;
-export declare function readSlackBlockActions(body: unknown): ContractResult<SlackBlockActions>;
-/** The tapped button: exactly one, Toolroll's (`actions[0].action_id: not a Toolroll button`). */
-export declare function readSlackButton(interaction: SlackBlockActions): ContractResult<SlackButton>;

package/dist/contracts/sort-answer.d.ts

@@ -1,83 +0,0 @@
-/**
- * A Sort zone's answer (flow-sort.ts): what Jev, through OpenRouter's Decisions API, says about a card, and what a
- * sort step keeps of it. The Decisions API takes questions, not a JSON Schema, so there is no model-facing schema:
- * the request's keys come from the flow contract (`SORT_ROUTE_KEY`, `sortNoteKeyOf`, `sortKeyOf` in flow.ts), and
- * `jevReplySchema` is how the reply is read before anything routes on it.
- *
- * The reply is an outside service's: keys Toolroll does not read (ids, token counts) are ignored rather than refused.
- * Optional metadata can have any type, as before: the reader defaults non-numeric confidences/chances to zero,
- * skips non-numeric notes, and defaults the model and cost. The route choice must still be text.
- *
- * `sortDecisionSchema` is the decision a sort step keeps (`flow_step_run.decision_json`), unversioned as every release
- * has written it; the card, Insights and spend read saved ones as before.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-/** Jev's answer to the zone's question: the key of the answer it picked, how sure it is (0–1), and every answer's chance. */
-export declare const jevChoiceSchema: z.ZodObject<{
-    choice: z.ZodString;
-    confidence: z.ZodOptional<z.ZodUnknown>;
-    probabilities: z.ZodOptional<z.ZodUnknown>;
-}, z.core.$strip>;
-/** Jev's answer to something else the zone notes: a score's level (as a number) or a yes/no's chance of yes. */
-export declare const jevNoteSchema: z.ZodObject<{
-    score: z.ZodOptional<z.ZodUnknown>;
-    noul: z.ZodOptional<z.ZodUnknown>;
-    confidence: z.ZodOptional<z.ZodUnknown>;
-}, z.core.$strip>;
-/** What Toolroll reads of Jev's reply. */
-export declare const jevReplySchema: z.ZodObject<{
-    model: z.ZodOptional<z.ZodUnknown>;
-    answers: z.ZodObject<{
-        route: z.ZodObject<{
-            choice: z.ZodString;
-            confidence: z.ZodOptional<z.ZodUnknown>;
-            probabilities: z.ZodOptional<z.ZodUnknown>;
-        }, z.core.$strip>;
-    }, z.core.$catchall<z.ZodObject<{
-        score: z.ZodOptional<z.ZodUnknown>;
-        noul: z.ZodOptional<z.ZodUnknown>;
-        confidence: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strip>>>;
-    usage: z.ZodOptional<z.ZodUnknown>;
-}, z.core.$strip>;
-export type JevReply = z.infer<typeof jevReplySchema>;
-/** Read Jev's reply, or path-named lines saying what it lacks (`answers.route.choice: required`). */
-export declare function readJevReply(input: unknown): ContractResult<JevReply>;
-/** One thing the zone also noted, as the card shows it: the level or yes/no, and how sure (0–1). */
-export declare const sortNoteAnswerSchema: z.ZodObject<{
-    id: z.ZodString;
-    question: z.ZodString;
-    kind: z.ZodEnum<{
-        score: "score";
-        "yes-no": "yes-no";
-    }>;
-    answer: z.ZodString;
-    sure: z.ZodNumber;
-}, z.core.$strict>;
-export type SortNoteAnswer = z.infer<typeof sortNoteAnswerSchema>;
-/** What a sort step decided, kept on its run (decision_json) and shown on the card. */
-export declare const sortDecisionSchema: z.ZodObject<{
-    model: z.ZodString;
-    answer: z.ZodString;
-    sure: z.ZodNumber;
-    sureAt: z.ZodNumber;
-    confident: z.ZodBoolean;
-    to: z.ZodNullable<z.ZodString>;
-    chances: z.ZodObject<{}, z.core.$catchall<z.ZodNumber>>;
-    notes: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        question: z.ZodString;
-        kind: z.ZodEnum<{
-            score: "score";
-            "yes-no": "yes-no";
-        }>;
-        answer: z.ZodString;
-        sure: z.ZodNumber;
-    }, z.core.$strict>>;
-    cost: z.ZodNullable<z.ZodNumber>;
-    ms: z.ZodNumber;
-}, z.core.$strict>;
-export type SortDecision = z.infer<typeof sortDecisionSchema>;
-/** Read a sort decision as a step keeps it. */
-export declare function readSortDecision(input: unknown): ContractResult<SortDecision>;

package/dist/contracts/stage-output.d.ts

@@ -1,127 +0,0 @@
-/**
- * What a finished zone hands the zones after it (docs/plans/zod-revamp.md, item 8): its `{{stage.<id>}}` words and, by
- * kind, more fields (a research zone's `{{stage.<id>.items}}` and `{{stage.<id>.report}}`), kept on the card as one
- * versioned payload (`flow_card.outputs_json`) with any output too long to pass on attached whole.
- *
- * - `stageHandoffSchema` is one zone's handoff; `STAGE_HANDOFFS` says which of its fields each zone kind hands on. A
- *   template's `{{stage.<id>.<field>}}` is checked against it when a flow is saved (`stageReferenceProblems`), so a
- *   refusal names the path: `stages[1].instructions: stage.research.unknown is not available`.
- * - `cardOutputsSchema` is what the card keeps: every handoff's fields flat (`<zone>`, `<zone>.items`, `<zone>.report`,
- *   as `{{stage.…}}` names them) and, for a zone whose output was over TEXT_LIMITS.stageOutput, the output whole: its
- *   `{{stage.<zone>}}` says where it is kept, and a task filed after it is given it whole (flowGoalCuts).
- *
- * Saved before this contract (version 0), a card's outputs were the flat map alone; they read exactly as every release
- * read them: the string values, anything else skipped.
- */
-import { z } from "zod";
-import { type ContractIssue, type ContractResult } from "./contract.js";
-import type { FlowDefinition, FlowStage, FlowStageKind } from "./flow.js";
-/** One zone's handoff to the zones after it. */
-export declare const stageHandoffSchema: z.ZodObject<{
-    text: z.ZodString;
-    items: z.ZodOptional<z.ZodString>;
-    report: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type StageHandoff = z.infer<typeof stageHandoffSchema>;
-export type StageField = Exclude<keyof StageHandoff, "text">;
-/**
- * What each zone kind hands on, or null when it hands nothing on (it holds, asks, messages or ends). A sort hands on its
- * decision in words (`sortWords` of the small-answers contract's SortDecision, src/contracts/sort-answer.ts), and a
- * Send to me zone what it sent.
- */
-export declare const STAGE_HANDOFFS: {
-    readonly inbox: null;
-    readonly task: z.ZodObject<{
-        text: z.ZodString;
-    }, z.core.$strict>;
-    readonly report: z.ZodObject<{
-        text: z.ZodString;
-        items: z.ZodOptional<z.ZodString>;
-        report: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    readonly approval: null;
-    readonly check: z.ZodObject<{
-        text: z.ZodString;
-    }, z.core.$strict>;
-    readonly "pull-request": z.ZodObject<{
-        text: z.ZodString;
-    }, z.core.$strict>;
-    readonly update: z.ZodObject<{
-        text: z.ZodString;
-    }, z.core.$strict>;
-    readonly notify: null;
-    readonly sort: z.ZodObject<{
-        text: z.ZodString;
-    }, z.core.$strict>;
-    readonly draft: z.ZodObject<{
-        text: z.ZodString;
-    }, z.core.$strict>;
-    readonly request: z.ZodObject<{
-        text: z.ZodString;
-    }, z.core.$strict>;
-    readonly email: z.ZodObject<{
-        text: z.ZodString;
-    }, z.core.$strict>;
-    readonly tool: z.ZodObject<{
-        text: z.ZodString;
-    }, z.core.$strict>;
-    readonly wait: z.ZodObject<{
-        text: z.ZodString;
-    }, z.core.$strict>;
-    readonly subagent: z.ZodObject<{
-        text: z.ZodString;
-    }, z.core.$strict>;
-    readonly send: z.ZodObject<{
-        text: z.ZodString;
-    }, z.core.$strict>;
-    readonly choose: null;
-    readonly done: null;
-};
-/** The extra `{{stage.<id>.<field>}}` fields a zone kind hands on. */
-export declare function stageFieldsOf(kind: FlowStageKind): StageField[];
-/** One zone's handoff, read from the card's flat outputs (a field it never wrote is left out; no words read as ""). */
-export declare function stageHandoffOf(outputs: Readonly<Record<string, string>>, zone: string): StageHandoff;
-/** The card's flat outputs with one zone's handoff in place of its last: a field this visit didn't hand on is gone, so
- * nothing stale is left behind. */
-export declare function withStageHandoff(outputs: Readonly<Record<string, string>>, zone: string, handoff: StageHandoff): Record<string, string>;
-export declare const CARD_OUTPUTS_VERSION = 1;
-export declare const cardOutputsSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    outputs: z.ZodObject<{}, z.core.$catchall<z.ZodString>>;
-    attached: z.ZodObject<{}, z.core.$catchall<z.ZodString>>;
-}, z.core.$strict>;
-export type CardOutputs = z.infer<typeof cardOutputsSchema>;
-/** Version 0, the flat map every release before wrote: its string values, as they read them; anything else is skipped. */
-export declare function upgradeFlatOutputs(raw: unknown): CardOutputs;
-/**
- * Read a card's outputs. Version 1 as itself and a newer version refused plainly. Anything without a numeric `version`
- * was saved before outputs carried one (a zone may be called `version`; its words were a string), and is read as the
- * flat map it is.
- */
-export declare function readCardOutputs(input: unknown): ContractResult<CardOutputs>;
-/** A card's outputs as the store keeps them: unreadable JSON is the empty card it always was; `newer` is a row a newer
- * Toolroll wrote, which this one reads as empty and never writes over. */
-export declare function cardOutputsFromStore(json: string): {
-    outputs: Record<string, string>;
-    attached: Record<string, string>;
-    issues: ContractIssue[];
-    newer: boolean;
-};
-/** A card's outputs as the store saves them. A zone's attachment is kept only while its output is the pointer to it. */
-export declare function cardOutputsForStore(outputs: Readonly<Record<string, string>>, attached: Readonly<Record<string, string>>): string;
-/** Where a zone's words take fill-ins, by the drawing's path: its instructions and message, a request's address,
- * headers and body, an email's fields and a tool's arguments. */
-export declare function templateFields(stage: FlowStage): {
-    path: string;
-    text: string;
-}[];
-export declare function stageReferences(text: string): string[];
-/** What one `{{stage.…}}` reference can't be, against the drawing: null when its zone hands that field on. */
-export declare function stageReferenceProblem(definition: FlowDefinition, reference: string): string | null;
-/**
- * Template references a save adds that its zones don't hand on, each named by its path
- * (`stages[1].instructions: stage.research.unknown is not available ...`). A reference the flow already had before
- * this save (`previous`, the saved drawing) is never refused, nor is any reference when a flow is only read or run:
- * this checks new and changed words alone.
- */
-export declare function stageReferenceProblems(definition: FlowDefinition, previous: FlowDefinition | null): ContractIssue[];

package/dist/contracts/storage.d.ts

@@ -1,37 +0,0 @@
-/**
- * The checkout cleanup setting (storage.ts, Settings → Storage): when a finished task's clean checkout is removed.
- * One schema for the four values `checkout_cleanup_setting.cleanup` may hold, and `CheckoutCleanup` derived from it.
- * The words a person types ("week", "off", "2 days") become a value in plain code (storage.ts `parseCleanup`) and
- * are then checked by this schema. The saved row is read by the store (item 18's to move onto `checkoutCleanupRowSchema`).
- */
-import { z } from "zod";
-export declare const checkoutCleanupSchema: z.ZodEnum<{
-    "2d": "2d";
-    "7d": "7d";
-    finished: "finished";
-    never: "never";
-}>;
-/** How long a task stays idle before its clean folder goes (v151, checkout-cleanup.ts). A saved row's NULL is the default. */
-export declare const checkoutIdleSchema: z.ZodEnum<{
-    "14d": "14d";
-    "30d": "30d";
-    "7d": "7d";
-    never: "never";
-}>;
-/** A saved `checkout_cleanup_setting` row (at most one; none means the default), unknown columns ignored. */
-export declare const checkoutCleanupRowSchema: z.ZodObject<{
-    cleanup: z.ZodEnum<{
-        "2d": "2d";
-        "7d": "7d";
-        finished: "finished";
-        never: "never";
-    }>;
-    idle: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-        "14d": "14d";
-        "30d": "30d";
-        "7d": "7d";
-        never: "never";
-    }>>>;
-}, z.core.$strip>;
-export type CheckoutCleanup = z.infer<typeof checkoutCleanupSchema>;
-export type CheckoutIdle = z.infer<typeof checkoutIdleSchema>;