@spendgraph/workflows 0.2.0 → 0.3.0

package/dist/noesis/run/produce.js

@@ -6,25 +6,12 @@ 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.
- */
+import { stageOptionsFor } from "./options.js";
+import { NO_TOOL_SPEND } from "../execute/spend.js";
+import { recordToolSpend } from "./state.js";
 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));
+    const brief1 = state.ledger.record("1", await brief(client, llm, { question, ...opts.context }, stageOptionsFor(opts, "1")));
     let asked = question;
     if (!brief1.is_right_question && brief1.better_question && opts.onAsk) {
         state.emit?.({
@@ -41,20 +28,14 @@ export async function frame(client, llm, question, opts, state) {
         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));
+    const split = state.ledger.record("2", await decompose(client, llm, { question: asked, ...opts.context }, stageOptionsFor(opts, "2")));
     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 });
+    recordToolSpend(state, execution.spend);
     state.ledger.record("4", {
         data: execution,
         rolloutIds: [],
@@ -69,24 +50,13 @@ export async function work(client, llm, question, opts, state, split) {
         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));
+    const checkpoint = state.ledger.record("4A", await thinkCheckpoint(client, llm, { question: soFar(state, question), ...opts.context }, stageOptionsFor(opts, "4A")));
     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 (;;) {
@@ -95,6 +65,7 @@ export async function produce(client, llm, question, opts, state, audits) {
             return assemble(asked, split, {
                 answers: [],
                 unresolved: split.sub_questions.map((sub) => sub.id),
+                spend: NO_TOOL_SPEND,
                 toolMs: 0,
             });
         }

package/dist/noesis/run/redo.js

@@ -1,18 +1,6 @@
 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)
@@ -25,17 +13,9 @@ export function parseStage(said) {
         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.js

@@ -1,27 +1,20 @@
 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(),
+        tools: state.toolSpend,
         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) {
@@ -44,8 +37,6 @@ export function finish(decided, state, latencyMs) {
         rolloutIds: ledger.rolloutIds,
         unattributed: state.unattributed ?? [],
         usage,
-        inputTokens: usage.inputTokens,
-        outputTokens: usage.outputTokens,
         latencyMs,
     };
 }

package/dist/noesis/run/run.js

@@ -4,32 +4,17 @@ 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 },
+    ...(opts.stages
+        ? {
+            stages: Object.fromEntries(Object.entries(opts.stages).map(([id, one]) => [id, { ...one, emit }])),
+        }
+        : {}),
 });
 export async function run(client, llm, question, options = {}) {
     const startedAt = Date.now();
@@ -53,7 +38,6 @@ export async function run(client, llm, question, options = {}) {
         },
         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?.({

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

@@ -1,9 +1,9 @@
 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. */
+import { stageOptionsFor } from "../options.js";
 export const classifyStage = (client, llm, question, opts, state) => async () => {
-    const stage = await triage(client, llm, { ...opts.triage, currentTask: state.currentTask, question }, { ...opts.triage });
+    const stage = await triage(client, llm, { ...opts.triage, currentTask: state.currentTask, question }, { ...stageOptionsFor(opts, "0"), ...opts.triage });
     state.estimates = state.ledger.record("0", { ...stage, data: stage.estimates });
     state.routing = routeFor(stage.estimates);
     state.currentTask = nextTask(stage.estimates, state.currentTask);

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

@@ -1,5 +1,4 @@
 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;

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

@@ -1,15 +1,6 @@
 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(), {

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

@@ -11,14 +11,6 @@ const lookup = (question, tool) => ({
     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();

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

@@ -1,13 +1,6 @@
 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(), {

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

@@ -1,3 +1,4 @@
+import { type ToolSpend } from "../execute/spend.js";
 import type { Emit } from "../events.js";
 import type { AnswerResult } from "../producers/toulmin/index.js";
 import type { TriageEstimates } from "../router/triage/index.js";
@@ -5,6 +6,8 @@ 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 {
+    /** What the tools reported they cost, which no stage's tokens include. */
+    toolSpend: ToolSpend;
     /** 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. */
@@ -19,6 +22,8 @@ export interface RunState {
     unattributed?: string[];
 }
 export declare const newRunState: (currentTask?: string, emit?: Emit, maxRetries?: number) => RunState;
+/** Adds one execution's tool spend to the run's. A retry refunds nothing. */
+export declare function recordToolSpend(state: RunState, spend: ToolSpend): void;
 /**
  * The open task after triage has read the request: the router's summary when it
  * calls the request new, otherwise the task carried in.

package/dist/noesis/run/state.js

@@ -1,13 +1,14 @@
+import { addToolSpend, NO_TOOL_SPEND } from "../execute/spend.js";
 import { newLedger } from "./ledger.js";
 export const newRunState = (currentTask, emit, maxRetries) => ({
+    toolSpend: NO_TOOL_SPEND,
     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 recordToolSpend(state, spend) {
+    state.toolSpend = addToolSpend(state.toolSpend, spend);
+}
 export function nextTask(estimates, current) {
     return estimates.is_new_task ? estimates.summary : (current ?? estimates.summary);
 }

package/dist/noesis/run/stream.js

@@ -1,18 +1,5 @@
 import { streamed } from "@spendgraph/harness";
 import { run } from "./run.js";
-/**
- * `run()`, watched.
- *
- * The run starts on the call rather than on the first read, so a client that
- * connects late still receives everything that already happened, and a caller
- * who only wants the answer never has to iterate.
- *
- * Events arrive unwrapped — a consumer switches on `event.type` directly rather
- * than reaching through the harness envelope the queue underneath uses.
- *
- * `opts.onEvent` still works and is called first, so a caller can log and
- * stream from the same run.
- */
 export function runStream(client, llm, question, opts = {}) {
     const inner = streamed((_emit, note) => run(client, llm, question, {
         ...opts,

package/dist/noesis/run/verify.js

@@ -7,21 +7,12 @@ import { invoke as reflection } from "../repair/reflection/index.js";
 import { blind, compare, render as renderChecks } from "../verify/index.js";
 import { soFar } from "./produce.js";
 import { parseStage, resumeAt } from "./redo.js";
-/**
- * Stages 5A, 5B and the pairing between them.
- *
- * 5B is given `blind()` rather than the questions themselves, so it answers
- * without sight of the claims it settles. Putting the two back together is the
- * step in between, and it stays in code for the same reason.
- *
- * A 5A that found nothing to check skips 5B rather than sending it an empty
- * turn, which every provider rejects.
- */
+import { answerOptions, stageOptionsFor } from "./options.js";
 export async function checks(client, llm, opts, state, draft) {
     const drafted = renderDraft(draft);
-    const questions = state.ledger.record("5A", await coveQuestions(client, llm, { question: drafted, ...opts.context }, opts.stage));
+    const questions = state.ledger.record("5A", await coveQuestions(client, llm, { question: drafted, ...opts.context }, stageOptionsFor(opts, "5A")));
     const answers = questions.questions.length
-        ? state.ledger.record("5B", await coveAnswers(client, llm, { question: blind(questions), ...opts.context }, opts.stage))
+        ? state.ledger.record("5B", await coveAnswers(client, llm, { question: blind(questions), ...opts.context }, stageOptionsFor(opts, "5B")))
         : { answers: [] };
     const verification = compare(questions, answers, opts.verify?.confidenceFloor);
     state.emit?.({
@@ -43,15 +34,8 @@ export async function checks(client, llm, opts, state, draft) {
     });
     return `${drafted}\n\n${renderChecks(verification)}`;
 }
-/**
- * Stage R. The earliest wrong decision, and the stage to redo from.
- *
- * The gate says where the problem surfaced; this says where it started, which
- * is rarely the same place and is the only one worth returning to. The gate's
- * own suggestion is the fallback, not the answer.
- */
 export async function reflect(client, llm, question, opts, state, gate, reason, hint) {
-    const looked = state.ledger.record("R", await reflection(client, llm, { question: `${soFar(state, question)}\n\nThe gate said: ${reason}`, ...opts.context }, opts.stage));
+    const looked = state.ledger.record("R", await reflection(client, llm, { question: `${soFar(state, question)}\n\nThe gate said: ${reason}`, ...opts.context }, stageOptionsFor(opts, "R")));
     const redoFrom = parseStage(looked.redo_from_stage) ?? parseStage(hint ?? "");
     state.emit?.({
         type: "reflect.pointed",
@@ -62,9 +46,8 @@ export async function reflect(client, llm, question, opts, state, gate, reason,
     });
     return redoFrom;
 }
-/** Stage 6C. Everything the ledger holds, compiled into a claim. */
 export async function compile(client, llm, question, opts, state) {
-    const answered = await answer(client, llm, { question, ...state.ledger.artifacts() }, opts.answer ?? {});
+    const answered = await answer(client, llm, { question, ...state.ledger.artifacts() }, answerOptions(opts));
     state.answered = answered;
     const loose = unattributed(answered.answer, state.ledger.byStage().map((one) => one.stage));
     state.unattributed = loose;

package/dist/noesis/slugs.js

@@ -13,20 +13,6 @@ import { BRIEF_SLUG } from "./producers/qn-brief/prompt.js";
 import { TOULMIN_SLUG } from "./producers/toulmin/prompt.js";
 import { REFLECTION_SLUG } from "./repair/reflection/prompt.js";
 import { TRIAGE_SLUG } from "./router/triage/prompt.js";
-/**
- * Which stage a slug belongs to.
- *
- * The inverse of what the fifteen modules already declare, and the reason
- * `runStage` can announce a stage it was only ever told the slug of. A slug
- * nobody claims is not an error — it means a caller reached `runStage` with a
- * prompt of their own, and an event for it would be a lie.
- *
- * Imported from each `prompt.ts` rather than from the module's `index.ts`,
- * which would be a cycle: an index re-exports `invoke`, `invoke` reaches
- * `announce`, and `announce` reads this map. A computed key whose value is
- * still uninitialised becomes the literal string "undefined" — no error, just a
- * stage that silently never announces itself.
- */
 export const STAGE_OF_SLUG = {
     [TRIAGE_SLUG]: "0",
     [BRIEF_SLUG]: "1",

package/dist/noesis/stage.js

@@ -3,7 +3,6 @@ import { askThrough, QUESTION_FIELD } from "./question.js";
 import { attempting } from "./retry.js";
 import { announce, failed } from "./started.js";
 import { usageOf } from "./usage.js";
-/** The reply came back, but not as the object the stage is supposed to return. */
 export class StageReplyError extends Error {
     slug;
     raw;
@@ -14,15 +13,6 @@ export class StageReplyError extends Error {
         this.name = "StageReplyError";
     }
 }
-/**
- * One stored prompt, called and parsed.
- *
- * Every stage does the same four things — pull by slug, put the request through
- * `{question}`, force the schema, hand back the object with what it cost — so
- * they do it here rather than thirteen times over. The call is recorded once,
- * as the prompt's rollout: the model client is told not to trace, or the same
- * tokens land again as usage and every run prices double.
- */
 export async function runStage(client, llm, slug, schema, input, opts = {}) {
     announce(opts.emit, slug, opts.model);
     return attempting(async () => {

package/dist/noesis/started.js

@@ -1,11 +1,5 @@
 import { STAGE_NAMES } from "./run/ledger.js";
 import { STAGE_OF_SLUG } from "./slugs.js";
-/**
- * Say a stage has begun, if anyone is listening and the slug is one of ours.
- *
- * Shared by the three call paths — `runStage` and the copies triage and 6C keep
- * — so the three of them cannot drift on what a `stage.started` looks like.
- */
 export function announce(emit, slug, model) {
     if (!emit)
         return;
@@ -15,15 +9,6 @@ export function announce(emit, slug, model) {
     emit({ type: "stage.started", stage, name: STAGE_NAMES[stage], slug, model });
 }
 const message = (err) => (err instanceof Error ? err.message : String(err));
-/**
- * Say a stage did not produce what it was asked for.
- *
- * The kind is read off the error's name rather than by importing the three
- * reply errors, which would be a cycle — `stage.ts` reaches this file, and the
- * errors live beside the calls that throw them. Every one of them ends in
- * `ReplyError`, and that is the distinction worth drawing: a reply that came
- * back wrong is the prompt's problem, anything else is the provider's.
- */
 export function failed(emit, slug, err) {
     if (!emit)
         return;

package/dist/noesis/types.d.ts

@@ -1,10 +1,11 @@
 import type { ToolBus } from "@spendgraph/tools";
+import type { ToolSpend } from "./execute/spend.js";
 import type { Asked } from "./context.js";
 import type { NoesisEvent } from "./events.js";
 import type { SubQuestionTool } from "./producers/decompose/index.js";
 import type { AnswerOptions, AnswerResult } from "./producers/toulmin/index.js";
 import type { TriageEstimates, TriageInput, TriageOptions } from "./router/triage/index.js";
-import type { Escalation, StageUsage } from "./run/ledger.js";
+import type { Escalation, StageKey, StageUsage } from "./run/ledger.js";
 import type { StageOptions } from "./stage.js";
 import type { Usage } from "./usage.js";
 /**
@@ -78,6 +79,13 @@ export interface NoesisOptions {
     context?: Omit<Asked, "question">;
     /** Model and params for every stage between triage and the answer. */
     stage?: StageOptions;
+    /**
+     * Per-stage overrides, keyed by the stage's key, winning over `stage`.
+     *
+     * `params` is not inherited by a stage that names its own `model`: sampling
+     * knobs are per model, and a body written for one is rejected by another.
+     */
+    stages?: Partial<Record<StageKey, StageOptions>>;
     /**
      * Reached when a stage wants a person before it can go on.
      *
@@ -152,13 +160,17 @@ export interface NoesisResult {
      * each inside its own output under the stage `4` artifact.
      */
     usage: RunUsage;
-    /** @deprecated Read `usage.inputTokens`. Kept so existing callers still work. */
-    inputTokens: number;
-    /** @deprecated Read `usage.outputTokens`. Kept so existing callers still work. */
-    outputTokens: number;
     latencyMs: number;
 }
 export interface RunUsage extends Usage {
+    /**
+     * What the tools reported, which the numbers above deliberately exclude.
+     *
+     * A tool call is somebody else's API at somebody else's rates and is no
+     * rollout of ours, so it is never folded into the model spend — but it is
+     * real money, so it is reachable rather than buried in an artifact.
+     */
+    tools: ToolSpend;
     /** Summed over every time the loop ran each stage. */
     byStage: StageUsage[];
     byModel: Record<string, Usage>;

package/dist/noesis/usage.js

@@ -6,14 +6,7 @@ export const NO_USAGE = {
     citationTokens: 0,
     reasoningTokens: 0,
 };
-/**
- * Sums two costs without inventing one.
- *
- * Undefined on both sides stays undefined; a priced call landing beside an
- * unpriced one gives the priced total, which is a floor rather than a fiction.
- */
 const addCost = (a, b) => a === undefined && b === undefined ? undefined : (a ?? 0) + (b ?? 0);
-/** Every token field filled, so a caller never has to guard one. Cost stays absent when it is. */
 export const usageOf = (reported) => ({
     inputTokens: reported.inputTokens ?? 0,
     outputTokens: reported.outputTokens ?? 0,
@@ -35,22 +28,13 @@ export const addUsage = (total, next) => ({
         return cost === undefined ? {} : { costMicros: cost };
     })(),
 });
-/** Every token the call is billed for, however the provider split them. */
 export const billableTokens = (usage) => usage.inputTokens +
     usage.outputTokens +
     usage.cacheReadTokens +
     usage.cacheWriteTokens +
     usage.citationTokens +
     usage.reasoningTokens;
-/** What the run is known to have cost, in micro-USD, or undefined where nothing priced it. */
 export const spend = (usage) => usage.costMicros;
-/**
- * One price for several calls: undefined unless at least one of them was priced.
- *
- * The cascade in 6C runs a tier at a time, so a run can hold several prices
- * still in flight. Summing them with `?? 0` alone would turn "nobody priced
- * any of these" into a confident zero.
- */
 export const totalCost = (costs) => costs.some((cost) => cost !== undefined)
     ? costs.reduce((sum, cost) => sum + (cost ?? 0), 0)
     : undefined;

package/dist/noesis/verify/verify.js

@@ -1,36 +1,8 @@
 const DEFAULT_FLOOR = 0.6;
-/**
- * What a check can honestly have been settled by when 5B is given no tools.
- *
- * `coveAnswers` is called with a client, a model and a question — there is no
- * `ToolBus` on that call, so parametric memory is the only thing the stage can
- * have used. Every other value in the enum is reachable only by passing a wider
- * set to `compare()`, which is the caller saying it wired the tools up.
- */
 export const SETTLED_WITHOUT_TOOLS = new Set(["knowledge"]);
-/**
- * The questions as 5B is allowed to see them: ids and questions, nothing else.
- *
- * `claim_it_tests` and `claim_type` are stripped here rather than trusted to a
- * prompt. Answering blind is the whole reason 5A and 5B are two stages, and a
- * stage that can read the claim will answer the claim.
- */
 export function blind(questions) {
     return questions.questions.map((q) => `${q.id}. ${q.question}`).join("\n");
 }
-/**
- * 5A and 5B paired back together by id.
- *
- * In code because it has to be: whatever does this sees both the claim and the
- * answer that was written without it, and a model given both is no longer a
- * blind check of anything.
- *
- * A reply that named no provenance at all is not overclaiming. `checked_by` is
- * required by the schema and nothing checks a reply against it on the way back,
- * so an absent one is the model being terse rather than the stage claiming a
- * tool it never had — it settles to `knowledge`, which is the floor anyway, and
- * is not reported as a correction nobody made.
- */
 export function compare(questions, answers, floor = DEFAULT_FLOOR, settledBy = SETTLED_WITHOUT_TOOLS) {
     const replies = new Map(answers.answers.map((a) => [a.id, a]));
     const asked = new Set(questions.questions.map((q) => q.id));
@@ -71,7 +43,6 @@ export function compare(questions, answers, floor = DEFAULT_FLOOR, settledBy = S
     };
 }
 const line = (c) => `${c.id}. ${c.claim}\n   asked: ${c.question}\n   found: ${c.unknown ? "nothing" : c.answer} (${c.settled ? "settled" : "unsettled"}, confidence ${c.confidence})${c.as_of ? `\n   as of: ${c.as_of}` : ""}`;
-/** The verification as a stage reads it. */
 export function render(verification) {
     const parts = [
         `<checks>\n${verification.checked.length

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spendgraph/workflows",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Ready-made workflows assembled from the spendgraph packages.",
   "license": "MIT",
   "repository": {
@@ -33,13 +33,13 @@
     "README.md"
   ],
   "dependencies": {
-    "@spendgraph/harness": "^0.2.0",
-    "@spendgraph/llms": "^0.2.0",
-    "@spendgraph/prompt": "^0.2.0",
-    "@spendgraph/tools": "^0.2.0"
+    "@spendgraph/harness": "^0.3.0",
+    "@spendgraph/llms": "^0.3.0",
+    "@spendgraph/prompt": "^0.3.0",
+    "@spendgraph/tools": "^0.3.0"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json --emitDeclarationOnly && tsc -p tsconfig.json --declaration false --removeComments",
     "prebuild": "npm run build --workspace @spendgraph/harness --workspace @spendgraph/llms --workspace @spendgraph/prompt --workspace @spendgraph/tools",
     "test": "vitest run",
     "eval": "vitest run --config evals/vitest.config.mts",
@@ -47,7 +47,7 @@
   },
   "devDependencies": {
     "@locusgraph/client": "^0.8.1",
-    "@spendgraph/evals": "^0.2.0",
+    "@spendgraph/evals": "^0.3.0",
     "typescript": "^5"
   },
   "engines": {