@spendgraph/workflows 0.2.0

package/dist/noesis/producers/toulmin/types.d.ts

@@ -0,0 +1,126 @@
+import type { Emit } from "../../events.js";
+import type { Usage } from "../../usage.js";
+/** One piece of evidence, and the stage it came from. */
+export interface Ground {
+    evidence: string;
+    source_stage: string;
+}
+/** The hedging, kept out of the claim and stated as scope plus a calibrated number. */
+export interface Qualifier {
+    confidence: number;
+    holds_when: string;
+    does_not_apply_to: string;
+}
+/** An objection that survived red-teaming, and what would make it fatal. */
+export interface Rebuttal {
+    objection: string;
+    defeats_claim_when: string;
+}
+/**
+ * Stage 6C. The answer, assembled from artifacts rather than written.
+ *
+ * `abstained` is a first-class outcome: true means the grounds supported no
+ * claim, and `claim` says what is not known and what would settle it.
+ */
+export interface ToulminAnswer {
+    claim: string;
+    grounds: Ground[];
+    warrant: string;
+    qualifier: Qualifier;
+    rebuttals: Rebuttal[];
+    would_change_my_mind: string;
+    abstained: boolean;
+}
+/**
+ * What the stage compiles from.
+ *
+ * A string is sent as written; anything else is serialised. The prompt declares
+ * no fields, so this arrives as the user turn rather than as a substitution.
+ */
+export type Artifacts = string | Record<string, unknown>;
+export interface ToulminOptions {
+    /**
+     * Attempts for this call, counting the first. Default 2.
+     *
+     * Separate from `maxRetries`, the loop's budget for a gate sending work
+     * backwards. This one covers a call that produced nothing to think about, and
+     * the two must not share an allowance.
+     */
+    attempts?: number;
+    /** Overrides the model the `Llm` was built with. */
+    model?: string;
+    /** Where this stage says what it is doing. Set by `run()`. */
+    emit?: Emit;
+    /**
+     * Merged into the request body.
+     *
+     * Where `temperature` goes, and it is per model: Haiku 4.5 takes it, Sonnet 5
+     * rejects it outright.
+     */
+    params?: Record<string, unknown>;
+}
+export interface ToulminResult extends Usage {
+    answer: ToulminAnswer;
+    rolloutId: string;
+    model: string;
+    latencyMs: number;
+    /** What the server will price this tier at, still in flight. */
+    pricing?: Promise<number | undefined>;
+}
+/**
+ * One rung of the cascade.
+ *
+ * `params` is per model because it has to be: Haiku 4.5 takes `temperature`,
+ * Sonnet 5 rejects it outright, and one shared body would fail on whichever it
+ * was not written for.
+ */
+export interface AnswerTier {
+    model: string;
+    params?: Record<string, unknown>;
+}
+export interface AnswerOptions {
+    /**
+     * Rungs in order, cheapest first. Defaults to the model the `Llm` carries, once.
+     *
+     * Name two to buy a second opinion. `params` is per tier because it has to
+     * be: models disagree about which sampling knobs they accept, and one shared
+     * request body fails on whichever tier it was not written for.
+     */
+    tiers?: AnswerTier[];
+    /** Where each tier says what it is doing. Set by `run()`. */
+    emit?: Emit;
+    /**
+     * Below this the answer escalates. Default 0.6.
+     *
+     * An abstention escalates whatever this is set to — a tier that could not
+     * answer has not answered, however calibrated it was about it.
+     */
+    minConfidence?: number;
+    /** Attempts per tier, counting the first. Default 2. */
+    attempts?: number;
+    /** Stop once the tiers have consumed this many tokens. */
+    maxTokens?: number;
+    /** Renders grounds and the warrant into the text. Default false. */
+    showGrounds?: boolean;
+}
+export interface AnswerResult extends Usage {
+    /** The reply, as a person reads it. */
+    text: string;
+    answer: ToulminAnswer;
+    /**
+     * Every tier's price, combined, still in flight.
+     *
+     * One promise rather than one per tier because the cascade is one stage in
+     * the ledger: an escalation is still 6C, and its cost is what 6C cost.
+     */
+    pricing?: Promise<number | undefined>;
+    /** The tier whose answer this is. */
+    model: string;
+    /** False when no tier cleared the bar and this is the last one's answer. */
+    accepted: boolean;
+    /** Tiers tried that did not supply the answer. */
+    escalated: string[];
+    /** One per tier that answered, in order. Each is its own recorded rollout. */
+    rolloutIds: string[];
+    latencyMs: number;
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/noesis/question.d.ts

@@ -0,0 +1,24 @@
+/** The variable every stored prompt takes its request through. */
+export declare const QUESTION_FIELD = "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 declare function askThrough<T extends {
+    role: string;
+    content: string;
+}>(messages: T[], question: string, prompt: string): T[];

package/dist/noesis/question.js

@@ -0,0 +1,37 @@
+/** 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;
+    if (!warned.has(prompt)) {
+        warned.add(prompt);
+        console.warn(`[noesis] ${prompt} renders no {${QUESTION_FIELD}}, so the request was put in its question ` +
+            "box instead and the text saved there was not sent. Publish the prompt: pull() serves the " +
+            "published wording, and a migration only reaches the draft.");
+    }
+    const last = messages.length - 1;
+    return messages.map((m, i) => i === last && m.role === "user" ? { ...m, content: question } : m);
+}

package/dist/noesis/repair/reflection/index.d.ts

@@ -0,0 +1,3 @@
+export { invoke } from "./invoke.js";
+export { REFLECTION_SCHEMA, REFLECTION_SLUG } from "./prompt.js";
+export type { Reflection, ReflectionInput, ReflectionOptions, ReflectionResult, } from "./types.js";

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

@@ -0,0 +1,2 @@
+export { invoke } from "./invoke.js";
+export { REFLECTION_SCHEMA, REFLECTION_SLUG } from "./prompt.js";

package/dist/noesis/repair/reflection/invoke.d.ts

@@ -0,0 +1,5 @@
+import type { Llm } from "@spendgraph/llms";
+import type { PromptClient } from "@spendgraph/prompt";
+import type { ReflectionInput, ReflectionOptions, ReflectionResult } from "./types.js";
+/** Stage R. The earliest wrong decision behind a failure, not the place it surfaced. */
+export declare function invoke(client: PromptClient, llm: Llm, input: ReflectionInput, opts?: ReflectionOptions): Promise<ReflectionResult>;

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

@@ -0,0 +1,6 @@
+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.d.ts

@@ -0,0 +1,5 @@
+import type { JsonSchema } from "@spendgraph/llms";
+/** Stage R. Pulled by slug, so an edit needs no release here. */
+export declare const REFLECTION_SLUG = "ctr-r-root-cause-reflection-7x0x90";
+/** What the reply must be, as the prompt itself specifies it. */
+export declare const REFLECTION_SCHEMA: JsonSchema;

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

@@ -0,0 +1,26 @@
+/** 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: {
+        symptom: { type: "string" },
+        earliest_faulty_stage: { type: "string" },
+        faulty_decision: { type: "string" },
+        symptom_equals_cause: { type: "boolean" },
+        redo_from_stage: { type: "string" },
+        do_differently: { type: "string" },
+        lesson: { type: "string" },
+        avoid_repeat_check: { type: "string" },
+    },
+    required: [
+        "symptom",
+        "earliest_faulty_stage",
+        "faulty_decision",
+        "symptom_equals_cause",
+        "redo_from_stage",
+        "do_differently",
+        "lesson",
+        "avoid_repeat_check",
+    ],
+};

package/dist/noesis/repair/reflection/types.d.ts

@@ -0,0 +1,17 @@
+import type { Asked } from "../../context.js";
+import type { StageOptions, StageOutcome } from "../../stage.js";
+export interface Reflection {
+    symptom: string;
+    earliest_faulty_stage: string;
+    faulty_decision: string;
+    /** True only when the place it surfaced really is where it went wrong. */
+    symptom_equals_cause: boolean;
+    redo_from_stage: string;
+    do_differently: string;
+    /** Follows the form "In situations like X, strategy Y failed because Z." */
+    lesson: string;
+    avoid_repeat_check: string;
+}
+export type ReflectionInput = Asked;
+export type ReflectionOptions = StageOptions;
+export type ReflectionResult = StageOutcome<Reflection>;

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

@@ -0,0 +1 @@
+export {};

package/dist/noesis/retry.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 declare function retryable(err: unknown): boolean;
+export interface AttemptOptions {
+    /** Total attempts including the first. Default 2. Set 1 to disable retrying. */
+    attempts?: number;
+    /** Called for every attempt that failed, retried or not. */
+    onFailure?: (err: unknown, willRetry: boolean) => void;
+}
+/**
+ * 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 declare function attempting<T>(run: () => Promise<T>, opts?: AttemptOptions): Promise<T>;

package/dist/noesis/retry.js

@@ -0,0 +1,60 @@
+/**
+ * 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;
+    if (err.name.endsWith("ReplyError") || err.name === "StructuredOutputError")
+        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++) {
+        try {
+            return await run();
+        }
+        catch (err) {
+            const willRetry = attempt < total && retryable(err);
+            opts.onFailure?.(err, willRetry);
+            if (!willRetry)
+                throw err;
+            await pause(BACKOFF_MS * attempt);
+        }
+    }
+}

package/dist/noesis/route.d.ts

@@ -0,0 +1,29 @@
+import type { Routing, TriageEstimates } from "./index.js";
+/**
+ * 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 declare function routeFor(estimates: TriageEstimates): Routing;

package/dist/noesis/route.js

@@ -0,0 +1,69 @@
+const AMBIGUOUS = 0.6;
+const CLEAR = 0.3;
+const CONFIDENT = 0.7;
+const NEEDS_TOOLS = 0.3;
+const VAGUE = 0.5;
+const UNSURE = 0.5;
+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;
+    const lookup = clear && estimates.tool_need >= NEEDS_TOOLS;
+    if (lookup && estimates.stakes !== "critical") {
+        return { route: "retrieve", redTeam, reason: `a lookup — tool_need is ${estimates.tool_need}` };
+    }
+    if (redTeam) {
+        return { route: "full", redTeam, reason: `stakes are ${estimates.stakes}` };
+    }
+    const capable = estimates.stakes === "low" && estimates.ambiguity < CLEAR && estimates.confidence >= CONFIDENT;
+    if (HARD.has(estimates.difficulty) && !capable) {
+        return { route: "full", redTeam, reason: `difficulty is ${estimates.difficulty}` };
+    }
+    if (estimates.ambiguity >= AMBIGUOUS) {
+        return { route: "full", redTeam, reason: `ambiguity is ${estimates.ambiguity}` };
+    }
+    if (estimates.ambiguity >= VAGUE && estimates.confidence < UNSURE) {
+        return {
+            route: "full",
+            redTeam,
+            reason: `ambiguity ${estimates.ambiguity} with confidence ${estimates.confidence}`,
+        };
+    }
+    if (clear && estimates.confidence >= CONFIDENT) {
+        return { route: "direct", redTeam, reason: `${estimates.difficulty} and already known` };
+    }
+    if (clear && estimates.confidence >= NEARLY) {
+        return { route: "retrieve", redTeam, reason: `${estimates.difficulty} but not certain` };
+    }
+    return { route: "standard", redTeam, reason: "neither trivial nor serious" };
+}

package/dist/noesis/router/triage/index.d.ts

@@ -0,0 +1,3 @@
+export { attached, invoke, TriageReplyError } from "./invoke.js";
+export { TRIAGE_SCHEMA, TRIAGE_SLUG } from "./prompt.js";
+export type { Difficulty, Stakes, TriageEstimates, TriageInput, TriageOptions, TriageResult, } from "./types.js";

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

@@ -0,0 +1,2 @@
+export { attached, invoke, TriageReplyError } from "./invoke.js";
+export { TRIAGE_SCHEMA, TRIAGE_SLUG } from "./prompt.js";

package/dist/noesis/router/triage/invoke.d.ts

@@ -0,0 +1,31 @@
+import type { Llm } from "@spendgraph/llms";
+import type { PromptClient } from "@spendgraph/prompt";
+import type { TriageInput, TriageOptions, TriageResult } from "./types.js";
+/**
+ * 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 declare function attached(content?: string): string;
+/** The reply came back, but not as the object the router is supposed to return. */
+export declare class TriageReplyError extends Error {
+    readonly raw: string;
+    constructor(raw: string);
+}
+/**
+ * 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 declare function invoke(client: PromptClient, llm: Llm, input: TriageInput, opts?: TriageOptions): Promise<TriageResult>;

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

@@ -0,0 +1,76 @@
+import { askThrough, QUESTION_FIELD } from "../../question.js";
+import { attempting } from "../../retry.js";
+import { announce, failed } from "../../started.js";
+import { usageOf } from "../../usage.js";
+import { TRIAGE_SCHEMA, TRIAGE_SLUG } from "./prompt.js";
+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) {
+        super("Triage returned no object matching its schema.");
+        this.raw = raw;
+        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 () => {
+        const prompt = await client.pull(TRIAGE_SLUG);
+        const question = input.question;
+        const values = {
+            file_content: attached(input.file_content),
+            image_content: attached(input.image_content),
+            [QUESTION_FIELD]: question,
+        };
+        let reply;
+        const outcome = await prompt.call(values, async ({ messages }) => {
+            reply = await llm.call(askThrough(messages, question, TRIAGE_SLUG), {
+                model: opts.model,
+                schema: TRIAGE_SCHEMA,
+                trace: false,
+                params: opts.params,
+            });
+            return reply;
+        }, { history: reTriage(input.currentTask) });
+        if (reply?.data === undefined)
+            throw new TriageReplyError(outcome.output);
+        return {
+            ...usageOf(outcome),
+            ...(outcome.pricing ? { pricing: outcome.pricing } : {}),
+            estimates: reply.data,
+            rolloutId: outcome.rolloutId,
+            model: outcome.model,
+            latencyMs: reply.latencyMs ?? 0,
+        };
+    }, { attempts: opts.attempts, onFailure: (err) => failed(opts.emit, TRIAGE_SLUG, err) });
+}

package/dist/noesis/router/triage/prompt.d.ts

@@ -0,0 +1,11 @@
+import type { JsonSchema } from "@spendgraph/llms";
+/** The stored router prompt. Pulled by slug, so an edit needs no release here. */
+export declare const TRIAGE_SLUG = "triage-router-v1-81c2cc";
+/**
+ * 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 declare const TRIAGE_SCHEMA: JsonSchema;

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

@@ -0,0 +1,34 @@
+/** 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: {
+        is_new_task: { type: "boolean" },
+        difficulty: {
+            type: "string",
+            enum: ["trivial", "easy", "medium", "hard", "expert", "research"],
+        },
+        stakes: { type: "string", enum: ["low", "medium", "high", "critical"] },
+        confidence: UNIT,
+        ambiguity: UNIT,
+        tool_need: UNIT,
+        summary: { type: "string" },
+    },
+    required: [
+        "is_new_task",
+        "difficulty",
+        "stakes",
+        "confidence",
+        "ambiguity",
+        "tool_need",
+        "summary",
+    ],
+};