@noetic-tools/core 3.2.0 → 5.0.0

package/dist/interpreter/collect-tools.d.ts

@@ -4,7 +4,7 @@ import type { Step, Tool } from '@noetic-tools/types';
  * declared on LLM steps. Used to build the unified tool set
  * that gets sent with every LLM call for prompt cache efficiency.
  */
-export declare function collectAllTools<TMemory = unknown, I = unknown, O = unknown>(step: Step<TMemory, I, O>): Tool[];
+export declare function collectAllTools<TContext = unknown, I = unknown, O = unknown>(step: Step<TContext, I, O>): Tool[];
 /**
  * Deduplicates tools by name, keeping the first occurrence.
  */

package/dist/interpreter/execute-action.d.ts

@@ -2,31 +2,31 @@
  * Action step handlers: run, llm, spawn, provide, tool.
  */
 import type { ItemSchemaRegistry, LayerStateStore } from './action-deps.js';
-import type { AgentHarnessContract, Context, ExecuteStepFn, MemoryLayer, StepLLM, StepProvide, StepRun, StepSpawn, StepTool } from './action-types.js';
-export declare function executeRun<TMemory, I, O>(step: StepRun<TMemory, I, O>, input: I, ctx: Context<TMemory>): Promise<O>;
+import type { AgentHarnessContract, Context, ContextLayer, ExecuteStepFn, StepLLM, StepProvide, StepRun, StepSpawn, StepTool } from './action-types.js';
+export declare function executeRun<TContext, I, O>(step: StepRun<TContext, I, O>, input: I, ctx: Context<TContext>): Promise<O>;
 /**
  * Resolves a `Lazy<T>` step field. If the value is a function, it is invoked
  * with the current context; otherwise the value is returned as-is. Supports
  * both sync and async getters.
  *
  * Lazy fields let a step inspect `ctx.harness.config.params`, `ctx.unifiedTools`,
- * or memory layer state to produce per-execution values (model, instructions,
+ * or context layer state to produce per-execution values (model, instructions,
  * tools) without baking them in at build time.
  */
-export declare function resolveLazy<T, TMemory>(value: T | ((ctx: Context<TMemory>) => T | Promise<T>), ctx: Context<TMemory>): Promise<T>;
-export declare function executeLLM<TMemory, I, O>(step: StepLLM<TMemory, I, O>, input: I, ctx: Context<TMemory>, layers?: MemoryLayer[]): Promise<O>;
+export declare function resolveLazy<T, TContext>(value: T | ((ctx: Context<TContext>) => T | Promise<T>), ctx: Context<TContext>): Promise<T>;
+export declare function executeLLM<TContext, I, O>(step: StepLLM<TContext, I, O>, input: I, ctx: Context<TContext>, layers?: ContextLayer[]): Promise<O>;
 export interface ExecuteSpawnOpts {
     layerStore?: LayerStateStore;
-    parentLayers?: MemoryLayer[];
+    parentLayers?: ContextLayer[];
     itemSchemas?: ItemSchemaRegistry;
 }
-export declare function executeSpawn<TMemory, I, O>(step: StepSpawn<TMemory, I, O>, input: I, ctx: Context<TMemory>, executeStep: ExecuteStepFn, opts?: ExecuteSpawnOpts): Promise<O>;
+export declare function executeSpawn<TContext, I, O>(step: StepSpawn<TContext, I, O>, input: I, ctx: Context<TContext>, executeStep: ExecuteStepFn, opts?: ExecuteSpawnOpts): Promise<O>;
 /**
- * Executes a provide step by attaching memory layers to the current context
+ * Executes a provide step by attaching context layers to the current context
  * without creating an isolated child context.
  *
  * Unlike spawn, provide does not create a new itemLog or clone state.
  * Events flow through to the parent in real-time.
  */
-export declare function executeProvide<TMemory, I, O>(step: StepProvide<TMemory, I, O>, input: I, ctx: Context<TMemory>, executeStep: ExecuteStepFn): Promise<O>;
-export declare function executeTool<TMemory, I, O>(step: StepTool<TMemory, I, O>, input: I, ctx: Context<TMemory>, harness: AgentHarnessContract, layers?: MemoryLayer[]): Promise<O>;
+export declare function executeProvide<TContext, I, O>(step: StepProvide<TContext, I, O>, input: I, ctx: Context<TContext>, executeStep: ExecuteStepFn): Promise<O>;
+export declare function executeTool<TContext, I, O>(step: StepTool<TContext, I, O>, input: I, ctx: Context<TContext>, harness: AgentHarnessContract, layers?: ContextLayer[]): Promise<O>;

package/dist/interpreter/execute-action.js

@@ -93,7 +93,7 @@ function mergeRecallResults(base, overrides, slotOf) {
  * both sync and async getters.
  *
  * Lazy fields let a step inspect `ctx.harness.config.params`, `ctx.unifiedTools`,
- * or memory layer state to produce per-execution values (model, instructions,
+ * or context layer state to produce per-execution values (model, instructions,
  * tools) without baking them in at build time.
  */
 export async function resolveLazy(value, ctx) {
@@ -266,7 +266,7 @@ export async function executeLLM(step, input, ctx, layers) {
     const hasLayers = layers !== undefined && layers.length > 0;
     // Resolve lazy step fields up-front. Function-form getters run once per
     // step execution with the live context, so `ctx.harness.config.params`,
-    // `ctx.unifiedTools`, and memory layer state are all visible at resolution.
+    // `ctx.unifiedTools`, and context layer state are all visible at resolution.
     const resolvedModel = await resolveLazy(step.model, ctx);
     if (!resolvedModel || resolvedModel.trim() === '') {
         throw new NoeticConfigError({
@@ -509,19 +509,19 @@ export async function executeLLM(step, input, ctx, layers) {
         retriesExhausted: true,
     });
 }
-function isMemoryConfig(value) {
+function isContextConfig(value) {
     return typeof value === 'object' && value !== null && 'layers' in value;
 }
 function resolveLayersForSpawn(step, parentLayers) {
-    if (!step.memory) {
+    if (!step.context) {
         return parentLayers ?? [];
     }
-    if (isMemoryConfig(step.memory)) {
+    if (isContextConfig(step.context)) {
         return [
-            ...step.memory.layers,
+            ...step.context.layers,
         ];
     }
-    return step.memory;
+    return step.context;
 }
 async function collectSpawnItems({ layers, parentExecutionCtx, childExecutionCtx, layerStore, itemSchemas = defaultItemSchemaRegistry, }) {
     const spawnResults = await spawnLayers({
@@ -563,7 +563,7 @@ export async function executeSpawn(step, input, ctx, executeStep, opts) {
     });
     const layerStore = opts?.layerStore;
     const hasLayers = layers.length > 0 && layerStore !== undefined;
-    // Collect items from memory layers via onSpawn hooks
+    // Collect items from context layers via onSpawn hooks
     let childItems = [];
     let parentExecutionCtx;
     if (hasLayers) {
@@ -594,7 +594,7 @@ export async function executeSpawn(step, input, ctx, executeStep, opts) {
     // Create child context — empty by default, layers provide items via onSpawn.
     // `id: childId` keeps the ContextImpl's id in sync with the executionId
     // used by spawnLayers/returnLayers in the layer-state store, so writes via
-    // `ctx.memory[layerId]` and spawn-boundary hooks read from the same key.
+    // `ctx.context[layerId]` and spawn-boundary hooks read from the same key.
     const childCtx = new ContextImpl({
         harness: baseCtx.harness,
         parent: baseCtx,
@@ -648,12 +648,12 @@ export async function executeSpawn(step, input, ctx, executeStep, opts) {
 //#endregion
 //#region provide
 function resolveLayers(step) {
-    if (isMemoryConfig(step.memory)) {
+    if (isContextConfig(step.context)) {
         return [
-            ...step.memory.layers,
+            ...step.context.layers,
         ];
     }
-    return step.memory;
+    return step.context;
 }
 function mergeLayers(existing, provided) {
     if (!existing || existing.length === 0) {
@@ -668,7 +668,7 @@ function mergeLayers(existing, provided) {
     ];
 }
 /**
- * Executes a provide step by attaching memory layers to the current context
+ * Executes a provide step by attaching context layers to the current context
  * without creating an isolated child context.
  *
  * Unlike spawn, provide does not create a new itemLog or clone state.

package/dist/interpreter/execute-control.d.ts

@@ -3,14 +3,14 @@
  */
 import type { Context, ExecuteStepFn, StepBranch, StepEvery, StepFork, StepLoop } from '@noetic-tools/types';
 import type { ItemSchemaRegistry, LayerStateStore } from './action-deps.js';
-export declare function executeBranch<TMemory, I, O>(step: StepBranch<TMemory, I, O>, input: I, ctx: Context<TMemory>, executeStep: ExecuteStepFn): Promise<O>;
+export declare function executeBranch<TContext, I, O>(step: StepBranch<TContext, I, O>, input: I, ctx: Context<TContext>, executeStep: ExecuteStepFn): Promise<O>;
 /** Layer-boundary wiring supplied by the interpreter (see `buildSpawnOpts`). */
 export interface ExecuteForkOpts {
     layerStore?: LayerStateStore;
     itemSchemas?: ItemSchemaRegistry;
 }
-export declare function executeFork<TMemory, I, O>(step: StepFork<TMemory, I, O>, input: I, ctx: Context<TMemory>, rawExecuteStep: ExecuteStepFn, opts?: ExecuteForkOpts): Promise<O>;
-export declare function executeLoop<TMemory, I, O>(step: StepLoop<TMemory, I, O>, input: I, ctx: Context<TMemory>, executeStep: ExecuteStepFn): Promise<O>;
+export declare function executeFork<TContext, I, O>(step: StepFork<TContext, I, O>, input: I, ctx: Context<TContext>, rawExecuteStep: ExecuteStepFn, opts?: ExecuteForkOpts): Promise<O>;
+export declare function executeLoop<TContext, I, O>(step: StepLoop<TContext, I, O>, input: I, ctx: Context<TContext>, executeStep: ExecuteStepFn): Promise<O>;
 /**
  * Executes an `every` step: runs the body step forever, paced by `ms ± jitter`,
  * woken early by `wakeOn`. Throws `cancelled` when the context is aborted.
@@ -23,4 +23,4 @@ export declare function executeLoop<TMemory, I, O>(step: StepLoop<TMemory, I, O>
  * The body's output is discarded — `every` runs forever and does not accumulate
  * iteration outputs. Only ever returns by throwing on cancellation or `fail`.
  */
-export declare function executeEvery<TMemory, I, O>(step: StepEvery<TMemory, I, O>, input: I, ctx: Context<TMemory>, executeStep: ExecuteStepFn): Promise<O>;
+export declare function executeEvery<TContext, I, O>(step: StepEvery<TContext, I, O>, input: I, ctx: Context<TContext>, executeStep: ExecuteStepFn): Promise<O>;

package/dist/interpreter/execute-control.js

@@ -44,7 +44,7 @@ function createChildContexts(ctx, count, stepId) {
         channelStore,
         cwdState: snapshotCwdState(ctx),
         // Layers and the harness tool pool cross the fork boundary: without
-        // them an `llm` step inside a path would run with no memory
+        // them an `llm` step inside a path would run with no context
         // projection and no layer tools, and a nested `spawn` would have no
         // parent layers to inherit. Per-path layer STATE is still isolated —
         // see `createForkLayerBridge`.

package/dist/interpreter/execute-sub-harness.d.ts

@@ -5,4 +5,4 @@
  * `executeLLM`.
  */
 import type { Context, StepSubHarness } from '@noetic-tools/types';
-export declare function executeSubHarness<TMemory, I, O>(step: StepSubHarness<TMemory, I, O>, input: I, ctx: Context<TMemory>): Promise<O>;
+export declare function executeSubHarness<TContext, I, O>(step: StepSubHarness<TContext, I, O>, input: I, ctx: Context<TContext>): Promise<O>;

package/dist/interpreter/execute.d.ts

@@ -1,4 +1,4 @@
-import type { ContextMemory } from '@noetic-tools/memory';
+import type { ContextData } from '@noetic-tools/context';
 import type { Context, Step } from '@noetic-tools/types';
 /**
  * @internal
@@ -12,7 +12,7 @@ import type { Context, Step } from '@noetic-tools/types';
  * through the adapter as normal, so per-step overrides on descendants
  * continue to work.
  */
-export declare function executeNoAdapter<TMemory, I, O>(step: Step<TMemory, I, O>, input: I, ctx: Context<TMemory>): Promise<O>;
+export declare function executeNoAdapter<TContext, I, O>(step: Step<TContext, I, O>, input: I, ctx: Context<TContext>): Promise<O>;
 /**
  * Executes a step within the interpreter, dispatching to the appropriate handler by step kind.
  *
@@ -23,4 +23,4 @@ export declare function executeNoAdapter<TMemory, I, O>(step: Step<TMemory, I, O
  * @throws `NoeticError` with kind `step_failed` if max depth is exceeded or an unknown step kind is encountered.
  * @throws `NoeticError` with kind `cancelled` if the context is aborted.
  */
-export declare function execute<TMemory = ContextMemory, I = unknown, O = unknown>(step: Step<TMemory, I, O>, input: I, ctx: Context<TMemory>): Promise<O>;
+export declare function execute<TContext = ContextData, I = unknown, O = unknown>(step: Step<TContext, I, O>, input: I, ctx: Context<TContext>): Promise<O>;

package/dist/interpreter/execute.js

@@ -112,6 +112,65 @@ export async function executeNoAdapter(step, input, ctx) {
             return execute(step, input, ctx);
     }
 }
+/**
+ * Resume path: when a previous run recorded this exact step at `ledgerPath`,
+ * replay its output instead of re-running. Held as a helper (rather than inline
+ * in `execute`) so the resume branch stays flat: it pops the frontier itself —
+ * the caller returns before the normal `leaveStep` runs — and emits
+ * `step_replayed`. Returns `{ hit: false }` when there is nothing to replay so
+ * the caller dispatches the step normally.
+ */
+function replayFromLedger(opts) {
+    const { ledger, ledgerPath, impl, step, broadcaster, agentName } = opts;
+    if (!ledger || ledgerPath === undefined || ledger.isEmpty) {
+        return {
+            hit: false,
+        };
+    }
+    const replayed = ledger.take(ledgerPath, {
+        id: step.id,
+        kind: step.kind,
+    });
+    if (!replayed) {
+        return {
+            hit: false,
+        };
+    }
+    if (impl && step.id.length > 0) {
+        impl.leaveStep(step.id);
+    }
+    emitFrameworkEvent({
+        broadcaster,
+        agentName,
+        eventType: 'step_replayed',
+        data: {
+            stepId: step.id,
+            kind: step.kind,
+        },
+    });
+    return {
+        hit: true,
+        output: frameworkCast(replayed.output),
+    };
+}
+/**
+ * Record a completed step's output so a resumed run replays it rather than
+ * re-executing. A no-op without a ledger or ledger path. Only successes reach
+ * here — a step that threw skips this call in `execute` and runs again on resume.
+ */
+async function recordToLedger(opts) {
+    const { ledger, ledgerPath, step, output } = opts;
+    if (!ledger || ledgerPath === undefined) {
+        return;
+    }
+    await ledger.record({
+        path: ledgerPath,
+        stepId: step.id,
+        kind: step.kind,
+        output,
+        completedAt: new Date().toISOString(),
+    });
+}
 //#endregion
 /**
  * Executes a step within the interpreter, dispatching to the appropriate handler by step kind.
@@ -173,30 +232,21 @@ export async function execute(step, input, ctx) {
         });
     }
     /* Resume: a previous run that completed this exact step replays its recorded
-     * output instead of re-running it. Captured before dispatch and held for the
-     * record below, because `leaveStep` pops the path on the way out. */
+     * output instead of re-running it. `ledgerPath`/`ledger` are captured before
+     * dispatch and reused by the record below, because `leaveStep` pops the path
+     * on the way out. */
     const ledgerPath = impl && step.id.length > 0 ? impl.currentPath() : undefined;
     const ledger = impl?.ledger;
-    if (ledger && ledgerPath !== undefined && !ledger.isEmpty) {
-        const replayed = ledger.take(ledgerPath, {
-            id: step.id,
-            kind: step.kind,
-        });
-        if (replayed) {
-            if (impl && step.id.length > 0) {
-                impl.leaveStep(step.id);
-            }
-            emitFrameworkEvent({
-                broadcaster,
-                agentName,
-                eventType: 'step_replayed',
-                data: {
-                    stepId: step.id,
-                    kind: step.kind,
-                },
-            });
-            return frameworkCast(replayed.output);
-        }
+    const replay = replayFromLedger({
+        ledger,
+        ledgerPath,
+        impl,
+        step,
+        broadcaster,
+        agentName,
+    });
+    if (replay.hit) {
+        return replay.output;
     }
     let result;
     try {
@@ -272,15 +322,12 @@ export async function execute(step, input, ctx) {
     /* Record the completed step so a resumed run replays this output rather than
      * re-running the step. Only successes are recorded: a step that threw must run
      * again. */
-    if (ledger && ledgerPath !== undefined) {
-        await ledger.record({
-            path: ledgerPath,
-            stepId: step.id,
-            kind: step.kind,
-            output: result,
-            completedAt: new Date().toISOString(),
-        });
-    }
+    await recordToLedger({
+        ledger,
+        ledgerPath,
+        step,
+        output: result,
+    });
     /* Durability boundary (spec 23): snapshot after each completed step, so a crash
      * lands on a checkpoint that includes the item-log and layer-state mutations this
      * step produced. A no-op unless the harness has a CheckpointStore, and a failing

package/dist/interpreter/step-dispatcher.d.ts

@@ -1,4 +1,4 @@
-import type { ContextMemory } from '@noetic-tools/memory';
+import type { ContextData } from '@noetic-tools/context';
 import type { Context, DetachedHandle, Step, SubprocessAdapter } from '@noetic-tools/types';
 /**
  * Resolve the subprocess adapter used for a given step dispatch.
@@ -10,7 +10,7 @@ import type { Context, DetachedHandle, Step, SubprocessAdapter } from '@noetic-t
  *
  * @internal
  */
-export declare function resolveStepAdapter<TMemory, I, O>(step: Step<TMemory, I, O>, callOverride: SubprocessAdapter | undefined, fallback: SubprocessAdapter): SubprocessAdapter;
+export declare function resolveStepAdapter<TContext, I, O>(step: Step<TContext, I, O>, callOverride: SubprocessAdapter | undefined, fallback: SubprocessAdapter): SubprocessAdapter;
 /**
  * Minimum harness surface the dispatcher needs. `AgentHarness` satisfies
  * this shape — kept structural so tests can pass a stub.
@@ -55,4 +55,4 @@ export interface DetachedSpawnOverrides {
  *
  * @internal
  */
-export declare function dispatchStepThroughAdapter<I, O>(h: StepDispatchHandle, s: Step<ContextMemory, I, O>, input: I, parentCtx: Context, overrides?: DetachedSpawnOverrides): DetachedHandle<O>;
+export declare function dispatchStepThroughAdapter<I, O>(h: StepDispatchHandle, s: Step<ContextData, I, O>, input: I, parentCtx: Context, overrides?: DetachedSpawnOverrides): DetachedHandle<O>;

package/dist/interpreter/sub-harness-events.d.ts

@@ -12,7 +12,7 @@
  * a result without streaming any text/tool parts, the result's content is
  * synthesized into events.
  */
-import type { Context, ContextMemory, StepSubHarness, SubHarnessStreamPart, SubHarnessTurnResult } from '@noetic-tools/types';
+import type { Context, ContextData, StepSubHarness, SubHarnessStreamPart, SubHarnessTurnResult } from '@noetic-tools/types';
 export declare class SubHarnessEventBridge {
     private readonly broadcaster?;
     private readonly agentName;
@@ -25,7 +25,7 @@ export declare class SubHarnessEventBridge {
     private messageOutputIndex;
     private sawText;
     private sawToolCall;
-    constructor(step: Pick<StepSubHarness, 'id' | 'kind' | 'emit'>, ctx: Context<ContextMemory>);
+    constructor(step: Pick<StepSubHarness, 'id' | 'kind' | 'emit'>, ctx: Context<ContextData>);
     /**
      * Open the turn on the event surface. Emits `response.created` so every turn
      * always brackets with a lifecycle marker — even a custom adapter that

package/dist/interpreter/typeguards.d.ts

@@ -1,17 +1,17 @@
-import type { ContextMemory } from '@noetic-tools/memory';
+import type { ContextData } from '@noetic-tools/context';
 import type { Context, FunctionCallItem, Item } from '@noetic-tools/types';
 import type { ChannelStore } from '../runtime/channel-store.js';
 import { ContextImpl } from '../runtime/context-impl.js';
 import type { MutableContext } from '../types/mutable-context.js';
 export { isAssistantMessage, isOutputText, isUserMessage } from '@noetic-tools/types';
-export declare function isMutableContext(ctx: Context<ContextMemory>): ctx is MutableContext;
-export declare function isContextImpl(ctx: Context<ContextMemory>): ctx is ContextImpl;
+export declare function isMutableContext(ctx: Context<ContextData>): ctx is MutableContext;
+export declare function isContextImpl(ctx: Context<ContextData>): ctx is ContextImpl;
 /**
  * Co-located with `isContextImpl` so the import of `ContextImpl` flows through
  * the same module other interpreters pull it from, sidestepping a circular
  * TDZ when this helper is used by `executeEvery` in `execute-control.ts`.
  */
-export declare function getContextChannelStore<TMemory>(ctx: Context<TMemory>): ChannelStore | undefined;
+export declare function getContextChannelStore<TContext>(ctx: Context<TContext>): ChannelStore | undefined;
 export declare function isFunctionCall(item: Item): item is FunctionCallItem;
 declare function assertNever(_value: never): never;
 export { assertNever };

package/dist/patterns/dynamic-workflow.d.ts

@@ -2,8 +2,9 @@
  * Pattern that lets an LLM generate a workflow as JSON during execution,
  * then hydrates and runs it within the same harness session.
  */
-import type { ContextMemory, MemoryLayer } from '@noetic-tools/memory';
+import type { ContextData, ContextLayer } from '@noetic-tools/context';
 import type { AgentHarnessContract, Context, Step, Tool } from '@noetic-tools/types';
+import type { WorkflowDocument } from '../schemas/workflow.js';
 /** @public Options for creating a dynamic workflow step. */
 export interface DynamicWorkflowOpts {
     model?: string;
@@ -25,7 +26,7 @@ export interface DynamicWorkflowOpts {
  * @param opts.maxRevisions - Retries with error feedback on validation failure. Default: 3.
  * @returns A `Step` that dynamically plans and executes.
  */
-export declare function dynamicWorkflow(opts: DynamicWorkflowOpts): Step<ContextMemory, string, string>;
+export declare function dynamicWorkflow(opts: DynamicWorkflowOpts): Step<ContextData, string, string>;
 /** @public Options for `parseAndRunWorkflow`. */
 export interface ParseAndRunWorkflowOpts {
     json: unknown;
@@ -35,11 +36,13 @@ export interface ParseAndRunWorkflowOpts {
     input?: string;
     maxDepth?: number;
     /**
-     * Memory layers the document's `provide` / `spawn` nodes may reference by name.
+     * Context layers the document's `provide` / `spawn` nodes may reference by name.
      * Without a registry those nodes resolve to NO layers rather than failing, so a
      * host that runs layer-bearing workflows must pass its layers here.
      */
-    layers?: ReadonlyMap<string, MemoryLayer>;
+    layers?: ReadonlyMap<string, ContextLayer>;
+    /** Named sub-workflows the document's `subflow` nodes may reference via `ref`. */
+    workflows?: ReadonlyMap<string, WorkflowDocument>;
 }
 /**
  * Parses raw JSON into a `WorkflowDocument`, hydrates it into a live step

package/dist/patterns/dynamic-workflow.js

@@ -28,6 +28,7 @@ A WorkflowNode is one of:
 - { "kind": "loop", "id": "<unique>", "body": <WorkflowNode>, "until": { "kind": "maxSteps", "n": <number> } }
 - { "kind": "branch", "id": "<unique>", "routes": [{ "match": "<substring>", "target": <WorkflowNode> }], "default": <WorkflowNode> }
 - { "kind": "spawn", "id": "<unique>", "child": <WorkflowNode> }
+- { "kind": "subflow", "id": "<unique>", "document": { "version": 1, "root": <WorkflowNode> } } (an inline sub-workflow run as one step; only emit the inline form — named refs require a registry this planner does not provide)
 - { "kind": "claude-code"|"codex"|"opencode"|"pi", "id": "<unique>", "prompt": "<turn prompt>", "settings": { "model": "<optional>", "permissionMode": "<optional>" } }
 
 SubHarness nodes (claude-code, codex, opencode, pi) delegate a turn to an external coding agent; only emit one if a matching harness adapter is registered for the workflow.
@@ -143,6 +144,7 @@ export async function parseAndRunWorkflow(opts) {
         tools: buildToolMap(opts.tools),
         executeStep,
         layers: opts.layers,
+        workflows: opts.workflows,
     };
     const hydrated = hydrateWorkflow(parseResult.doc, hydrationCtx);
     const runSpan = beginWorkflowRunSpan(opts.harness, opts.ctx, parseResult.doc);

package/dist/patterns/interview.d.ts

@@ -1,4 +1,4 @@
-import type { ContextMemory } from '@noetic-tools/memory';
+import type { ContextData } from '@noetic-tools/context';
 import type { Step } from '@noetic-tools/types';
 import type { ZodType } from 'zod';
 /** @public Answer captured by the host for a single interview question. */
@@ -50,4 +50,4 @@ export interface InterviewOpts<Q, C> {
  * @returns A `Step` whose output is `InterviewResult<Q, C>` — either the completion envelope or
  *          `maxQuestions` when the budget is exhausted before the model emits `complete`.
  */
-export declare function interview<Q, C>(opts: InterviewOpts<Q, C>): Step<ContextMemory, string, InterviewResult<Q, C>>;
+export declare function interview<Q, C>(opts: InterviewOpts<Q, C>): Step<ContextData, string, InterviewResult<Q, C>>;

package/dist/patterns/plans.d.ts

@@ -1,4 +1,4 @@
-import type { ContextMemory } from '@noetic-tools/memory';
+import type { ContextData } from '@noetic-tools/context';
 import type { Context, ExecuteStepFn, Step } from '@noetic-tools/types';
 import { z } from 'zod';
 export interface PlanNode {
@@ -26,7 +26,7 @@ export interface PlanConstraints {
  * @param executeStep - Optional step executor for non-run step kinds.
  * @returns A compiled `Step` ready for execution.
  */
-export declare function compilePlan<O, A = unknown>(plan: PlanNode, agents: Record<string, (prompt: string) => Step<ContextMemory, string, A>>, constraints?: PlanConstraints, executeStep?: ExecuteStepFn): Step<ContextMemory, string, O>;
+export declare function compilePlan<O, A = unknown>(plan: PlanNode, agents: Record<string, (prompt: string) => Step<ContextData, string, A>>, constraints?: PlanConstraints, executeStep?: ExecuteStepFn): Step<ContextData, string, O>;
 /**
  * Creates a step that dynamically generates a plan via a planner step and executes it,
  * retrying with error feedback up to `maxRevisions` times on failure.
@@ -36,9 +36,9 @@ export declare function compilePlan<O, A = unknown>(plan: PlanNode, agents: Reco
  * @returns A `Step` that adaptively plans and executes.
  */
 export declare function adaptivePlan<O, A = unknown>(opts: {
-    planner: Step<ContextMemory, string, PlanNode>;
-    agents: Record<string, (prompt: string) => Step<ContextMemory, string, A>>;
+    planner: Step<ContextData, string, PlanNode>;
+    agents: Record<string, (prompt: string) => Step<ContextData, string, A>>;
     constraints?: PlanConstraints;
     maxRevisions: number;
     executeStep?: ExecuteStepFn;
-}): Step<ContextMemory, string, O>;
+}): Step<ContextData, string, O>;

package/dist/patterns/ralph-wiggum.d.ts

@@ -1,4 +1,4 @@
-import type { ContextMemory } from '@noetic-tools/memory';
+import type { ContextData } from '@noetic-tools/context';
 import type { StepLoop, Tool } from '@noetic-tools/types';
 import type { VerifyFn } from '../until/predicates.js';
 /**
@@ -16,4 +16,4 @@ export declare function ralphWiggum(opts: {
     verify: VerifyFn;
     maxIterations?: number;
     innerMaxSteps?: number;
-}): StepLoop<ContextMemory, string, string>;
+}): StepLoop<ContextData, string, string>;

package/dist/patterns/react.d.ts

@@ -1,11 +1,11 @@
-import type { ContextMemory, MemoryConfig, MemoryLayer } from '@noetic-tools/memory';
+import type { ContextConfig, ContextData, ContextLayer } from '@noetic-tools/context';
 import type { StepLoop, StepSpawn, Tool } from '@noetic-tools/types';
 /**
  * Creates a ReAct (Reason + Act) agent loop: an LLM step with tools iterated until no tool calls or limits are hit.
  *
  * @public
- * @param opts - Model, tools, optional instructions, step/cost limits, and memory layers.
- * @returns A `StepLoop` (no memory) or `StepSpawn` wrapping a loop (with memory).
+ * @param opts - Model, tools, optional instructions, step/cost limits, and context layers.
+ * @returns A `StepLoop` (no context layers) or `StepSpawn` wrapping a loop (with them).
  */
 export declare function react(opts: {
     model: string;
@@ -13,5 +13,7 @@ export declare function react(opts: {
     tools: Tool[];
     maxSteps?: number;
     maxCost?: number;
-    memory?: MemoryConfig | MemoryLayer[];
-}): StepLoop<ContextMemory, string, string> | StepSpawn<ContextMemory, string, string>;
+    context?: ContextConfig | ContextLayer[];
+    /** @deprecated Renamed to `context`. */
+    memory?: ContextConfig | ContextLayer[];
+}): StepLoop<ContextData, string, string> | StepSpawn<ContextData, string, string>;

package/dist/patterns/react.js

@@ -1,3 +1,4 @@
+import { resolveContextOption } from '../builders/context-option.js';
 import { loop } from '../builders/loop-builder.js';
 import { spawn } from '../builders/spawn-builder.js';
 import { step } from '../builders/step-builders.js';
@@ -7,8 +8,8 @@ import { until } from '../until/predicates.js';
  * Creates a ReAct (Reason + Act) agent loop: an LLM step with tools iterated until no tool calls or limits are hit.
  *
  * @public
- * @param opts - Model, tools, optional instructions, step/cost limits, and memory layers.
- * @returns A `StepLoop` (no memory) or `StepSpawn` wrapping a loop (with memory).
+ * @param opts - Model, tools, optional instructions, step/cost limits, and context layers.
+ * @returns A `StepLoop` (no context layers) or `StepSpawn` wrapping a loop (with them).
  */
 export function react(opts) {
     const llmStep = step.llm({
@@ -28,12 +29,13 @@ export function react(opts) {
             ]
             : [])),
     });
-    if (!opts.memory) {
+    const layers = resolveContextOption(opts);
+    if (!layers) {
         return loopStep;
     }
     return spawn({
         id: 'react-agent',
         child: loopStep,
-        memory: opts.memory,
+        context: layers,
     });
 }

package/dist/portable/builders.js

@@ -6,6 +6,8 @@ export { layerData, layerFn } from '../builders/layer-provides-builders.js';
 export { loop } from '../builders/loop-builder.js';
 /** @public */
 export { spawn } from '../builders/spawn-builder.js';
+// The base namespace, without `step.workflow` — the portable surface stays
+// free of the hydrator so restricted runtimes don't pull it in.
 /** @public */
 export { step } from '../builders/step-builders.js';
 /** @public */

package/dist/portable/context-layers.d.ts

@@ -0,0 +1,8 @@
+/** @public */
+/** @public */
+/** @public */
+/** @public */
+/** @public */
+/** @public */
+/** @public */
+export { durableTaskState, historyWindow, observationalContext, planContext, temporalContext, toolContextLayer, workingMemoryContext, } from '@noetic-tools/context';

package/dist/portable/context-layers.js

@@ -0,0 +1,8 @@
+/** @public */
+/** @public */
+/** @public */
+/** @public */
+/** @public */
+/** @public */
+/** @public */
+export { durableTaskState, historyWindow, observationalContext, planContext, temporalContext, toolContextLayer, workingMemoryContext, } from '@noetic-tools/context';

package/dist/portable.d.ts

@@ -1,8 +1,8 @@
 /** @public */
-export { Slot } from '@noetic-tools/memory';
+export { Slot } from '@noetic-tools/context';
 export * from './portable/adapters.js';
 export * from './portable/ask-user.js';
 export * from './portable/builders.js';
-export * from './portable/memory-layers.js';
+export * from './portable/context-layers.js';
 export * from './portable/runtime.js';
 export * from './portable/until.js';

package/dist/portable.js

@@ -1,8 +1,8 @@
 /** @public */
-export { Slot } from '@noetic-tools/memory';
+export { Slot } from '@noetic-tools/context';
 export * from './portable/adapters.js';
 export * from './portable/ask-user.js';
 export * from './portable/builders.js';
-export * from './portable/memory-layers.js';
+export * from './portable/context-layers.js';
 export * from './portable/runtime.js';
 export * from './portable/until.js';