@deepstrike/wasm 0.2.77 → 0.2.79

package/dist/runtime/types/agent.d.ts

@@ -84,18 +84,8 @@ export interface LoopResult {
     finalMessage?: ModelMessage;
     turnsUsed: number;
     totalTokensUsed: number;
-    /** loop-control loop stop signal: a loop iteration sets `false` to end the loop before `max_iters`.
-     *  `undefined` (every non-loop result) ⇒ no opinion → run to the cap. Sent only when set. */
-    loopContinue?: boolean;
-    /** A#2 classify routing: a classifier node reports the chosen branch label here; the kernel runs
-     *  that branch and prunes the rest. Sent only when set. */
-    classifyBranch?: string;
-    /** A#2 tournament verdict: a judge reports the winning entrant's agent id here. Sent only when set. */
-    tournamentWinner?: string;
     /** ③ loop-agent pacing: the kernel-adjudicated after-round decision, surfaced by the orchestrator
-     *  from the child's done event. For a loop-node iteration this is the PRIMARY continuation
-     *  vocabulary (stop → loopContinue=false).
-     *  SDK-internal — stripped by `subAgentResultToKernel`. */
+     *  from the child's done event. SDK-internal — stripped by `subAgentResultToKernel`. */
     paceDecision?: import("../kernel-step.js").PaceDecision;
 }
 export interface SubAgentResult {
@@ -170,27 +160,6 @@ export interface WorkflowNodeSpec {
     trust?: NodeTrust;
     /** G3: JSON Schema the node's output must conform to (validated + retried SDK-side). */
     outputSchema?: Record<string, unknown>;
-    /** G2: make this a deterministic reduce node — runs no LLM; the runner routes it to the registered
-     *  reducer of this name over its `dependsOn` nodes' outputs. */
-    reducer?: string;
-    /** loop-control: make this a *loop* node — re-run its agent up to `maxIters` times. An iteration may end
-     *  the loop early by reporting `loopContinue: false` (the runner solicits this from the agent). */
-    loop?: {
-        maxIters: number;
-    };
-    /** A#2: make this a *classify* node — its agent picks exactly one branch `label`; that branch's
-     *  nodes run and the others are pruned. Each branch node must list this node's index in `dependsOn`. */
-    classify?: {
-        branches: Array<{
-            label: string;
-            nodes: number[];
-        }>;
-    };
-    /** A#2: make this a *tournament controller* — generate each `entrants` candidate in parallel, then
-     *  pairwise-judge them to one winner (this node's `task.goal` is the judging criterion). ≥2 entrants. */
-    tournament?: {
-        entrants: WorkflowTaskSpec[];
-    };
     /** M4/G5: cap this node's child run at `tokenBudget` cumulative tokens (the per-node "use N tokens"). */
     tokenBudget?: number;
     /** O3: cap this node's child run at `maxTurns` provider turns (falls back to the parent's). */
@@ -239,6 +208,13 @@ export interface WorkflowOutcome {
     rejection?: ControlRequestRejection;
 }
 export declare function workflowNodeOutcomeFromKernel(raw: KernelWorkflowNodeOutcome): WorkflowNodeOutcome;
+/** Plan task 1.1 · one parent knowledge item a child run starts with (kernel-chosen by scope). */
+export interface InheritedKnowledge {
+    content: string;
+    key?: string;
+    tokens?: number;
+    pinned?: boolean;
+}
 /** Per-node spawn descriptor carried in the `workflow_batch_spawned` observation. */
 export interface WorkflowSpawnInfo {
     agent_id: string;
@@ -253,23 +229,13 @@ export interface WorkflowSpawnInfo {
     trust?: string;
     /** G3: JSON Schema the node's output must conform to (carried verbatim from the spec). */
     output_schema?: Record<string, unknown>;
-    /** G2: for a reduce node, the registered reducer name to run (no LLM). */
-    reducer?: string;
-    /** The dependency agent ids for EVERY dependent node (W-N2: a DAG edge carries data). A reduce
-     *  node's registered function consumes them; every other node gets its deps' outputs in context. */
+    /** The dependency agent ids for EVERY dependent node (W-N2: a DAG edge carries data): the node
+     *  gets its deps' outputs in context. */
     input_agent_ids?: string[];
-    /** A#2: present only for a tournament *judge* spawn — the two entrant agent ids whose produced
-     *  outputs this judge compares. The runner looks them up and reports the winner as `tournamentWinner`. */
-    judge_match?: {
-        left: string;
-        right: string;
-    };
-    /** loop-control: present only for a *loop* iteration spawn — the loop's `max_iters`. Marks the spawn as a
-     *  loop iteration so the runner solicits + reports a `loopContinue` stop signal. */
-    loop_max_iters?: number;
-    /** A#2: present only for a *classify* spawn — the branch labels the classifier must choose among.
-     *  Non-empty marks the spawn as a classifier so the runner instructs the agent + reports `classifyBranch`. */
-    classify_labels?: string[];
+    /** The kernel-composed dependency section that follows the node's goal. */
+    dependency_brief?: string;
+    /** Plan task 1.1 · the parent knowledge the kernel lets this node inherit (by item scope). */
+    inherited_knowledge?: InheritedKnowledge[];
     /** M4/G5: the node's per-node cumulative token cap, if set — the runner caps the child run here. */
     token_budget?: number;
     /** O3: per-node turn cap → the child run's `maxTurns`. */
@@ -317,8 +283,8 @@ export declare function generateAndFilter(generators: WorkflowTaskSpec[], filter
  */
 export declare function verifyRules(rules: WorkflowTaskSpec[], skeptic?: WorkflowTaskSpec): WorkflowSpec;
 /**
- * Generate → evaluate loop template (parity with node/python `genEval`): a worker Loop node
- * (worktree isolation, full context) feeding a fresh-context verifier whose output is pinned
- * to the kernel's verdict schema. Async because the wasm kernel module loads lazily.
+ * Generate → evaluate template (parity with node/python `genEval`): a worker node (worktree
+ * isolation, full context) feeding a fresh-context verifier whose output is pinned to the kernel's
+ * verdict schema. Retry-with-feedback is `AttemptLoop`. Async because the wasm kernel loads lazily.
  */
-export declare function genEval(worker: WorkflowTaskSpec, evaluate: WorkflowTaskSpec, maxIters?: number, extractSkillOnPass?: boolean): Promise<WorkflowSpec>;
+export declare function genEval(worker: WorkflowTaskSpec, evaluate: WorkflowTaskSpec, extractSkillOnPass?: boolean): Promise<WorkflowSpec>;

package/dist/runtime/types/agent.js

@@ -96,11 +96,6 @@ export function subAgentResultToKernel(result) {
                 : null,
             turns_used: result.result.turnsUsed,
             total_tokens_used: result.result.totalTokensUsed,
-            // A#2: control-flow signals — additive, omitted on the wire when unset so a plain spawn's
-            // result is byte-identical to before. The kernel reads each only for the matching node kind.
-            ...(result.result.loopContinue !== undefined ? { loop_continue: result.result.loopContinue } : {}),
-            ...(result.result.classifyBranch !== undefined ? { classify_branch: result.result.classifyBranch } : {}),
-            ...(result.result.tournamentWinner !== undefined ? { tournament_winner: result.result.tournamentWinner } : {}),
         },
     };
 }
@@ -179,28 +174,9 @@ function workflowTaskToKernel(t) {
         ...(task.lane ? { lane: task.lane } : {}),
     };
 }
-/** Lower a node's control-flow kind to the kernel's serde-tagged `NodeKind` JSON, or `undefined` for
- *  a plain spawn. `reducer` / `loop` / `classify` / `tournament` are mutually exclusive. */
-function nodeKindToKernel(n) {
-    const declared = [n.reducer != null, n.loop != null, n.classify != null, n.tournament != null].filter(Boolean).length;
-    if (declared > 1) {
-        throw new Error("a workflow node may declare at most one of: reducer, loop, classify, tournament");
-    }
-    if (n.reducer != null)
-        return { type: "reduce", reducer: n.reducer };
-    if (n.loop != null)
-        return { type: "loop", max_iters: n.loop.maxIters };
-    if (n.classify != null) {
-        return { type: "classify", branches: n.classify.branches.map(b => ({ label: b.label, nodes: b.nodes })) };
-    }
-    if (n.tournament != null)
-        return { type: "tournament", entrants: n.tournament.entrants.map(workflowTaskToKernel) };
-    return undefined;
-}
 /** Map one host `WorkflowNodeSpec` to its snake_case canonical JSON. Shared by the workflow root and
  *  `submit_workflow_nodes` (R3-1) so the two encodings never drift. */
 export function workflowNodeSpecToKernel(n) {
-    const kind = nodeKindToKernel(n);
     const schedulingFactors = schedulingFactorsToKernel(n.schedulingFactors);
     return {
         ...(n.nodeId ? { node_id: n.nodeId } : {}),
@@ -211,8 +187,6 @@ export function workflowNodeSpecToKernel(n) {
         ...(n.modelHint ? { model_hint: n.modelHint } : {}),
         ...(n.trust && n.trust !== "trusted" ? { trust: n.trust } : {}),
         ...(n.outputSchema ? { output_schema: n.outputSchema } : {}),
-        // A#2/G2: loop / classify / tournament / reduce lower to a serde-tagged `NodeKind`; spawn omits it.
-        ...(kind ? { kind } : {}),
         // M4/G5: per-node token cap (additive; omitted when unset).
         ...(n.tokenBudget != null ? { token_budget: n.tokenBudget } : {}),
         // O3: per-node turn / wall-clock caps (additive; omitted when unset).
@@ -304,15 +278,10 @@ export const startWorkflowTool = {
 };
 /** Build a sub-agent run spec for a kernel-generated workflow node. */
 export function workflowNodeToSpec(node, parentSessionId) {
-    // W-N6 transcript-as-carry: a loop node's iterations share ONE stable session id (the `-i{k}`
-    // suffix names the spawn, not the session), so iteration k replays the transcript of 0..k-1 —
-    // "do the next increment" actually sees the previous increments. The agent_id keeps the
-    // per-iteration suffix (kernel completion routing).
-    const sessionNodeId = node.loop_max_iters != null ? node.agent_id.replace(/-i\d+$/, "") : node.agent_id;
     return {
         identity: {
             agentId: node.agent_id,
-            sessionId: `${parentSessionId}-${sessionNodeId}`,
+            sessionId: `${parentSessionId}-${node.agent_id}`,
             isSubAgent: true,
             parentSessionId,
         },
@@ -326,11 +295,6 @@ export function workflowNodeToSpec(node, parentSessionId) {
         // O3: carry the node's turn / wall-clock caps (the orchestrator already honors these).
         ...(node.max_turns != null ? { maxTurns: node.max_turns } : {}),
         ...(node.max_wall_ms != null ? { maxWallMs: node.max_wall_ms } : {}),
-        // DW-3 one continuation vocabulary: a loop ITERATION runs with the pacing trap armed, so the
-        // agent signals continue/stop through the kernel-adjudicated `pace` meta-tool instead of a
-        // text-sniffed JSON blob. One iteration = one round; the DAG (not max_rounds) caps iterations,
-        // and default stop means "ended without pacing" = done — the CC silence-is-completion contract.
-        ...(node.loop_max_iters != null ? { loopRound: { defaultAction: "stop" } } : {}),
     };
 }
 /** Build the host manifest for a kernel-generated workflow node. */
@@ -362,7 +326,7 @@ export function fanoutSynthesize(workers, synthesize) {
         task: asTask(synthesize),
         role: "plan",
         isolation: "shared",
-        contextInheritance: "full",
+        contextInheritance: "system_only",
         dependsOn: workers.map((_, i) => i),
     });
     return { nodes };
@@ -373,7 +337,7 @@ export function generateAndFilter(generators, filter) {
         task: asTask(t),
         role: "implement",
         isolation: "worktree",
-        contextInheritance: "full",
+        contextInheritance: "system_only",
     }));
     nodes.push({
         task: asTask(filter),
@@ -407,11 +371,11 @@ export function verifyRules(rules, skeptic) {
     return { nodes };
 }
 /**
- * Generate → evaluate loop template (parity with node/python `genEval`): a worker Loop node
- * (worktree isolation, full context) feeding a fresh-context verifier whose output is pinned
- * to the kernel's verdict schema. Async because the wasm kernel module loads lazily.
+ * Generate → evaluate template (parity with node/python `genEval`): a worker node (worktree
+ * isolation, full context) feeding a fresh-context verifier whose output is pinned to the kernel's
+ * verdict schema. Retry-with-feedback is `AttemptLoop`. Async because the wasm kernel loads lazily.
  */
-export async function genEval(worker, evaluate, maxIters = 3, extractSkillOnPass = true) {
+export async function genEval(worker, evaluate, extractSkillOnPass = true) {
     const kernel = await getKernel();
     const schema = JSON.parse(kernel.verdictOutputSchema(extractSkillOnPass));
     return {
@@ -420,8 +384,7 @@ export async function genEval(worker, evaluate, maxIters = 3, extractSkillOnPass
                 task: asTask(worker),
                 role: "implement",
                 isolation: "worktree",
-                contextInheritance: "full",
-                loop: { maxIters: Math.max(1, maxIters) },
+                contextInheritance: "system_only",
             },
             {
                 task: asTask(evaluate),

package/dist/types.d.ts

@@ -243,6 +243,16 @@ export interface ProviderDescriptor {
         supported: boolean;
         requiresStrictPairing: boolean;
     };
+    /** Context tiers this provider performs natively as configured. The runner hands each one to
+     *  the provider and the kernel skips its own; renewal is never delegated. */
+    nativeContext?: NativeContextTiers;
+}
+/** Context-management tiers a provider can perform server-side. */
+export interface NativeContextTiers {
+    /** Old tool results are cleared before the model sees them. */
+    toolResultClearing?: boolean;
+    /** Earlier history is summarized server-side. */
+    compaction?: boolean;
 }
 export type MeasurementSource = {
     kind: "native";
@@ -321,8 +331,3 @@ export interface LLMProvider {
      *  providers that ignore it still stop processing immediately. */
     signal?: AbortSignal): AsyncIterable<StreamEvent>;
 }
-export interface MemorySummarizer {
-    summarize(archived: ModelMessage[], context: {
-        action?: string;
-    }): Promise<string>;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/wasm",
-  "version": "0.2.77",
+  "version": "0.2.79",
   "description": "DeepStrike WASM SDK — browser, Cloudflare Workers, Deno Deploy",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
@@ -14,10 +14,10 @@
     "build:wasm": "wasm-pack build ../crates/deepstrike-wasm --target bundler --out-dir ../../wasm/pkg",
     "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "test": "node --experimental-vm-modules node_modules/.bin/jest",
-    "test:canonical-binding": "wasm-pack build ../crates/deepstrike-wasm --target nodejs --dev --out-dir ../../wasm/pkg-node && node tests/canonical-binding.node.cjs && node tests/golden-fixtures-sweep.node.cjs && npm run build && node tests/boundary-p0-regressions.node.mjs && node tests/boundary-p1-regressions.node.mjs && node tests/boundary-p2-regressions.node.mjs"
+    "test:canonical-binding": "wasm-pack build ../crates/deepstrike-wasm --target nodejs --dev --out-dir ../../wasm/pkg-node && node tests/canonical-binding.node.cjs && node tests/golden-fixtures-sweep.node.cjs && npm run build && node tests/boundary-p0-regressions.node.mjs && node tests/boundary-p1-regressions.node.mjs && node tests/boundary-p2-regressions.node.mjs && node tests/memory-candidate-binding.node.mjs && node tests/memory-recall-renewal.node.mjs"
   },
   "dependencies": {
-    "@deepstrike/wasm-kernel": "0.2.77"
+    "@deepstrike/wasm-kernel": "0.2.79"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",

package/dist/memory/extraction.d.ts

@@ -1,4 +0,0 @@
-import type { LLMProvider } from "../types.js";
-import type { MemoryRecord, MemoryScope, SessionData } from "./index.js";
-export declare function extractSessionMemories(provider: LLMProvider, session: SessionData, scope: MemoryScope, systemPrompt?: string): Promise<MemoryRecord[]>;
-export declare function parseExtractedMemories(output: string, session: SessionData, scope: MemoryScope): MemoryRecord[];

package/dist/memory/extraction.js

@@ -1,48 +0,0 @@
-const KINDS = new Set(["user", "feedback", "project", "reference"]);
-export async function extractSessionMemories(provider, session, scope, systemPrompt) {
-    const transcript = session.messages.map(message => `[${message.role.toUpperCase()}] ${message.content}`).join("\n").slice(0, 8_000);
-    const context = {
-        systemText: [systemPrompt, "Extract durable, reusable facts from this completed session. Return only JSON; do not include transient progress or guesses."].filter(Boolean).join("\n\n"),
-        turns: [{ role: "user", content: `${transcript}\n\nReturn {"memories":[{"name":"stable-kebab-key","kind":"user|feedback|project|reference","content":"fact","description":"why durable","confidence":0.0,"links":[],"pinned":false,"ttl_days":null,"evidence_refs":[]}]} with at most 10 items. Return {"memories":[]} when nothing is durable.`, toolCalls: [] }],
-    };
-    let output = "";
-    const state = provider.createRunState?.();
-    for await (const event of provider.stream(context, [], undefined, state)) {
-        if (event.type === "text_delta" && "delta" in event)
-            output += event.delta;
-    }
-    return parseExtractedMemories(output, session, scope);
-}
-export function parseExtractedMemories(output, session, scope) {
-    let value;
-    try {
-        value = JSON.parse(output.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, ""));
-    }
-    catch {
-        return [];
-    }
-    if (!value || typeof value !== "object" || !Array.isArray(value.memories))
-        return [];
-    const records = [];
-    for (const raw of value.memories.slice(0, 10)) {
-        if (!raw || typeof raw !== "object")
-            continue;
-        const draft = raw;
-        const name = typeof draft.name === "string" ? draft.name.trim() : "";
-        const kind = typeof draft.kind === "string" && KINDS.has(draft.kind) ? draft.kind : undefined;
-        const content = typeof draft.content === "string" ? draft.content.trim() : "";
-        if (!name || !kind || !content)
-            continue;
-        records.push({
-            record_id: `${scope.tenant_id}:${scope.namespace}:${kind}:${name}`, scope, name, kind, content,
-            description: typeof draft.description === "string" ? draft.description.trim() : "",
-            provenance: { session_id: session.sessionId, author: "extraction", trust: "untrusted", evidence_refs: Array.isArray(draft.evidence_refs) ? draft.evidence_refs.filter((ref) => typeof ref === "string") : [] },
-            created_at: session.updatedAtMs, updated_at: session.updatedAtMs, recall_count: 0,
-            confidence: typeof draft.confidence === "number" ? Math.max(0, Math.min(1, draft.confidence)) : 0.5,
-            links: Array.isArray(draft.links) ? draft.links.filter((link) => typeof link === "string") : [],
-            pinned: draft.pinned === true,
-            ...(typeof draft.ttl_days === "number" && Number.isInteger(draft.ttl_days) && draft.ttl_days > 0 ? { ttl_days: draft.ttl_days } : {}),
-        });
-    }
-    return records;
-}

package/dist/runtime/context.d.ts

@@ -1,28 +0,0 @@
-import type { RecordedPromptMeasurement, ResolvedProviderRoute } from "../providers/request-plan.js";
-import type { ContextExecutionInput, ContextPlan, ContextState, EvaluationContextBinding } from "./evolution.js";
-/** Host evidence completing the kernel's immutable context candidate. */
-export interface ContextProviderPreparationRequest {
-    readonly effect: Record<string, unknown>;
-    readonly request_fingerprint: string;
-    readonly provider_route: ResolvedProviderRoute;
-    readonly prompt_measurement: RecordedPromptMeasurement;
-}
-export interface ContextPrepared {
-    readonly state: ContextState;
-    readonly provider_route: ResolvedProviderRoute;
-    readonly prompt_measurement: RecordedPromptMeasurement;
-    readonly execution_input: ContextExecutionInput;
-    readonly plan: ContextPlan;
-    readonly binding: EvaluationContextBinding;
-}
-export type ContextPrepareJson = (request: string) => string;
-export type ContextVerifyJson = (request: string) => string;
-/** All validation and content addressing are delegated to the Rust authority. */
-export declare function createContextPreparationAdapter(prepareJson: ContextPrepareJson, verifyJson: ContextVerifyJson): {
-    verify(effect: Record<string, unknown>, preparation: ContextPrepared): boolean;
-    prepare(request: ContextProviderPreparationRequest): ContextPrepared;
-};
-export declare function createNativeContextPreparationAdapter(): Promise<{
-    verify(effect: Record<string, unknown>, preparation: ContextPrepared): boolean;
-    prepare(request: ContextProviderPreparationRequest): ContextPrepared;
-}>;

package/dist/runtime/context.js

@@ -1,16 +0,0 @@
-import { getKernel } from "./kernel.js";
-/** All validation and content addressing are delegated to the Rust authority. */
-export function createContextPreparationAdapter(prepareJson, verifyJson) {
-    return {
-        verify(effect, preparation) {
-            return JSON.parse(verifyJson(JSON.stringify({ effect, preparation })));
-        },
-        prepare(request) {
-            return JSON.parse(prepareJson(JSON.stringify(request)));
-        },
-    };
-}
-export async function createNativeContextPreparationAdapter() {
-    const kernel = await getKernel();
-    return createContextPreparationAdapter(kernel.contextPrepareJson, kernel.contextVerifyJson);
-}

package/dist/runtime/evolution.d.ts

@@ -1,189 +0,0 @@
-export type ArtifactKind = "runtime" | "skill" | "prompt" | "policy" | "toolset" | "bundle";
-export interface ArtifactRef {
-    readonly kind: ArtifactKind;
-    readonly digest: string;
-}
-export interface ArtifactManifest {
-    readonly kind: ArtifactKind;
-    readonly payload_digest: string;
-    readonly parents: readonly string[];
-    readonly toolchain_digest: string;
-    readonly scope: string;
-}
-export interface ArtifactVersion {
-    readonly digest: string;
-    readonly manifest: ArtifactManifest;
-}
-export interface ArtifactSet {
-    readonly digest: string;
-    readonly artifacts: readonly ArtifactRef[];
-}
-export interface EvolutionProposal {
-    readonly digest: string;
-    readonly base_artifact_set: string;
-    readonly candidate_artifact_set: string;
-    readonly objective: string;
-    readonly change_manifest: string;
-    readonly proposer: string;
-    readonly constraints: readonly string[];
-}
-export interface EvaluationContextBinding {
-    readonly digest: string;
-    readonly operation_id: string;
-    readonly execution_input: string;
-    readonly context_state: string;
-    readonly context_policy: string;
-    readonly context_plan: string;
-    readonly rendered_snapshot: string;
-    readonly prompt_measurement: string;
-    readonly provider_route: string;
-    readonly cache_prefix?: string;
-}
-export type ContextEntrySource = "system" | "knowledge" | "history" | "state" | "signal";
-export type ContextPlanAction = "include" | "excerpt" | "collapse" | "page_out" | "omit";
-export interface ContextEntryRef {
-    readonly entry_id: string;
-    readonly content_digest: string;
-    readonly source: ContextEntrySource;
-    readonly ordinal: number;
-}
-export interface ContextState {
-    readonly schema: "context/v1";
-    readonly generation: number;
-    readonly system: readonly ContextEntryRef[];
-    readonly knowledge: readonly ContextEntryRef[];
-    readonly history: readonly ContextEntryRef[];
-    readonly state: readonly ContextEntryRef[];
-    readonly task_state: string;
-    readonly signals: readonly string[];
-    readonly digest: string;
-}
-export interface ContextSelection {
-    readonly entry_id: string;
-    readonly action: ContextPlanAction;
-    readonly reason: string;
-}
-export interface ContextPlan {
-    readonly schema: "context/v1";
-    readonly plan_id: string;
-    readonly operation_id: string;
-    readonly step_id: string;
-    readonly state_digest: string;
-    readonly state_generation: number;
-    readonly runtime_inputs: string;
-    readonly policy_digest: string;
-    readonly provider_profile_digest: string;
-    readonly measurement_fingerprints: readonly string[];
-    readonly selections: readonly ContextSelection[];
-    readonly input_budget_tokens: number;
-    readonly projected_tokens: number;
-    readonly pressure_ppm: number;
-    readonly cache_prefix: {
-        readonly digest: string;
-        readonly entries: number;
-    } | null;
-}
-export interface ContextExecutionInput {
-    readonly schema: "context/v1";
-    readonly input_digest: string;
-    readonly operation_id: string;
-    readonly step_id: string;
-    readonly input_sequence: number;
-    readonly state_digest: string;
-    readonly policy_digest: string;
-    readonly plan_digest: string;
-    readonly rendered_snapshot: string;
-    readonly prompt_measurement: string;
-    readonly provider_route: string;
-    readonly cache_prefix: {
-        readonly digest: string;
-        readonly entries: number;
-    } | null;
-}
-export interface ContextPreparationRequest {
-    readonly operation_id: string;
-    readonly step_id: string;
-    readonly input_sequence: number;
-    readonly policy_digest: string;
-    readonly prompt_measurement: string;
-    readonly provider_route: string;
-}
-export interface EvaluationRun {
-    readonly digest: string;
-    readonly proposal: string;
-    readonly baseline_artifact_set: string;
-    readonly candidate_artifact_set: string;
-    readonly evaluator: string;
-    readonly dataset: string;
-    readonly operation_ids: readonly string[];
-    readonly contexts: readonly EvaluationContextBinding[];
-    readonly evidence_refs: readonly string[];
-}
-export interface EvaluationMetric {
-    readonly name: string;
-    readonly baseline: string;
-    readonly candidate: string;
-    readonly improved: boolean;
-}
-export interface EvaluationGate {
-    readonly name: string;
-    readonly required: boolean;
-    readonly passed: boolean;
-}
-export interface EvaluationFact {
-    readonly digest: string;
-    readonly evaluation: string;
-    readonly metrics: readonly EvaluationMetric[];
-    readonly gates: readonly EvaluationGate[];
-    readonly replay_passed: boolean;
-}
-export type PromotionOutcome = "promote" | "reject" | "hold";
-export interface PromotionDecision {
-    readonly digest: string;
-    readonly proposal: string;
-    readonly evaluation_facts: readonly string[];
-    readonly policy: string;
-    readonly outcome: PromotionOutcome;
-    readonly selected_artifact_set: string;
-}
-export interface ActivationBinding {
-    readonly digest: string;
-    readonly operation_id: string;
-    readonly artifact_set: string;
-    readonly promotion_decision: string;
-}
-export interface EvolutionBundle {
-    readonly artifacts: readonly ArtifactVersion[];
-    readonly artifact_sets: readonly ArtifactSet[];
-    readonly proposals: readonly EvolutionProposal[];
-    readonly evaluations: readonly EvaluationRun[];
-    readonly facts: readonly EvaluationFact[];
-    readonly decisions: readonly PromotionDecision[];
-    readonly activations: readonly ActivationBinding[];
-}
-export type EvolutionVerdict = "pass" | "fail" | "unavailable";
-export interface EvolutionReport {
-    readonly schema: "evolution-report/v1";
-    readonly verdict: EvolutionVerdict;
-    readonly violations: readonly {
-        readonly code: string;
-        readonly detail: string;
-    }[];
-}
-export type EvolutionValidateJson = (request: string) => string;
-export interface EvolutionStore {
-    loadBundle(): Promise<EvolutionBundle> | EvolutionBundle;
-}
-export declare function createEvolutionRuntimeAdapter(validateJson: EvolutionValidateJson): {
-    validate: (bundle: EvolutionBundle) => EvolutionReport;
-};
-export declare function createNativeEvolutionRuntimeAdapter(): Promise<{
-    validate: (bundle: EvolutionBundle) => EvolutionReport;
-}>;
-export declare class EvolutionRuntime {
-    private readonly adapter;
-    constructor(adapter: ReturnType<typeof createEvolutionRuntimeAdapter>);
-    validate(bundle: EvolutionBundle): EvolutionReport;
-    validateStore(store: EvolutionStore): Promise<EvolutionReport>;
-    activate(bundle: EvolutionBundle, operationId: string): ActivationBinding;
-}

package/dist/runtime/evolution.js

@@ -1,25 +0,0 @@
-import { getKernel } from "./kernel.js";
-export function createEvolutionRuntimeAdapter(validateJson) {
-    return { validate: (bundle) => JSON.parse(validateJson(JSON.stringify(bundle))) };
-}
-export async function createNativeEvolutionRuntimeAdapter() {
-    const kernel = await getKernel();
-    return createEvolutionRuntimeAdapter(kernel.evolutionValidateJson);
-}
-export class EvolutionRuntime {
-    adapter;
-    constructor(adapter) {
-        this.adapter = adapter;
-    }
-    validate(bundle) { return this.adapter.validate(bundle); }
-    async validateStore(store) { return this.validate(await store.loadBundle()); }
-    activate(bundle, operationId) {
-        const report = this.validate(bundle);
-        if (report.verdict !== "pass")
-            throw new Error(`evolution bundle is not activatable: ${report.violations.map(v => v.code).join(", ")}`);
-        const activation = bundle.activations.find(value => value.operation_id === operationId);
-        if (!activation)
-            throw new Error(`no verified activation binding for operation ${operationId}`);
-        return activation;
-    }
-}

package/dist/runtime/reducers.d.ts

@@ -1,15 +0,0 @@
-/** One dependency's contribution to a reduce: the producing node's agent id and its output text. */
-export interface ReducerInput {
-    agentId: string;
-    output: string;
-}
-/** A pure function over a reduce node's dependency outputs → the reduce node's output string. */
-export type Reducer = (inputs: ReducerInput[]) => string;
-export type ReducerRegistry = Record<string, Reducer>;
-/**
- * Built-in reducers, available to every workflow without registration. A user-supplied registry is
- * merged over these (so a custom reducer can shadow a built-in of the same name).
- */
-export declare const builtinReducers: ReducerRegistry;
-/** Resolve a reducer by name from the built-ins overlaid with a user registry. */
-export declare function resolveReducer(name: string, user?: ReducerRegistry): Reducer | undefined;