@spendgraph/workflows 0.2.0

package/dist/noesis/router/triage/types.d.ts

@@ -0,0 +1,70 @@
+import type { Emit } from "../../events.js";
+import type { Usage } from "../../usage.js";
+/** How hard the task is for a strong model with standard tools. */
+export type Difficulty = "trivial" | "easy" | "medium" | "hard" | "expert" | "research";
+/** Blast radius if the answer is wrong. Judged by consequence, not by topic. */
+export type Stakes = "low" | "medium" | "high" | "critical";
+/** The five signals and the summary. Nothing here is a route — code derives that. */
+export interface TriageEstimates {
+    is_new_task: boolean;
+    difficulty: Difficulty;
+    stakes: Stakes;
+    confidence: number;
+    ambiguity: number;
+    tool_need: number;
+    summary: string;
+}
+/**
+ * What the router classifies.
+ *
+ * The prompt's question box wraps every request in an `<attachments>` block, so
+ * all three fields render in one pass: `{file_content}` and `{image_content}`
+ * inside the block, `{question}` after it.
+ *
+ * Both attachment fields are optional and an unset one is sent as `(none)`
+ * rather than empty — empty tags read as an attachment the router cannot open,
+ * which it prices as ambiguity and tool need.
+ */
+export interface TriageInput {
+    /**
+     * The open task from earlier in the session, if there is one.
+     *
+     * First because it is sent first: the block goes ahead of the user message,
+     * which is the only thing that makes `is_new_task` mean anything. With no
+     * block the prompt is told to always answer true, so retriage never fires and
+     * every follow-up starts a fresh run. A summary of the open task, never the
+     * conversation.
+     */
+    currentTask?: string;
+    /** The request being classified. Named for the variable it fills, like every stage. */
+    question: string;
+    file_content?: string;
+    image_content?: string;
+}
+export interface TriageOptions {
+    /**
+     * Attempts for this call, counting the first. Default 2.
+     *
+     * Separate from `maxRetries`, the loop's budget for a gate sending work
+     * backwards. This one covers a call that produced nothing to think about, and
+     * the two must not share an allowance.
+     */
+    attempts?: number;
+    /** Overrides the model the `Llm` was built with. */
+    model?: string;
+    /**
+     * Merged into the request body.
+     *
+     * Where `temperature` goes, and it is per model: Haiku 4.5 takes it, Sonnet 5
+     * rejects it outright.
+     */
+    params?: Record<string, unknown>;
+    /** Where this stage says what it is doing. Set by `run()`. */
+    emit?: Emit;
+}
+export interface TriageResult extends Usage {
+    estimates: TriageEstimates;
+    rolloutId: string;
+    model: string;
+    latencyMs: number;
+}

package/dist/noesis/router/triage/types.js

@@ -0,0 +1 @@
+export {};

package/dist/noesis/run/artifacts.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The artifacts as a stage that reasons about them reads them, long strings cut.
+ *
+ * Every stage handed the whole ledger — 3A, 3B, 3C, 4A and R — is reading it
+ * for the decisions it records, and a decision is legible from the head of a
+ * tool answer. 6C is the exception and takes the artifacts whole: it cites
+ * evidence rather than reviewing choices, and a citation cut in half is a
+ * citation of nothing.
+ */
+export declare const digest: (artifacts: Record<string, unknown>, limit?: number) => Record<string, unknown>;
+/** One artifact, cut the same way — what an event carries rather than a prompt. */
+export declare const digestOne: (artifact: unknown, limit?: number) => unknown;

package/dist/noesis/run/artifacts.js

@@ -0,0 +1,31 @@
+/**
+ * How much of any one string an artifact may carry into a prompt.
+ *
+ * A tool answer is the one artifact with no bound on its size: everything else
+ * is a model reply against a schema, and a wide `deep_recall` can be larger
+ * than every other stage put together.
+ */
+const DEFAULT_LIMIT = 2000;
+const cut = (text, limit) => `${text.slice(0, limit)}… (${text.length - limit} more characters)`;
+function shorten(value, limit) {
+    if (typeof value === "string")
+        return value.length > limit ? cut(value, limit) : value;
+    if (Array.isArray(value))
+        return value.map((item) => shorten(item, limit));
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, shorten(item, limit)]));
+    }
+    return value;
+}
+/**
+ * The artifacts as a stage that reasons about them reads them, long strings cut.
+ *
+ * Every stage handed the whole ledger — 3A, 3B, 3C, 4A and R — is reading it
+ * for the decisions it records, and a decision is legible from the head of a
+ * tool answer. 6C is the exception and takes the artifacts whole: it cites
+ * evidence rather than reviewing choices, and a citation cut in half is a
+ * citation of nothing.
+ */
+export const digest = (artifacts, limit = DEFAULT_LIMIT) => shorten(artifacts, limit);
+/** One artifact, cut the same way — what an event carries rather than a prompt. */
+export const digestOne = (artifact, limit = DEFAULT_LIMIT) => shorten(artifact, limit);

package/dist/noesis/run/errors.d.ts

@@ -0,0 +1,38 @@
+import type { TriageEstimates } from "../router/triage/index.js";
+import type { Routing } from "../types.js";
+/**
+ * A route the table names with nothing behind it.
+ *
+ * Thrown only where the fallback ran — `RouteResult.route` is null — which is
+ * the one case where the branch really does not exist. A branch that ran and
+ * threw is a `RouteFailedError`, and the two are separate classes because the
+ * answer to them is: write the branch, versus try again.
+ */
+export declare class RouteNotBuiltError extends Error {
+    readonly route: string;
+    readonly estimates?: TriageEstimates | undefined;
+    readonly routing?: Routing | undefined;
+    readonly detail?: string | undefined;
+    constructor(route: string, estimates?: TriageEstimates | undefined, routing?: Routing | undefined, detail?: string | undefined);
+}
+/**
+ * A branch that ran and threw, with the estimates that chose it.
+ *
+ * `detail` is the branch's own message, carried up because the graph underneath
+ * catches whatever a branch throws and reports only a failed run. A caller
+ * catching this should decide whether the cause is worth retrying; catching
+ * `RouteNotBuiltError` never is.
+ */
+export declare class RouteFailedError extends Error {
+    readonly route: string;
+    readonly estimates?: TriageEstimates | undefined;
+    readonly routing?: Routing | undefined;
+    readonly detail?: string | undefined;
+    constructor(route: string, estimates?: TriageEstimates | undefined, routing?: Routing | undefined, detail?: string | undefined);
+}
+/** A branch named in the routing table with nothing behind it yet. */
+export declare const notBuilt: (route: string) => () => never;
+/** A route that has to look something up, with nothing to look it up with. */
+export declare class NoToolsError extends Error {
+    constructor();
+}

package/dist/noesis/run/errors.js

@@ -0,0 +1,55 @@
+/**
+ * A route the table names with nothing behind it.
+ *
+ * Thrown only where the fallback ran — `RouteResult.route` is null — which is
+ * the one case where the branch really does not exist. A branch that ran and
+ * threw is a `RouteFailedError`, and the two are separate classes because the
+ * answer to them is: write the branch, versus try again.
+ */
+export class RouteNotBuiltError extends Error {
+    route;
+    estimates;
+    routing;
+    detail;
+    constructor(route, estimates, routing, detail) {
+        super(detail || `The "${route}" route is not built yet.`);
+        this.route = route;
+        this.estimates = estimates;
+        this.routing = routing;
+        this.detail = detail;
+        this.name = "RouteNotBuiltError";
+    }
+}
+/**
+ * A branch that ran and threw, with the estimates that chose it.
+ *
+ * `detail` is the branch's own message, carried up because the graph underneath
+ * catches whatever a branch throws and reports only a failed run. A caller
+ * catching this should decide whether the cause is worth retrying; catching
+ * `RouteNotBuiltError` never is.
+ */
+export class RouteFailedError extends Error {
+    route;
+    estimates;
+    routing;
+    detail;
+    constructor(route, estimates, routing, detail) {
+        super(detail || `The "${route}" route failed.`);
+        this.route = route;
+        this.estimates = estimates;
+        this.routing = routing;
+        this.detail = detail;
+        this.name = "RouteFailedError";
+    }
+}
+/** A branch named in the routing table with nothing behind it yet. */
+export const notBuilt = (route) => () => {
+    throw new RouteNotBuiltError(route);
+};
+/** A route that has to look something up, with nothing to look it up with. */
+export class NoToolsError extends Error {
+    constructor() {
+        super("This route looks something up, so it needs a ToolBus in opts.tools.");
+        this.name = "NoToolsError";
+    }
+}

package/dist/noesis/run/index.d.ts

@@ -0,0 +1,6 @@
+export { NoToolsError, RouteFailedError, RouteNotBuiltError } from "./errors.js";
+export type { Entry, Escalation, Ledger, Recorded, StageId, StageUsage } from "./ledger.js";
+export { newLedger, STAGE_NAMES, STAGES } from "./ledger.js";
+export { run } from "./run.js";
+export type { NoesisStream } from "./stream.js";
+export { runStream } from "./stream.js";

package/dist/noesis/run/index.js

@@ -0,0 +1,4 @@
+export { NoToolsError, RouteFailedError, RouteNotBuiltError } from "./errors.js";
+export { newLedger, STAGE_NAMES, STAGES } from "./ledger.js";
+export { run } from "./run.js";
+export { runStream } from "./stream.js";

package/dist/noesis/run/ledger.d.ts

@@ -0,0 +1,110 @@
+import type { Emit } from "../events.js";
+import { type PartialUsage, type Usage } from "../usage.js";
+/** Every stage the loop can run, in the order it runs them. */
+export declare const STAGES: readonly ["0", "1", "2", "3A", "3B", "3C", "4", "4A", "4B", "5A", "5B", "5", "5C", "6A", "6B", "6C", "R"];
+export type StageId = (typeof STAGES)[number];
+/** What a stage is called where a person or a model has to read it. */
+export declare const STAGE_NAMES: Record<StageId, string>;
+/** What one stage left behind, and what it cost. */
+export interface Entry extends Usage {
+    stage: StageId;
+    data: unknown;
+    /** More than one where the stage cascaded, so an escalation is not lost. */
+    rolloutIds: string[];
+    model: string;
+    latencyMs: number;
+}
+/** One stage's spend, summed over every time the loop ran it. */
+export interface StageUsage extends Usage {
+    stage: StageId;
+    name: string;
+    /** More than one where a back edge ran the stage again. */
+    models: string[];
+    rolloutIds: string[];
+    latencyMs: number;
+    calls: number;
+}
+/**
+ * A stage result, however the stage reports its rollouts.
+ *
+ * `StageOutcome` carries one and `AnswerResult` carries several, and both are
+ * recorded the same way.
+ */
+export type Recorded<T> = {
+    data: T;
+    model: string;
+    latencyMs: number;
+    /** What the server will price the call at, still in flight. Settled by `settle()`. */
+    pricing?: Promise<number | undefined>;
+} & PartialUsage & ({
+    rolloutId: string;
+} | {
+    rolloutIds: string[];
+});
+/** A run that stopped and wants a person. */
+export interface Escalation {
+    from: StageId;
+    reason: string;
+}
+export interface Ledger {
+    /** Files a stage's result and hands its data straight back. */
+    record<T>(stage: StageId, result: Recorded<T>): T;
+    /**
+     * Waits for every price still in flight and files it against its stage.
+     *
+     * Called once, at the end. Each stage hands back a promise rather than
+     * waiting on it, so a run pays the report round trip once in parallel instead
+     * of fifteen times in series — the money is not read until here anyway.
+     */
+    settle(): Promise<void>;
+    /** Everything filed, in the order the stages ran. */
+    entries(): Entry[];
+    /**
+     * What 6C compiles from.
+     *
+     * Keyed by stage id and name together, because the model writes one of them
+     * back as `grounds[].source_stage` and either has to lead to the entry.
+     */
+    artifacts(): Record<string, unknown>;
+    /**
+     * Notes a gate sending work backwards, and says whether it may.
+     *
+     * False once the budget is spent, which is the run's cue to stop looping and
+     * ask for a person instead.
+     */
+    retry(gate: StageId): boolean;
+    /**
+     * Forgets that stage and everything after it.
+     *
+     * What it cost stays: tokens were spent and rollouts were recorded, and a
+     * retry does not un-spend them. Only the artifacts go, so nothing stale is
+     * compiled into the answer.
+     */
+    dropFrom(stage: StageId): void;
+    /** How many times each gate sent work back. */
+    retries(): Partial<Record<StageId, number>>;
+    /** Stops the run and asks for a person. */
+    escalate(from: StageId, reason: string): void;
+    escalated(): Escalation | undefined;
+    /** Every token the run was billed for, whatever a back edge later dropped. */
+    usage(): Usage;
+    /** The same totals split by stage, summed over every time the loop ran it. */
+    byStage(): StageUsage[];
+    /** And split by model, which is the only split a price list can be applied to. */
+    byModel(): Record<string, Usage>;
+    rolloutIds: string[];
+    inputTokens: number;
+    outputTokens: number;
+}
+/**
+ * What a run leaves behind, as one thing.
+ *
+ * A branch that keeps its own artifacts hands 6C a different shape from the
+ * next branch, and nothing can invalidate a stale one on a retry. Cost is
+ * counted here too, because the graph underneath reads a node's tokens off its
+ * return value — and a branch that returns text reports none.
+ *
+ * `maxRetries` is a total across every gate: one gate flapping and five gates
+ * failing once each are the same amount of a run going nowhere.
+ */
+export declare function newLedger(maxRetries?: number, emit?: Emit): Ledger;

package/dist/noesis/run/ledger.js

@@ -0,0 +1,184 @@
+import { addUsage, NO_USAGE, usageOf } from "../usage.js";
+import { digestOne } from "./artifacts.js";
+/** Every stage the loop can run, in the order it runs them. */
+export const STAGES = [
+    "0",
+    "1",
+    "2",
+    "3A",
+    "3B",
+    "3C",
+    "4",
+    "4A",
+    "4B",
+    "5A",
+    "5B",
+    "5",
+    "5C",
+    "6A",
+    "6B",
+    "6C",
+    "R",
+];
+/** What a stage is called where a person or a model has to read it. */
+export const STAGE_NAMES = {
+    "0": "triage",
+    "1": "question brief",
+    "2": "decomposition",
+    "3A": "plan candidates",
+    "3B": "premortem",
+    "3C": "cqot gate",
+    "4": "execution",
+    "4A": "think checkpoint",
+    "4B": "discriminating test",
+    "5A": "verification questions",
+    "5B": "verification answers",
+    "5": "verification",
+    "5C": "standards review",
+    "6A": "closure checklist",
+    "6B": "red team",
+    "6C": "answer",
+    R: "root cause",
+};
+const DEFAULT_MAX_RETRIES = 5;
+const rolloutsOf = (result) => "rolloutIds" in result ? result.rolloutIds : [result.rolloutId];
+/**
+ * What a run leaves behind, as one thing.
+ *
+ * A branch that keeps its own artifacts hands 6C a different shape from the
+ * next branch, and nothing can invalidate a stale one on a retry. Cost is
+ * counted here too, because the graph underneath reads a node's tokens off its
+ * return value — and a branch that returns text reports none.
+ *
+ * `maxRetries` is a total across every gate: one gate flapping and five gates
+ * failing once each are the same amount of a run going nowhere.
+ */
+export function newLedger(maxRetries = DEFAULT_MAX_RETRIES, emit) {
+    const filed = [];
+    const spentOn = [];
+    const pending = [];
+    const backEdges = {};
+    let stopped;
+    let spent = 0;
+    const ledger = {
+        rolloutIds: [],
+        inputTokens: 0,
+        outputTokens: 0,
+        record(stage, result) {
+            const rolloutIds = rolloutsOf(result);
+            const entry = {
+                ...usageOf(result),
+                stage,
+                data: result.data,
+                rolloutIds,
+                model: result.model,
+                latencyMs: result.latencyMs,
+            };
+            filed.push(entry);
+            spentOn.push(entry);
+            if (result.pricing)
+                pending.push({ entry, pricing: result.pricing });
+            ledger.rolloutIds.push(...rolloutIds);
+            ledger.inputTokens += entry.inputTokens;
+            ledger.outputTokens += entry.outputTokens;
+            emit?.({
+                type: "stage.finished",
+                stage,
+                name: STAGE_NAMES[stage],
+                artifact: digestOne(entry.data),
+                model: entry.model,
+                rolloutIds,
+                usage: usageOf(entry),
+                latencyMs: entry.latencyMs,
+            });
+            return result.data;
+        },
+        async settle() {
+            const priced = await Promise.all(pending.map((one) => one.pricing));
+            priced.forEach((cost, i) => {
+                if (cost === undefined)
+                    return;
+                const entry = pending[i]?.entry;
+                if (entry)
+                    entry.costMicros = (entry.costMicros ?? 0) + cost;
+            });
+            pending.length = 0;
+        },
+        entries: () => [...filed],
+        artifacts: () => Object.fromEntries([...filed]
+            .sort((a, b) => STAGES.indexOf(a.stage) - STAGES.indexOf(b.stage))
+            .map((entry) => [`${entry.stage} ${STAGE_NAMES[entry.stage]}`, entry.data])),
+        retry(gate) {
+            backEdges[gate] = (backEdges[gate] ?? 0) + 1;
+            spent += 1;
+            const granted = spent <= maxRetries;
+            emit?.({
+                type: "retry.spent",
+                gate,
+                spent,
+                left: Math.max(0, maxRetries - spent),
+                budget: maxRetries,
+                granted,
+            });
+            return granted;
+        },
+        dropFrom(stage) {
+            const cutAt = STAGES.indexOf(stage);
+            const dropped = [];
+            for (let i = filed.length - 1; i >= 0; i -= 1) {
+                const entry = filed[i];
+                if (entry && STAGES.indexOf(entry.stage) >= cutAt) {
+                    dropped.push(entry.stage);
+                    filed.splice(i, 1);
+                }
+            }
+            if (dropped.length) {
+                emit?.({ type: "ledger.dropped", from: stage, dropped: [...new Set(dropped)] });
+            }
+        },
+        retries: () => ({ ...backEdges }),
+        usage: () => spentOn.reduce(addUsage, NO_USAGE),
+        byStage() {
+            const totals = new Map();
+            for (const entry of spentOn) {
+                const running = totals.get(entry.stage) ?? {
+                    ...NO_USAGE,
+                    stage: entry.stage,
+                    name: STAGE_NAMES[entry.stage],
+                    models: [],
+                    rolloutIds: [],
+                    latencyMs: 0,
+                    calls: 0,
+                };
+                totals.set(entry.stage, {
+                    ...running,
+                    ...addUsage(running, entry),
+                    models: running.models.includes(entry.model)
+                        ? running.models
+                        : [...running.models, entry.model].filter(Boolean),
+                    rolloutIds: [...running.rolloutIds, ...entry.rolloutIds],
+                    latencyMs: running.latencyMs + entry.latencyMs,
+                    calls: running.calls + 1,
+                });
+            }
+            return [...totals.values()].sort((a, b) => STAGES.indexOf(a.stage) - STAGES.indexOf(b.stage));
+        },
+        byModel() {
+            const totals = {};
+            for (const entry of spentOn) {
+                if (!entry.model)
+                    continue;
+                totals[entry.model] = addUsage(totals[entry.model] ?? NO_USAGE, entry);
+            }
+            return totals;
+        },
+        escalate(from, reason) {
+            if (stopped)
+                return;
+            stopped = { from, reason };
+            emit?.({ type: "run.escalated", from, reason });
+        },
+        escalated: () => stopped,
+    };
+    return ledger;
+}

package/dist/noesis/run/loop.d.ts

@@ -0,0 +1,15 @@
+import type { Llm } from "@spendgraph/llms";
+import type { PromptClient } from "@spendgraph/prompt";
+import type { Draft } from "../draft/index.js";
+import type { NoesisOptions } from "../types.js";
+import type { RunState } from "./state.js";
+export interface Gates {
+    /** 5C. Full only. */
+    standards: boolean;
+    /** 6B. Set from stakes, so a full run reached another way does not pay for it. */
+    redTeam: boolean;
+    /** Everything up to the draft, run again. */
+    reproduce(): Promise<Draft>;
+}
+/** Check the draft, and keep going back until every gate lets it close. */
+export declare function settle(client: PromptClient, llm: Llm, question: string, opts: NoesisOptions, state: RunState, first: Draft, gates: Gates): Promise<void>;

package/dist/noesis/run/loop.js

@@ -0,0 +1,91 @@
+import { invoke as closureChecklist } from "../gates/closure-checklist/index.js";
+import { invoke as redTeam } from "../gates/red-team/index.js";
+import { invoke as standardsReview } from "../gates/standards-review/index.js";
+import { STAGE_NAMES } from "./ledger.js";
+import { dropPoint, resumeAt } from "./redo.js";
+import { checks, reflect } from "./verify.js";
+/**
+ * One return trip: spend a retry, find the root cause, cut the ledger back.
+ *
+ * The budget is checked before R runs, because a run with nothing left to spend
+ * has no use for knowing where it went wrong.
+ *
+ * The ledger is cut where the loop actually restarts, not where R pointed. A
+ * gate is the same gate on the same input, so anything it names redoes the
+ * checks — and cutting only from the gate would leave the stale checks filed
+ * beside the fresh ones.
+ */
+async function stepBack(client, llm, question, opts, state, gates, gate, reason, hint) {
+    if (!state.ledger.retry(gate)) {
+        state.ledger.escalate(gate, `Out of retries. ${gate} last said: ${reason}`);
+        return { stopped: true };
+    }
+    const redo = await reflect(client, llm, question, opts, state, gate, reason, hint);
+    const again = resumeAt(redo);
+    state.ledger.dropFrom(again === "produce" ? dropPoint(redo) : "5A");
+    return { stopped: false, draft: again === "produce" ? await gates.reproduce() : undefined };
+}
+/**
+ * The gates, in the order they earn their place.
+ *
+ * 5C reads the answer against its standards, 6A asks the last questions before
+ * closing, and 6B attacks what survived both. The first refusal returns, so a
+ * gate that fires early saves the later ones the work.
+ */
+async function judge(client, llm, opts, state, checked, gates) {
+    if (gates.standards) {
+        const review = state.ledger.record("5C", await standardsReview(client, llm, { question: checked, ...opts.context }, opts.stage));
+        if (review.overall !== "accept") {
+            return {
+                stage: "5C",
+                reason: `the answer ${review.overall}s on ${review.failed.join(", ")}`,
+            };
+        }
+        state.emit?.({ type: "gate.passed", stage: "5C", name: STAGE_NAMES["5C"] });
+    }
+    const closure = state.ledger.record("6A", await closureChecklist(client, llm, { question: checked, ...opts.context }, opts.stage));
+    if (closure.gate !== "close") {
+        return {
+            stage: "6A",
+            reason: closure.reason,
+            hint: closure.loop_back_to,
+            escalate: closure.gate === "escalate",
+        };
+    }
+    state.emit?.({ type: "gate.passed", stage: "6A", name: STAGE_NAMES["6A"] });
+    if (gates.redTeam) {
+        const attacked = state.ledger.record("6B", await redTeam(client, llm, { question: checked, ...opts.context }, opts.stage));
+        if (attacked.verdict !== "survives") {
+            return { stage: "6B", reason: `${attacked.verdict}: ${attacked.would_break_it}` };
+        }
+        state.emit?.({ type: "gate.passed", stage: "6B", name: STAGE_NAMES["6B"] });
+    }
+    return undefined;
+}
+/** Check the draft, and keep going back until every gate lets it close. */
+export async function settle(client, llm, question, opts, state, first, gates) {
+    if (state.ledger.escalated())
+        return;
+    let draft = first;
+    for (;;) {
+        const checked = await checks(client, llm, opts, state, draft);
+        const refused = await judge(client, llm, opts, state, checked, gates);
+        if (!refused)
+            return;
+        state.emit?.({
+            type: "gate.refused",
+            stage: refused.stage,
+            name: STAGE_NAMES[refused.stage],
+            reason: refused.reason,
+            hint: refused.hint,
+        });
+        if (refused.escalate) {
+            state.ledger.escalate(refused.stage, refused.reason);
+            return;
+        }
+        const went = await stepBack(client, llm, question, opts, state, gates, refused.stage, refused.reason, refused.hint);
+        if (went.stopped)
+            return;
+        draft = went.draft ?? draft;
+    }
+}

package/dist/noesis/run/plan.d.ts

@@ -0,0 +1,18 @@
+import type { Llm } from "@spendgraph/llms";
+import type { PromptClient } from "@spendgraph/prompt";
+import type { NoesisOptions } from "../types.js";
+import type { RunState } from "./state.js";
+/**
+ * Stage 3A, and the audits only `full` pays for.
+ *
+ * Both long routes plan, because 4A judges each step against the `tolerance` 3A
+ * wrote for it and a run with no plan has nothing to check against. What `full`
+ * adds is 3B and 3C: the plan assumed dead, then gated.
+ *
+ * Chained rather than forked, because 3C points at the step at fault and 3B may
+ * have patched that step. Run side by side, 3C would gate a plan 3B had already
+ * said was wrong. A patch is prose, so `patch_and_proceed` proceeds and the
+ * premortem is filed — 3C reads the plan with the patches beside it rather than
+ * a plan nobody rewrote.
+ */
+export declare function plan(client: PromptClient, llm: Llm, question: string, opts: NoesisOptions, state: RunState, audits: boolean): Promise<void>;