@wrenautomation/birdwatch 0.0.0-stage → 0.30.0

package/dist/ledger/records.d.ts

@@ -0,0 +1,1424 @@
+import { z } from "../engine/types.js";
+/** Who wrote a record: a model, a person, or a tool (a source adapter, the engine). */
+export declare const From: z.ZodEnum<{
+    ai: "ai";
+    human: "human";
+    tool: "tool";
+}>;
+export type From = z.infer<typeof From>;
+/** The steps, in order. An edge's `to` names one of the first five. */
+export declare const Step: z.ZodEnum<{
+    check: "check";
+    plan: "plan";
+    fetch: "fetch";
+    triage: "triage";
+    read: "read";
+    extract: "extract";
+    review: "review";
+}>;
+export type Step = z.infer<typeof Step>;
+export declare const STEPS: ("check" | "plan" | "fetch" | "triage" | "read" | "extract" | "review")[];
+export declare const RECORD_TYPES: readonly ["query", "hit", "document", "finding", "verdict", "call", "spend", "snapshot", "edge", "done", "steer", "gap", "check", "pattern", "found", "draft", "class", "dead", "judge", "person"];
+export declare const RecordType: z.ZodEnum<{
+    check: "check";
+    gap: "gap";
+    pattern: "pattern";
+    steer: "steer";
+    verdict: "verdict";
+    person: "person";
+    query: "query";
+    hit: "hit";
+    document: "document";
+    finding: "finding";
+    call: "call";
+    spend: "spend";
+    snapshot: "snapshot";
+    edge: "edge";
+    done: "done";
+    found: "found";
+    draft: "draft";
+    class: "class";
+    dead: "dead";
+    judge: "judge";
+}>;
+export type RecordType = z.infer<typeof RecordType>;
+/** What every record carries. `step` is absent on a record written outside a run's steps (a call by hand). */
+export declare const Envelope: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+}, z.core.$strip>;
+export type Envelope = z.infer<typeof Envelope>;
+/** What a follow lists from a page: its channel's or author's own posts, or pages like it. */
+export declare const FOLLOW_AS: readonly ["posts", "similar", "refs", "citers"];
+export declare const FollowAs: z.ZodEnum<{
+    posts: "posts";
+    similar: "similar";
+    refs: "refs";
+    citers: "citers";
+}>;
+export type FollowAs = z.infer<typeof FollowAs>;
+/** One thing to look for, as the plan step made it; or a follow: a page's own posts, or pages like it. */
+export declare const QueryRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"query">;
+    kind: z.ZodEnum<{
+        video: "video";
+        channel: "channel";
+        web: "web";
+        person: "person";
+        site: "site";
+    }>;
+    why: z.ZodString;
+    site: z.ZodOptional<z.ZodString>;
+    terms: z.ZodString;
+    facet: z.ZodOptional<z.ZodString>;
+    tier: z.ZodOptional<z.ZodNumber>;
+    needs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    follow: z.ZodOptional<z.ZodObject<{
+        url: z.ZodString;
+        as: z.ZodEnum<{
+            posts: "posts";
+            similar: "similar";
+            refs: "refs";
+            citers: "citers";
+        }>;
+        document: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type QueryRecord = z.infer<typeof QueryRecord>;
+/** What a source returned for a query, before any read. One per canonical URL per fetch step. */
+export declare const HitRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"hit">;
+    url: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    channel: z.ZodOptional<z.ZodString>;
+    length: z.ZodOptional<z.ZodNumber>;
+    date: z.ZodOptional<z.ZodString>;
+    snippet: z.ZodOptional<z.ZodString>;
+    sources: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    odds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    key: z.ZodString;
+    queries: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type HitRecord = z.infer<typeof HitRecord>;
+/** A hit read whole. */
+export declare const DocumentRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"document">;
+    url: z.ZodString;
+    media: z.ZodEnum<{
+        html: "html";
+        pdf: "pdf";
+        text: "text";
+        video: "video";
+        audio: "audio";
+    }>;
+    title: z.ZodOptional<z.ZodString>;
+    text: z.ZodString;
+    channel: z.ZodOptional<z.ZodString>;
+    date: z.ZodOptional<z.ZodString>;
+    length: z.ZodOptional<z.ZodNumber>;
+    hit: z.ZodString;
+}, z.core.$strip>;
+export type DocumentRecord = z.infer<typeof DocumentRecord>;
+/** One fact drawn from a document, with its proof, and the document's date when it has one. */
+export declare const FindingRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"finding">;
+    kind: z.ZodString;
+    text: z.ZodString;
+    proof: z.ZodObject<{
+        url: z.ZodString;
+        quote: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodOptional<z.ZodNumber>;
+        frame: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    document: z.ZodString;
+    date: z.ZodOptional<z.ZodString>;
+    fixes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FindingRecord = z.infer<typeof FindingRecord>;
+/**
+ * The extractor's word on a document once its findings are through the gate: how much of the
+ * ask it held, and what the ask still lacks. One per document per extract; the extract step's
+ * checkpoint, and the review's view of what the reads were worth.
+ */
+export declare const VerdictRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"verdict">;
+    quality: z.ZodEnum<{
+        rich: "rich";
+        thin: "thin";
+        off: "off";
+        empty: "empty";
+    }>;
+    gap: z.ZodOptional<z.ZodString>;
+    document: z.ZodString;
+}, z.core.$strip>;
+export type VerdictRecord = z.infer<typeof VerdictRecord>;
+/**
+ * The call: keep or drop, on a hit (read or skip) or a finding, with why. The latest call on a
+ * record is its state. A person's call and a model's are the same row with a different `from`.
+ */
+export declare const CallRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"call">;
+    on: z.ZodString;
+    verdict: z.ZodEnum<{
+        keep: "keep";
+        drop: "drop";
+    }>;
+    why: z.ZodString;
+}, z.core.$strip>;
+export type CallRecord = z.infer<typeof CallRecord>;
+export declare const CostKind: z.ZodEnum<{
+    free: "free";
+    metered: "metered";
+    browser: "browser";
+}>;
+export type CostKind = z.infer<typeof CostKind>;
+/** One use of a source or a model: what it was asked, whether it answered, what it cost. */
+export declare const SpendRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"spend">;
+    source: z.ZodString;
+    op: z.ZodEnum<{
+        ask: "ask";
+        search: "search";
+        open: "open";
+    }>;
+    about: z.ZodString;
+    on: z.ZodOptional<z.ZodString>;
+    ok: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+    retryAfter: z.ZodOptional<z.ZodString>;
+    cost: z.ZodEnum<{
+        free: "free";
+        metered: "metered";
+        browser: "browser";
+    }>;
+    ms: z.ZodNumber;
+    usd: z.ZodOptional<z.ZodNumber>;
+    tokens: z.ZodOptional<z.ZodObject<{
+        input: z.ZodOptional<z.ZodNumber>;
+        output: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SpendRecord = z.infer<typeof SpendRecord>;
+/** What the plan step was given for one round: the ask, the allow-list, the budget, the snapshot. */
+export declare const SnapshotRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"snapshot">;
+    known: z.ZodArray<z.ZodString>;
+    planFile: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodNumber;
+    }, z.core.$strip>;
+    model: z.ZodNullable<z.ZodString>;
+    yieldRows: z.ZodNumber;
+    ask: z.ZodObject<{
+        text: z.ZodString;
+        kind: z.ZodEnum<{
+            video: "video";
+            channel: "channel";
+            web: "web";
+            person: "person";
+            site: "site";
+        }>;
+        known: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        premises: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        steer: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        open: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        criteria: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            question: z.ZodString;
+        }, z.core.$strip>>>;
+        site: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    sources: z.ZodArray<z.ZodString>;
+    opens: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    budget: z.ZodObject<{
+        queries: z.ZodNumber;
+        reads: z.ZodNumber;
+        rounds: z.ZodNumber;
+        checks: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    parent: z.ZodOptional<z.ZodObject<{
+        run: z.ZodString;
+        round: z.ZodNumber;
+        why: z.ZodString;
+    }, z.core.$strip>>;
+    treeReads: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type SnapshotRecord = z.infer<typeof SnapshotRecord>;
+/** The edge taken after a round. */
+export declare const EdgeRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"edge">;
+    why: z.ZodString;
+    next: z.ZodEnum<{
+        stop: "stop";
+        again: "again";
+        back: "back";
+    }>;
+    to: z.ZodOptional<z.ZodEnum<{
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+    }>>;
+}, z.core.$strip>;
+export type EdgeRecord = z.infer<typeof EdgeRecord>;
+/** A step finished (`ok`) or gave up (`ok: false`, `note` says why). Resume reads these. */
+export declare const DoneRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"done">;
+    step: z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>;
+    ok: z.ZodBoolean;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DoneRecord = z.infer<typeof DoneRecord>;
+/**
+ * What the person says to the run: free text, written between rounds (`birdwatch steer`), rendered
+ * first in every prompt of the rounds after it. Always `from: human`; `step` absent.
+ */
+export declare const SteerRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"steer">;
+    text: z.ZodString;
+}, z.core.$strip>;
+export type SteerRecord = z.infer<typeof SteerRecord>;
+/**
+ * What a step or a person says the round lacks, in English: a query with no new hits, a hit no
+ * source could open, a person's word. The round's review reads every gap, and the next round's
+ * plan reads them as what was left open. `step` is the step that wrote it; a person's has none.
+ */
+export declare const GapRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"gap">;
+    note: z.ZodString;
+    on: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GapRecord = z.infer<typeof GapRecord>;
+/**
+ * The sample check's word on one kept finding: does its quote back it? A finding that fails
+ * also gets a drop call, so it leaves what the run has found; a person's keep puts it back.
+ */
+export declare const CheckRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"check">;
+    on: z.ZodString;
+    ok: z.ZodBoolean;
+    why: z.ZodString;
+}, z.core.$strip>;
+export type CheckRecord = z.infer<typeof CheckRecord>;
+/**
+ * What several findings say together, by the agent (or the person): `./document`'s `Pattern`, its
+ * source count computed by code when it is written. The report leads with patterns; a finding
+ * no pattern rests on is a fact on its own. `step` absent: written between steps.
+ */
+export declare const PatternRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"pattern">;
+    text: z.ZodString;
+    findings: z.ZodArray<z.ZodString>;
+    sources: z.ZodNumber;
+}, z.core.$strip>;
+export type PatternRecord = z.infer<typeof PatternRecord>;
+/**
+ * A hit the run already had came back for another query: the hit's record stays one, this says
+ * which other query found it. The brief ranks a hit by how many facets found it.
+ */
+export declare const FoundRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"found">;
+    hit: z.ZodString;
+    query: z.ZodString;
+}, z.core.$strip>;
+export type FoundRecord = z.infer<typeof FoundRecord>;
+/**
+ * A rough synthesis over the run's kept findings and patterns: options, a pick, the gap that
+ * would change it. Each item cites finding or pattern ids, and each number in it is in a cited
+ * finding (the study's draft gate). A draft, never the final: a person or an agent polishes it
+ * outside the ledger.
+ */
+export declare const DraftRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"draft">;
+    for: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        body: z.ZodString;
+        cites: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    dropped: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        why: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type DraftRecord = z.infer<typeof DraftRecord>;
+/** What kind of source a page is. A closed set, so counts per class add up across agents. */
+export declare const SOURCE_CLASSES: readonly ["primary_data", "survey", "practitioner", "vendor", "forum", "news", "other"];
+export declare const SourceClass: z.ZodEnum<{
+    primary_data: "primary_data";
+    survey: "survey";
+    practitioner: "practitioner";
+    vendor: "vendor";
+    forum: "forum";
+    news: "news";
+    other: "other";
+}>;
+export type SourceClass = z.infer<typeof SourceClass>;
+/**
+ * The agent's word on what kind of source a document is, with why. Its findings take the class;
+ * a class on a finding overrides it (a vendor page that quotes a survey). The latest per target
+ * wins. A model never writes one.
+ */
+export declare const ClassRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"class">;
+    on: z.ZodString;
+    class: z.ZodEnum<{
+        primary_data: "primary_data";
+        survey: "survey";
+        practitioner: "practitioner";
+        vendor: "vendor";
+        forum: "forum";
+        news: "news";
+        other: "other";
+    }>;
+    why: z.ZodString;
+}, z.core.$strip>;
+export type ClassRecord = z.infer<typeof ClassRecord>;
+/**
+ * A facet the agent gives up on, with why: thin after its tries. Later tiers and rounds of the
+ * run skip it, and a parent's next plan reads it as a dead end.
+ */
+export declare const DeadRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"dead">;
+    facet: z.ZodString;
+    why: z.ZodString;
+}, z.core.$strip>;
+export type DeadRecord = z.infer<typeof DeadRecord>;
+/**
+ * A judge's answers on one hit, document or finding: each question's label probabilities (a
+ * yes or no as `yes` and `no`). A hint and a router, never a call: the agent or a model decides.
+ * `by` is the judge's model id; its spend carries the cost.
+ */
+export declare const JudgeRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"judge">;
+    on: z.ZodString;
+    answers: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strip>;
+export type JudgeRecord = z.infer<typeof JudgeRecord>;
+/**
+ * One person across platforms, by the agent, with why: the profile URLs (a channel, a Substack,
+ * an X account, a blog) and the names they post under. Signals cluster in people: the brief
+ * counts kept findings per person. The latest per name wins.
+ */
+export declare const PersonRecord: z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"person">;
+    name: z.ZodString;
+    profiles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    aka: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    why: z.ZodString;
+}, z.core.$strip>;
+export type PersonRecord = z.infer<typeof PersonRecord>;
+export declare const LedgerRecord: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"query">;
+    kind: z.ZodEnum<{
+        video: "video";
+        channel: "channel";
+        web: "web";
+        person: "person";
+        site: "site";
+    }>;
+    why: z.ZodString;
+    site: z.ZodOptional<z.ZodString>;
+    terms: z.ZodString;
+    facet: z.ZodOptional<z.ZodString>;
+    tier: z.ZodOptional<z.ZodNumber>;
+    needs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    follow: z.ZodOptional<z.ZodObject<{
+        url: z.ZodString;
+        as: z.ZodEnum<{
+            posts: "posts";
+            similar: "similar";
+            refs: "refs";
+            citers: "citers";
+        }>;
+        document: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"hit">;
+    url: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    channel: z.ZodOptional<z.ZodString>;
+    length: z.ZodOptional<z.ZodNumber>;
+    date: z.ZodOptional<z.ZodString>;
+    snippet: z.ZodOptional<z.ZodString>;
+    sources: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    odds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    key: z.ZodString;
+    queries: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"document">;
+    url: z.ZodString;
+    media: z.ZodEnum<{
+        html: "html";
+        pdf: "pdf";
+        text: "text";
+        video: "video";
+        audio: "audio";
+    }>;
+    title: z.ZodOptional<z.ZodString>;
+    text: z.ZodString;
+    channel: z.ZodOptional<z.ZodString>;
+    date: z.ZodOptional<z.ZodString>;
+    length: z.ZodOptional<z.ZodNumber>;
+    hit: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"finding">;
+    kind: z.ZodString;
+    text: z.ZodString;
+    proof: z.ZodObject<{
+        url: z.ZodString;
+        quote: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodOptional<z.ZodNumber>;
+        frame: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    document: z.ZodString;
+    date: z.ZodOptional<z.ZodString>;
+    fixes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"verdict">;
+    quality: z.ZodEnum<{
+        rich: "rich";
+        thin: "thin";
+        off: "off";
+        empty: "empty";
+    }>;
+    gap: z.ZodOptional<z.ZodString>;
+    document: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"call">;
+    on: z.ZodString;
+    verdict: z.ZodEnum<{
+        keep: "keep";
+        drop: "drop";
+    }>;
+    why: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"spend">;
+    source: z.ZodString;
+    op: z.ZodEnum<{
+        ask: "ask";
+        search: "search";
+        open: "open";
+    }>;
+    about: z.ZodString;
+    on: z.ZodOptional<z.ZodString>;
+    ok: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+    retryAfter: z.ZodOptional<z.ZodString>;
+    cost: z.ZodEnum<{
+        free: "free";
+        metered: "metered";
+        browser: "browser";
+    }>;
+    ms: z.ZodNumber;
+    usd: z.ZodOptional<z.ZodNumber>;
+    tokens: z.ZodOptional<z.ZodObject<{
+        input: z.ZodOptional<z.ZodNumber>;
+        output: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"snapshot">;
+    known: z.ZodArray<z.ZodString>;
+    planFile: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodNumber;
+    }, z.core.$strip>;
+    model: z.ZodNullable<z.ZodString>;
+    yieldRows: z.ZodNumber;
+    ask: z.ZodObject<{
+        text: z.ZodString;
+        kind: z.ZodEnum<{
+            video: "video";
+            channel: "channel";
+            web: "web";
+            person: "person";
+            site: "site";
+        }>;
+        known: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        premises: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        steer: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        open: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        criteria: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            question: z.ZodString;
+        }, z.core.$strip>>>;
+        site: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    sources: z.ZodArray<z.ZodString>;
+    opens: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    budget: z.ZodObject<{
+        queries: z.ZodNumber;
+        reads: z.ZodNumber;
+        rounds: z.ZodNumber;
+        checks: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    parent: z.ZodOptional<z.ZodObject<{
+        run: z.ZodString;
+        round: z.ZodNumber;
+        why: z.ZodString;
+    }, z.core.$strip>>;
+    treeReads: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"edge">;
+    why: z.ZodString;
+    next: z.ZodEnum<{
+        stop: "stop";
+        again: "again";
+        back: "back";
+    }>;
+    to: z.ZodOptional<z.ZodEnum<{
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"done">;
+    step: z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>;
+    ok: z.ZodBoolean;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"steer">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"gap">;
+    note: z.ZodString;
+    on: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"check">;
+    on: z.ZodString;
+    ok: z.ZodBoolean;
+    why: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"pattern">;
+    text: z.ZodString;
+    findings: z.ZodArray<z.ZodString>;
+    sources: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"found">;
+    hit: z.ZodString;
+    query: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"draft">;
+    for: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        body: z.ZodString;
+        cites: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    dropped: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        why: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"class">;
+    on: z.ZodString;
+    class: z.ZodEnum<{
+        primary_data: "primary_data";
+        survey: "survey";
+        practitioner: "practitioner";
+        vendor: "vendor";
+        forum: "forum";
+        news: "news";
+        other: "other";
+    }>;
+    why: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"dead">;
+    facet: z.ZodString;
+    why: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"judge">;
+    on: z.ZodString;
+    answers: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    run: z.ZodString;
+    round: z.ZodNumber;
+    step: z.ZodOptional<z.ZodEnum<{
+        check: "check";
+        plan: "plan";
+        fetch: "fetch";
+        triage: "triage";
+        read: "read";
+        extract: "extract";
+        review: "review";
+    }>>;
+    at: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+        tool: "tool";
+    }>;
+    by: z.ZodString;
+    type: z.ZodLiteral<"person">;
+    name: z.ZodString;
+    profiles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    aka: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    why: z.ZodString;
+}, z.core.$strip>], "type">;
+export type LedgerRecord = z.infer<typeof LedgerRecord>;
+/** A record of one type. */
+export type RecordOf<T extends RecordType> = Extract<LedgerRecord, {
+    type: T;
+}>;
+/** Time, then id: two writers' clocks can tie. */
+export declare function byTime(a: Pick<Envelope, "at" | "id">, b: Pick<Envelope, "at" | "id">): number;