toolroll 0.9.103 → 0.9.105

package/dist/contracts/mcp-oauth.d.ts

@@ -1,53 +0,0 @@
-/**
- * MCP sign-in (mcp-oauth.ts): what an MCP client may send when it registers itself (RFC 7591) and when it trades a
- * code or a refresh secret for tokens (RFC 6749 §4.1.3, §6, with PKCE, RFC 7636).
- *
- * A registration is read strictly for the fields Toolroll uses and ignores the rest (RFC 7591 §2: unknown metadata
- * is ignored). Only public clients register: no secret is issued, so `token_endpoint_auth_method` is `none` when
- * given. Whether a redirect is https, or http on 127.0.0.1 / [::1], is checked by mcp-oauth.ts after reading.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-/** The most redirects one client registers, and how long each and the client's name may be. */
-export declare const OAUTH_LIMITS: {
-    readonly redirects: 5;
-    readonly redirect: 512;
-    readonly name: 100;
-};
-export declare const OAUTH_GRANTS: readonly ["authorization_code", "refresh_token"];
-export declare const oauthRegistrationSchema: z.ZodObject<{
-    redirect_uris: z.ZodArray<z.ZodString>;
-    client_name: z.ZodOptional<z.ZodString>;
-    token_endpoint_auth_method: z.ZodOptional<z.ZodLiteral<"none">>;
-    grant_types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        authorization_code: "authorization_code";
-        refresh_token: "refresh_token";
-    }>>>;
-    response_types: z.ZodOptional<z.ZodArray<z.ZodLiteral<"code">>>;
-}, z.core.$strip>;
-/** A PKCE verifier (RFC 7636 §4.1) and a S256 challenge (43 base64url characters). */
-export declare const PKCE_VERIFIER: RegExp;
-export declare const PKCE_CHALLENGE: RegExp;
-/** A token request, by grant type. Every value is one form field. */
-export declare const oauthTokenRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    grant_type: z.ZodLiteral<"authorization_code">;
-    code: z.ZodString;
-    redirect_uri: z.ZodString;
-    client_id: z.ZodString;
-    code_verifier: z.ZodString;
-    resource: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    grant_type: z.ZodLiteral<"refresh_token">;
-    refresh_token: z.ZodString;
-    client_id: z.ZodString;
-    resource: z.ZodOptional<z.ZodString>;
-    scope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>], "grant_type">;
-export type OAuthRegistration = z.infer<typeof oauthRegistrationSchema>;
-export type OAuthTokenRequest = z.infer<typeof oauthTokenRequestSchema>;
-export declare const readOAuthRegistration: (input: unknown) => ContractResult<OAuthRegistration>;
-/** A token request's form: a field given twice is refused (RFC 6749 §3.2); fields this grant doesn't take are ignored. */
-export declare function readOAuthTokenRequest(form: URLSearchParams): ContractResult<OAuthTokenRequest> | {
-    ok: false;
-    repeated: true;
-};

package/dist/contracts/memory-pass.d.ts

@@ -1,157 +0,0 @@
-/**
- * The memory pass (memory-pass.ts): one schema for the verdict a model returns on one session — the analyser's
- * `--json-schema` (Codex's output schema), with a tolerant read side for older answers — the verdict each session keeps
- * (`memory_session.verdict`), and a proposal with its evidence (`memory_proposal`). What JSON Schema cannot state —
- * a quote really in the trace, an instruction id on the surface audited — is checked in plain code after parsing.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-export declare const MEMORY_EFFECTS: readonly ["harm", "non-compliance", "irrelevant"];
-export declare const MEMORY_DOMAINS: readonly ["project", "orchestration"];
-export declare const MEMORY_PROPOSAL_KINDS: readonly ["instruction-add", "instruction-remove", "decision-add"];
-/** The verdict a model returns on one session. */
-export declare const memoryVerdictSchema: z.ZodObject<{
-    positive: z.ZodArray<z.ZodObject<{
-        instruction: z.ZodString;
-        effect: z.ZodString;
-        quote: z.ZodString;
-    }, z.core.$strict>>;
-    negative: z.ZodArray<z.ZodObject<{
-        instruction: z.ZodString;
-        effect: z.ZodString;
-        class: z.ZodEnum<{
-            harm: "harm";
-            irrelevant: "irrelevant";
-            "non-compliance": "non-compliance";
-        }>;
-        quote: z.ZodString;
-    }, z.core.$strict>>;
-    gaps: z.ZodArray<z.ZodObject<{
-        mistake: z.ZodString;
-        proposedInstruction: z.ZodString;
-        domain: z.ZodEnum<{
-            orchestration: "orchestration";
-            project: "project";
-        }>;
-        quote: z.ZodString;
-        matchesGap: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-/** What the analyser is told to return: `--json-schema` for Claude, the output schema for Codex, and the prompt for
- * every other provider. */
-export declare const MEMORY_VERDICT_MODEL_SCHEMA: Record<string, unknown>;
-export type Verdict = z.infer<typeof memoryVerdictSchema>;
-export declare const memoryVerdictReadSchema: z.ZodObject<{
-    positive: z.ZodCatch<z.ZodArray<z.ZodCatch<z.ZodNullable<z.ZodPipe<z.ZodObject<{
-        quote: z.ZodString;
-    }, z.core.$loose>, z.ZodTransform<{
-        quote: string;
-        claim: {
-            quote: string;
-            instruction: string;
-            effect: string;
-        } | null;
-    }, {
-        [x: string]: unknown;
-        quote: string;
-    }>>>>>>;
-    negative: z.ZodCatch<z.ZodArray<z.ZodCatch<z.ZodNullable<z.ZodPipe<z.ZodObject<{
-        quote: z.ZodString;
-    }, z.core.$loose>, z.ZodTransform<{
-        quote: string;
-        claim: {
-            quote: string;
-            instruction: string;
-            effect: string;
-            class: "harm" | "irrelevant" | "non-compliance";
-        } | null;
-    }, {
-        [x: string]: unknown;
-        quote: string;
-    }>>>>>>;
-    gaps: z.ZodCatch<z.ZodArray<z.ZodCatch<z.ZodNullable<z.ZodPipe<z.ZodObject<{
-        quote: z.ZodString;
-    }, z.core.$loose>, z.ZodTransform<{
-        quote: string;
-        claim: {
-            quote: string;
-            mistake: string;
-            proposedInstruction: string;
-            domain: "orchestration" | "project";
-            matchesGap: string | null;
-        } | null;
-    }, {
-        [x: string]: unknown;
-        quote: string;
-    }>>>>>>;
-}, z.core.$strip>;
-export declare const MEMORY_VERDICT_VERSION = 1;
-/** A verdict as a session keeps it. */
-export declare const savedVerdictSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    positive: z.ZodArray<z.ZodObject<{
-        instruction: z.ZodString;
-        effect: z.ZodString;
-        quote: z.ZodString;
-    }, z.core.$strict>>;
-    negative: z.ZodArray<z.ZodObject<{
-        instruction: z.ZodString;
-        effect: z.ZodString;
-        class: z.ZodEnum<{
-            harm: "harm";
-            irrelevant: "irrelevant";
-            "non-compliance": "non-compliance";
-        }>;
-        quote: z.ZodString;
-    }, z.core.$strict>>;
-    gaps: z.ZodArray<z.ZodObject<{
-        mistake: z.ZodString;
-        proposedInstruction: z.ZodString;
-        domain: z.ZodEnum<{
-            orchestration: "orchestration";
-            project: "project";
-        }>;
-        quote: z.ZodString;
-        matchesGap: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type SavedVerdict = z.infer<typeof savedVerdictSchema>;
-/**
- * A verdict kept before it carried `version` (through 0.9.36), as version 1. Those left a gap's `matchesGap` out when
- * there was none; that reads as null. Values are never rewritten.
- */
-export declare function upgradeVerdictV0(body: Record<string, unknown>): Record<string, unknown>;
-export declare const MEMORY_VERDICT_UPGRADES: {
-    readonly 0: typeof upgradeVerdictV0;
-};
-/** Read a kept verdict: version 1 as itself, an unversioned one upgraded, a newer one refused plainly. */
-export declare function readSavedVerdict(input: unknown): ContractResult<SavedVerdict>;
-/** One corroborating sighting: the session and its verbatim quote. A proposal keeps at most six. */
-export declare const memoryEvidenceSchema: z.ZodArray<z.ZodObject<{
-    session: z.ZodString;
-    quote: z.ZodString;
-}, z.core.$strict>>;
-/** A proposal as its row reads; its evidence is a JSON list (an older runtime reads it as one, so it has no envelope). */
-export declare const memoryProposalSchema: z.ZodObject<{
-    id: z.ZodInt;
-    repo: z.ZodString;
-    kind: z.ZodEnum<{
-        "decision-add": "decision-add";
-        "instruction-add": "instruction-add";
-        "instruction-remove": "instruction-remove";
-    }>;
-    fingerprint: z.ZodString;
-    title: z.ZodString;
-    rationale: z.ZodString;
-    beforeText: z.ZodNullable<z.ZodString>;
-    afterText: z.ZodString;
-    evidence: z.ZodArray<z.ZodObject<{
-        session: z.ZodString;
-        quote: z.ZodString;
-    }, z.core.$strict>>;
-    sessions: z.ZodInt;
-    status: z.ZodString;
-    createdAt: z.ZodString;
-    surface: z.ZodString;
-}, z.core.$strict>;
-export type MemoryProposal = z.infer<typeof memoryProposalSchema>;

package/dist/contracts/model-catalog.d.ts

@@ -1,21 +0,0 @@
-/**
- * What the model catalog (model-catalog.ts) reads from outside Toolroll: the Codex CLI's own model list
- * (`~/.codex/models_cache.json`) and npm's latest-version answer for each agent CLI. Both belong to someone else, so
- * both are read loosely: unknown keys are ignored, an entry that doesn't fit is skipped, and a file or answer that
- * doesn't fit at all reads as nothing (an empty list, no version) — never an error.
- */
-import { z } from "zod";
-/** One listed Codex model: a usable id, shown in the picker. Its display name is used when it is text. */
-export declare const codexModelSchema: z.ZodObject<{
-    slug: z.ZodString;
-    visibility: z.ZodLiteral<"list">;
-    display_name: z.ZodOptional<z.ZodUnknown>;
-}, z.core.$strip>;
-/** The Codex cache file: its `models` list, entries read one by one with `codexModelSchema`. */
-export declare const codexModelsCacheSchema: z.ZodObject<{
-    models: z.ZodArray<z.ZodUnknown>;
-}, z.core.$strip>;
-/** npm's `/<package>/latest` answer: a version starting with major.minor.patch. */
-export declare const npmLatestSchema: z.ZodObject<{
-    version: z.ZodString;
-}, z.core.$strip>;

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

@@ -1,37 +0,0 @@
-/**
- * A focused observation request (observations.ts `parseObservationCases`): the file a builder writes to ask for one to
- * four focused test runs, each naming a criterion, base or head, one test file and one test name.
- *
- * Toolroll defines this request, so it is strict: an unknown key, at the top or in an observation, is refused, as it
- * always was. It must say `version: 1`, as it always had to: a request without `version`, or with any other version, is
- * refused. What JSON Schema can't say —
- * a criterion the brief asked about, a normalized test path, a usable test name, one distinct observation per
- * criterion — is checked after parsing.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-export declare const observationCaseSchema: z.ZodObject<{
-    criterion: z.ZodString;
-    at: z.ZodEnum<{
-        base: "base";
-        head: "head";
-    }>;
-    testPath: z.ZodString;
-    testName: z.ZodString;
-}, z.core.$strict>;
-export declare const observationRequestSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    observations: z.ZodArray<z.ZodObject<{
-        criterion: z.ZodString;
-        at: z.ZodEnum<{
-            base: "base";
-            head: "head";
-        }>;
-        testPath: z.ZodString;
-        testName: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type ObservationCase = z.infer<typeof observationCaseSchema>;
-export type ObservationRequest = z.infer<typeof observationRequestSchema>;
-/** A parsed request (JSON already read). Only version 1 is read; there is no earlier version to upgrade. */
-export declare function readObservationRequest(input: unknown): ContractResult<ObservationRequest>;

package/dist/contracts/plan.d.ts

@@ -1,58 +0,0 @@
-/**
- * The planner's handoff: one schema for the file a planner writes, the JSON Schema it is given (`--json-schema`) and
- * the parser that reads it back (`parsePlan` in plan.ts). The rules JSON Schema cannot state — the plan document's
- * sections, UTF-8 byte limits, control characters, duplicate criterion ids, the Proof naming every criterion and the
- * silent-amendment contract check — run in plain code after parsing, each with a named error.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-/** How many paths a plan may say it touches. */
-export declare const PLAN_TOUCHES = 32;
-/** One acceptance criterion: the scope's own shape (scope.ts `AcceptanceCriterion`), `how` advisory and unsigned. */
-export declare const acceptanceCriterionSchema: 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>;
-export declare const PLAN_VERSION = 1;
-export declare const planSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    goal: z.ZodString;
-    outOfScope: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    touches: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    acceptance: 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>>;
-    plan: z.ZodString;
-    amendment: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strict>;
-export type PlanPayload = z.infer<typeof planSchema>;
-/** What the planner's `--json-schema` is: the plan schema, exactly. */
-export declare const PLAN_MODEL_SCHEMA: Readonly<Record<string, unknown>>;
-/**
- * A plan written before plans carried `version` (every plan through 0.9.33), as version 1. The old parser read only
- * the fields it knew and ignored any others, read a null goal, plan or acceptance as missing and null touches as
- * none; this keeps exactly that, so every plan that parsed then parses now. Values themselves are never rewritten.
- */
-export declare function upgradeUnversionedPlan(body: Record<string, unknown>): Record<string, unknown>;
-export declare const PLAN_UPGRADES: {
-    readonly 0: typeof upgradeUnversionedPlan;
-};
-/** The payload as version 1, upgraded when it was saved unversioned; null for anything that is not an object. */
-export declare function planPayloadBody(input: unknown): Record<string, unknown> | null;
-/** Read a plan payload: version 1 as itself, an unversioned one upgraded, a newer one refused plainly. */
-export declare function readPlanPayload(input: unknown): ContractResult<PlanPayload>;

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

@@ -1,159 +0,0 @@
-/**
- * Project knowledge (project-knowledge.ts): one schema for the saved knowledge (instructions and references, every
- * revision in `knowledge_change` and the current one in `project_knowledge`), and for the selection a run is given and
- * keeps (`knowledge_snapshot`). The rules JSON Schema cannot state — UTF-8 byte limits, control characters, secrets,
- * the selection's total size — run in plain code when knowledge is written. A saved payload's digest is checked
- * against its stored bytes before it is parsed, and it is upgraded only in memory: stored bytes are never rewritten.
- */
-import { z } from "zod";
-import type { RepositoryContext } from "../repository-context.js";
-import { type ContractResult } from "./contract.js";
-/** How many references a project keeps, and how many a run is given. Text limits live in TEXT_LIMITS. */
-export declare const KNOWLEDGE_COUNTS: {
-    readonly references: 12;
-    readonly selected: 3;
-    readonly decisions: 8;
-};
-export declare const KNOWLEDGE_VERSION = 1;
-/** Knowledge as it is written. */
-export declare const knowledgeSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    instructions: z.ZodString;
-    references: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        title: z.ZodString;
-        content: z.ZodString;
-        path: z.ZodNullable<z.ZodString>;
-        sourceSha: z.ZodNullable<z.ZodString>;
-        sourceRevision: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-/** Knowledge as it is read back. */
-export declare const savedKnowledgeSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    instructions: z.ZodString;
-    references: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        title: z.ZodString;
-        content: z.ZodString;
-        path: z.ZodNullable<z.ZodString>;
-        sourceSha: z.ZodNullable<z.ZodString>;
-        sourceRevision: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-/** Knowledge as every reader returns it: the payload without its envelope. */
-export type Knowledge = Omit<z.infer<typeof knowledgeSchema>, "version">;
-export type KnowledgeReference = Knowledge["references"][number];
-/**
- * Knowledge saved before it carried `version` (through 0.9.36: `{instructions, references}`), as version 1. Its
- * readers took the fields they knew, so this keeps exactly those; values are never rewritten.
- */
-export declare function upgradeKnowledgeV0(body: Record<string, unknown>): Record<string, unknown>;
-export declare const KNOWLEDGE_UPGRADES: {
-    readonly 0: typeof upgradeKnowledgeV0;
-};
-/** Read saved knowledge: version 1 as itself, an unversioned one upgraded, a newer one refused plainly. */
-export declare function readKnowledge(input: unknown): ContractResult<Knowledge>;
-/** What a person drafts on the Knowledge page or the CLI; each action reads the fields it needs. */
-export declare const knowledgeDraftSchema: z.ZodObject<{
-    instructions: z.ZodOptional<z.ZodString>;
-    title: z.ZodOptional<z.ZodString>;
-    content: z.ZodOptional<z.ZodString>;
-    path: z.ZodOptional<z.ZodString>;
-    id: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type KnowledgeDraft = z.infer<typeof knowledgeDraftSchema>;
-/** A source a run was not given, and why. */
-export declare const knowledgeOmissionSchema: z.ZodObject<{
-    title: z.ZodString;
-    reason: z.ZodString;
-}, z.core.$strict>;
-/** Version 2 (docs/plans/learning-loops.md, "Versioned snapshots"): a selection says when it was frozen, and its decision
- * lines their revision. Version 1 stays readable exactly as it was frozen, its fields as they are. */
-export declare const KNOWLEDGE_SELECTION_VERSION = 2;
-/** The selection a run is given, as it is frozen. The keys are in the order a selection has always been written. */
-export declare const knowledgeSelectionSchema: z.ZodObject<{
-    version: z.ZodLiteral<2>;
-    revision: z.ZodInt;
-    instructions: z.ZodString;
-    references: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        title: z.ZodString;
-        content: z.ZodString;
-        path: z.ZodNullable<z.ZodString>;
-        sourceSha: z.ZodNullable<z.ZodString>;
-        sourceRevision: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>;
-    omitted: z.ZodArray<z.ZodObject<{
-        title: z.ZodString;
-        reason: z.ZodString;
-    }, z.core.$strict>>;
-    inheritedFrom: z.ZodNullable<z.ZodInt>;
-    decisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodInt;
-        claim: z.ZodString;
-        decidedAt: z.ZodString;
-        revision: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>>>;
-    repository: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
-    capturedAt: z.ZodString;
-}, z.core.$strict>;
-/** A frozen selection as it is read back: the version it was frozen under. */
-export declare const savedKnowledgeSelectionSchema: z.ZodObject<{
-    version: z.ZodLiteral<2>;
-    revision: z.ZodInt;
-    instructions: z.ZodString;
-    references: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        title: z.ZodString;
-        content: z.ZodString;
-        path: z.ZodNullable<z.ZodString>;
-        sourceSha: z.ZodNullable<z.ZodString>;
-        sourceRevision: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>;
-    omitted: z.ZodArray<z.ZodObject<{
-        title: z.ZodString;
-        reason: z.ZodString;
-    }, z.core.$strict>>;
-    inheritedFrom: z.ZodNullable<z.ZodInt>;
-    decisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodInt;
-        claim: z.ZodString;
-        decidedAt: z.ZodString;
-        revision: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>>>;
-    repository: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
-    capturedAt: z.ZodString;
-}, z.core.$strict>;
-export declare const savedKnowledgeSelectionV1Schema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    revision: z.ZodInt;
-    instructions: z.ZodString;
-    references: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        title: z.ZodString;
-        content: z.ZodString;
-        path: z.ZodNullable<z.ZodString>;
-        sourceSha: z.ZodNullable<z.ZodString>;
-        sourceRevision: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>;
-    omitted: z.ZodArray<z.ZodObject<{
-        title: z.ZodString;
-        reason: z.ZodString;
-    }, z.core.$strict>>;
-    inheritedFrom: z.ZodNullable<z.ZodInt>;
-    decisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodInt;
-        claim: z.ZodString;
-        decidedAt: z.ZodString;
-        revision: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>>>;
-    repository: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
-}, z.core.$strict>;
-export type KnowledgeSelection = Omit<z.infer<typeof knowledgeSelectionSchema>, "repository" | "version" | "capturedAt"> & {
-    version: 1 | 2;
-    capturedAt?: string;
-    repository?: RepositoryContext;
-};
-/** Read a frozen selection: version 1 and 2 each as themselves, a newer one refused plainly. */
-export declare function readKnowledgeSelection(input: unknown): ContractResult<KnowledgeSelection>;

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

@@ -1,119 +0,0 @@
-/**
- * Project memory's decisions (project-memory.ts): one schema for a decision as its row reads, the record its history
- * keeps, the change a person or the lead drafts, and the one line a brief carries. The rules JSON Schema cannot state —
- * UTF-8 byte limits, blank text, control characters and secrets — run in plain code (`clean`) when a decision is
- * written; a row is read as it was written, and its digest is checked against the row before anything trusts it.
- */
-import { z } from "zod";
-export declare const DECISION_STATUSES: readonly ["active", "superseded", "retired"];
-export declare const DECISION_SOURCES: readonly ["conversation", "task", "result", "manual", "backward-pass"];
-/** A decision as it is recorded, in the order its digest lists the fields. */
-export declare const decisionRecordSchema: z.ZodObject<{
-    repo: z.ZodString;
-    revision: z.ZodInt;
-    claim: z.ZodString;
-    why: z.ZodString;
-    status: z.ZodEnum<{
-        active: "active";
-        retired: "retired";
-        superseded: "superseded";
-    }>;
-    supersedes: z.ZodNullable<z.ZodInt>;
-    decidedBy: z.ZodString;
-    decidedAt: z.ZodString;
-    sourceKind: z.ZodEnum<{
-        "backward-pass": "backward-pass";
-        conversation: "conversation";
-        manual: "manual";
-        result: "result";
-        task: "task";
-    }>;
-    sourceRef: z.ZodNullable<z.ZodString>;
-    recordedBy: z.ZodString;
-}, z.core.$strict>;
-/** A decision as its row reads. */
-export declare const decisionSchema: z.ZodObject<{
-    repo: z.ZodString;
-    revision: z.ZodInt;
-    claim: z.ZodString;
-    why: z.ZodString;
-    status: z.ZodEnum<{
-        active: "active";
-        retired: "retired";
-        superseded: "superseded";
-    }>;
-    supersedes: z.ZodNullable<z.ZodInt>;
-    decidedBy: z.ZodString;
-    decidedAt: z.ZodString;
-    sourceKind: z.ZodEnum<{
-        "backward-pass": "backward-pass";
-        conversation: "conversation";
-        manual: "manual";
-        result: "result";
-        task: "task";
-    }>;
-    sourceRef: z.ZodNullable<z.ZodString>;
-    recordedBy: z.ZodString;
-    id: z.ZodInt;
-}, z.core.$strict>;
-export type Decision = z.infer<typeof decisionSchema>;
-export type DecisionRecord = z.infer<typeof decisionRecordSchema>;
-/** What a person or the lead asks to record; only the choice and its reason are required. */
-export declare const decisionDraftSchema: z.ZodObject<{
-    claim: z.ZodString;
-    why: z.ZodString;
-    decidedBy: z.ZodOptional<z.ZodString>;
-    decidedAt: z.ZodOptional<z.ZodString>;
-    sourceKind: z.ZodOptional<z.ZodEnum<{
-        "backward-pass": "backward-pass";
-        conversation: "conversation";
-        manual: "manual";
-        result: "result";
-        task: "task";
-    }>>;
-    sourceRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    supersedes: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
-}, z.core.$strict>;
-export type DecisionDraft = z.infer<typeof decisionDraftSchema>;
-/** One decision in a brief: its id, the choice and when (the revision on snapshots from version 2 on); the why loads on
- * demand by id. */
-export declare const decisionLineSchema: z.ZodObject<{
-    id: z.ZodInt;
-    claim: z.ZodString;
-    decidedAt: z.ZodString;
-    revision: z.ZodOptional<z.ZodInt>;
-}, z.core.$strict>;
-export type DecisionLine = z.infer<typeof decisionLineSchema>;
-export declare const DECISION_CHANGE_VERSION = 1;
-/**
- * One entry of a decision's history (`decision_change.payload`): the record when it was made, or the reason its status
- * changed. Entries written before this carried `version` are the same shapes without it; nothing reads them back.
- */
-export declare const decisionChangeSchema: z.ZodUnion<readonly [z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    repo: z.ZodString;
-    revision: z.ZodInt;
-    claim: z.ZodString;
-    why: z.ZodString;
-    status: z.ZodEnum<{
-        active: "active";
-        retired: "retired";
-        superseded: "superseded";
-    }>;
-    supersedes: z.ZodNullable<z.ZodInt>;
-    decidedBy: z.ZodString;
-    decidedAt: z.ZodString;
-    sourceKind: z.ZodEnum<{
-        "backward-pass": "backward-pass";
-        conversation: "conversation";
-        manual: "manual";
-        result: "result";
-        task: "task";
-    }>;
-    sourceRef: z.ZodNullable<z.ZodString>;
-    recordedBy: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    reason: z.ZodString;
-}, z.core.$strict>]>;
-export type DecisionChange = z.infer<typeof decisionChangeSchema>;