@verevoir/recipes 0.13.0 → 0.14.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.14.0 — 2026-07-02
+
+- **Plan-first execution engine** (`plan-execute.ts`), relocated from the mcp so it's a shared engine primitive alongside `buildPlanGraph`. Pure (no SDK/network — deps injected): `executePlanParallel` (layer the DAG, run each layer concurrently, thread upstream results, isolate failures), `layerPlan`, `buildExecutionPlan`, `gatePlan`, `parseEntrySelection`, `defaultBuildDirective`, and the `NodeRun` / `PlanExecDeps` / `PlanExecResult` / `GateVerdict` / `RecordedCall` types. Exported from the engine entry. The mcp keeps the LLM-specific bits (`selectEntryTypes`, `enactNode`, the coordinator harness) and consumes these. 101 tests.
+
 ## 0.13.0 — 2026-07-01
 
 - **The capability join lives here now — `capabilityWithRun` / `capabilitiesWithRun`** (STDIO-515). Recipes already owned a capability's DATA half (`parseCapability` → `CapabilityDescriptor`); the CODE half (a consumer's `run` executor, keyed by type) was joined to it in each consumer (aigency-web's `capabilities.ts`). That join is engine logic in the wrong place — and it must be **universally available to aigency AND the MCP**, which can't import aigency, so a shared lib is the only home. Lifted here: `capabilityWithRun<Run>(corpus, type, executors)` (single lookup) and `capabilitiesWithRun<Run>(corpus, executors)` (bulk), plus the `CapabilityWithRun<Run> = CapabilityDescriptor & { run?: Run }` type. **Generic over the executor signature** — recipes owns the join, not the executor shape, so each consumer plugs in its own (`run: undefined` for a conversation-only capability with no executor; `undefined` when no descriptor of that type exists). Consumers refactor to call it and drop their local copies.

package/dist/engine.d.ts

@@ -1,6 +1,7 @@
 export * from './retrieval.js';
 export * from './provisioning.js';
 export * from './plan.js';
+export * from './plan-execute.js';
 export * from './verify.js';
 export * from './run-verify.js';
 export * from './adversarial-review.js';

package/dist/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAIA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAIA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC"}

package/dist/engine.js

@@ -5,6 +5,7 @@
 export * from './retrieval.js';
 export * from './provisioning.js';
 export * from './plan.js';
+export * from './plan-execute.js';
 export * from './verify.js';
 export * from './run-verify.js';
 export * from './adversarial-review.js';

package/dist/engine.js.map

@@ -1 +1 @@
-{"version":3,"file":"engine.js","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,gFAAgF;AAChF,oFAAoF;AACpF,kFAAkF;AAClF,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"engine.js","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,gFAAgF;AAChF,oFAAoF;AACpF,kFAAkF;AAClF,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC"}

package/dist/plan-execute.d.ts

@@ -0,0 +1,110 @@
+import type { CapabilityDescriptor } from './index.js';
+import type { ExecutionPlan, PlanNode } from './plan.js';
+/** One real tool call a node ran, with what it cost — the opaque accounting unit
+ * the executor threads through to a caller's cost aggregation. Recipes never
+ * interprets these; it only collects them per node and hands the union back. */
+export interface RecordedCall {
+    /** The tool the call ran (`enact_capability`, `delegate`, …). */
+    tool: string;
+    /** The concrete model id that ran the work, or `'(none)'` for an inline call. */
+    model: string;
+    /** FRESH input tokens only — cache read/write are separate below so a caller
+     * can price them at their real (cheaper) rates. */
+    tokensIn: number;
+    tokensOut: number;
+    /** Cache-read / cache-write input tokens, SEPARATE from `tokensIn`. */
+    cacheRead?: number;
+    cacheWrite?: number;
+    /** Wall-clock for the call, ms. */
+    ms: number;
+}
+/** The outcome of running one plan node: its produced text, every model call it
+ * made (for the cost rollup), and whether it failed. A failed run's dependents
+ * can never satisfy their deps, so they are skipped. */
+export interface NodeRun {
+    /** The node's produced output — threaded into its dependents' directives. */
+    text: string;
+    /** Every model call this node made, for the whole-run cost aggregation. */
+    calls: RecordedCall[];
+    /** True when the node's enact errored or its gate failed. */
+    failed?: boolean;
+}
+export interface PlanExecDeps {
+    /** Run ONE node: enact its capability with a directive already threaded from
+     * upstream results. Injected so the executor is testable without a network;
+     * the coordinator provides the real one (a wrapper over `enactCapability`). */
+    enactNode: (node: PlanNode, directive: string) => Promise<NodeRun>;
+    /** Build a node's directive from the request and its upstream results (the
+     * produced text of each capability in `node.dependsOn`). Optional — a sensible
+     * default grounds the request with a labelled block per upstream. */
+    buildDirective?: (node: PlanNode, request: string, upstream: Map<string, string>) => string;
+}
+export interface PlanExecResult {
+    /** Capability type → produced text, for every node that ran (not the skipped). */
+    results: Map<string, string>;
+    /** All RecordedCalls across all nodes that ran, for the cost aggregation. */
+    calls: RecordedCall[];
+    /** The layers as executed; each is the capability types run CONCURRENTLY.
+     * `layers.length` is the critical-path depth; the total size is the node
+     * count. Order within a layer is stable (sorted by capability). */
+    layers: string[][];
+    /** Nodes that failed — their transitive dependents were skipped, so a failure
+     * leaves a legible partial result rather than throwing. */
+    failed: string[];
+}
+/** The default directive builder: the request, followed by one labelled grounding
+ * block per upstream result, so a node sees what its prerequisites produced. */
+export declare function defaultBuildDirective(_node: PlanNode, request: string, upstream: Map<string, string>): string;
+/**
+ * Layer the plan's DAG: layer 0 is the nodes with no in-plan dependency, and
+ * layer k is the nodes whose every dependency sits in an earlier layer. PURE and
+ * deterministic — membership follows only from `dependsOn`, and each layer is
+ * sorted by capability so the order is stable across runs. A dependency naming a
+ * capability not in the plan is treated as already-satisfied (it can't be waited
+ * on). A cycle (which a well-formed plan never contains) leaves its nodes
+ * unlayered rather than looping.
+ */
+export declare function layerPlan(plan: ExecutionPlan): PlanNode[][];
+/**
+ * Execute a plan with its independent nodes running CONCURRENTLY. The DAG is
+ * layered (`layerPlan`); each layer runs via `Promise.all`, and a barrier between
+ * layers means a node never starts before its dependencies' results exist. Before
+ * a node runs, its upstream results are gathered and threaded into its directive
+ * (`deps.buildDirective`, or a labelled-grounding default).
+ *
+ * Failure is isolated: a node whose run reports `failed` — or whose `enactNode`
+ * throws (caught, treated as failed) — is recorded in `failed`, and its
+ * transitive dependents are SKIPPED (they can never satisfy their deps) while
+ * independent nodes and layers proceed. This never throws: a failure yields a
+ * legible partial result, not a dropped run.
+ */
+export declare function executePlanParallel(plan: ExecutionPlan, deps: PlanExecDeps): Promise<PlanExecResult>;
+/** A gate verdict over a plan: whether it's safe to spend on, and the findings
+ * that failed it. `ok` false means the plan should be aborted, not executed. */
+export interface GateVerdict {
+    ok: boolean;
+    findings: string[];
+}
+/**
+ * Gate a plan before any spend — the "inspect before you spend" control point.
+ * PURE. A plan passes only when:
+ *  - it has at least one node (an empty plan produces nothing);
+ *  - every entry capability resolves to a node in the plan;
+ *  - no node depends on a capability the plan doesn't contain (a dangling edge);
+ *  - the plan is acyclic — topologically orderable via its `dependsOn` edges.
+ *
+ * buildPlanGraph already topologically orders and drops unresolvable edges, so a
+ * gate failure here signals a plan built some other way, or a corpus/entry
+ * mismatch. Findings name what failed so the caller can abort legibly.
+ */
+export declare function gatePlan(plan: ExecutionPlan): GateVerdict;
+/** Parse selected ids from a model reply, matching only against the supplied id
+ * set, order preserved by the corpus. Word-boundary anchored so a hyphenated id
+ * doesn't fire on its substrings (same rule as recipes' parseSelectedIds). PURE
+ * string parsing — no model call. */
+export declare function parseEntrySelection(text: string, ids: string[]): string[];
+/** Build an ExecutionPlan from buildPlanGraph's output. Practices are `[]` — this
+ * builds the DAG's cost + parallel structure, not per-node provisioning (that's
+ * `planExecution`'s job, which needs an embedder). PURE. */
+export declare function buildExecutionPlan(request: string, entry: string[], corpus: CapabilityDescriptor[]): ExecutionPlan;
+//# sourceMappingURL=plan-execute.d.ts.map

package/dist/plan-execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-execute.d.ts","sourceRoot":"","sources":["../src/plan-execute.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAEzD;;gFAEgF;AAChF,MAAM,WAAW,YAAY;IAC3B,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,iFAAiF;IACjF,KAAK,EAAE,MAAM,CAAC;IACd;uDACmD;IACnD,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mCAAmC;IACnC,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;wDAEwD;AACxD,MAAM,WAAW,OAAO;IACtB,6EAA6E;IAC7E,IAAI,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,6DAA6D;IAC7D,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B;;mFAE+E;IAC/E,SAAS,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACnE;;yEAEqE;IACrE,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;CAC7F;AAED,MAAM,WAAW,cAAc;IAC7B,kFAAkF;IAClF,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,6EAA6E;IAC7E,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB;;uEAEmE;IACnE,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB;+DAC2D;IAC3D,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;gFACgF;AAChF,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC5B,MAAM,CAMR;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,aAAa,GAAG,QAAQ,EAAE,EAAE,CAkB3D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,cAAc,CAAC,CA4CzB;AAED;gFACgF;AAChF,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,OAAO,CAAC;IACZ,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,aAAa,GAAG,WAAW,CA2BzD;AA2BD;;;qCAGqC;AACrC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAOzE;AAED;;4DAE4D;AAC5D,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,oBAAoB,EAAE,GAC7B,aAAa,CAaf"}

package/dist/plan-execute.js

@@ -0,0 +1,199 @@
+// PLAN EXECUTION — the PURE, plan-first execution engine, sibling to
+// `buildPlanGraph` in plan.ts. Where plan.ts turns a request into a dependency
+// DAG of capability nodes, this module GATES that plan (inspect before you
+// spend), LAYERS it, and EXECUTES it with independent nodes running CONCURRENTLY.
+//
+// Everything here is a PURE function of the plan (its `dependsOn` edges) plus
+// INJECTED enactment — no LLM, no network, no SDK. A real coordinator wraps
+// `enactCapability`; tests pass a mock. That purity is why these live in recipes
+// as a shared engine primitive (aigency, the MCP, or anyone can drive them),
+// rather than in any one consumer.
+//
+// `RecordedCall` is the executor's opaque cost-accounting unit — the executor
+// threads a node's recorded calls through to the aggregate without interpreting
+// them, so recipes stays free of any measurement machinery.
+import { buildPlanGraph } from './plan.js';
+/** The default directive builder: the request, followed by one labelled grounding
+ * block per upstream result, so a node sees what its prerequisites produced. */
+export function defaultBuildDirective(_node, request, upstream) {
+    if (upstream.size === 0)
+        return request;
+    const grounding = [...upstream.entries()]
+        .map(([capability, text]) => `grounding: ${capability}:\n${text}`)
+        .join('\n\n');
+    return `${request}\n\n${grounding}`;
+}
+/**
+ * Layer the plan's DAG: layer 0 is the nodes with no in-plan dependency, and
+ * layer k is the nodes whose every dependency sits in an earlier layer. PURE and
+ * deterministic — membership follows only from `dependsOn`, and each layer is
+ * sorted by capability so the order is stable across runs. A dependency naming a
+ * capability not in the plan is treated as already-satisfied (it can't be waited
+ * on). A cycle (which a well-formed plan never contains) leaves its nodes
+ * unlayered rather than looping.
+ */
+export function layerPlan(plan) {
+    const inPlan = new Set(plan.nodes.map((n) => n.capability));
+    const placed = new Set();
+    const layers = [];
+    while (placed.size < plan.nodes.length) {
+        const ready = plan.nodes.filter((n) => !placed.has(n.capability) && n.dependsOn.every((d) => !inPlan.has(d) || placed.has(d)));
+        // No node became ready but some remain unplaced → a dependency cycle. Stop
+        // rather than loop; the remaining nodes are left unlayered (never runnable).
+        if (ready.length === 0)
+            break;
+        ready.sort((a, b) => a.capability.localeCompare(b.capability));
+        for (const n of ready)
+            placed.add(n.capability);
+        layers.push(ready);
+    }
+    return layers;
+}
+/**
+ * Execute a plan with its independent nodes running CONCURRENTLY. The DAG is
+ * layered (`layerPlan`); each layer runs via `Promise.all`, and a barrier between
+ * layers means a node never starts before its dependencies' results exist. Before
+ * a node runs, its upstream results are gathered and threaded into its directive
+ * (`deps.buildDirective`, or a labelled-grounding default).
+ *
+ * Failure is isolated: a node whose run reports `failed` — or whose `enactNode`
+ * throws (caught, treated as failed) — is recorded in `failed`, and its
+ * transitive dependents are SKIPPED (they can never satisfy their deps) while
+ * independent nodes and layers proceed. This never throws: a failure yields a
+ * legible partial result, not a dropped run.
+ */
+export async function executePlanParallel(plan, deps) {
+    const buildDirective = deps.buildDirective ?? defaultBuildDirective;
+    const layers = layerPlan(plan);
+    const results = new Map();
+    const calls = [];
+    const failed = new Set();
+    for (const layer of layers) {
+        // A node is skipped when any dependency failed or was itself skipped — the
+        // failure propagates transitively down the DAG, layer by layer.
+        const runnable = layer.filter((n) => !n.dependsOn.some((d) => failed.has(d)));
+        for (const n of layer)
+            if (!runnable.includes(n))
+                failed.add(n.capability);
+        const runs = await Promise.all(runnable.map(async (node) => {
+            const upstream = new Map();
+            for (const dep of node.dependsOn) {
+                const text = results.get(dep);
+                if (text !== undefined)
+                    upstream.set(dep, text);
+            }
+            const directive = buildDirective(node, plan.request, upstream);
+            try {
+                return [node, await deps.enactNode(node, directive)];
+            }
+            catch (err) {
+                const message = `<enact ${node.capability} failed: ${String(err).slice(0, 200)}>`;
+                return [node, { text: message, calls: [], failed: true }];
+            }
+        }));
+        for (const [node, run] of runs) {
+            calls.push(...run.calls);
+            if (run.failed)
+                failed.add(node.capability);
+            else
+                results.set(node.capability, run.text);
+        }
+    }
+    return {
+        results,
+        calls,
+        layers: layers.map((layer) => layer.map((n) => n.capability)),
+        failed: [...failed],
+    };
+}
+/**
+ * Gate a plan before any spend — the "inspect before you spend" control point.
+ * PURE. A plan passes only when:
+ *  - it has at least one node (an empty plan produces nothing);
+ *  - every entry capability resolves to a node in the plan;
+ *  - no node depends on a capability the plan doesn't contain (a dangling edge);
+ *  - the plan is acyclic — topologically orderable via its `dependsOn` edges.
+ *
+ * buildPlanGraph already topologically orders and drops unresolvable edges, so a
+ * gate failure here signals a plan built some other way, or a corpus/entry
+ * mismatch. Findings name what failed so the caller can abort legibly.
+ */
+export function gatePlan(plan) {
+    const findings = [];
+    const present = new Set(plan.nodes.map((n) => n.capability));
+    if (plan.nodes.length === 0) {
+        findings.push('plan is empty — no capabilities to execute');
+    }
+    for (const entry of plan.entry) {
+        if (!present.has(entry)) {
+            findings.push(`entry capability "${entry}" has no node in the plan`);
+        }
+    }
+    for (const node of plan.nodes) {
+        for (const dep of node.dependsOn) {
+            if (!present.has(dep)) {
+                findings.push(`node "${node.capability}" depends on missing capability "${dep}"`);
+            }
+        }
+    }
+    if (!isAcyclic(plan.nodes)) {
+        findings.push('plan has a dependency cycle — it cannot be topologically ordered');
+    }
+    return { ok: findings.length === 0, findings };
+}
+/** Whether a node set's `dependsOn` edges form a DAG — a Kahn peel that consumes
+ * every node iff there is no cycle. Edges to absent capabilities are ignored here
+ * (the dangling-dep check reports those); this asks only about cyclicity. */
+function isAcyclic(nodes) {
+    const present = new Set(nodes.map((n) => n.capability));
+    const indeg = new Map();
+    for (const n of nodes) {
+        indeg.set(n.capability, n.dependsOn.filter((d) => present.has(d)).length);
+    }
+    const ready = nodes.filter((n) => (indeg.get(n.capability) ?? 0) === 0).map((n) => n.capability);
+    let consumed = 0;
+    while (ready.length > 0) {
+        const t = ready.pop();
+        consumed++;
+        for (const n of nodes) {
+            if (n.dependsOn.includes(t)) {
+                const d = (indeg.get(n.capability) ?? 0) - 1;
+                indeg.set(n.capability, d);
+                if (d === 0)
+                    ready.push(n.capability);
+            }
+        }
+    }
+    return consumed === nodes.length;
+}
+/** Parse selected ids from a model reply, matching only against the supplied id
+ * set, order preserved by the corpus. Word-boundary anchored so a hyphenated id
+ * doesn't fire on its substrings (same rule as recipes' parseSelectedIds). PURE
+ * string parsing — no model call. */
+export function parseEntrySelection(text, ids) {
+    const out = [];
+    for (const id of ids) {
+        const re = new RegExp(`(?<![a-z-])${id}(?![a-z-])`);
+        if (re.test(text) && !out.includes(id))
+            out.push(id);
+    }
+    return out;
+}
+/** Build an ExecutionPlan from buildPlanGraph's output. Practices are `[]` — this
+ * builds the DAG's cost + parallel structure, not per-node provisioning (that's
+ * `planExecution`'s job, which needs an embedder). PURE. */
+export function buildExecutionPlan(request, entry, corpus) {
+    const graph = buildPlanGraph(entry, corpus);
+    const nodes = graph.map((g) => ({
+        capability: g.capability,
+        practices: [],
+        dependsOn: g.dependsOn,
+        source: g.source,
+    }));
+    return {
+        request,
+        entry: graph.filter((g) => g.source === 'retrieved').map((g) => g.capability),
+        nodes,
+    };
+}
+//# sourceMappingURL=plan-execute.js.map

package/dist/plan-execute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-execute.js","sourceRoot":"","sources":["../src/plan-execute.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@verevoir/recipes",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Recipe-descriptor format + zero-dependency parser: a flat-frontmatter .md describes a parameterised procedure (typed inputs → instructions → result) that a host compiles to a chat-time tool or an MCP prompt.",
   "license": "Apache-2.0",
   "type": "module",