@spendgraph/workflows 0.2.0 → 0.2.1

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

@@ -7,21 +7,10 @@ function reTriage(currentTask) {
     const task = currentTask?.trim();
     return task ? [{ role: "user", content: `<CURRENT_TASK>\n${task}\n</CURRENT_TASK>` }] : [];
 }
-/** Stands in for an attachment nobody sent. */
 const NOTHING_ATTACHED = "(none)";
-/**
- * An attachment slot, filled or explicitly empty.
- *
- * The prompt's question box wraps every request in an `<attachments>` block, so
- * the tags are sent whether or not anything was attached. Left empty they read
- * as an attachment the router cannot open, which it prices as ambiguity and
- * tool need — enough on its own to push a plain question from `standard` to
- * `full` and pay for the long route on every call that attaches nothing.
- */
 export function attached(content) {
     return content?.trim() ? content : NOTHING_ATTACHED;
 }
-/** The reply came back, but not as the object the router is supposed to return. */
 export class TriageReplyError extends Error {
     raw;
     constructor(raw) {
@@ -30,18 +19,6 @@ export class TriageReplyError extends Error {
         this.name = "TriageReplyError";
     }
 }
-/**
- * Stage 0. Pulls the router, calls it, and hands back the parsed signals.
- *
- * 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.
- *
- * An open task is sent as `<CURRENT_TASK>…</CURRENT_TASK>`. The prompt names
- * the block but never shows its markup, so this is the form it is given — keep
- * the two matching, or the router is pattern-matching on something it was never
- * shown.
- */
 export async function invoke(client, llm, input, opts = {}) {
     announce(opts.emit, TRIAGE_SLUG, opts.model);
     return attempting(async () => {

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

@@ -1,13 +1,5 @@
-/** The stored router prompt. Pulled by slug, so an edit needs no release here. */
 export const TRIAGE_SLUG = "triage-router-v1-81c2cc";
 const UNIT = { type: "number", minimum: 0, maximum: 1 };
-/**
- * What the reply must be, as the prompt itself specifies it.
- *
- * `route`, `next_stage` and the rest are deliberately absent: the prompt forbids
- * them and code derives them, so a model that returns one fails here rather
- * than having it read downstream.
- */
 export const TRIAGE_SCHEMA = {
     type: "object",
     properties: {

package/dist/noesis/run/artifacts.js

@@ -1,10 +1,3 @@
-/**
- * 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) {
@@ -17,15 +10,5 @@ function shorten(value, 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.js

@@ -1,11 +1,3 @@
-/**
- * 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;
@@ -20,14 +12,6 @@ export class RouteNotBuiltError extends Error {
         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;
@@ -42,11 +26,9 @@ export class RouteFailedError extends Error {
         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.");

package/dist/noesis/run/ledger.js

@@ -1,6 +1,5 @@
 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",
@@ -20,7 +19,6 @@ export const STAGES = [
     "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",
@@ -42,17 +40,6 @@ export const STAGE_NAMES = {
 };
 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 = [];

package/dist/noesis/run/loop.js

@@ -4,17 +4,6 @@ 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}`);
@@ -25,13 +14,6 @@ async function stepBack(client, llm, question, opts, state, gates, gate, reason,
     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));
@@ -62,7 +44,6 @@ async function judge(client, llm, opts, state, checked, gates) {
     }
     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;

package/dist/noesis/run/plan.js

@@ -2,19 +2,6 @@ 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");

package/dist/noesis/run/produce.js

@@ -6,23 +6,7 @@ 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;
@@ -44,13 +28,6 @@ export async function frame(client, llm, question, opts, state) {
     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();
@@ -76,17 +53,6 @@ export async function work(client, llm, question, opts, state, split) {
         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 (;;) {

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,17 +1,10 @@
 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 {
@@ -21,7 +14,6 @@ function usageOfRun(state) {
         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) {

package/dist/noesis/run/run.js

@@ -4,27 +4,7 @@ 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 },
@@ -53,7 +33,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,7 +1,6 @@
 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 });

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.js

@@ -4,10 +4,6 @@ export const newRunState = (currentTask, emit, maxRetries) => ({
     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);
 }

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,16 +7,6 @@ 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.
- */
 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));
@@ -43,13 +33,6 @@ 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 redoFrom = parseStage(looked.redo_from_stage) ?? parseStage(hint ?? "");
@@ -62,7 +45,6 @@ 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 ?? {});
     state.answered = answered;

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/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;