@wrenautomation/raven 0.0.0-stage → 0.1.0

package/dist/plans/index.js

@@ -0,0 +1,196 @@
+/**
+ * The default plan file per ask kind. A copy of one, tuned and stored beside a ledger, is how
+ * a run learns: the recipe changes, raven does not. `raven plans <kind>` prints one to start from.
+ */
+import { PlanFile as PlanFileShape } from "../types.js";
+const SHAPE_QUERIES = `Return ONLY a JSON object, no prose, exactly this shape:
+{"queries": [{"terms": "...", "why": "..."}]}`;
+const SHAPE_HITS = `Return ONLY a JSON object, no prose, exactly this shape:
+{"hits": [{"url": "...", "read": true, "why": "..."}]}`;
+const SHAPE_EDGE = `Return ONLY a JSON object, no prose, exactly this shape:
+{"next": "stop", "why": "..."}
+where "next" is "stop", "again" (a new round from plan) or "back" (rerun one step of this round, named in "to": "plan", "fetch", "read" or "extract").`;
+const CONTEXT = `Ask: {ask}
+Known already (look past these):
+{known}
+What yielded before (hits, reads, proposed, kept):
+{yield}`;
+const TRIAGE_RULES = `- One entry per hit, with its url as given. Mark "read": true for at most {n}.
+- Read a hit when what it shows for free (title, snippet, channel, length, date) says it holds what the ask needs and is not known already.
+- A hit returned by more than one source is a good sign, not a duplicate.
+- "why" is one short line a person reads to agree or not.`;
+const REVIEW = `You decide what happens after one round of research.
+
+${SHAPE_EDGE}
+
+Rules:
+- "stop" when the found lines answer the ask, or when another round would likely add nothing.
+- "again" when the ask is still open and new queries could find more. Say what to look for next in "why".
+- "back" when one step of this round failed for a reason a rerun fixes (a source was down, reads timed out). Name the step in "to".
+- "why" is one short line a person reads to agree or not.
+
+Ask: {ask}
+Round {round} of at most {rounds}. Hits {hits}, reads {reads}, findings proposed {proposed}, kept {kept}.
+Found:
+{found}
+Notes:
+{notes}`;
+const web = {
+    id: "raven/web",
+    kind: "web",
+    version: 1,
+    propose: `You plan web searches for one research ask.
+
+${SHAPE_QUERIES}
+
+Rules:
+- At most {n} queries, each 3 to 10 words, as a person types into a search engine.
+- Each query finds a different kind of source: a survey or benchmark with numbers, a trade publication or industry association, people in the field talking (forums, Reddit, reviews), a government statistic.
+- "why" says in one short line what the query would add that is not known yet.
+- Put a year in a query only when fresh numbers matter. This year is {year}.
+- No site: operators. Quotes only around a phrase that must match exactly.
+
+${CONTEXT}`,
+    triage: `You decide which search hits to read for one research ask. A read costs time; a skip costs nothing.
+
+${SHAPE_HITS}
+
+Rules:
+${TRIAGE_RULES}
+- Prefer primary sources and people in the field over listicles and aggregators.
+
+${CONTEXT}
+Hits:
+{hits}`,
+    review: REVIEW,
+    sources: ["searxng", "exa", "google"],
+    budget: { queries: 3, reads: 6, rounds: 3 },
+};
+const video = {
+    id: "raven/video",
+    kind: "video",
+    version: 1,
+    propose: `You plan video searches for one research ask: talks, walkthroughs, interviews and reviews on YouTube and podcast feeds.
+
+${SHAPE_QUERIES}
+
+Rules:
+- At most {n} queries, each 2 to 8 words, as a person types into a video search box.
+- Each query reaches a different kind of speaker: a practitioner showing their work, a conference talk, an interview or podcast, a critic or reviewer.
+- "why" says in one short line what the query would add that is not known yet.
+- This year is {year}; add it only when the topic moves fast.
+
+${CONTEXT}`,
+    triage: `You decide which videos to read (transcript and screen) for one research ask. A read costs minutes per video; a skip costs nothing.
+
+${SHAPE_HITS}
+
+Rules:
+${TRIAGE_RULES}
+- Length is in seconds. Skip a clip under 60 seconds unless the ask is about short-form video. Prefer 5 to 60 minutes.
+- A channel that yielded nothing before is a reason to skip.
+
+${CONTEXT}
+Hits:
+{hits}`,
+    review: REVIEW,
+    sources: ["youtube", "podcasts"],
+    budget: { queries: 3, reads: 4, rounds: 2 },
+};
+const channel = {
+    id: "raven/channel",
+    kind: "channel",
+    version: 1,
+    propose: `You plan searches that find the people and channels worth following for one research ask: creators, newsletters, podcasts, forums.
+
+${SHAPE_QUERIES}
+
+Rules:
+- At most {n} queries, each 3 to 10 words.
+- Each query finds a different kind of channel: a creator on video, a writer or newsletter, a podcast, a community.
+- "why" says in one short line what the query would add that is not known yet.
+
+${CONTEXT}`,
+    triage: `You decide which channel pages to read for one research ask: a profile, an about page, a feed. A read costs time; a skip costs nothing.
+
+${SHAPE_HITS}
+
+Rules:
+${TRIAGE_RULES}
+- Prefer the channel's own page over a page about it.
+
+${CONTEXT}
+Hits:
+{hits}`,
+    review: REVIEW,
+    sources: ["searxng", "youtube", "exa"],
+    budget: { queries: 3, reads: 6, rounds: 2 },
+};
+const person = {
+    id: "raven/person",
+    kind: "person",
+    version: 1,
+    propose: `You plan searches about one person or company for one research ask: what they do, what they said, what others say about them.
+
+${SHAPE_QUERIES}
+
+Rules:
+- At most {n} queries, each 3 to 10 words. Name the person or company in each, as written in the ask.
+- Each query finds a different kind of page: their own site or profile, an interview or talk, press or reviews, a filing or directory.
+- "why" says in one short line what the query would add that is not known yet.
+- No site: operators.
+
+${CONTEXT}`,
+    triage: `You decide which pages about one person or company to read for one research ask. A read costs time; a skip costs nothing.
+
+${SHAPE_HITS}
+
+Rules:
+${TRIAGE_RULES}
+- Skip a page about a different person or company with the same name.
+- Prefer what they wrote or said over what a directory copied.
+
+${CONTEXT}
+Hits:
+{hits}`,
+    review: REVIEW,
+    sources: ["searxng", "exa", "linkedin", "google"],
+    budget: { queries: 4, reads: 6, rounds: 2 },
+};
+const site = {
+    id: "raven/site",
+    kind: "site",
+    version: 1,
+    propose: `You plan searches inside one website for one research ask. Every query runs on {site} only.
+
+${SHAPE_QUERIES}
+
+Rules:
+- At most {n} queries, each 2 to 8 words, as a person types into the site's own search box.
+- Each query reaches a different part of the site: its product or service pages, its pricing, its blog or help, its people.
+- "why" says in one short line what the query would add that is not known yet.
+- No site: operators: the site is set for you.
+
+${CONTEXT}`,
+    triage: `You decide which pages of {site} to read for one research ask. A read costs time; a skip costs nothing.
+
+${SHAPE_HITS}
+
+Rules:
+${TRIAGE_RULES}
+- Skip a url off {site}.
+
+${CONTEXT}
+Hits:
+{hits}`,
+    review: REVIEW,
+    sources: ["sitemap", "searxng", "fetch"],
+    budget: { queries: 4, reads: 8, rounds: 2 },
+};
+const DEFAULTS = { web, video, channel, person, site };
+/** The default plan file for a kind, validated, as a fresh copy. */
+export function defaultPlanFile(kind) {
+    return PlanFileShape.parse(structuredClone(DEFAULTS[kind]));
+}
+export const PLAN_KINDS = Object.keys(DEFAULTS);
+//# sourceMappingURL=index.js.map

package/dist/render.d.ts

@@ -0,0 +1,7 @@
+/** Text the prompts take: what is known, what yielded, what a hit shows for free. */
+import type { HitView, YieldRow } from "./types.js";
+export declare const lines: (xs: readonly string[], none?: string) => string;
+/** One line per row, the keys it has first: `source=exa channel=... hits=12 reads=4 proposed=9 kept=3`. */
+export declare function renderYield(rows: readonly YieldRow[]): string;
+/** Numbered, one hit per line, only the fields it has. */
+export declare function renderHits(hits: readonly HitView[]): string;

package/dist/render.js

@@ -0,0 +1,40 @@
+export const lines = (xs, none = "(nothing)") => xs.length ? xs.map((x) => `- ${x}`).join("\n") : none;
+/** One line per row, the keys it has first: `source=exa channel=... hits=12 reads=4 proposed=9 kept=3`. */
+export function renderYield(rows) {
+    if (!rows.length)
+        return "(no history yet)";
+    return rows
+        .map((r) => {
+        const who = ["by", "source", "channel", "kind"]
+            .filter((k) => r[k] !== undefined)
+            .map((k) => `${k}=${r[k]}`);
+        return `- ${[...who, `hits=${r.hits}`, `reads=${r.reads}`, `proposed=${r.proposed}`, `kept=${r.kept}`].join(" ")}`;
+    })
+        .join("\n");
+}
+const oneLine = (s, max) => {
+    const t = s.replace(/\s+/g, " ").trim();
+    return t.length > max ? `${t.slice(0, max - 1)}…` : t;
+};
+/** Numbered, one hit per line, only the fields it has. */
+export function renderHits(hits) {
+    return hits
+        .map((h, i) => {
+        const parts = [h.url];
+        if (h.title)
+            parts.push(`title: ${oneLine(h.title, 120)}`);
+        if (h.channel)
+            parts.push(`channel: ${h.channel}`);
+        if (h.length !== undefined)
+            parts.push(`length: ${Math.round(h.length)}s`);
+        if (h.date)
+            parts.push(`date: ${h.date}`);
+        if (h.sources.length)
+            parts.push(`sources: ${h.sources.join(",")}`);
+        if (h.snippet)
+            parts.push(`snippet: ${oneLine(h.snippet, 240)}`);
+        return `${i + 1}. ${parts.join(" | ")}`;
+    })
+        .join("\n");
+}
+//# sourceMappingURL=render.js.map

package/dist/review.d.ts

@@ -0,0 +1,11 @@
+/**
+ * After a round: stop, go again from plan, or back to one step. The round budget is a guard
+ * rail, not a stop rule: when it is spent raven stops and says so; before that the model decides
+ * and says why. The runner takes the edge; raven never loops.
+ */
+import { type Model } from "./model.js";
+import { type Edge, type PlanFile, type Round } from "./types.js";
+export declare function reviewPrompt(round: Round, planFile: PlanFile): string;
+export declare function review(round: Round, model: Model, options?: {
+    planFile?: PlanFile;
+}): Promise<Edge>;

package/dist/review.js

@@ -0,0 +1,44 @@
+/**
+ * After a round: stop, go again from plan, or back to one step. The round budget is a guard
+ * rail, not a stop rule: when it is spent raven stops and says so; before that the model decides
+ * and says why. The runner takes the edge; raven never loops.
+ */
+import { fill } from "./model.js";
+import { defaultPlanFile } from "./plans/index.js";
+import { lines } from "./render.js";
+import { Step, z } from "./types.js";
+const EdgeAnswer = z.object({
+    next: z.enum(["stop", "again", "back"]),
+    to: Step.optional(),
+    why: z.string(),
+});
+export function reviewPrompt(round, planFile) {
+    return fill(planFile.review, {
+        ask: round.ask.text,
+        round: String(round.round),
+        rounds: String(round.budget.rounds),
+        hits: String(round.hits),
+        reads: String(round.reads),
+        proposed: String(round.proposed),
+        kept: String(round.kept),
+        found: lines(round.found),
+        notes: lines(round.notes, "(none)"),
+    });
+}
+export async function review(round, model, options = {}) {
+    if (round.round >= round.budget.rounds) {
+        return {
+            next: "stop",
+            why: `round budget spent (${round.round} of ${round.budget.rounds})`,
+            from: "ai",
+            by: "raven:budget",
+        };
+    }
+    const planFile = options.planFile ?? defaultPlanFile(round.ask.kind);
+    const out = await model.ask(reviewPrompt(round, planFile), EdgeAnswer);
+    const edge = { next: out.next, why: out.why, from: "ai", by: model.id };
+    if (out.next === "back")
+        edge.to = out.to ?? "fetch";
+    return edge;
+}
+//# sourceMappingURL=review.js.map

package/dist/triage.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The filter before the read: for each hit, read or skip, from what the hit shows for free.
+ * Hits dedupe by url and keep every source that returned them. The model picks; the read budget
+ * caps it; a hit the model did not name is a skip, written down as one.
+ */
+import { type Model } from "./model.js";
+import { type HitView, type Plan, type PlanFile, type Triage, type YieldRow } from "./types.js";
+/** One hit per url, sources merged, order of first sight. */
+export declare function dedupeHits(hits: readonly HitView[]): HitView[];
+export declare function triagePrompt(hits: readonly HitView[], plan: Plan, planFile: PlanFile, yieldRows: readonly YieldRow[]): string;
+/** Read or skip per hit, with why. Reads over the plan's budget flip to skips, in the model's order. */
+export declare function triage(hits: readonly HitView[], plan: Plan, model: Model, options?: {
+    planFile?: PlanFile;
+    yieldRows?: readonly YieldRow[];
+}): Promise<Triage[]>;

package/dist/triage.js

@@ -0,0 +1,65 @@
+/**
+ * The filter before the read: for each hit, read or skip, from what the hit shows for free.
+ * Hits dedupe by url and keep every source that returned them. The model picks; the read budget
+ * caps it; a hit the model did not name is a skip, written down as one.
+ */
+import { fill } from "./model.js";
+import { defaultPlanFile } from "./plans/index.js";
+import { lines, renderHits, renderYield } from "./render.js";
+import { z } from "./types.js";
+const TriageAnswer = z.object({
+    hits: z.array(z.object({ url: z.string(), read: z.boolean(), why: z.string() })),
+});
+/** One hit per url, sources merged, order of first sight. */
+export function dedupeHits(hits) {
+    const byUrl = new Map();
+    for (const h of hits) {
+        const url = h.url.trim();
+        const have = byUrl.get(url);
+        if (!have) {
+            byUrl.set(url, { ...h, url, sources: [...new Set(h.sources)] });
+            continue;
+        }
+        for (const s of h.sources)
+            if (!have.sources.includes(s))
+                have.sources.push(s);
+        for (const k of ["title", "channel", "length", "date", "snippet"]) {
+            if (have[k] === undefined && h[k] !== undefined)
+                have[k] = h[k];
+        }
+    }
+    return [...byUrl.values()];
+}
+export function triagePrompt(hits, plan, planFile, yieldRows) {
+    return fill(planFile.triage, {
+        n: String(plan.budget.reads),
+        ask: plan.ask.text,
+        site: plan.ask.site ?? "",
+        known: lines(plan.ask.known),
+        yield: renderYield(yieldRows),
+        hits: renderHits(hits),
+    });
+}
+/** Read or skip per hit, with why. Reads over the plan's budget flip to skips, in the model's order. */
+export async function triage(hits, plan, model, options = {}) {
+    const unique = dedupeHits(hits);
+    if (!unique.length)
+        return [];
+    const planFile = options.planFile ?? defaultPlanFile(plan.ask.kind);
+    const out = await model.ask(triagePrompt(unique, plan, planFile, options.yieldRows ?? []), TriageAnswer);
+    const said = new Map(out.hits.map((h) => [h.url.trim(), h]));
+    let reads = 0;
+    return unique.map((h) => {
+        const a = said.get(h.url);
+        const base = { url: h.url, from: "ai", by: model.id };
+        if (!a)
+            return { ...base, read: false, why: "not named by the model" };
+        if (!a.read)
+            return { ...base, read: false, why: a.why };
+        if (reads >= plan.budget.reads)
+            return { ...base, read: false, why: `over the read budget (${plan.budget.reads})` };
+        reads++;
+        return { ...base, read: true, why: a.why };
+    });
+}
+//# sourceMappingURL=triage.js.map

package/dist/types.d.ts

@@ -0,0 +1,265 @@
+/**
+ * The shapes raven owns. A query says what to look for and who asked for it; a plan is the
+ * queries of one round plus the sources and budget it runs under; a plan file is the tuned
+ * recipe per ask kind. Hits are weaver's; raven sees them through `HitView`, the fields a
+ * source shows for free, because weaver depends on raven and not the reverse.
+ */
+import { z } from "zod";
+export declare const AskKind: z.ZodEnum<{
+    web: "web";
+    video: "video";
+    channel: "channel";
+    person: "person";
+    site: "site";
+}>;
+export type AskKind = z.infer<typeof AskKind>;
+/** Who wrote a record: a model, a plan file or a person. */
+export declare const From: z.ZodEnum<{
+    ai: "ai";
+    human: "human";
+}>;
+export type From = z.infer<typeof From>;
+/** What someone wants to know, and what is known already. */
+export declare const Ask: z.ZodObject<{
+    text: z.ZodString;
+    kind: z.ZodEnum<{
+        web: "web";
+        video: "video";
+        channel: "channel";
+        person: "person";
+        site: "site";
+    }>;
+    known: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    site: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Ask = z.infer<typeof Ask>;
+/** One thing to look for. `terms` is what a person would type; a source adapter forms its own call from it. */
+export declare const Query: z.ZodObject<{
+    kind: z.ZodEnum<{
+        web: "web";
+        video: "video";
+        channel: "channel";
+        person: "person";
+        site: "site";
+    }>;
+    terms: z.ZodString;
+    site: z.ZodOptional<z.ZodString>;
+    why: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+    }>;
+    by: z.ZodString;
+}, z.core.$strip>;
+export type Query = z.infer<typeof Query>;
+/** Queries from one proposer. The model is one; a plan file, a teammate or a second model are others. */
+export declare const Proposal: z.ZodObject<{
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+    }>;
+    by: z.ZodString;
+    queries: z.ZodArray<z.ZodObject<{
+        site: z.ZodOptional<z.ZodString>;
+        kind: z.ZodEnum<{
+            web: "web";
+            video: "video";
+            channel: "channel";
+            person: "person";
+            site: "site";
+        }>;
+        terms: z.ZodString;
+        why: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Proposal = z.infer<typeof Proposal>;
+export declare const Budget: z.ZodObject<{
+    queries: z.ZodNumber;
+    reads: z.ZodNumber;
+    rounds: z.ZodNumber;
+}, z.core.$strip>;
+export type Budget = z.infer<typeof Budget>;
+/**
+ * The recipe for one ask kind: the prompts, the sources it may use, the budget. Versioned and
+ * tuned like an SOP, stored beside the ledger. `{name}` marks in a prompt are filled from the
+ * ask: `{ask}`, `{known}`, `{yield}`, `{n}`, `{year}`, `{site}`.
+ */
+export declare const PlanFile: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        web: "web";
+        video: "video";
+        channel: "channel";
+        person: "person";
+        site: "site";
+    }>;
+    version: z.ZodNumber;
+    propose: z.ZodString;
+    triage: z.ZodString;
+    review: z.ZodString;
+    sources: z.ZodArray<z.ZodString>;
+    budget: z.ZodObject<{
+        queries: z.ZodNumber;
+        reads: z.ZodNumber;
+        rounds: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PlanFile = z.infer<typeof PlanFile>;
+/** What a source, channel or proposer yielded before. Raven reads it; wren or the files ledger writes it. */
+export declare const YieldRow: z.ZodObject<{
+    by: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    channel: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        web: "web";
+        video: "video";
+        channel: "channel";
+        person: "person";
+        site: "site";
+    }>>;
+    hits: z.ZodNumber;
+    reads: z.ZodNumber;
+    proposed: z.ZodNumber;
+    kept: z.ZodNumber;
+}, z.core.$strip>;
+export type YieldRow = z.infer<typeof YieldRow>;
+/** What raven was given for one round: the RL state, kept with the plan. */
+export declare const Snapshot: z.ZodObject<{
+    at: z.ZodString;
+    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;
+}, z.core.$strip>;
+export type Snapshot = z.infer<typeof Snapshot>;
+export declare const Plan: z.ZodObject<{
+    ask: z.ZodObject<{
+        text: z.ZodString;
+        kind: z.ZodEnum<{
+            web: "web";
+            video: "video";
+            channel: "channel";
+            person: "person";
+            site: "site";
+        }>;
+        known: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        site: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    round: z.ZodNumber;
+    queries: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            web: "web";
+            video: "video";
+            channel: "channel";
+            person: "person";
+            site: "site";
+        }>;
+        terms: z.ZodString;
+        site: z.ZodOptional<z.ZodString>;
+        why: z.ZodString;
+        from: z.ZodEnum<{
+            ai: "ai";
+            human: "human";
+        }>;
+        by: z.ZodString;
+    }, z.core.$strip>>;
+    sources: z.ZodArray<z.ZodString>;
+    budget: z.ZodObject<{
+        queries: z.ZodNumber;
+        reads: z.ZodNumber;
+        rounds: z.ZodNumber;
+    }, z.core.$strip>;
+    snapshot: z.ZodObject<{
+        at: z.ZodString;
+        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;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type Plan = z.infer<typeof Plan>;
+/** A hit as a source shows it for free: no read has happened. `sources` is every source that returned it. */
+export declare const HitView: z.ZodObject<{
+    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>>;
+}, z.core.$strip>;
+export type HitView = z.infer<typeof HitView>;
+export declare const Triage: z.ZodObject<{
+    url: z.ZodString;
+    read: z.ZodBoolean;
+    why: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+    }>;
+    by: z.ZodString;
+}, z.core.$strip>;
+export type Triage = z.infer<typeof Triage>;
+/** What one round came to, as counts and notes. The runner fills it; raven reads it. */
+export declare const Round: z.ZodObject<{
+    ask: z.ZodObject<{
+        text: z.ZodString;
+        kind: z.ZodEnum<{
+            web: "web";
+            video: "video";
+            channel: "channel";
+            person: "person";
+            site: "site";
+        }>;
+        known: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        site: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    round: z.ZodNumber;
+    budget: z.ZodObject<{
+        queries: z.ZodNumber;
+        reads: z.ZodNumber;
+        rounds: z.ZodNumber;
+    }, z.core.$strip>;
+    hits: z.ZodNumber;
+    reads: z.ZodNumber;
+    proposed: z.ZodNumber;
+    kept: z.ZodNumber;
+    found: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    notes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type Round = z.infer<typeof Round>;
+export declare const Step: z.ZodEnum<{
+    read: "read";
+    plan: "plan";
+    fetch: "fetch";
+    extract: "extract";
+}>;
+export type Step = z.infer<typeof Step>;
+/** The edge out of a round. `again` is a new round from `plan`; `back` reruns one step of this round. */
+export declare const Edge: z.ZodObject<{
+    next: z.ZodEnum<{
+        stop: "stop";
+        again: "again";
+        back: "back";
+    }>;
+    to: z.ZodOptional<z.ZodEnum<{
+        read: "read";
+        plan: "plan";
+        fetch: "fetch";
+        extract: "extract";
+    }>>;
+    why: z.ZodString;
+    from: z.ZodEnum<{
+        ai: "ai";
+        human: "human";
+    }>;
+    by: z.ZodString;
+}, z.core.$strip>;
+export type Edge = z.infer<typeof Edge>;
+export { z };