@spendgraph/workflows 0.2.0 → 0.3.0

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;

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/index.d.ts

@@ -1,6 +1,6 @@
 export { NoToolsError, RouteFailedError, RouteNotBuiltError } from "./errors.js";
-export type { Entry, Escalation, Ledger, Recorded, StageId, StageUsage } from "./ledger.js";
-export { newLedger, STAGE_NAMES, STAGES } from "./ledger.js";
+export type { Entry, Escalation, Ledger, Recorded, StageId, StageKey, StageName, StageUsage } from "./ledger.js";
+export { newLedger, STAGE_KEYS, STAGE_NAMES, STAGES } from "./ledger.js";
 export { run } from "./run.js";
 export type { NoesisStream } from "./stream.js";
 export { runStream } from "./stream.js";

package/dist/noesis/run/index.js

@@ -1,4 +1,4 @@
 export { NoToolsError, RouteFailedError, RouteNotBuiltError } from "./errors.js";
-export { newLedger, STAGE_NAMES, STAGES } from "./ledger.js";
+export { newLedger, STAGE_KEYS, STAGE_NAMES, STAGES } from "./ledger.js";
 export { run } from "./run.js";
 export { runStream } from "./stream.js";

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

@@ -4,7 +4,55 @@ import { type PartialUsage, type Usage } from "../usage.js";
 export declare const STAGES: readonly ["0", "1", "2", "3A", "3B", "3C", "4", "4A", "4B", "5A", "5B", "5", "5C", "6A", "6B", "6C", "R"];
 export type StageId = (typeof STAGES)[number];
 /** What a stage is called where a person or a model has to read it. */
-export declare const STAGE_NAMES: Record<StageId, string>;
+export declare const STAGE_NAMES: {
+    readonly "0": "triage";
+    readonly "1": "question brief";
+    readonly "2": "decomposition";
+    readonly "3A": "plan candidates";
+    readonly "3B": "premortem";
+    readonly "3C": "cqot gate";
+    readonly "4": "execution";
+    readonly "4A": "think checkpoint";
+    readonly "4B": "discriminating test";
+    readonly "5A": "verification questions";
+    readonly "5B": "verification answers";
+    readonly "5": "verification";
+    readonly "5C": "standards review";
+    readonly "6A": "closure checklist";
+    readonly "6B": "red team";
+    readonly "6C": "answer";
+    readonly R: "root cause";
+};
+/** A stage by the name it announces itself under. */
+export type StageName = (typeof STAGE_NAMES)[StageId];
+/**
+ * What a stage is called where it is a key rather than prose.
+ *
+ * `STAGE_NAMES` with the spaces closed up, kept apart from it because those
+ * names are read back out of the artifacts by the answer and cannot be renamed
+ * for a config's convenience.
+ */
+export declare const STAGE_KEYS: {
+    readonly "0": "triage";
+    readonly "1": "question_brief";
+    readonly "2": "decomposition";
+    readonly "3A": "plan_candidates";
+    readonly "3B": "premortem";
+    readonly "3C": "cqot_gate";
+    readonly "4": "execution";
+    readonly "4A": "think_checkpoint";
+    readonly "4B": "discriminating_test";
+    readonly "5A": "verification_questions";
+    readonly "5B": "verification_answers";
+    readonly "5": "verification";
+    readonly "5C": "standards_review";
+    readonly "6A": "closure_checklist";
+    readonly "6B": "red_team";
+    readonly "6C": "answer";
+    readonly R: "root_cause";
+};
+/** A stage by the key a config names it under. */
+export type StageKey = (typeof STAGE_KEYS)[StageId];
 /** What one stage left behind, and what it cost. */
 export interface Entry extends Usage {
     stage: StageId;

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",
@@ -40,19 +38,27 @@ export const STAGE_NAMES = {
     "6C": "answer",
     R: "root cause",
 };
+export const STAGE_KEYS = {
+    "0": "triage",
+    "1": "question_brief",
+    "2": "decomposition",
+    "3A": "plan_candidates",
+    "3B": "premortem",
+    "3C": "cqot_gate",
+    "4": "execution",
+    "4A": "think_checkpoint",
+    "4B": "discriminating_test",
+    "5A": "verification_questions",
+    "5B": "verification_answers",
+    "5": "verification",
+    "5C": "standards_review",
+    "6A": "closure_checklist",
+    "6B": "red_team",
+    "6C": "answer",
+    R: "root_cause",
+};
 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,7 @@ 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.
- */
+import { stageOptionsFor } from "./options.js";
 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,16 +15,9 @@ 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));
+        const review = state.ledger.record("5C", await standardsReview(client, llm, { question: checked, ...opts.context }, stageOptionsFor(opts, "5C")));
         if (review.overall !== "accept") {
             return {
                 stage: "5C",
@@ -43,7 +26,7 @@ async function judge(client, llm, opts, state, checked, gates) {
         }
         state.emit?.({ type: "gate.passed", stage: "5C", name: STAGE_NAMES["5C"] });
     }
-    const closure = state.ledger.record("6A", await closureChecklist(client, llm, { question: checked, ...opts.context }, opts.stage));
+    const closure = state.ledger.record("6A", await closureChecklist(client, llm, { question: checked, ...opts.context }, stageOptionsFor(opts, "6A")));
     if (closure.gate !== "close") {
         return {
             stage: "6A",
@@ -54,7 +37,7 @@ async function judge(client, llm, opts, state, checked, gates) {
     }
     state.emit?.({ type: "gate.passed", stage: "6A", name: STAGE_NAMES["6A"] });
     if (gates.redTeam) {
-        const attacked = state.ledger.record("6B", await redTeam(client, llm, { question: checked, ...opts.context }, opts.stage));
+        const attacked = state.ledger.record("6B", await redTeam(client, llm, { question: checked, ...opts.context }, stageOptionsFor(opts, "6B")));
         if (attacked.verdict !== "survives") {
             return { stage: "6B", reason: `${attacked.verdict}: ${attacked.would_break_it}` };
         }
@@ -62,7 +45,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/options.d.ts

@@ -0,0 +1,11 @@
+import type { AnswerOptions } from "../producers/toulmin/index.js";
+import type { StageOptions } from "../stage.js";
+import type { NoesisOptions } from "../types.js";
+import { type StageId } from "./ledger.js";
+/**
+ * What one stage runs on: `stages[id]` over `stage`, with `params` dropped
+ * rather than inherited when the stage names a model of its own.
+ */
+export declare function stageOptionsFor(opts: NoesisOptions, id: StageId): StageOptions;
+/** The answer's tiers, defaulting to whatever `stages.answer` named. */
+export declare function answerOptions(opts: NoesisOptions): AnswerOptions;

package/dist/noesis/run/options.js

@@ -0,0 +1,18 @@
+import { STAGE_KEYS } from "./ledger.js";
+export function stageOptionsFor(opts, id) {
+    const base = opts.stage ?? {};
+    const per = opts.stages?.[STAGE_KEYS[id]];
+    if (!per)
+        return base;
+    const ownModel = per.model !== undefined && per.model !== base.model;
+    const params = ownModel ? per.params : { ...base.params, ...per.params };
+    const rest = Object.fromEntries(Object.entries({ ...base, ...per }).filter(([field]) => field !== "params"));
+    return params && Object.keys(params).length > 0 ? { ...rest, params } : rest;
+}
+export function answerOptions(opts) {
+    const base = opts.answer ?? {};
+    const sixC = opts.stages?.[STAGE_KEYS["6C"]];
+    if (base.tiers || !sixC?.model)
+        return base;
+    return { ...base, tiers: [{ model: sixC.model, ...(sixC.params ? { params: sixC.params } : {}) }] };
+}

package/dist/noesis/run/plan.js

@@ -2,33 +2,21 @@ 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.
- */
+import { stageOptionsFor } from "./options.js";
 export async function plan(client, llm, question, opts, state, audits) {
     for (;;) {
         state.ledger.dropFrom("3A");
-        state.ledger.record("3A", await planCandidates(client, llm, { question: soFar(state, question), ...opts.context }, opts.stage));
+        state.ledger.record("3A", await planCandidates(client, llm, { question: soFar(state, question), ...opts.context }, stageOptionsFor(opts, "3A")));
         if (!audits)
             return;
-        const dead = state.ledger.record("3B", await premortem(client, llm, { question: soFar(state, question), ...opts.context }, opts.stage));
+        const dead = state.ledger.record("3B", await premortem(client, llm, { question: soFar(state, question), ...opts.context }, stageOptionsFor(opts, "3B")));
         if (dead.fatal || dead.verdict === "replan") {
             if (state.ledger.retry("3B"))
                 continue;
             state.ledger.escalate("3B", "Out of retries: the premortem keeps killing the plan.");
             return;
         }
-        const gate = state.ledger.record("3C", await cqotGate(client, llm, { question: soFar(state, question), ...opts.context }, opts.stage));
+        const gate = state.ledger.record("3C", await cqotGate(client, llm, { question: soFar(state, question), ...opts.context }, stageOptionsFor(opts, "3C")));
         if (gate.gate === "pass")
             return;
         if (state.ledger.retry("3C"))