@spendgraph/workflows 0.2.0

package/README.md

@@ -0,0 +1,149 @@
+# @spendgraph/workflows
+
+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.
+
+```ts
+import { run } from "@spendgraph/workflows";
+
+const result = await run(client, llm, "Has the price changed since March?", {
+  tools: bus,
+  context: { now: new Date().toISOString(), locale: "IN / INR" },
+});
+
+result.text; // the answer, as a person reads it
+result.status; // "answered" | "abstained" | "escalated"
+result.route; // which of the four it earned
+```
+
+`client` is a `PromptClient` and `llm` an `Llm`. The two are separate on
+purpose: the prompt client pulls the stored wording and records what the call
+cost, and the model client makes it.
+
+## Four routes, chosen in code
+
+Stage 0 is a router prompt that returns five signals — difficulty, stakes,
+confidence, ambiguity, tool need — and never a route. `routeFor` in
+`src/noesis/route.ts` turns those into one, from thresholds you can move after
+an eval run without touching a prompt.
+
+| route | what it runs | when |
+| --- | --- | --- |
+| `direct` | 6C alone | easy, unambiguous, already known |
+| `retrieve` | one tool call, then 6C | easy and unambiguous, but the answer is elsewhere |
+| `standard` | frame, split, plan, execute, check, close | everything in between |
+| `full` | standard plus four audits | high stakes, expert difficulty, or real ambiguity |
+
+Stakes are tested first, because that is the one signal where being wrong is
+expensive in only one direction: an easy question answered the long way costs
+tokens, a critical one answered directly costs more than that.
+
+## The stages
+
+| | | |
+| --- | --- | --- |
+| 0 | triage | five signals |
+| 1 | question brief | the question interrogated, never answered |
+| 2 | decompose | ordered sub-questions, at most seven, depth one |
+| 3A | plan candidates | approaches, the one chosen, the steps that follow |
+| 3B | premortem | the plan assumed dead, and what killed it |
+| 3C | cqot gate | eight questions of the plan |
+| 4 | execution | **code** — every sub-question through the tool its hint named |
+| 4A | think checkpoint | predicted against actual, against 3A's own tolerance |
+| 4B | discriminating test | the one test that tells the live hypotheses apart |
+| 5A | cove questions | the verification questions the draft invites |
+| 5B | cove answers | each answered blind |
+| 5 | verification | **code** — 5A and 5B paired back together by id |
+| 5C | standards review | the answer against eight standards |
+| 6A | closure checklist | the last questions before it may close |
+| 6B | red team | the answer attacked |
+| 6C | toulmin | the artifacts compiled into a claim and its qualifier |
+| R | reflection | the earliest wrong decision behind a failed gate |
+
+Two of them are code and not model calls. Stage 4 dispatches and does not
+reason, because `deep_recall` and `web_search` already return a synthesised
+answer. Stage 5 pairs 5A's claims back to 5B's blind answers, and it has to be
+code: whatever does it sees both the claim and the answer written without it,
+and a model given both is no longer a blind check of anything.
+
+## The ledger
+
+Every stage files its result, its rollouts and its tokens in one place. That
+record is what 6C compiles from, keyed by stage id and name together — `"3A plan
+candidates"` — because the model writes one of them back as
+`grounds[].source_stage` and either has to lead to the entry.
+
+It also carries the retry budget. A gate that will not let the answer through
+spends one, runs R to find the earliest wrong decision, and cuts the ledger back
+to where the loop restarts, so nothing stale is compiled into the answer. What
+it cost stays: tokens were spent and rollouts were recorded, and going back does
+not un-spend them. The nth retry escalates instead of looping again.
+
+## Asking, and stopping
+
+Two different problems, so two mechanisms.
+
+`onAsk` is asking. Stage 1 is the only stage that reaches for a person mid-run,
+and only when it says the asker aimed at the wrong thing; a replacement question
+restarts the framing with it, and with nobody to ask the run proceeds on the
+question as put.
+
+`result.status` is stopping. `answered` is an answer to act on. `abstained` is
+6C saying the grounds supported no claim. `escalated` is a gate, or a spent
+retry budget, asking for a person — and it outranks an abstention, because a
+gate that asked for somebody said so about the whole run. Both still carry
+`text`, because saying what is not known is worth reading.
+
+`onDeliver` runs once, after the loop, and only for `answered`. Anything that
+renders a deliverable belongs there: 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.
+
+## Where it sits
+
+`@spendgraph/harness` holds the patterns — `refine`, `route`, `chain`,
+`parallel`, `loop`, `orchestrate`, `cascade` — each general and unaware of any
+particular job. This package holds finished workflows built out of them, each
+solving one job end to end. Nothing that belongs to all seven ever lands here.
+
+Nothing here talks to the database or holds a provider key. `run()` is handed
+its clients and its `ToolBus`; where a workflow needs the server it goes through
+`@spendgraph/sdk`.
+
+## Layout
+
+```
+src/
+  index.ts                the public surface
+  noesis/
+    route.ts              the thresholds, and nothing else
+    stage.ts              pull, ask through {question}, force the schema
+    question.ts           askThrough — the unmigrated-prompt floor
+    router/ producers/ gates/ repair/    one directory per stage
+    execute/ draft/ verify/              the code stages, and what they render
+    run/                  the ledger, the routes, and the gate loop
+    tests/                excluded from dist
+evals/                  scoring the loop — the free layers run in CI
+TODO.md                 how it was built, brick by brick
+GAPS.md                 what is wrong, what was fixed, what needs a decision
+```
+
+## Not yet met a real prompt
+
+Every test runs against a fake `PromptClient` and `Llm`, which is what made
+building this cheap. Two assumptions carry the design and neither has been
+exercised against the server:
+
+1. **The stored prompts render `{question}`.** Where one does not, `askThrough`
+   overwrites the box and warns once on stderr. The run still succeeds and
+   quietly answers whatever was saved on the prompt, so a warning per stage on
+   the first live run is the signal, and publishing is the fix.
+2. **6C reads the artifact keys back**, so a citation names the stage that
+   produced its evidence.
+
+`examples/` runs each route against the real prompts for a few pennies. Start
+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.

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./noesis/index.js";

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./noesis/index.js";

package/dist/noesis/attribution.d.ts

@@ -0,0 +1,24 @@
+import type { ToulminAnswer } from "./producers/toulmin/index.js";
+import { type StageId } from "./run/ledger.js";
+/**
+ * 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 declare function stageCited(source: string): StageId | undefined;
+/**
+ * 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 declare function unattributed(answer: ToulminAnswer, ran: Iterable<StageId>): string[];

package/dist/noesis/attribution.js

@@ -0,0 +1,43 @@
+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
+        .toUpperCase()
+        .replace(/^STAGE\s*/, "")
+        .replace(/[^0-9A-Z]/g, "");
+    if (IDS.has(id))
+        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 ?? [];
+    return grounds
+        .filter((ground) => {
+        const stage = stageCited(ground.source_stage ?? "");
+        return !stage || !filed.has(stage);
+    })
+        .map((ground) => ground.source_stage);
+}

package/dist/noesis/context.d.ts

@@ -0,0 +1,18 @@
+/** The `now` and `locale` facts a stage is given rather than asked for. */
+export interface Asked {
+    /** The request itself. */
+    question: string;
+    /** Current date and time with offset. The stage is told to trust it over its own sense of the present. */
+    now?: string;
+    /** Country, currency, units, language variant. It governs jurisdiction, not only geography. */
+    locale?: string;
+}
+/**
+ * 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 declare function asked(input: Asked): string;

package/dist/noesis/context.js

@@ -0,0 +1,16 @@
+/**
+ * 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}` : "",
+        input.locale ? `locale: ${input.locale}` : "",
+    ].filter(Boolean);
+    const question = input.question.trim();
+    return facts.length ? `<context>\n${facts.join("\n")}\n</context>\n\n${question}` : question;
+}

package/dist/noesis/draft/draft.d.ts

@@ -0,0 +1,18 @@
+import type { Execution } from "../execute/index.js";
+import type { Decomposition } from "../producers/decompose/index.js";
+import type { Draft } from "./types.js";
+/**
+ * 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 declare function assemble(question: string, decomposition: Decomposition, execution: Execution): Draft;
+/**
+ * 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 declare function render(draft: Draft): string;

package/dist/noesis/draft/draft.js

@@ -0,0 +1,50 @@
+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 = [];
+    const missing = [];
+    for (const answer of execution.answers) {
+        if (answer.status === "answered") {
+            findings.push({ id: answer.id, question: answer.question, answer: answer.result });
+        }
+        else {
+            missing.push({
+                id: answer.id,
+                question: answer.question,
+                reason: answer.reason ?? `The sub-question ${answer.status}.`,
+            });
+        }
+    }
+    for (const id of execution.unresolved) {
+        missing.push({ id, question: asked.get(id) ?? id, reason: NEVER_RAN });
+    }
+    return { question, composition: decomposition.composition, findings, missing };
+}
+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),
+        block("composition", draft.composition),
+        block("findings", draft.findings.length
+            ? draft.findings.map((f) => `${f.id}. ${f.question}\n${asText(f.answer)}`).join("\n\n")
+            : "Nothing was answered."),
+    ];
+    if (draft.missing.length) {
+        parts.push(block("unanswered", draft.missing.map((m) => `${m.id}. ${m.question} — ${m.reason}`).join("\n")));
+    }
+    return parts.join("\n\n");
+}

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

@@ -0,0 +1,2 @@
+export { assemble, render } from "./draft.js";
+export type { Draft, Finding, Missing } from "./types.js";

package/dist/noesis/draft/index.js

@@ -0,0 +1 @@
+export { assemble, render } from "./draft.js";

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

@@ -0,0 +1,27 @@
+/** One sub-question and whatever answering it produced. */
+export interface Finding {
+    id: string;
+    question: string;
+    /** The tool's output. Absent where the sub-question was never answered. */
+    answer?: unknown;
+}
+/** A sub-question that produced nothing, and why. */
+export interface Missing {
+    id: string;
+    question: string;
+    reason: string;
+}
+/**
+ * What the producing half leaves for the verifying half.
+ *
+ * Assembled in code and not written by a model: nothing here is a claim anybody
+ * made, only what was asked and what came back. 5A is the first stage allowed
+ * to treat any of it as something to check.
+ */
+export interface Draft {
+    question: string;
+    /** How stage 2 said the sub-answers combine. */
+    composition: string;
+    findings: Finding[];
+    missing: Missing[];
+}

package/dist/noesis/draft/types.js

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

package/dist/noesis/events.d.ts

@@ -0,0 +1,158 @@
+import type { TriageEstimates } from "./router/triage/index.js";
+import type { StageId } from "./run/ledger.js";
+import type { Route, Routing, Status } from "./types.js";
+import type { Usage } from "./usage.js";
+/** What every event carries, whatever else it says. */
+export interface EventBase {
+    /** Monotonic within a run, so a consumer can order or de-duplicate. */
+    seq: number;
+    /** Milliseconds since the run started. */
+    at: number;
+}
+/**
+ * What the loop says while it runs.
+ *
+ * Named `noun.verb` in the past tense, because every one of these reports
+ * something that has already happened — there is nothing to cancel or confirm.
+ */
+export type NoesisEvent = EventBase & ({
+    type: "run.started";
+    question: string;
+    hasTools: boolean;
+    retryBudget: number;
+} | {
+    type: "run.routed";
+    route: Route;
+    routing: Routing;
+    estimates: TriageEstimates;
+} | {
+    type: "run.escalated";
+    from: StageId;
+    reason: string;
+} | {
+    type: "run.finished";
+    status: Status;
+    text: string;
+    route: Route;
+    usage: Usage;
+    rollouts: number;
+    latencyMs: number;
+} | {
+    type: "stage.started";
+    stage: StageId;
+    name: string;
+    slug: string;
+    model?: string;
+} | {
+    type: "stage.finished";
+    stage: StageId;
+    name: string;
+    /** The stage's own object, with long strings cut. */
+    artifact: unknown;
+    model: string;
+    rolloutIds: string[];
+    usage: Usage;
+    latencyMs: number;
+} | {
+    type: "stage.failed";
+    stage: StageId;
+    kind: "reply" | "transport";
+    error: string;
+} | {
+    type: "tools.planned";
+    waves: string[][];
+    unresolved: string[];
+} | {
+    type: "tool.started";
+    id: string;
+    question: string;
+    tool: string;
+    wave: number;
+} | {
+    type: "tool.finished";
+    id: string;
+    tool: string;
+    status: "answered" | "skipped" | "failed";
+    latencyMs: number;
+    reason?: string;
+} | {
+    type: "draft.assembled";
+    findings: number;
+    missing: {
+        id: string;
+        reason: string;
+    }[];
+} | {
+    type: "checks.paired";
+    checked: number;
+    settled: number;
+    unsettled: string[];
+    unanswered: string[];
+    unasked: string[];
+    /** Ids whose `checked_by` the run could not support, corrected to `knowledge`. */
+    overclaimed: string[];
+} | {
+    type: "gate.passed";
+    stage: StageId;
+    name: string;
+} | {
+    type: "gate.refused";
+    stage: StageId;
+    name: string;
+    reason: string;
+    hint?: string | null;
+} | {
+    type: "retry.spent";
+    gate: StageId;
+    spent: number;
+    left: number;
+    budget: number;
+    /** False on the ask that ran the budget out — the run escalates instead. */
+    granted: boolean;
+} | {
+    type: "reflect.pointed";
+    from: StageId;
+    redoFrom?: StageId;
+    resumeAt: "produce" | "verify";
+    lesson?: string;
+} | {
+    type: "ledger.dropped";
+    from: StageId;
+    dropped: StageId[];
+} | {
+    type: "ask.raised";
+    question: string;
+    better: string;
+    reason: string;
+} | {
+    type: "ask.answered";
+    replacement: string | null;
+} | {
+    type: "grounds.checked";
+    cited: number;
+    /** The `source_stage` values naming a stage the run never ran. */
+    unattributed: string[];
+} | {
+    type: "delivered";
+});
+/**
+ * One event before the emitter stamps it.
+ *
+ * Distributed over the union rather than a plain `Omit`, which would collapse
+ * seventeen shapes into their common fields and lose the discriminant.
+ */
+type Unstamped<T> = T extends unknown ? Omit<T, "seq" | "at"> : never;
+export type NoesisEventInput = Unstamped<NoesisEvent>;
+/** What a stage or the ledger calls to say something happened. */
+export type Emit = (event: NoesisEventInput) => void;
+/**
+ * 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 declare function emitter(listener: ((event: NoesisEvent) => void) | undefined, now?: () => number): Emit | undefined;
+export {};

package/dist/noesis/events.js

@@ -0,0 +1,24 @@
+/**
+ * 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;
+    const startedAt = now();
+    let seq = 0;
+    return (event) => {
+        const stamped = { ...event, seq: seq++, at: now() - startedAt };
+        try {
+            listener(stamped);
+        }
+        catch {
+            // A listener that throws does not get to fail the run.
+        }
+    };
+}

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

@@ -0,0 +1,22 @@
+import type { ToolBus } from "@spendgraph/tools";
+import type { SubQuestion, SubQuestionTool } from "../producers/decompose/index.js";
+import type { ExecuteOptions, Execution, Wiring } from "./types.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 declare const DEFAULT_TOOLS: Partial<Record<SubQuestionTool, Wiring>>;
+/**
+ * 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 declare function execute(bus: ToolBus, plan: SubQuestion[], opts?: ExecuteOptions): Promise<Execution>;

package/dist/noesis/execute/execute.js

@@ -0,0 +1,85 @@
+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" },
+    web_search: { name: "web_search", arg: "query" },
+    fetch_url: { name: "http_request", arg: "url" },
+};
+const parsed = (output) => {
+    try {
+        return JSON.parse(output);
+    }
+    catch {
+        return output;
+    }
+};
+async function answerOne(bus, wiring, sub, wave, emit) {
+    const base = { id: sub.id, question: sub.question, tool: sub.tool, latencyMs: 0 };
+    const wired = wiring[sub.tool];
+    const done = (answer) => {
+        emit?.({
+            type: "tool.finished",
+            id: answer.id,
+            tool: wired?.name ?? answer.tool,
+            status: answer.status,
+            latencyMs: answer.latencyMs,
+            reason: answer.reason,
+        });
+        return answer;
+    };
+    if (!wired) {
+        return done({
+            ...base,
+            status: "skipped",
+            reason: sub.tool === "none"
+                ? "The stage named no tool, so there is nothing to call."
+                : `Nothing is wired for "${sub.tool}".`,
+        });
+    }
+    emit?.({
+        type: "tool.started",
+        id: sub.id,
+        question: sub.question,
+        tool: wired.name,
+        wave,
+    });
+    const result = await bus.invoke(wired.name, { [wired.arg]: sub.question });
+    return done(result.status === "failed"
+        ? { ...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);
+    const answers = [];
+    opts.emit?.({
+        type: "tools.planned",
+        waves: waves.map((wave) => wave.map((sub) => sub.id)),
+        unresolved,
+    });
+    for (const [index, wave] of waves.entries()) {
+        answers.push(...(await Promise.all(wave.map((sub) => answerOne(bus, wiring, sub, index, opts.emit)))));
+    }
+    return {
+        answers,
+        unresolved,
+        toolMs: answers.reduce((total, answer) => total + answer.latencyMs, 0),
+    };
+}

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

@@ -0,0 +1,3 @@
+export { DEFAULT_TOOLS, execute } from "./execute.js";
+export { order } from "./order.js";
+export type { ExecuteOptions, Execution, SubAnswer, Waves, Wiring } from "./types.js";

package/dist/noesis/execute/index.js

@@ -0,0 +1,2 @@
+export { DEFAULT_TOOLS, execute } from "./execute.js";
+export { order } from "./order.js";