@spendgraph/workflows 0.2.0 → 0.3.0

package/README.md

@@ -3,6 +3,10 @@
 Ready-made workflows assembled from the other packages. One so far: **noesis**,
 a question-answering loop that decides how much of itself a question is worth.
 
+```sh
+npm install @spendgraph/workflows
+```
+
 ```ts
 import { run } from "@spendgraph/workflows";
 
@@ -66,6 +70,57 @@ answer. Stage 5 pairs 5A's claims back to 5B's blind answers, and it has to be
 code: whatever does it sees both the claim and the answer written without it,
 and a model given both is no longer a blind check of anything.
 
+## Choosing models
+
+`stage` sets the model every stage runs on. `stages` overrides it by name, for
+the stages worth paying more or less for.
+
+```ts
+await run(client, llm, question, {
+  stage: { model: "claude-haiku-4-5" },
+  stages: {
+    plan_candidates: { model: "claude-sonnet-4-6" },
+    red_team: { model: "claude-opus-4-8" },
+    answer: { model: "claude-sonnet-4-6" },
+  },
+});
+```
+
+The keys are the stage names from the table above with the spaces closed up —
+`triage`, `question_brief`, `plan_candidates`, `red_team`, `answer` — and
+`STAGE_KEYS` maps every id to its own. `triage` and `answer` also have
+`opts.triage` and `opts.answer`, which
+take more than a model — a current task, and the answer's escalating tiers —
+and win where both are set.
+
+**`params` does not follow a model it was not written for.** A stage naming its
+own `model` gets its own `params` or none: Haiku takes `temperature`, Sonnet 5
+rejects it outright, and one shared request body fails on whichever it was not
+written for. A stage overriding only `params` still merges over `stage`.
+
+## What a run cost
+
+`usage` is the model spend: six numbers rather than two, summed across every
+stage and every retry, split `byStage` and `byModel` because the answer can
+cascade. A back edge refunds nothing.
+
+`usage.tools` is what the tools reported, and it is deliberately **not** folded
+in — a tool call is somebody else's API at somebody else's rates and is no
+rollout of ours.
+
+```ts
+result.usage.inputTokens;              // the model side
+result.usage.byModel["claude-sonnet-4-6"];
+
+result.usage.tools.calls;              // the tool side
+result.usage.tools.costMicros;         // where a tool priced itself
+result.usage.tools.byTool.web_search;  // tokens, keyed by the tool that ran
+```
+
+Bill both or you undercharge every run that touched the web: `web_search`
+reports Perplexity's four token counts and `deep_recall` reports micro-USD,
+and stage 4 records zero tokens of its own.
+
 ## The ledger
 
 Every stage files its result, its rollouts and its tokens in one place. That
@@ -147,3 +202,7 @@ with `04-retrieve.mjs`: it is the cheapest, and it exercises triage, the
 dispatcher, the ledger and 6C. The routes that look something up need one of
 the two lookups configured — `LOCUSGRAPH_AGENT_SECRET` for `deep_recall`, or
 `PERPLEXITY_API_KEY` for `web_search` — and say so rather than half-running.
+
+## License
+
+MIT

package/dist/noesis/attribution.js

@@ -1,14 +1,6 @@
 import { STAGE_NAMES, STAGES } from "./run/ledger.js";
 const BY_NAME = new Map(Object.entries(STAGE_NAMES).map(([id, name]) => [name.toLowerCase(), id]));
 const IDS = new Set(STAGES);
-/**
- * The stage a ground says it came from, or nothing.
- *
- * Lenient because the field is free text on a model reply, and "5B", "stage 5B"
- * and "verification answers" are the same citation. It will not guess: a string
- * that resolves to nothing is a ground that cannot be traced, which is the
- * finding rather than a parsing problem to work around.
- */
 export function stageCited(source) {
     const raw = source.trim();
     const id = raw
@@ -19,18 +11,6 @@ export function stageCited(source) {
         return id;
     return BY_NAME.get(raw.toLowerCase());
 }
-/**
- * The grounds citing a stage this run never ran.
- *
- * 6C compiles `grounds[]` out of the artifacts and each one names its
- * `source_stage`; the ledger knows which stages were actually paid for. A
- * citation of anything else is the stage writing evidence rather than
- * assembling it, and it is the cheapest check available that catches a
- * fabricated answer without a judge and without a reference.
- *
- * Returns the `source_stage` strings as written, because what the model claimed
- * is the useful thing to read back.
- */
 export function unattributed(answer, ran) {
     const filed = new Set(ran);
     const grounds = answer.grounds ?? [];

package/dist/noesis/context.js

@@ -1,11 +1,3 @@
-/**
- * The request with the `<context>` block ahead of it.
- *
- * The prompts name `now` and `locale` but never show the markup they expect
- * them in, so this is the form they are given. An absent fact is omitted rather
- * than sent empty: a missing one is recorded as something to find out, an empty
- * one reads as a fact already in hand.
- */
 export function asked(input) {
     const facts = [
         input.now ? `now: ${input.now}` : "",

package/dist/noesis/draft/draft.js

@@ -1,11 +1,4 @@
 const NEVER_RAN = "It depended on something that was never answered.";
-/**
- * The sub-answers, paired back to the sub-questions that asked for them.
- *
- * A sub-question that produced nothing is named rather than dropped: 6A asks
- * whether every one was answered, and a draft that quietly omits the failures
- * would let it say yes.
- */
 export function assemble(question, decomposition, execution) {
     const asked = new Map(decomposition.sub_questions.map((sub) => [sub.id, sub.question]));
     const findings = [];
@@ -29,12 +22,6 @@ export function assemble(question, decomposition, execution) {
 }
 const block = (tag, body) => `<${tag}>\n${body}\n</${tag}>`;
 const asText = (answer) => typeof answer === "string" ? answer : JSON.stringify(answer, null, 2);
-/**
- * The draft as a stage reads it.
- *
- * Tagged the way `asked()` tags the context block, because every stage
- * downstream takes this through `{question}` and has to tell the parts apart.
- */
 export function render(draft) {
     const parts = [
         block("question", draft.question),

package/dist/noesis/events.js

@@ -1,12 +1,3 @@
-/**
- * One emitter per run, stamping order and elapsed time.
- *
- * Deliberately synchronous and deliberately swallowing: a listener that throws
- * is a bug in the listener, and letting it take the run down would make
- * watching a run more dangerous than not watching one. Returns `undefined`
- * where nobody is listening, so every emit site can stay a `?.` call and cost
- * nothing.
- */
 export function emitter(listener, now = Date.now) {
     if (!listener)
         return undefined;
@@ -18,7 +9,6 @@ export function emitter(listener, now = Date.now) {
             listener(stamped);
         }
         catch {
-            // A listener that throws does not get to fail the run.
         }
     };
 }

package/dist/noesis/execute/execute.js

@@ -1,10 +1,5 @@
 import { order } from "./order.js";
-/**
- * What each hint reaches for, and where the question goes.
- *
- * `code_exec` and `get_documents` are unwired because nothing ships them —
- * a sub-question asking for one is reported rather than quietly dropped.
- */
+import { toolSpendOf } from "./spend.js";
 export const DEFAULT_TOOLS = {
     calculator: { name: "calculate", arg: "expression" },
     deeprecall: { name: "deep_recall", arg: "question" },
@@ -54,17 +49,6 @@ async function answerOne(bus, wiring, sub, wave, emit) {
         ? { ...base, status: "failed", reason: result.error, latencyMs: result.latencyMs }
         : { ...base, status: "answered", result: parsed(result.output), latencyMs: result.latencyMs });
 }
-/**
- * Stage 4. Every sub-question put through the tool its hint named.
- *
- * The dispatcher dispatches and does not reason: `deep_recall` and `web_search`
- * already return a synthesised answer, and a sub-question with no tool is
- * recorded as unanswered rather than guessed at.
- *
- * `done_when` is carried rather than acted on. It describes an observable
- * condition, which is 4A's job to judge against what actually happened, not
- * something this can evaluate.
- */
 export async function execute(bus, plan, opts = {}) {
     const wiring = { ...DEFAULT_TOOLS, ...opts.tools };
     const { waves, unresolved } = order(plan);
@@ -80,6 +64,7 @@ export async function execute(bus, plan, opts = {}) {
     return {
         answers,
         unresolved,
+        spend: toolSpendOf(answers, wiring),
         toolMs: answers.reduce((total, answer) => total + answer.latencyMs, 0),
     };
 }

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

@@ -1,3 +1,5 @@
 export { DEFAULT_TOOLS, execute } from "./execute.js";
 export { order } from "./order.js";
 export type { ExecuteOptions, Execution, SubAnswer, Waves, Wiring } from "./types.js";
+export type { ToolSpend, ToolUsage } from "./spend.js";
+export { addToolSpend, NO_TOOL_SPEND, readToolUsage, toolSpendOf } from "./spend.js";

package/dist/noesis/execute/index.js

@@ -1,2 +1,3 @@
 export { DEFAULT_TOOLS, execute } from "./execute.js";
 export { order } from "./order.js";
+export { addToolSpend, NO_TOOL_SPEND, readToolUsage, toolSpendOf } from "./spend.js";

package/dist/noesis/execute/order.js

@@ -1,11 +1,3 @@
-/**
- * The plan, grouped into what may run together.
- *
- * `read_only` siblings share a wave and `synthesis` takes one alone, which is
- * the distinction the stage went to the trouble of typing. A dependency on an
- * id nothing created can never be satisfied, so it lands in `unresolved`
- * alongside a cycle rather than being run in the wrong order.
- */
 export function order(plan) {
     const known = new Set(plan.map((sub) => sub.id));
     const done = new Set();

package/dist/noesis/execute/spend.d.ts

@@ -0,0 +1,36 @@
+import type { SubAnswer, Wiring } from "./types.js";
+import type { SubQuestionTool } from "../producers/decompose/index.js";
+/** What one tool reported it cost, keyed by the tool that reported it. */
+export interface ToolSpend {
+    calls: number;
+    /** Summed where a tool priced itself. Undefined where none did. */
+    costMicros?: number;
+    byTool: Record<string, ToolUsage>;
+}
+export interface ToolUsage {
+    calls: number;
+    model?: string;
+    inputTokens: number;
+    outputTokens: number;
+    citationTokens: number;
+    reasoningTokens: number;
+    costMicros?: number;
+}
+export declare const NO_TOOL_SPEND: ToolSpend;
+/**
+ * What a tool result says it cost, read by duck typing.
+ *
+ * A tool is somebody else's API and prices itself however it likes: `web_search`
+ * reports Perplexity's four token counts, `deep_recall` reports micro-USD. Both
+ * are read where present and nothing is invented where absent.
+ */
+export declare function readToolUsage(result: unknown): Omit<ToolUsage, "calls"> | null;
+/**
+ * Every tool call in one execution, summed under the tool that actually ran.
+ *
+ * Keyed by the bus tool's name rather than the sub-question's, because that is
+ * the one a rate applies to and the one the bus offered.
+ */
+export declare function toolSpendOf(answers: SubAnswer[], wiring?: Partial<Record<SubQuestionTool, Wiring>>): ToolSpend;
+/** Two executions' tool spend, added. A retry does not refund the first attempt. */
+export declare function addToolSpend(a: ToolSpend, b: ToolSpend): ToolSpend;

package/dist/noesis/execute/spend.js

@@ -0,0 +1,79 @@
+export const NO_TOOL_SPEND = { calls: 0, byTool: {} };
+const numberAt = (source, field) => {
+    const value = source[field];
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+};
+export function readToolUsage(result) {
+    if (!result || typeof result !== "object")
+        return null;
+    const shape = result;
+    const usage = (shape.usage ?? {});
+    const tokens = {
+        inputTokens: numberAt(usage, "inputTokens"),
+        outputTokens: numberAt(usage, "outputTokens"),
+        citationTokens: numberAt(usage, "citationTokens"),
+        reasoningTokens: numberAt(usage, "reasoningTokens"),
+    };
+    const priced = typeof shape.costMicroUsd === "number" ? shape.costMicroUsd : undefined;
+    const model = typeof shape.model === "string" ? shape.model : undefined;
+    const spent = tokens.inputTokens + tokens.outputTokens + tokens.citationTokens + tokens.reasoningTokens;
+    if (spent === 0 && priced === undefined)
+        return null;
+    return { ...tokens, ...(model ? { model } : {}), ...(priced !== undefined ? { costMicros: priced } : {}) };
+}
+export function toolSpendOf(answers, wiring = {}) {
+    const byTool = {};
+    let calls = 0;
+    let costMicros;
+    for (const answer of answers) {
+        const one = readToolUsage(answer.result);
+        if (!one)
+            continue;
+        calls++;
+        const named = wiring[answer.tool]?.name ?? answer.tool;
+        const prior = byTool[named] ?? {
+            calls: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            citationTokens: 0,
+            reasoningTokens: 0,
+        };
+        const merged = {
+            calls: prior.calls + 1,
+            inputTokens: prior.inputTokens + one.inputTokens,
+            outputTokens: prior.outputTokens + one.outputTokens,
+            citationTokens: prior.citationTokens + one.citationTokens,
+            reasoningTokens: prior.reasoningTokens + one.reasoningTokens,
+            ...(one.model ?? prior.model ? { model: one.model ?? prior.model } : {}),
+        };
+        if (one.costMicros !== undefined || prior.costMicros !== undefined) {
+            merged.costMicros = (prior.costMicros ?? 0) + (one.costMicros ?? 0);
+            costMicros = (costMicros ?? 0) + (one.costMicros ?? 0);
+        }
+        byTool[named] = merged;
+    }
+    return { calls, byTool, ...(costMicros !== undefined ? { costMicros } : {}) };
+}
+export function addToolSpend(a, b) {
+    const byTool = { ...a.byTool };
+    for (const [tool, one] of Object.entries(b.byTool)) {
+        const prior = byTool[tool];
+        byTool[tool] = prior
+            ? {
+                calls: prior.calls + one.calls,
+                inputTokens: prior.inputTokens + one.inputTokens,
+                outputTokens: prior.outputTokens + one.outputTokens,
+                citationTokens: prior.citationTokens + one.citationTokens,
+                reasoningTokens: prior.reasoningTokens + one.reasoningTokens,
+                ...(one.model ?? prior.model ? { model: one.model ?? prior.model } : {}),
+                ...(prior.costMicros !== undefined || one.costMicros !== undefined
+                    ? { costMicros: (prior.costMicros ?? 0) + (one.costMicros ?? 0) }
+                    : {}),
+            }
+            : one;
+    }
+    const costMicros = a.costMicros !== undefined || b.costMicros !== undefined
+        ? (a.costMicros ?? 0) + (b.costMicros ?? 0)
+        : undefined;
+    return { calls: a.calls + b.calls, byTool, ...(costMicros !== undefined ? { costMicros } : {}) };
+}

package/dist/noesis/execute/types.d.ts

@@ -1,3 +1,4 @@
+import type { ToolSpend } from "./spend.js";
 import type { Emit } from "../events.js";
 import type { SubQuestion, SubQuestionTool } from "../producers/decompose/index.js";
 /** Which tool answers a sub-question, and the argument its question fills. */
@@ -27,6 +28,7 @@ export interface Execution {
     answers: SubAnswer[];
     /** Ids that could never run: a cycle, or a dependency nothing created. */
     unresolved: string[];
+    spend: ToolSpend;
     /** Time spent inside tools. Not wall clock — a wave runs together. */
     toolMs: number;
 }

package/dist/noesis/gates/closure-checklist/invoke.js

@@ -1,6 +1,5 @@
 import { runStage } from "../../stage.js";
 import { CLOSURE_SCHEMA, CLOSURE_SLUG } from "./prompt.js";
-/** Stage 6A. The last questions before an answer is allowed to close. */
 export function invoke(client, llm, input, opts = {}) {
     return runStage(client, llm, CLOSURE_SLUG, CLOSURE_SCHEMA, input, opts);
 }

package/dist/noesis/gates/closure-checklist/prompt.js

@@ -1,6 +1,4 @@
-/** Stage 6A. Pulled by slug, so an edit needs no release here. */
 export const CLOSURE_SLUG = "ctr-6a-closure-checklist-292xfc";
-/** What the reply must be, as the prompt itself specifies it. */
 export const CLOSURE_SCHEMA = {
     type: "object",
     properties: {

package/dist/noesis/gates/cqot-gate/invoke.js

@@ -1,6 +1,5 @@
 import { runStage } from "../../stage.js";
 import { GATE_SCHEMA, GATE_SLUG } from "./prompt.js";
-/** Stage 3C. Eight questions asked of the plan, and whether it may proceed. */
 export function invoke(client, llm, input, opts = {}) {
     return runStage(client, llm, GATE_SLUG, GATE_SCHEMA, input, opts);
 }

package/dist/noesis/gates/cqot-gate/prompt.js

@@ -1,6 +1,4 @@
-/** Stage 3C. Pulled by slug, so an edit needs no release here. */
 export const GATE_SLUG = "ctr-3c-cqot-gate-7128w7";
-/** What the reply must be, as the prompt itself specifies it. */
 export const GATE_SCHEMA = {
     type: "object",
     properties: {

package/dist/noesis/gates/premortem/invoke.js

@@ -1,6 +1,5 @@
 import { runStage } from "../../stage.js";
 import { PREMORTEM_SCHEMA, PREMORTEM_SLUG } from "./prompt.js";
-/** Stage 3B. The plan assumed dead, and what killed it. */
 export function invoke(client, llm, input, opts = {}) {
     return runStage(client, llm, PREMORTEM_SLUG, PREMORTEM_SCHEMA, input, opts);
 }

package/dist/noesis/gates/premortem/prompt.js

@@ -1,6 +1,4 @@
-/** Stage 3B. Pulled by slug, so an edit needs no release here. */
 export const PREMORTEM_SLUG = "ctr-3b-premortem-0w34wx";
-/** What the reply must be, as the prompt itself specifies it. */
 export const PREMORTEM_SCHEMA = {
     type: "object",
     properties: {

package/dist/noesis/gates/red-team/invoke.js

@@ -1,6 +1,5 @@
 import { runStage } from "../../stage.js";
 import { RED_TEAM_SCHEMA, RED_TEAM_SLUG } from "./prompt.js";
-/** Stage 6B. The answer attacked, and whether it survived. */
 export function invoke(client, llm, input, opts = {}) {
     return runStage(client, llm, RED_TEAM_SLUG, RED_TEAM_SCHEMA, input, opts);
 }

package/dist/noesis/gates/red-team/prompt.js

@@ -1,6 +1,4 @@
-/** Stage 6B. Pulled by slug, so an edit needs no release here. */
 export const RED_TEAM_SLUG = "ctr-6b-red-team-f084c0";
-/** What the reply must be, as the prompt itself specifies it. */
 export const RED_TEAM_SCHEMA = {
     type: "object",
     properties: {

package/dist/noesis/gates/standards-review/invoke.js

@@ -1,6 +1,5 @@
 import { runStage } from "../../stage.js";
 import { STANDARDS_SCHEMA, STANDARDS_SLUG } from "./prompt.js";
-/** Stage 5C. The answer against eight standards, each passed or failed on the evidence. */
 export function invoke(client, llm, input, opts = {}) {
     return runStage(client, llm, STANDARDS_SLUG, STANDARDS_SCHEMA, input, opts);
 }

package/dist/noesis/gates/standards-review/prompt.js

@@ -1,6 +1,4 @@
-/** Stage 5C. Pulled by slug, so an edit needs no release here. */
 export const STANDARDS_SLUG = "ctr-5c-standards-review-17c6w4";
-/** What the reply must be, as the prompt itself specifies it. */
 export const STANDARDS_SCHEMA = {
     type: "object",
     properties: {

package/dist/noesis/gates/think-checkpoint/invoke.js

@@ -1,6 +1,5 @@
 import { runStage } from "../../stage.js";
 import { CHECKPOINT_SCHEMA, CHECKPOINT_SLUG } from "./prompt.js";
-/** Stage 4A. What was predicted against what happened, and whether to carry on. */
 export function invoke(client, llm, input, opts = {}) {
     return runStage(client, llm, CHECKPOINT_SLUG, CHECKPOINT_SCHEMA, input, opts);
 }

package/dist/noesis/gates/think-checkpoint/prompt.js

@@ -1,6 +1,4 @@
-/** Stage 4A. Pulled by slug, so an edit needs no release here. */
 export const CHECKPOINT_SLUG = "ctr-4a-think-checkpoint-8d5302";
-/** What the reply must be, as the prompt itself specifies it. */
 export const CHECKPOINT_SCHEMA = {
     type: "object",
     properties: {

package/dist/noesis/index.d.ts

@@ -38,8 +38,8 @@ export { invoke as reflection } from "./repair/reflection/index.js";
 export { routeFor } from "./route.js";
 export type { Difficulty, Stakes, TriageEstimates, TriageInput, TriageOptions, TriageResult, } from "./router/triage/index.js";
 export { invoke as triage, TriageReplyError } from "./router/triage/index.js";
-export type { Entry, Escalation, Ledger, NoesisStream, Recorded, StageId, StageUsage, } from "./run/index.js";
-export { NoToolsError, newLedger, RouteFailedError, RouteNotBuiltError, run, runStream, STAGE_NAMES, STAGES, } from "./run/index.js";
+export type { Entry, Escalation, Ledger, NoesisStream, Recorded, StageId, StageKey, StageName, StageUsage, } from "./run/index.js";
+export { NoToolsError, newLedger, RouteFailedError, RouteNotBuiltError, run, runStream, STAGE_KEYS, STAGE_NAMES, STAGES, } from "./run/index.js";
 export { dropPoint, parseStage, resumeAt } from "./run/redo.js";
 export { STAGE_OF_SLUG } from "./slugs.js";
 export type { StageOptions, StageOutcome } from "./stage.js";

package/dist/noesis/index.js

@@ -19,7 +19,7 @@ export { answer, invoke as toulmin, NoAnswerError, render, ToulminReplyError, }
 export { invoke as reflection } from "./repair/reflection/index.js";
 export { routeFor } from "./route.js";
 export { invoke as triage, TriageReplyError } from "./router/triage/index.js";
-export { NoToolsError, newLedger, RouteFailedError, RouteNotBuiltError, run, runStream, STAGE_NAMES, STAGES, } from "./run/index.js";
+export { NoToolsError, newLedger, RouteFailedError, RouteNotBuiltError, run, runStream, STAGE_KEYS, STAGE_NAMES, STAGES, } from "./run/index.js";
 export { dropPoint, parseStage, resumeAt } from "./run/redo.js";
 export { STAGE_OF_SLUG } from "./slugs.js";
 export { runStage, StageReplyError } from "./stage.js";

package/dist/noesis/producers/cove-answers/invoke.js

@@ -1,6 +1,5 @@
 import { runStage } from "../../stage.js";
 import { COVE_ANSWERS_SCHEMA, COVE_ANSWERS_SLUG } from "./prompt.js";
-/** Stage 5B. Each verification question answered blind, without sight of the answer under test. */
 export function invoke(client, llm, input, opts = {}) {
     return runStage(client, llm, COVE_ANSWERS_SLUG, COVE_ANSWERS_SCHEMA, input, opts);
 }

package/dist/noesis/producers/cove-answers/prompt.js

@@ -1,6 +1,4 @@
-/** Stage 5B. Pulled by slug, so an edit needs no release here. */
 export const COVE_ANSWERS_SLUG = "ctr-5b-cove-blind-answer-1w1479";
-/** What the reply must be, as the prompt itself specifies it. */
 export const COVE_ANSWERS_SCHEMA = {
     type: "object",
     properties: {

package/dist/noesis/producers/cove-questions/invoke.js

@@ -1,6 +1,5 @@
 import { runStage } from "../../stage.js";
 import { COVE_QUESTIONS_SCHEMA, COVE_QUESTIONS_SLUG } from "./prompt.js";
-/** Stage 5A. The verification questions the answer's own claims invite. */
 export function invoke(client, llm, input, opts = {}) {
     return runStage(client, llm, COVE_QUESTIONS_SLUG, COVE_QUESTIONS_SCHEMA, input, opts);
 }

package/dist/noesis/producers/cove-questions/prompt.js

@@ -1,6 +1,4 @@
-/** Stage 5A. Pulled by slug, so an edit needs no release here. */
 export const COVE_QUESTIONS_SLUG = "ctr-5a-cove-questions-d9633d";
-/** What the reply must be, as the prompt itself specifies it. */
 export const COVE_QUESTIONS_SCHEMA = {
     type: "object",
     properties: {

package/dist/noesis/producers/decompose/invoke.js

@@ -1,6 +1,5 @@
 import { runStage } from "../../stage.js";
 import { DECOMPOSE_SCHEMA, DECOMPOSE_SLUG } from "./prompt.js";
-/** Stage 2. Splits the question into ordered sub-questions, and answers none. */
 export function invoke(client, llm, input, opts = {}) {
     return runStage(client, llm, DECOMPOSE_SLUG, DECOMPOSE_SCHEMA, input, opts);
 }

package/dist/noesis/producers/decompose/prompt.js

@@ -1,22 +1,4 @@
-/** The stored decomposition prompt. Pulled by slug, so an edit needs no release here. */
 export const DECOMPOSE_SLUG = "ctr-2-decompose-b559f2";
-/**
- * What the reply must be, as the prompt itself specifies it.
- *
- * `maxItems` is 7 because the prompt caps it there, and the cap is the point:
- * unbounded splitting — task lists breeding task lists — is the failure this
- * stage exists to avoid.
- */
-/**
- * What each hint means, sent with the schema.
- *
- * Seven bare identifiers left the choice to be guessed from the name, and two of
- * them are wired to nothing by default — a sub-question hinting `code_exec` or
- * `get_documents` comes back skipped, so a guess between `deeprecall` and
- * `get_documents` silently costs an answer. Saying which is which is the whole
- * of the fix. `tests/tool-hints.test.ts` holds this text to what
- * `DEFAULT_TOOLS` actually wires.
- */
 export const TOOL_HINT = [
     "Which tool the executor should reach for. Name the cheapest one that can answer, and prefer none over a call that is not needed.",
     "- none: answerable from the question and the brief alone. Nothing is called.",

package/dist/noesis/producers/discriminating-test/invoke.js

@@ -1,6 +1,5 @@
 import { runStage } from "../../stage.js";
 import { TEST_SCHEMA, TEST_SLUG } from "./prompt.js";
-/** Stage 4B. The one test whose result tells the live hypotheses apart. */
 export function invoke(client, llm, input, opts = {}) {
     return runStage(client, llm, TEST_SLUG, TEST_SCHEMA, input, opts);
 }

package/dist/noesis/producers/discriminating-test/prompt.js

@@ -1,6 +1,4 @@
-/** Stage 4B. Pulled by slug, so an edit needs no release here. */
 export const TEST_SLUG = "ctr-4b-discriminating-test-w92055";
-/** What the reply must be, as the prompt itself specifies it. */
 export const TEST_SCHEMA = {
     type: "object",
     properties: {

package/dist/noesis/producers/plan-candidates/invoke.js

@@ -1,6 +1,5 @@
 import { runStage } from "../../stage.js";
 import { PLAN_SCHEMA, PLAN_SLUG } from "./prompt.js";
-/** Stage 3A. Three approaches, the one chosen, and the steps that follow from it. */
 export function invoke(client, llm, input, opts = {}) {
     return runStage(client, llm, PLAN_SLUG, PLAN_SCHEMA, input, opts);
 }

package/dist/noesis/producers/plan-candidates/prompt.js

@@ -1,6 +1,4 @@
-/** Stage 3A. Pulled by slug, so an edit needs no release here. */
 export const PLAN_SLUG = "ctr-3a-plan-candidates-898095";
-/** What the reply must be, as the prompt itself specifies it. */
 export const PLAN_SCHEMA = {
     type: "object",
     properties: {

package/dist/noesis/producers/qn-brief/invoke.js

@@ -1,6 +1,5 @@
 import { runStage } from "../../stage.js";
 import { BRIEF_SCHEMA, BRIEF_SLUG } from "./prompt.js";
-/** Stage 1. Interrogates the question and hands back the brief, never an answer. */
 export function invoke(client, llm, input, opts = {}) {
     return runStage(client, llm, BRIEF_SLUG, BRIEF_SCHEMA, input, opts);
 }

package/dist/noesis/producers/qn-brief/prompt.js

@@ -1,15 +1,6 @@
-/** The stored question-brief prompt. Pulled by slug, so an edit needs no release here. */
 export const BRIEF_SLUG = "ctr-1-question-brief-f2w9fd";
 const STRINGS = { type: "array", items: { type: "string" } };
 const NULLABLE_STRING = { type: ["string", "null"] };
-/**
- * What the reply must be, as the prompt itself specifies it.
- *
- * Every key is required, including the two that are usually null: the prompt
- * returns `better_question` and `interpretation` as null rather than omitting
- * them, and a missing key would read downstream as "nothing was ambiguous"
- * instead of "the stage did not say".
- */
 export const BRIEF_SCHEMA = {
     type: "object",
     properties: {

package/dist/noesis/producers/toulmin/answer.js

@@ -3,19 +3,7 @@ import { addUsage, totalCost, NO_USAGE } from "../../usage.js";
 import { invoke } from "./invoke.js";
 import { render } from "./render.js";
 const DEFAULT_MIN_CONFIDENCE = 0.6;
-/**
- * The tiers to run, when the caller named none.
- *
- * One tier, and it is the model the `Llm` was built with. A default list of
- * model ids chosen here would answer on a model the caller never picked, and on
- * a provider that has never heard of those ids it fails outright — at the last
- * stage, after every earlier one has been paid for.
- *
- * So a cascade is something you ask for. Naming two tiers is what buys the
- * second opinion; naming none gets the model already configured, once.
- */
 const tiersFor = (llm, named) => named?.length ? named : [{ model: llm.model }];
-/** Every tier fell over, so there is no answer to render. */
 export class NoAnswerError extends Error {
     escalated;
     constructor(escalated) {
@@ -24,15 +12,6 @@ export class NoAnswerError extends Error {
         this.name = "NoAnswerError";
     }
 }
-/**
- * Stage 6C, cheapest model first.
- *
- * A tier is accepted when it committed to a claim and its own calibrated
- * confidence clears the bar; an abstention escalates whatever the bar is,
- * because a stage that could not answer has not answered. Nothing is rewritten
- * on the way up — each rung answers from the artifacts again, so an escalation
- * is a second opinion rather than a polish of the first.
- */
 export async function answer(client, llm, artifacts, opts = {}) {
     const tiers = tiersFor(llm, opts.tiers);
     const floor = opts.minConfidence ?? DEFAULT_MIN_CONFIDENCE;