@spendgraph/workflows 0.2.0

package/dist/noesis/run/plan.js

@@ -0,0 +1,39 @@
+import { invoke as cqotGate } from "../gates/cqot-gate/index.js";
+import { invoke as premortem } from "../gates/premortem/index.js";
+import { invoke as planCandidates } from "../producers/plan-candidates/index.js";
+import { soFar } from "./produce.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 async function plan(client, llm, question, opts, state, audits) {
+    for (;;) {
+        state.ledger.dropFrom("3A");
+        state.ledger.record("3A", await planCandidates(client, llm, { question: soFar(state, question), ...opts.context }, opts.stage));
+        if (!audits)
+            return;
+        const dead = state.ledger.record("3B", await premortem(client, llm, { question: soFar(state, question), ...opts.context }, opts.stage));
+        if (dead.fatal || dead.verdict === "replan") {
+            if (state.ledger.retry("3B"))
+                continue;
+            state.ledger.escalate("3B", "Out of retries: the premortem keeps killing the plan.");
+            return;
+        }
+        const gate = state.ledger.record("3C", await cqotGate(client, llm, { question: soFar(state, question), ...opts.context }, opts.stage));
+        if (gate.gate === "pass")
+            return;
+        if (state.ledger.retry("3C"))
+            continue;
+        state.ledger.escalate("3C", `Out of retries: the gate still blocks ${gate.blocking.join(", ")}.`);
+        return;
+    }
+}

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

@@ -0,0 +1,50 @@
+import type { Llm } from "@spendgraph/llms";
+import type { PromptClient } from "@spendgraph/prompt";
+import { type Draft } from "../draft/index.js";
+import type { Decomposition } from "../producers/decompose/index.js";
+import type { NoesisOptions } from "../types.js";
+import type { RunState } from "./state.js";
+/**
+ * Everything the ledger holds so far, as a stage reads it.
+ *
+ * Cut through `digest`, because every caller here is reviewing decisions rather
+ * than citing evidence and one wide tool answer would otherwise be most of the
+ * prompt. 6C reads `ledger.artifacts()` itself, uncut.
+ */
+export declare const soFar: (state: RunState, question: string) => string;
+/**
+ * Stages 1 and 2: interrogate the question, then split it.
+ *
+ * Stage 1 is the one place a person is worth asking mid-run. It answers
+ * `is_right_question: false` when the asker aimed at the wrong thing, and
+ * splitting the wrong question is the most expensive way to find that out. With
+ * nobody to ask it proceeds on the question as put, and the brief says so in
+ * the ledger either way.
+ */
+export declare function frame(client: PromptClient, llm: Llm, question: string, opts: NoesisOptions, state: RunState): Promise<{
+    asked: string;
+    split: Decomposition;
+}>;
+/**
+ * Stages 4 and 4A: answer the parts, then judge what came back against the plan.
+ *
+ * The draft is assembled either way. 4A decides whether it is worth reading:
+ * `continue` means the work is done, and the two that are not are the run's to
+ * act on.
+ */
+export declare function work(client: PromptClient, llm: Llm, question: string, opts: NoesisOptions, state: RunState, split: Decomposition): Promise<{
+    draft: Draft;
+    action: "go" | "replan" | "escalate";
+}>;
+/**
+ * Everything up to the draft, and the checkpoint's word that it is worth having.
+ *
+ * The framing happens once. `replan` returns to 3A because a result outside the
+ * tolerance a step predicted is the plan being wrong, not the question — and
+ * re-framing would ask the person the same thing twice.
+ *
+ * A plan that never cleared its own audits stops here rather than executing:
+ * the run already knows it needs somebody, and the draft it hands back says
+ * nothing was answered rather than pretending otherwise.
+ */
+export declare function produce(client: PromptClient, llm: Llm, question: string, opts: NoesisOptions, state: RunState, audits: boolean): Promise<Draft>;

package/dist/noesis/run/produce.js

@@ -0,0 +1,114 @@
+import { assemble } from "../draft/index.js";
+import { execute } from "../execute/index.js";
+import { invoke as thinkCheckpoint } from "../gates/think-checkpoint/index.js";
+import { invoke as decompose } from "../producers/decompose/index.js";
+import { invoke as brief } from "../producers/qn-brief/index.js";
+import { digest } from "./artifacts.js";
+import { NoToolsError } from "./errors.js";
+import { plan } from "./plan.js";
+/**
+ * Everything the ledger holds so far, as a stage reads it.
+ *
+ * Cut through `digest`, because every caller here is reviewing decisions rather
+ * than citing evidence and one wide tool answer would otherwise be most of the
+ * prompt. 6C reads `ledger.artifacts()` itself, uncut.
+ */
+export const soFar = (state, question) => JSON.stringify({ question, ...digest(state.ledger.artifacts()) }, null, 2);
+/**
+ * Stages 1 and 2: interrogate the question, then split it.
+ *
+ * Stage 1 is the one place a person is worth asking mid-run. It answers
+ * `is_right_question: false` when the asker aimed at the wrong thing, and
+ * splitting the wrong question is the most expensive way to find that out. With
+ * nobody to ask it proceeds on the question as put, and the brief says so in
+ * the ledger either way.
+ */
+export async function frame(client, llm, question, opts, state) {
+    const brief1 = state.ledger.record("1", await brief(client, llm, { question, ...opts.context }, opts.stage));
+    let asked = question;
+    if (!brief1.is_right_question && brief1.better_question && opts.onAsk) {
+        state.emit?.({
+            type: "ask.raised",
+            question,
+            better: brief1.better_question,
+            reason: brief1.purpose,
+        });
+        const replacement = await opts.onAsk({
+            question,
+            better: brief1.better_question,
+            reason: brief1.purpose,
+        });
+        state.emit?.({ type: "ask.answered", replacement: replacement ?? null });
+        asked = replacement ?? question;
+    }
+    const split = state.ledger.record("2", await decompose(client, llm, { question: asked, ...opts.context }, opts.stage));
+    return { asked, split };
+}
+/**
+ * Stages 4 and 4A: answer the parts, then judge what came back against the plan.
+ *
+ * The draft is assembled either way. 4A decides whether it is worth reading:
+ * `continue` means the work is done, and the two that are not are the run's to
+ * act on.
+ */
+export async function work(client, llm, question, opts, state, split) {
+    if (!opts.tools)
+        throw new NoToolsError();
+    const execution = await execute(opts.tools, split.sub_questions, { emit: state.emit });
+    state.ledger.record("4", {
+        data: execution,
+        rolloutIds: [],
+        model: "",
+        inputTokens: 0,
+        outputTokens: 0,
+        latencyMs: execution.toolMs,
+    });
+    const draft = assemble(question, split, execution);
+    state.emit?.({
+        type: "draft.assembled",
+        findings: draft.findings.length,
+        missing: draft.missing.map((one) => ({ id: one.id, reason: one.reason })),
+    });
+    const checkpoint = state.ledger.record("4A", await thinkCheckpoint(client, llm, { question: soFar(state, question), ...opts.context }, opts.stage));
+    if (checkpoint.next_action === "replan")
+        return { draft, action: "replan" };
+    if (checkpoint.next_action === "escalate")
+        return { draft, action: "escalate" };
+    return { draft, action: "go" };
+}
+/**
+ * Everything up to the draft, and the checkpoint's word that it is worth having.
+ *
+ * The framing happens once. `replan` returns to 3A because a result outside the
+ * tolerance a step predicted is the plan being wrong, not the question — and
+ * re-framing would ask the person the same thing twice.
+ *
+ * A plan that never cleared its own audits stops here rather than executing:
+ * the run already knows it needs somebody, and the draft it hands back says
+ * nothing was answered rather than pretending otherwise.
+ */
+export async function produce(client, llm, question, opts, state, audits) {
+    const { asked, split } = await frame(client, llm, question, opts, state);
+    for (;;) {
+        await plan(client, llm, asked, opts, state, audits);
+        if (state.ledger.escalated()) {
+            return assemble(asked, split, {
+                answers: [],
+                unresolved: split.sub_questions.map((sub) => sub.id),
+                toolMs: 0,
+            });
+        }
+        const { draft, action } = await work(client, llm, asked, opts, state, split);
+        if (action === "go")
+            return draft;
+        if (action === "escalate") {
+            state.ledger.escalate("4A", "The checkpoint asked for a person.");
+            return draft;
+        }
+        if (!state.ledger.retry("4A")) {
+            state.ledger.escalate("4A", "Out of retries: the plan kept missing its own tolerances.");
+            return draft;
+        }
+        state.ledger.dropFrom("3A");
+    }
+}

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

@@ -0,0 +1,24 @@
+import { type StageId } from "./ledger.js";
+/**
+ * A stage id out of whatever a stage called it.
+ *
+ * `redo_from_stage` and `loop_back_to` are free strings, so they arrive as
+ * `"2"`, `"stage 3A"` or `"the decomposition"`. Longest first, or `"5A"` is
+ * read as `"5"`.
+ *
+ * Absent counts as unnameable. Both fields are `required` in their schemas and
+ * neither is checked on the way back, so a stage that omitted one hands this
+ * `undefined` — and a stage nobody can name redoes everything, which is the
+ * answer this already had for a name it could not parse.
+ */
+export declare function parseStage(said: string | undefined): StageId | undefined;
+/**
+ * Which half of the route has to run again.
+ *
+ * The draft is the seam: anything up to 4B was produced, and anything after it
+ * only read what the draft already held. A stage nobody could name redoes the
+ * lot, because the alternative is compiling something stale.
+ */
+export declare function resumeAt(stage: StageId | undefined): "produce" | "verify";
+/** Where the ledger is cut back to. The earliest thing a retry can redo is 1. */
+export declare const dropPoint: (stage: StageId | undefined) => StageId;

package/dist/noesis/run/redo.js

@@ -0,0 +1,41 @@
+import { STAGE_NAMES, STAGES } from "./ledger.js";
+const LONGEST_FIRST = [...STAGES].sort((a, b) => b.length - a.length);
+const boundary = (id) => new RegExp(`(^|[^a-z0-9])${id.toLowerCase()}([^a-z0-9]|$)`);
+/**
+ * A stage id out of whatever a stage called it.
+ *
+ * `redo_from_stage` and `loop_back_to` are free strings, so they arrive as
+ * `"2"`, `"stage 3A"` or `"the decomposition"`. Longest first, or `"5A"` is
+ * read as `"5"`.
+ *
+ * Absent counts as unnameable. Both fields are `required` in their schemas and
+ * neither is checked on the way back, so a stage that omitted one hands this
+ * `undefined` — and a stage nobody can name redoes everything, which is the
+ * answer this already had for a name it could not parse.
+ */
+export function parseStage(said) {
+    const text = said?.trim().toLowerCase();
+    if (!text)
+        return undefined;
+    const exact = LONGEST_FIRST.find((id) => text === id.toLowerCase());
+    if (exact)
+        return exact;
+    const mentioned = LONGEST_FIRST.find((id) => boundary(id).test(text));
+    if (mentioned)
+        return mentioned;
+    return STAGES.find((id) => text.includes(STAGE_NAMES[id]));
+}
+/**
+ * Which half of the route has to run again.
+ *
+ * The draft is the seam: anything up to 4B was produced, and anything after it
+ * only read what the draft already held. A stage nobody could name redoes the
+ * lot, because the alternative is compiling something stale.
+ */
+export function resumeAt(stage) {
+    if (!stage)
+        return "produce";
+    return STAGES.indexOf(stage) <= STAGES.indexOf("4B") ? "produce" : "verify";
+}
+/** Where the ledger is cut back to. The earliest thing a retry can redo is 1. */
+export const dropPoint = (stage) => !stage || stage === "0" ? "1" : stage;

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

@@ -0,0 +1,5 @@
+import type { RouteResult } from "@spendgraph/harness";
+import type { NoesisResult } from "../types.js";
+import type { RunState } from "./state.js";
+/** The state, once every branch has run, as a result. */
+export declare function finish(decided: RouteResult, state: RunState, latencyMs: number): NoesisResult;

package/dist/noesis/run/result.js

@@ -0,0 +1,51 @@
+import { RouteFailedError, RouteNotBuiltError } from "./errors.js";
+/**
+ * What the run is worth acting on.
+ *
+ * An escalation outranks an abstention: a gate that asked for a person said so
+ * about the whole run, and 6C abstaining afterwards is a consequence of it.
+ */
+function statusOf(state) {
+    if (state.ledger.escalated())
+        return "escalated";
+    const answered = state.answered;
+    return answered && (answered.answer.abstained || !answered.accepted) ? "abstained" : "answered";
+}
+/** Everything the run was billed for, whole and split two ways. */
+function usageOfRun(state) {
+    const byStage = state.ledger.byStage();
+    return {
+        ...state.ledger.usage(),
+        byStage,
+        byModel: state.ledger.byModel(),
+        calls: byStage.reduce((total, stage) => total + stage.calls, 0),
+    };
+}
+/** The state, once every branch has run, as a result. */
+export function finish(decided, state, latencyMs) {
+    const { estimates, routing, answered, text, ledger } = state;
+    if (decided.status === "failed" || !estimates || !routing || !answered || !text) {
+        const named = routing?.route ?? decided.classified;
+        throw decided.route === null
+            ? new RouteNotBuiltError(named, estimates, routing, decided.error)
+            : new RouteFailedError(named, estimates, routing, decided.error);
+    }
+    const escalation = ledger.escalated();
+    const usage = usageOfRun(state);
+    return {
+        text,
+        status: statusOf(state),
+        ...(escalation ? { escalation } : {}),
+        currentTask: state.currentTask ?? estimates.summary,
+        route: routing.route,
+        routing,
+        estimates,
+        answer: answered,
+        rolloutIds: ledger.rolloutIds,
+        unattributed: state.unattributed ?? [],
+        usage,
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        latencyMs,
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { Llm } from "@spendgraph/llms";
+import type { PromptClient } from "@spendgraph/prompt";
+import type { NoesisOptions, NoesisResult } from "../types.js";
+export declare function run(client: PromptClient, llm: Llm, question: string, options?: NoesisOptions): Promise<NoesisResult>;

package/dist/noesis/run/run.js

@@ -0,0 +1,73 @@
+import { route } from "@spendgraph/harness";
+import { emitter } from "../events.js";
+import { notBuilt } from "./errors.js";
+import { finish } from "./result.js";
+import { classifyStage, directStage, fullStage, retrieveStage, standardStage, } from "./stages/index.js";
+import { newRunState } from "./state.js";
+/**
+ * Question in, answer out.
+ *
+ * `onDeliver` runs once, after the loop, and only for an answer worth acting
+ * on. Anything that renders a deliverable belongs there rather than inside a
+ * branch: nothing downstream reads it, no gate can check it, every back edge
+ * would make it again, and generating a finished-looking document out of an
+ * abstention is the worst thing this loop could produce.
+ *
+ * Pass the previous run's `currentTask` back in through `opts.triage` to keep a
+ * session going: it is what lets triage answer `is_new_task` at all, and the
+ * result carries the task forward for the turn after this one.
+ */
+const DEFAULT_MAX_RETRIES = 5;
+/**
+ * The options every stage is handed, with the emitter already on them.
+ *
+ * Threading it here rather than at each stage call is what let fifteen stages
+ * start announcing themselves without one of them being edited: they all
+ * already forward `opts.stage`, `opts.triage` and `opts.answer` verbatim.
+ */
+const watched = (opts, emit) => ({
+    ...opts,
+    triage: { ...opts.triage, emit },
+    stage: { ...opts.stage, emit },
+    answer: { ...opts.answer, emit },
+});
+export async function run(client, llm, question, options = {}) {
+    const startedAt = Date.now();
+    const emit = emitter(options.onEvent);
+    const opts = watched(options, emit);
+    const retryBudget = opts.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const state = newRunState(opts.triage?.currentTask, emit, retryBudget);
+    emit?.({
+        type: "run.started",
+        question,
+        hasTools: !!opts.tools,
+        retryBudget,
+    });
+    const decided = await route({ question }, {
+        classify: classifyStage(client, llm, question, opts, state),
+        routes: {
+            direct: directStage(client, llm, question, opts, state),
+            retrieve: retrieveStage(client, llm, question, opts, state),
+            standard: standardStage(client, llm, question, opts, state),
+            full: fullStage(client, llm, question, opts, state),
+        },
+        fallback: notBuilt("unknown"),
+    });
+    // Every price the stages left in flight, collected before the result is built.
+    await state.ledger.settle();
+    const result = finish(decided, state, Date.now() - startedAt);
+    emit?.({
+        type: "run.finished",
+        status: result.status,
+        text: result.text,
+        route: result.route,
+        usage: result.usage,
+        rollouts: result.rolloutIds.length,
+        latencyMs: result.latencyMs,
+    });
+    if (result.status === "answered") {
+        await opts.onDeliver?.(result);
+        emit?.({ type: "delivered" });
+    }
+    return result;
+}

package/dist/noesis/run/stages/classify.d.ts

@@ -0,0 +1,7 @@
+import type { Classification } from "@spendgraph/harness";
+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 0, and the route its estimates earn. */
+export declare const classifyStage: (client: PromptClient, llm: Llm, question: string, opts: NoesisOptions, state: RunState) => () => Promise<Classification>;

package/dist/noesis/run/stages/classify.js

@@ -0,0 +1,23 @@
+import { routeFor } from "../../route.js";
+import { invoke as triage } from "../../router/triage/index.js";
+import { nextTask } from "../state.js";
+/** Stage 0, and the route its estimates earn. */
+export const classifyStage = (client, llm, question, opts, state) => async () => {
+    const stage = await triage(client, llm, { ...opts.triage, currentTask: state.currentTask, question }, { ...opts.triage });
+    state.estimates = state.ledger.record("0", { ...stage, data: stage.estimates });
+    state.routing = routeFor(stage.estimates);
+    state.currentTask = nextTask(stage.estimates, state.currentTask);
+    state.emit?.({
+        type: "run.routed",
+        route: state.routing.route,
+        routing: state.routing,
+        estimates: stage.estimates,
+    });
+    return {
+        route: state.routing.route,
+        reason: state.routing.reason,
+        model: stage.model,
+        inputTokens: stage.inputTokens,
+        outputTokens: stage.outputTokens,
+    };
+};

package/dist/noesis/run/stages/direct.d.ts

@@ -0,0 +1,6 @@
+import type { Llm } from "@spendgraph/llms";
+import type { PromptClient } from "@spendgraph/prompt";
+import type { NoesisOptions } from "../../types.js";
+import type { RunState } from "../state.js";
+/** The direct branch: the question and what triage made of it, straight to 6C. */
+export declare const directStage: (client: PromptClient, llm: Llm, question: string, opts: NoesisOptions, state: RunState) => () => Promise<string>;

package/dist/noesis/run/stages/direct.js

@@ -0,0 +1,8 @@
+import { answer } from "../../producers/toulmin/index.js";
+/** The direct branch: the question and what triage made of it, straight to 6C. */
+export const directStage = (client, llm, question, opts, state) => async () => {
+    const answered = await answer(client, llm, { question, ...state.ledger.artifacts() }, opts.answer ?? {});
+    state.answered = answered;
+    state.text = state.ledger.record("6C", { ...answered, data: answered.answer }).claim;
+    return state.text;
+};

package/dist/noesis/run/stages/full.d.ts

@@ -0,0 +1,14 @@
+import type { Llm } from "@spendgraph/llms";
+import type { PromptClient } from "@spendgraph/prompt";
+import type { NoesisOptions } from "../../types.js";
+import type { RunState } from "../state.js";
+/**
+ * The full branch: everything standard does, plus the audits.
+ *
+ * 3B and 3C interrogate the plan before it runs; 5C and 6B interrogate the
+ * answer before it ships. Standard already plans, so what full adds is four
+ * audits and nothing else. 6B fires on `routing.redTeam` rather than on the
+ * route, because stakes are what earn it — a run sent here by difficulty or
+ * ambiguity has no attacker to pay for.
+ */
+export declare const fullStage: (client: PromptClient, llm: Llm, question: string, opts: NoesisOptions, state: RunState) => () => Promise<string>;

package/dist/noesis/run/stages/full.js

@@ -0,0 +1,21 @@
+import { settle } from "../loop.js";
+import { produce } from "../produce.js";
+import { compile } from "../verify.js";
+/**
+ * The full branch: everything standard does, plus the audits.
+ *
+ * 3B and 3C interrogate the plan before it runs; 5C and 6B interrogate the
+ * answer before it ships. Standard already plans, so what full adds is four
+ * audits and nothing else. 6B fires on `routing.redTeam` rather than on the
+ * route, because stakes are what earn it — a run sent here by difficulty or
+ * ambiguity has no attacker to pay for.
+ */
+export const fullStage = (client, llm, question, opts, state) => async () => {
+    const reproduce = () => produce(client, llm, question, opts, state, true);
+    await settle(client, llm, question, opts, state, await reproduce(), {
+        standards: true,
+        redTeam: state.routing?.redTeam ?? false,
+        reproduce,
+    });
+    return compile(client, llm, question, opts, state);
+};

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

@@ -0,0 +1,5 @@
+export { classifyStage } from "./classify.js";
+export { directStage } from "./direct.js";
+export { fullStage } from "./full.js";
+export { retrieveStage } from "./retrieve.js";
+export { standardStage } from "./standard.js";

package/dist/noesis/run/stages/index.js

@@ -0,0 +1,5 @@
+export { classifyStage } from "./classify.js";
+export { directStage } from "./direct.js";
+export { fullStage } from "./full.js";
+export { retrieveStage } from "./retrieve.js";
+export { standardStage } from "./standard.js";

package/dist/noesis/run/stages/retrieve.d.ts

@@ -0,0 +1,13 @@
+import type { Llm } from "@spendgraph/llms";
+import type { PromptClient } from "@spendgraph/prompt";
+import type { NoesisOptions } from "../../types.js";
+import type { RunState } from "../state.js";
+/**
+ * The retrieve branch: one lookup, then 6C compiles what came back.
+ *
+ * No brief and no decomposition, because there is nothing to interrogate or
+ * split — the question is clear and the only reason the model cannot answer it
+ * is that the answer is somewhere else. A tool that finds nothing leaves 6C
+ * with no grounds, which is what abstention is for.
+ */
+export declare const retrieveStage: (client: PromptClient, llm: Llm, question: string, opts: NoesisOptions, state: RunState) => () => Promise<string>;

package/dist/noesis/run/stages/retrieve.js

@@ -0,0 +1,38 @@
+import { execute } from "../../execute/index.js";
+import { answer } from "../../producers/toulmin/index.js";
+import { NoToolsError } from "../errors.js";
+const DEFAULT_TOOL = "deeprecall";
+const lookup = (question, tool) => ({
+    id: "q",
+    question,
+    depends_on: [],
+    verify_by: "the tool returned something to cite",
+    done_when: "the lookup came back",
+    kind: "read_only",
+    tool,
+});
+/**
+ * The retrieve branch: one lookup, then 6C compiles what came back.
+ *
+ * No brief and no decomposition, because there is nothing to interrogate or
+ * split — the question is clear and the only reason the model cannot answer it
+ * is that the answer is somewhere else. A tool that finds nothing leaves 6C
+ * with no grounds, which is what abstention is for.
+ */
+export const retrieveStage = (client, llm, question, opts, state) => async () => {
+    if (!opts.tools)
+        throw new NoToolsError();
+    const execution = await execute(opts.tools, [lookup(question, opts.retrieve?.tool ?? DEFAULT_TOOL)], { emit: state.emit });
+    state.ledger.record("4", {
+        data: execution,
+        rolloutIds: [],
+        model: "",
+        inputTokens: 0,
+        outputTokens: 0,
+        latencyMs: execution.toolMs,
+    });
+    const answered = await answer(client, llm, { question, ...state.ledger.artifacts() }, opts.answer ?? {});
+    state.answered = answered;
+    state.text = state.ledger.record("6C", { ...answered, data: answered.answer }).claim;
+    return state.text;
+};

package/dist/noesis/run/stages/standard.d.ts

@@ -0,0 +1,12 @@
+import type { Llm } from "@spendgraph/llms";
+import type { PromptClient } from "@spendgraph/prompt";
+import type { NoesisOptions } from "../../types.js";
+import type { RunState } from "../state.js";
+/**
+ * The standard branch: frame it, split it, answer the parts, then check them.
+ *
+ * It plans, because 4A judges each step against the tolerance 3A wrote for it.
+ * What it does not do is audit: no premortem or gate on the plan, and no
+ * standards review or red team on the answer. That is what `full` buys.
+ */
+export declare const standardStage: (client: PromptClient, llm: Llm, question: string, opts: NoesisOptions, state: RunState) => () => Promise<string>;

package/dist/noesis/run/stages/standard.js

@@ -0,0 +1,19 @@
+import { settle } from "../loop.js";
+import { produce } from "../produce.js";
+import { compile } from "../verify.js";
+/**
+ * The standard branch: frame it, split it, answer the parts, then check them.
+ *
+ * It plans, because 4A judges each step against the tolerance 3A wrote for it.
+ * What it does not do is audit: no premortem or gate on the plan, and no
+ * standards review or red team on the answer. That is what `full` buys.
+ */
+export const standardStage = (client, llm, question, opts, state) => async () => {
+    const reproduce = () => produce(client, llm, question, opts, state, false);
+    await settle(client, llm, question, opts, state, await reproduce(), {
+        standards: false,
+        redTeam: false,
+        reproduce,
+    });
+    return compile(client, llm, question, opts, state);
+};

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

@@ -0,0 +1,26 @@
+import type { Emit } from "../events.js";
+import type { AnswerResult } from "../producers/toulmin/index.js";
+import type { TriageEstimates } from "../router/triage/index.js";
+import type { Routing } from "../types.js";
+import { type Ledger } from "./ledger.js";
+/** What each branch writes down, since `route()` hands back only its output. */
+export interface RunState {
+    /** Every stage's result and what it cost, in one place. */
+    ledger: Ledger;
+    /** Where the run layer says what it is doing. Undefined when nobody listens. */
+    emit?: Emit;
+    /** The open task, carried into the run and rewritten once triage has read it. */
+    currentTask?: string;
+    estimates?: TriageEstimates;
+    routing?: Routing;
+    answered?: AnswerResult;
+    text?: string;
+    /** `source_stage` values 6C cited that no stage in this run produced. */
+    unattributed?: string[];
+}
+export declare const newRunState: (currentTask?: string, emit?: Emit, maxRetries?: number) => RunState;
+/**
+ * The open task after triage has read the request: the router's summary when it
+ * calls the request new, otherwise the task carried in.
+ */
+export declare function nextTask(estimates: TriageEstimates, current?: string): string;

package/dist/noesis/run/state.js

@@ -0,0 +1,13 @@
+import { newLedger } from "./ledger.js";
+export const newRunState = (currentTask, emit, maxRetries) => ({
+    ledger: newLedger(maxRetries, emit),
+    emit,
+    currentTask,
+});
+/**
+ * The open task after triage has read the request: the router's summary when it
+ * calls the request new, otherwise the task carried in.
+ */
+export function nextTask(estimates, current) {
+    return estimates.is_new_task ? estimates.summary : (current ?? estimates.summary);
+}