@spendgraph/workflows 0.2.0 → 0.2.1

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";
 
@@ -147,3 +151,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,4 @@
 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.
- */
 export const DEFAULT_TOOLS = {
     calculator: { name: "calculate", arg: "expression" },
     deeprecall: { name: "deep_recall", arg: "question" },
@@ -54,17 +48,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);

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

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

@@ -3,7 +3,6 @@ import { attempting } from "../../retry.js";
 import { announce, failed } from "../../started.js";
 import { usageOf } from "../../usage.js";
 import { TOULMIN_SCHEMA, TOULMIN_SLUG } from "./prompt.js";
-/** The reply came back, but not as the object the stage is supposed to return. */
 export class ToulminReplyError extends Error {
     raw;
     constructor(raw) {
@@ -15,15 +14,6 @@ export class ToulminReplyError extends Error {
 function asText(artifacts) {
     return typeof artifacts === "string" ? artifacts : JSON.stringify(artifacts, null, 2);
 }
-/**
- * Stage 6C. Compiles the artifacts into the final answer and its qualifier.
- *
- * The artifacts are the request, so they go through `{question}` like every
- * other stage's. They used to arrive as a history turn instead, which worked
- * only while the prompt's question box was empty: `renderMessages` puts history
- * between the system turn and the question, so anything saved in that box would
- * have been the last thing the model read.
- */
 export async function invoke(client, llm, artifacts, opts = {}) {
     announce(opts.emit, TOULMIN_SLUG, opts.model);
     return attempting(async () => {

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

@@ -1,14 +1,5 @@
-/** The stored answer-assembly prompt. Pulled by slug, so an edit needs no release here. */
 export const TOULMIN_SLUG = "ctr-6c-toulmin-answer-d28bb8";
 const UNIT = { type: "number", minimum: 0, maximum: 1 };
-/**
- * What the reply must be, as the prompt itself specifies it.
- *
- * `rebuttals` and `would_change_my_mind` are required rather than optional on
- * purpose: an empty list is a claim the stage may make, but a missing key would
- * let a surviving objection be dropped silently, which is what this stage
- * exists to prevent.
- */
 export const TOULMIN_SCHEMA = {
     type: "object",
     properties: {

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

@@ -9,21 +9,9 @@ function confidencePhrase(confidence) {
         return "low";
     return "very low";
 }
-/**
- * Whether the model actually said this.
- *
- * Takes `string | undefined` although `ToulminAnswer` types every field as a
- * string, because nothing enforces that: the schema's `required` list is sent
- * to the provider and never checked on the way back, so a field the model
- * omitted arrives as `undefined` and reads here as unsaid.
- */
 function said(value) {
     return !!value && value.trim().length > 0;
 }
-/**
- * The model writes these as sentences, and the label already supplies the
- * conjunction — without this they read "holds when when the trace shows".
- */
 function clause(text) {
     return text.trim().replace(/^(when|if)\s+/i, "");
 }
@@ -54,18 +42,6 @@ function groundLines(answer) {
     const warrant = said(answer.warrant) ? `Warrant: ${answer.warrant}` : "";
     return [grounds, warrant].filter(said).join("\n\n");
 }
-/**
- * The answer as a person reads it.
- *
- * Pure, and deliberately not a seventh prompt. Every part of a `ToulminAnswer`
- * is something the stage was forbidden to soften — a surviving objection, a
- * calibrated number, an abstention — and handing the object to a model to write
- * up returns each of those chances on the last call before anyone sees it.
- *
- * Objections are never dropped. Where something has to give, grounds go first,
- * which is why they are off by default: they are the audit trail, and the
- * rollout already has them.
- */
 export function render(answer, opts = {}) {
     const rebuttals = rebuttalLines(answer.rebuttals);
     const changes = said(answer.would_change_my_mind)

package/dist/noesis/question.js

@@ -1,28 +1,9 @@
-/** The variable every stored prompt takes its request through. */
 export const QUESTION_FIELD = "question";
 const warned = new Set();
 function carries(messages, question) {
     const last = messages[messages.length - 1];
     return last?.role === "user" && last.content.includes(question);
 }
-/**
- * The messages to send, with the request in the turn the prompt renders.
- *
- * A prompt whose question box is `{question}` needs nothing from this: the
- * value passed alongside fills it and the rendered turn already carries the
- * request. Asked of the messages rather than of `prompt.fields`, because
- * `applyVariables` substitutes any `{name}` it finds against the values it is
- * given and never reads the field list — so a placeholder typed into the box
- * works with no field declared, and would not show up in `fields` at all.
- *
- * Where the box holds something else — a question typed while testing, or
- * nothing at all — the trailing turn is overwritten with the request and the
- * stored text is not sent. That is what the placeholder would have done, and it
- * keeps the shape the prompt expects: one system turn, one user turn. It warns
- * once per prompt, because the alternative failure is silent: an unmigrated
- * prompt would answer the question saved on it and return a well-formed result
- * about the wrong thing.
- */
 export function askThrough(messages, question, prompt) {
     if (carries(messages, question))
         return messages;

package/dist/noesis/repair/reflection/invoke.js

@@ -1,6 +1,5 @@
 import { runStage } from "../../stage.js";
 import { REFLECTION_SCHEMA, REFLECTION_SLUG } from "./prompt.js";
-/** Stage R. The earliest wrong decision behind a failure, not the place it surfaced. */
 export function invoke(client, llm, input, opts = {}) {
     return runStage(client, llm, REFLECTION_SLUG, REFLECTION_SCHEMA, input, opts);
 }

package/dist/noesis/repair/reflection/prompt.js

@@ -1,6 +1,4 @@
-/** Stage R. Pulled by slug, so an edit needs no release here. */
 export const REFLECTION_SLUG = "ctr-r-root-cause-reflection-7x0x90";
-/** What the reply must be, as the prompt itself specifies it. */
 export const REFLECTION_SCHEMA = {
     type: "object",
     properties: {

package/dist/noesis/retry.js

@@ -1,33 +1,7 @@
-/**
- * How many times a stage call may be made, counting the first.
- *
- * Two, not more. A flake is usually gone on the second try, and a call that
- * failed has often still been billed — so the budget is deliberately small and
- * the classifier below deliberately narrow.
- */
 const DEFAULT_ATTEMPTS = 2;
-/** Milliseconds before the next attempt, multiplied by the attempt number. */
 const BACKOFF_MS = 300;
 const pause = (ms) => new Promise((done) => setTimeout(done, ms));
-/**
- * Signals that a second attempt could plausibly land.
- *
- * Matched on the message because a stage is handed whatever the caller's client
- * threw, and nothing here can assume a status code survived. Anything else is
- * not retried: a 400 naming a model that does not exist and a 402 for credits
- * that are not there fail the same way however many times they are sent, and
- * spending three round trips to learn that is worse than failing once.
- */
 const TRANSIENT = /\b(429|500|502|503|504|522|524)\b|rate.?limit|overloaded|timed? ?out|timeout|ECONNRESET|ETIMEDOUT|EAI_AGAIN|socket hang up|fetch failed|network error/i;
-/**
- * Whether the same call is worth making again.
- *
- * Two families qualify. A reply error means a schema-forced call came back with
- * nothing to parse — the model declined to emit the tool call, which is a flake
- * rather than a fault in the prompt, and the bounded budget covers the case
- * where it is not. A transient transport error is the provider asking to be
- * asked later.
- */
 export function retryable(err) {
     if (!(err instanceof Error))
         return false;
@@ -35,14 +9,6 @@ export function retryable(err) {
         return true;
     return TRANSIENT.test(err.message);
 }
-/**
- * Runs a stage call, once more if the first failure looks worth repeating.
- *
- * This is deliberately not the gate retry budget. That one is spent when a gate
- * refuses and reflection sends work backwards — the loop thinking again. This
- * one covers a call that never produced anything to think about, and mixing the
- * two would let a flaky provider eat the allowance reserved for reasoning.
- */
 export async function attempting(run, opts = {}) {
     const total = Math.max(1, opts.attempts ?? DEFAULT_ATTEMPTS);
     for (let attempt = 1;; attempt++) {

package/dist/noesis/route.js

@@ -8,33 +8,6 @@ const NEARLY = 0.6;
 const HARD = new Set(["expert", "research"]);
 const EASY = new Set(["trivial", "easy"]);
 const SERIOUS = new Set(["high", "critical"]);
-/**
- * The estimates, turned into a route.
- *
- * Deliberately code and deliberately dull: the router prompt is told not to
- * choose its own budget, and a threshold written here can be moved after an
- * eval run without touching a prompt or re-running anything.
- *
- * A lookup is answered as a lookup, even when the stakes are high. `redTeam` is
- * a flag rather than a route, so it still fires — the care is kept and the
- * planning stages that have nothing to plan are not paid for. `critical` is the
- * exception, and keeps the whole loop.
- *
- * Difficulty alone does not buy the audit set. The premortem and the standards
- * review bite on risk and vagueness, not on how hard the reasoning is, so a
- * hard question that is low-stakes, well-posed and already understood takes
- * `standard`. Hard and *unsure* still takes `full`.
- *
- * Vagueness and doubt compound. Either one alone is survivable; a question that
- * is both under-specified and one the model cannot place is what 3B and 3C
- * exist for, and it takes `full` below the ambiguity bar that would catch it on
- * its own.
- *
- * `retrieve` splits the two reasons a clear question fails `direct`: high tool
- * need, and a confidence that only just misses. Both mean the model should not
- * answer from memory, and neither makes it a hard question — looking it up is
- * cheaper than planning it, and likelier to be right.
- */
 export function routeFor(estimates) {
     const redTeam = SERIOUS.has(estimates.stakes);
     const clear = EASY.has(estimates.difficulty) && estimates.ambiguity < CLEAR;