@noetic-tools/core 3.2.0 → 4.0.0

package/dist/builders/workflow-hydrator.js

@@ -146,15 +146,22 @@ function hydrateToolNode(node, ctx) {
                 arguments: JSON.stringify(args),
             };
             execCtx.itemLog.append(callItem);
+            const layerState = {
+                get: (_layerId) => undefined,
+                set: (_layerId, _state) => { },
+            };
             const toolCtx = {
                 ctx: execCtx,
                 harness: execCtx.harness,
                 fs: execCtx.fs,
                 shell: execCtx.shell,
-                memory: {
-                    get: (_layerId) => undefined,
-                    set: (_layerId, _state) => { },
-                },
+                context: layerState,
+                // Deprecated alias — the same accessor object, as
+                // `buildToolExecutionContext` does. `Tool.execute` takes its second
+                // argument as `unknown`, so nothing here is structurally checked
+                // against `ToolExecutionContext`; the annotation above is what makes
+                // a missing field a compile error instead of a runtime `undefined`.
+                memory: layerState,
                 assembledView: execCtx.itemLog.items,
                 lastStepMeta: execCtx.lastStepMeta,
             };
@@ -285,7 +292,7 @@ function resolveNamedLayers({ names, nodeKind, nodeId, ctx, }) {
         if (!layer) {
             throw new NoeticConfigError({
                 code: 'UNKNOWN_LAYER_REFERENCE',
-                message: `Memory layer '${name}' referenced in ${nodeKind} node '${nodeId}' is not registered.`,
+                message: `Context layer '${name}' referenced in ${nodeKind} node '${nodeId}' is not registered.`,
                 hint: `Available layers: ${[
                     ...(ctx.layers?.keys() ?? []),
                 ].join(', ') || '(none)'}. Pass named layers via HydrationContext.layers.`,
@@ -298,7 +305,7 @@ function hydrateSpawnNode(node, ctx) {
     if (node.kind !== 'spawn') {
         return frameworkCast(undefined);
     }
-    // `memory` is left undefined when the node names no layers so the child
+    // `context` is left undefined when the node names no layers so the child
     // inherits the parent's layers (spec 04). An explicit list replaces them.
     const resolvedLayers = node.layers
         ? resolveNamedLayers({
@@ -312,7 +319,7 @@ function hydrateSpawnNode(node, ctx) {
         id: node.id,
         child: hydrateNode(node.child, ctx),
         timeout: node.timeout,
-        memory: resolvedLayers,
+        context: resolvedLayers,
     });
 }
 function hydrateProvideNode(node, ctx) {
@@ -322,7 +329,7 @@ function hydrateProvideNode(node, ctx) {
     return provide({
         id: node.id,
         child: hydrateNode(node.child, ctx),
-        memory: resolveNamedLayers({
+        context: resolveNamedLayers({
             names: node.layers,
             nodeKind: 'provide',
             nodeId: node.id,
@@ -401,6 +408,75 @@ function hydrateSubHarnessNode(node, ctx) {
         session: node.session,
     });
 }
+/**
+ * Hydrates a `subflow` node lazily: the target document resolves and hydrates
+ * on first execution, memoized. Lazy because `HydrationContext.workflows` may
+ * be a live view that gains entries after hydration, and because it keeps
+ * cycle detection path-scoped — each ref chain threads its own ancestry set,
+ * so diamond reuse of a named workflow is legal while A→B→A throws.
+ */
+function hydrateSubflowNode(node, ctx) {
+    if (node.kind !== 'subflow') {
+        return frameworkCast(undefined);
+    }
+    let cached;
+    const resolve = () => {
+        if (!cached) {
+            const { doc, childCtx } = resolveSubflowDocument(node, ctx);
+            cached = hydrateNode(suffixNodeIds(doc.root, `-${node.id}`), childCtx);
+        }
+        return cached;
+    };
+    return frameworkCast(step.run({
+        id: node.id,
+        execute: async (input, execCtx) => {
+            const child = resolve();
+            return stringifyResult(await ctx.executeStep(child, node.input ?? input, execCtx));
+        },
+    }));
+}
+function resolveSubflowDocument(node, ctx) {
+    if (node.document) {
+        // Inline documents are finite JSON trees — they cannot cycle, so they
+        // add nothing to the ancestry chain.
+        return {
+            doc: node.document,
+            childCtx: ctx,
+        };
+    }
+    const ref = node.ref ?? '';
+    const ancestry = ctx.subflowAncestry ?? new Set();
+    if (ancestry.has(ref)) {
+        throw new NoeticConfigError({
+            code: 'WORKFLOW_CYCLE',
+            message: `Sub-workflow '${ref}' referenced in subflow node '${node.id}' forms a reference cycle (${[
+                ...ancestry,
+                ref,
+            ].join(' -> ')}).`,
+            hint: 'A named sub-workflow may not reference itself, directly or transitively. Break the cycle or inline the document.',
+        });
+    }
+    const doc = ctx.workflows?.get(ref);
+    if (!doc) {
+        throw new NoeticConfigError({
+            code: 'UNKNOWN_WORKFLOW_REFERENCE',
+            message: `Sub-workflow '${ref}' referenced in subflow node '${node.id}' is not registered.`,
+            hint: `Pass named workflows via HydrationContext.workflows. Available: ${[
+                ...(ctx.workflows?.keys() ?? []),
+            ].join(', ') || '(none)'}.`,
+        });
+    }
+    return {
+        doc,
+        childCtx: {
+            ...ctx,
+            subflowAncestry: new Set([
+                ...ancestry,
+                ref,
+            ]),
+        },
+    };
+}
 //#endregion
 //#region Handler Registry
 const NODE_HYDRATORS = {
@@ -414,6 +490,7 @@ const NODE_HYDRATORS = {
     loop: hydrateLoopNode,
     sequence: hydrateSequenceNode,
     every: hydrateEveryNode,
+    subflow: hydrateSubflowNode,
     'claude-code': hydrateSubHarnessNode,
     codex: hydrateSubHarnessNode,
     opencode: hydrateSubHarnessNode,
@@ -611,6 +688,8 @@ async function runCodeViaSubprocess(opts) {
  * @throws `NoeticConfigError` with code `UNKNOWN_NODE_KIND` if the node kind is unrecognised.
  * @throws `NoeticConfigError` with code `UNKNOWN_TOOL_REFERENCE` if a tool name cannot be resolved.
  * @throws `NoeticConfigError` with code `UNKNOWN_UNTIL_PREDICATE` if an until predicate kind is unrecognised.
+ * @throws `NoeticConfigError` with code `UNKNOWN_WORKFLOW_REFERENCE` (at execution time) if a subflow ref names no registered workflow.
+ * @throws `NoeticConfigError` with code `WORKFLOW_CYCLE` (at execution time) if named sub-workflow refs form a cycle.
  */
 export function hydrateNode(node, ctx) {
     const hydrator = NODE_HYDRATORS[node.kind];

package/dist/builders/workflow-step.d.ts

@@ -0,0 +1,61 @@
+/**
+ * `step.workflow` — runs a `WorkflowDocument` as a single composable step.
+ *
+ * Lives beside `step-builders.ts` (rather than inside it) because the hydrator
+ * imports the base `step` object; adding a hydrating builder there would create
+ * an import cycle. This module composes the public `step` namespace instead.
+ */
+import type { ContextData, ContextLayer } from '@noetic-tools/context';
+import type { OutputCodec, StepRun, SubHarness, SubHarnessKind, SubprocessAdapter, Tool, WorkflowDocument } from '@noetic-tools/types';
+import * as stepBuilders from './step-builders.js';
+/** @public Options for `step.workflow`. */
+export interface StepWorkflowOpts {
+    id: string;
+    /** Inline workflow document. Mutually exclusive with `ref`. */
+    document?: WorkflowDocument;
+    /** Named workflow resolved from `workflows`. Mutually exclusive with `document`. */
+    ref?: string;
+    /** Client tools the document's `llm`/`tool` nodes may reference by name. Default: none. */
+    tools?: Tool[];
+    /** Named context layers for `provide`/`spawn` nodes. */
+    layers?: ReadonlyMap<string, ContextLayer>;
+    /** Named sub-workflows for `subflow` nodes — and for resolving `ref` itself. */
+    workflows?: ReadonlyMap<string, WorkflowDocument>;
+    /** SubHarness adapters for `claude-code`/`codex`/`opencode`/`pi` nodes. */
+    subHarnesses?: ReadonlyMap<SubHarnessKind, SubHarness>;
+    /** Output codecs for `llm` nodes' `output` codec references. */
+    uiLibraries?: ReadonlyMap<string, OutputCodec>;
+    /** Resolver for named subprocess adapters on `run` nodes. */
+    resolveSubprocess?: (ref: string) => SubprocessAdapter | undefined;
+    /** `'inherit'` (default) runs in the caller's session; `'spawn'` isolates via `spawn()`. */
+    isolation?: 'inherit' | 'spawn';
+}
+/**
+ * Creates a step that hydrates and executes a JSON workflow document.
+ *
+ * The document resolves lazily on first execution (so a `ref` may target a
+ * workflow registered after the step is built) and the hydrated tree is
+ * memoized across executions. When the step itself is built from a `ref`,
+ * that name seeds the subflow ancestry chain, so a self-referencing named
+ * workflow fails with `WORKFLOW_CYCLE` instead of recursing forever.
+ *
+ * @public
+ * @param opts - See `StepWorkflowOpts`.
+ * @returns A `StepRun` executing the workflow via the harness on the context.
+ * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
+ * @throws `NoeticConfigError` with code `INVALID_WORKFLOW_SOURCE` unless exactly one of `document`/`ref` is set.
+ * @throws `NoeticConfigError` with code `MISSING_HARNESS_CONTEXT` (at execution) without `ctx.harness`.
+ * @throws `NoeticConfigError` with code `UNKNOWN_WORKFLOW_REFERENCE` (at execution) if `ref` names no registered workflow.
+ */
+export declare function stepWorkflow(opts: StepWorkflowOpts): StepRun<ContextData, string, string>;
+/** @public The step builder namespace: the base builders plus `workflow`. */
+export declare const step: {
+    readonly run: <TContext = Readonly<Record<string, Record<string, unknown>>>, I = unknown, O = unknown>(opts: stepBuilders.StepRunOpts<TContext, I, O>) => StepRun<TContext, I, O>;
+    readonly llm: <TContext = Readonly<Record<string, Record<string, unknown>>>, I = unknown, O = unknown>(opts: stepBuilders.StepLLMOpts<TContext, O>) => import("@noetic-tools/types").StepLLM<TContext, I, O>;
+    readonly tool: <TContext = Readonly<Record<string, Record<string, unknown>>>, I = unknown, O = unknown>(opts: stepBuilders.StepToolOpts<I, O>) => import("@noetic-tools/types").StepTool<TContext, I, O>;
+    readonly claudeCode: <TContext = Readonly<Record<string, Record<string, unknown>>>, I = unknown, O = unknown>(opts: stepBuilders.StepSubHarnessOpts<TContext, O>) => import("@noetic-tools/types").StepSubHarness<TContext, I, O>;
+    readonly codex: <TContext = Readonly<Record<string, Record<string, unknown>>>, I = unknown, O = unknown>(opts: stepBuilders.StepSubHarnessOpts<TContext, O>) => import("@noetic-tools/types").StepSubHarness<TContext, I, O>;
+    readonly opencode: <TContext = Readonly<Record<string, Record<string, unknown>>>, I = unknown, O = unknown>(opts: stepBuilders.StepSubHarnessOpts<TContext, O>) => import("@noetic-tools/types").StepSubHarness<TContext, I, O>;
+    readonly pi: <TContext = Readonly<Record<string, Record<string, unknown>>>, I = unknown, O = unknown>(opts: stepBuilders.StepSubHarnessOpts<TContext, O>) => import("@noetic-tools/types").StepSubHarness<TContext, I, O>;
+    readonly workflow: typeof stepWorkflow;
+};

package/dist/builders/workflow-step.js

@@ -0,0 +1,126 @@
+/**
+ * `step.workflow` — runs a `WorkflowDocument` as a single composable step.
+ *
+ * Lives beside `step-builders.ts` (rather than inside it) because the hydrator
+ * imports the base `step` object; adding a hydrating builder there would create
+ * an import cycle. This module composes the public `step` namespace instead.
+ */
+import { frameworkCast, NoeticConfigError } from '@noetic-tools/types';
+import { spawn } from './spawn-builder.js';
+import * as stepBuilders from './step-builders.js';
+import { hydrateWorkflow } from './workflow-hydrator.js';
+//#endregion
+//#region Builder
+/**
+ * Creates a step that hydrates and executes a JSON workflow document.
+ *
+ * The document resolves lazily on first execution (so a `ref` may target a
+ * workflow registered after the step is built) and the hydrated tree is
+ * memoized across executions. When the step itself is built from a `ref`,
+ * that name seeds the subflow ancestry chain, so a self-referencing named
+ * workflow fails with `WORKFLOW_CYCLE` instead of recursing forever.
+ *
+ * @public
+ * @param opts - See `StepWorkflowOpts`.
+ * @returns A `StepRun` executing the workflow via the harness on the context.
+ * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
+ * @throws `NoeticConfigError` with code `INVALID_WORKFLOW_SOURCE` unless exactly one of `document`/`ref` is set.
+ * @throws `NoeticConfigError` with code `MISSING_HARNESS_CONTEXT` (at execution) without `ctx.harness`.
+ * @throws `NoeticConfigError` with code `UNKNOWN_WORKFLOW_REFERENCE` (at execution) if `ref` names no registered workflow.
+ */
+export function stepWorkflow(opts) {
+    if (!opts.id || opts.id.trim() === '') {
+        throw new NoeticConfigError({
+            code: 'EMPTY_STEP_ID',
+            message: 'step.workflow() requires a non-empty id.',
+            hint: 'Pass a unique string as the id field, e.g. step.workflow({ id: "verify", ... }).',
+        });
+    }
+    if ((opts.document === undefined) === (opts.ref === undefined)) {
+        throw new NoeticConfigError({
+            code: 'INVALID_WORKFLOW_SOURCE',
+            message: `step.workflow('${opts.id}') requires exactly one of 'document' (inline) or 'ref' (named).`,
+            hint: "Pass document: { version: 1, root: ... } or ref: '<name>' with a workflows registry.",
+        });
+    }
+    // The hydrated tree bakes the harness's executeStep into every nested
+    // node's closure, so the cache is keyed on the harness: a step shared
+    // across sessions re-hydrates when it runs under a different harness
+    // instead of routing nested steps through the first one.
+    let cached;
+    return stepBuilders.step.run({
+        id: opts.id,
+        execute: async (input, ctx) => {
+            const harness = ctx.harness;
+            if (!harness) {
+                throw new NoeticConfigError({
+                    code: 'MISSING_HARNESS_CONTEXT',
+                    message: 'step.workflow requires a harness on the execution context.',
+                    hint: 'Execute this step via AgentHarness.run() or ensure ctx.harness is set.',
+                });
+            }
+            const executeStep = frameworkCast(harness.run.bind(harness));
+            if (!cached || cached.harness !== harness) {
+                cached = {
+                    harness,
+                    step: hydrate(opts, executeStep),
+                };
+            }
+            return stringify(await executeStep(cached.step, input, ctx));
+        },
+    });
+}
+/** @public The step builder namespace: the base builders plus `workflow`. */
+export const step = {
+    ...stepBuilders.step,
+    workflow: stepWorkflow,
+};
+//#endregion
+//#region Helpers
+function hydrate(opts, executeStep) {
+    const doc = opts.document ?? (opts.ref ? opts.workflows?.get(opts.ref) : undefined);
+    if (!doc) {
+        throw new NoeticConfigError({
+            code: 'UNKNOWN_WORKFLOW_REFERENCE',
+            message: `Workflow '${opts.ref}' referenced by step.workflow('${opts.id}') is not registered.`,
+            hint: `Pass named workflows via the workflows option. Available: ${[
+                ...(opts.workflows?.keys() ?? []),
+            ].join(', ') || '(none)'}.`,
+        });
+    }
+    const hydrationCtx = {
+        tools: new Map((opts.tools ?? []).map((t) => [
+            t.name,
+            t,
+        ])),
+        executeStep,
+        layers: opts.layers,
+        workflows: opts.workflows,
+        subHarnesses: opts.subHarnesses,
+        uiLibraries: opts.uiLibraries,
+        resolveSubprocess: opts.resolveSubprocess,
+        subflowAncestry: opts.ref
+            ? new Set([
+                opts.ref,
+            ])
+            : undefined,
+    };
+    const hydrated = hydrateWorkflow(doc, hydrationCtx);
+    if (opts.isolation !== 'spawn') {
+        return hydrated;
+    }
+    return spawn({
+        id: `${opts.id}-spawn`,
+        child: hydrated,
+    });
+}
+function stringify(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value === null || value === undefined) {
+        return '';
+    }
+    return JSON.stringify(value);
+}
+//#endregion

package/dist/conditions/conditions.d.ts

@@ -1,17 +1,17 @@
-import type { ContextMemory, StorageAdapter } from '@noetic-tools/memory';
+import type { ContextData, StorageAdapter } from '@noetic-tools/context';
 import type { Context, Step } from '@noetic-tools/types';
 import type { EmbedFn } from '../types/embed.js';
 export type Condition<I> = (input: I, ctx: Context) => Promise<boolean>;
-export interface WhenClause<TMemory = ContextMemory, I = unknown, O = unknown> {
+export interface WhenClause<TContext = ContextData, I = unknown, O = unknown> {
     readonly kind: 'when';
     readonly condition: Condition<I>;
-    readonly step: Step<TMemory, I, O>;
+    readonly step: Step<TContext, I, O>;
 }
-export interface OtherwiseClause<TMemory = ContextMemory, I = unknown, O = unknown> {
+export interface OtherwiseClause<TContext = ContextData, I = unknown, O = unknown> {
     readonly kind: 'otherwise';
-    readonly step: Step<TMemory, I, O>;
+    readonly step: Step<TContext, I, O>;
 }
-type Clause<TMemory, I, O> = WhenClause<TMemory, I, O> | OtherwiseClause<TMemory, I, O>;
+type Clause<TContext, I, O> = WhenClause<TContext, I, O> | OtherwiseClause<TContext, I, O>;
 /**
  * Creates a conditional clause that routes to the given step when the condition is true.
  *
@@ -20,7 +20,7 @@ type Clause<TMemory, I, O> = WhenClause<TMemory, I, O> | OtherwiseClause<TMemory
  * @param step - Step to execute when the condition matches.
  * @returns A `WhenClause` for use in `semanticRoute`.
  */
-export declare function when<TMemory = ContextMemory, I = unknown, O = unknown>(condition: Condition<I>, step: Step<TMemory, I, O>): WhenClause<TMemory, I, O>;
+export declare function when<TContext = ContextData, I = unknown, O = unknown>(condition: Condition<I>, step: Step<TContext, I, O>): WhenClause<TContext, I, O>;
 /**
  * Creates a fallback clause that always matches, used as the last clause in `semanticRoute`.
  *
@@ -28,7 +28,7 @@ export declare function when<TMemory = ContextMemory, I = unknown, O = unknown>(
  * @param step - Step to execute when no prior `when` clause matches.
  * @returns An `OtherwiseClause` for use in `semanticRoute`.
  */
-export declare function otherwise<TMemory = ContextMemory, I = unknown, O = unknown>(step: Step<TMemory, I, O>): OtherwiseClause<TMemory, I, O>;
+export declare function otherwise<TContext = ContextData, I = unknown, O = unknown>(step: Step<TContext, I, O>): OtherwiseClause<TContext, I, O>;
 /**
  * Builds a route function from an ordered list of `when`/`otherwise` clauses.
  * Evaluates clauses sequentially, returning the first matching step or `null`.
@@ -37,21 +37,21 @@ export declare function otherwise<TMemory = ContextMemory, I = unknown, O = unkn
  * @param clauses - Ordered `WhenClause` and optional trailing `OtherwiseClause`.
  * @returns A route function suitable for `branch({ route })`.
  */
-export declare function semanticRoute<TMemory = ContextMemory, I = unknown, O = unknown>(...clauses: Clause<TMemory, I, O>[]): (input: I, ctx: Context) => Promise<Step<TMemory, I, O> | null>;
-interface SemanticSwitchSimple<TMemory, I, O> {
+export declare function semanticRoute<TContext = ContextData, I = unknown, O = unknown>(...clauses: Clause<TContext, I, O>[]): (input: I, ctx: Context) => Promise<Step<TContext, I, O> | null>;
+interface SemanticSwitchSimple<TContext, I, O> {
     embed: EmbedFn;
-    cases: Record<string, Step<TMemory, I, O>>;
-    default?: Step<TMemory, I, O>;
+    cases: Record<string, Step<TContext, I, O>>;
+    default?: Step<TContext, I, O>;
     threshold?: number;
     cache?: StorageAdapter;
 }
-interface SemanticSwitchAdvanced<TMemory, I, O> {
+interface SemanticSwitchAdvanced<TContext, I, O> {
     embed: EmbedFn;
     cases: {
         labels: string | string[];
-        step: Step<TMemory, I, O>;
+        step: Step<TContext, I, O>;
     }[];
-    default?: Step<TMemory, I, O>;
+    default?: Step<TContext, I, O>;
     threshold?: number;
     cache?: StorageAdapter;
 }
@@ -62,9 +62,9 @@ interface SemanticSwitchAdvanced<TMemory, I, O> {
  * @param opts - Simple form with `Record<string, Step>` cases, or advanced form with multi-label cases.
  * @returns A route function suitable for `branch({ route })`.
  */
-export declare function semanticSwitch<TMemory = ContextMemory, I = unknown, O = unknown>(opts: SemanticSwitchSimple<TMemory, I, O>): (input: I, ctx: Context) => Promise<Step<TMemory, I, O> | null>;
+export declare function semanticSwitch<TContext = ContextData, I = unknown, O = unknown>(opts: SemanticSwitchSimple<TContext, I, O>): (input: I, ctx: Context) => Promise<Step<TContext, I, O> | null>;
 /** @public */
-export declare function semanticSwitch<TMemory = ContextMemory, I = unknown, O = unknown>(opts: SemanticSwitchAdvanced<TMemory, I, O>): (input: I, ctx: Context) => Promise<Step<TMemory, I, O> | null>;
+export declare function semanticSwitch<TContext = ContextData, I = unknown, O = unknown>(opts: SemanticSwitchAdvanced<TContext, I, O>): (input: I, ctx: Context) => Promise<Step<TContext, I, O> | null>;
 /**
  * Creates a condition that matches when the input embedding is within a cosine similarity threshold of a label.
  *

package/dist/conditions/conditions.js

@@ -1,4 +1,4 @@
-import { storageGetMany } from '@noetic-tools/memory';
+import { storageGetMany } from '@noetic-tools/context';
 import { createMessage, extractAssistantText, trackUsage } from '@noetic-tools/types';
 import { z } from 'zod';
 import { cosineSimilarity } from './cosine-similarity.js';

package/dist/deprecated.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Deprecated aliases from the "memory layer" era of the framework.
+ *
+ * The layer system assembles the model's *context window* — recall, budget
+ * allocation, history projection, the item-append pipeline — so it is named
+ * after context, not memory. Every name below still resolves to its
+ * replacement; nothing here changes behaviour.
+ *
+ * Most of these are plain pass-throughs: the alias and its replacement already
+ * live in `@noetic-tools/types` / `@noetic-tools/context`, and re-exporting
+ * carries each name's `@deprecated` pointer along with it. Only the renaming
+ * aliases — where core exports a symbol under a *different* name than its
+ * source package does — are declared here.
+ *
+ * The matching runtime aliases (the `memory:` config key on `provide`/`spawn`/
+ * `tool`/`react`/`AgentHarness`, and the `ctx.memory` accessor) are handled at
+ * their call sites — see `resolveContextOption`.
+ *
+ * Scheduled for removal in the next major of `@noetic-tools/core`.
+ */
+export type { ObservationalMemoryConfig, PlanMemoryConfig, TemporalMemoryConfig, WorkingMemoryConfig, WorkingMemoryState, } from '@noetic-tools/context';
+export { observationalMemory, planMemory, temporalMemory, toolMemoryLayer, workingMemory, } from '@noetic-tools/context';
+export type { ContextMemory, InferMemory, InferMemoryShape, MemoryCallModelRequest, MemoryConfig, MemoryHooks, MemoryLayer, MemoryScope, MemoryTraceSpan, ToolMemory, ToolMemoryDeclaration, } from '@noetic-tools/types';
+export { 
+/**
+ * @public
+ * @deprecated Renamed to `context`. Declared here rather than re-exported
+ * because the builder itself lives in core under its new name.
+ */
+context as memory, } from './builders/context-builder.js';

package/dist/deprecated.js

@@ -0,0 +1,28 @@
+/**
+ * Deprecated aliases from the "memory layer" era of the framework.
+ *
+ * The layer system assembles the model's *context window* — recall, budget
+ * allocation, history projection, the item-append pipeline — so it is named
+ * after context, not memory. Every name below still resolves to its
+ * replacement; nothing here changes behaviour.
+ *
+ * Most of these are plain pass-throughs: the alias and its replacement already
+ * live in `@noetic-tools/types` / `@noetic-tools/context`, and re-exporting
+ * carries each name's `@deprecated` pointer along with it. Only the renaming
+ * aliases — where core exports a symbol under a *different* name than its
+ * source package does — are declared here.
+ *
+ * The matching runtime aliases (the `memory:` config key on `provide`/`spawn`/
+ * `tool`/`react`/`AgentHarness`, and the `ctx.memory` accessor) are handled at
+ * their call sites — see `resolveContextOption`.
+ *
+ * Scheduled for removal in the next major of `@noetic-tools/core`.
+ */
+export { observationalMemory, planMemory, temporalMemory, toolMemoryLayer, workingMemory, } from '@noetic-tools/context';
+export { 
+/**
+ * @public
+ * @deprecated Renamed to `context`. Declared here rather than re-exported
+ * because the builder itself lives in core under its new name.
+ */
+context as memory, } from './builders/context-builder.js';

package/dist/harness/agent-harness.d.ts

@@ -1,14 +1,16 @@
 import { ItemSchemaRegistry } from '@noetic-tools/types';
+import type { LayerStateStore, RecallCache } from './deps/context.js';
 import type { DetachedSpawnOverrides } from './deps/interpreter.js';
-import type { LayerStateStore, RecallCache } from './deps/memory.js';
 import type { CheckpointStore, EventBroadcaster, RestoreCheckpointOptions, StepLedgerRetention, StepLedgerStore } from './deps/runtime.js';
-import type { AgentConfig, AgentHarnessContract, AgentHooks, CallModelRequest, Channel, ChannelHandle, Context, ContextMemory, CwdState, DeliveryMode, DetachedHandle, ExecuteInput, ExecuteOptions, ExternalChannel, FsAdapter, HarnessResponse, HarnessStatus, Item, ItemSchemaExtensions, LLMResponse, LlmProviderConfig, MemoryLayer, ProjectionPolicy, RecallLayerOutput, SessionScope, ShellAdapter, Span, SteeringDecision, Step, StorageAdapter, StreamEvent, StreamingItem, SubHarnessSession, SubprocessAdapter, Tool, TraceExporter, ZodType } from './deps/types.js';
+import type { AgentConfig, AgentHarnessContract, AgentHooks, CallModelRequest, Channel, ChannelHandle, Context, ContextData, ContextLayer, CwdState, DeliveryMode, DetachedHandle, ExecuteInput, ExecuteOptions, ExternalChannel, FsAdapter, HarnessResponse, HarnessStatus, Item, ItemSchemaExtensions, LLMResponse, LlmProviderConfig, ProjectionPolicy, RecallLayerOutput, SessionScope, ShellAdapter, Span, SteeringDecision, Step, StorageAdapter, StreamEvent, StreamingItem, SubHarnessSession, SubprocessAdapter, Tool, TraceExporter, ZodType } from './deps/types.js';
 export { createStreamIdleWatchdog } from './model-call.js';
 interface AgentHarnessOpts<TParams extends Record<string, unknown> = Record<string, unknown>> {
     name: string;
-    initialStep?: Step<ContextMemory, string, string>;
-    /** Default memory layers applied to every context created via `createContext()` / `execute()`. */
-    memory?: MemoryLayer[];
+    initialStep?: Step<ContextData, string, string>;
+    /** Default context layers applied to every context created via `createContext()` / `execute()`. */
+    context?: ContextLayer[];
+    /** @deprecated Renamed to `context`. */
+    memory?: ContextLayer[];
     storage?: StorageAdapter;
     hooks?: AgentHooks;
     /**
@@ -93,8 +95,8 @@ export interface ResolvedLlmClient {
  */
 export declare function resolveLlmClient(config: LlmProviderConfig | undefined, env: LlmEnv): ResolvedLlmClient | undefined;
 /**
- * Default agent harness for executing agent steps with built-in channel, memory, and trace support.
- * Provides channel store, memory layer lifecycle, and trace export with no external dependencies.
+ * Default agent harness for executing agent steps with built-in channel, context, and trace support.
+ * Provides channel store, context layer lifecycle, and trace export with no external dependencies.
  *
  * Messages submitted via `execute()` are enqueued on a per-thread session and
  * processed by a `SessionRunner`. Consumers observe responses via the session-
@@ -128,10 +130,10 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
     private readonly initialStep?;
     /** Harness-wide tool pool merged into every context's `unifiedTools`. */
     private readonly harnessTools;
-    /** @internal Memory layers configured for this harness. Exposed non-private
+    /** @internal Context layers configured for this harness. Exposed non-private
      *  so free functions in `runtime/durable/` (checkpoint/restore) can read it
      *  without friend-class gymnastics. Do not access from outside core. */
-    readonly _memory?: MemoryLayer[];
+    readonly _contextLayers?: ContextLayer[];
     private readonly client?;
     private readonly channelStore;
     private readonly callModelOverride?;
@@ -189,7 +191,7 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
     private getOrCreateSession;
     private requireSession;
     callModel(request: CallModelRequest): Promise<LLMResponse>;
-    run<I, O>(s: Step<ContextMemory, I, O>, input: I, ctx: Context): Promise<O>;
+    run<I, O>(s: Step<ContextData, I, O>, input: I, ctx: Context): Promise<O>;
     /** Run all layer `init` hooks before the first step executes. Per spec 11,
      *  init MUST complete before any recall fires so layer state is populated. */
     private initAndRun;
@@ -201,14 +203,16 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
      * clobber accumulated in-memory state.
      */
     private ensureLayersInit;
-    detachedSpawn<I, O>(s: Step<ContextMemory, I, O>, input: I, parentCtx: Context, overrides?: DetachedSpawnOverrides): DetachedHandle<O>;
+    detachedSpawn<I, O>(s: Step<ContextData, I, O>, input: I, parentCtx: Context, overrides?: DetachedSpawnOverrides): DetachedHandle<O>;
     createContext(opts?: {
         parent?: Context;
         items?: Item[];
         state?: unknown;
         threadId?: string;
         resourceId?: string;
-        memory?: MemoryLayer[];
+        context?: ContextLayer[];
+        /** @deprecated Renamed to `context`. */
+        memory?: ContextLayer[];
         /**
          * Initial cwd for the new context. When set, takes precedence over both
          * the parent snapshot and the harness root cwd — used by worktree
@@ -226,15 +230,15 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
     /** Resolves layer-provided tools and merges with step tools into ctx.unifiedTools. */
     private setUnifiedTools;
     private toExecCtx;
-    initLayers(layers: MemoryLayer[], ctx: Context, storage: StorageAdapter): Promise<void>;
-    recallLayers(layers: MemoryLayer[], input: string, ctx: Context): Promise<RecallLayerOutput[]>;
+    initLayers(layers: ContextLayer[], ctx: Context, storage: StorageAdapter): Promise<void>;
+    recallLayers(layers: ContextLayer[], input: string, ctx: Context): Promise<RecallLayerOutput[]>;
     /** Allocate per-layer recall budgets from the harness projection policy. */
     private layerBudgets;
-    recallLayersAtomic(layers: MemoryLayer[], input: string, ctx: Context, budgets: Map<string, number>): Promise<RecallLayerOutput[]>;
-    recallLayersEventual(layers: MemoryLayer[], input: string, ctx: Context, budgets: Map<string, number>): Promise<RecallLayerOutput[]>;
+    recallLayersAtomic(layers: ContextLayer[], input: string, ctx: Context, budgets: Map<string, number>): Promise<RecallLayerOutput[]>;
+    recallLayersEventual(layers: ContextLayer[], input: string, ctx: Context, budgets: Map<string, number>): Promise<RecallLayerOutput[]>;
     /**
      * Compute the items array that would be sent to the model on the next turn —
-     * the same arrangement `executeLLM` builds: harness-level memory layers'
+     * the same arrangement `executeLLM` builds: harness-level context layers'
      * recall outputs concatenated with the session's accumulated history.
      *
      * Read-mostly: `recallLayers` writes layer-state snapshots to
@@ -242,8 +246,8 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
      * remain consistent with what the next real turn produces.
      */
     previewRequestItems(scope?: SessionScope): Promise<ReadonlyArray<Item>>;
-    storeLayers(layers: MemoryLayer[], response: LLMResponse, ctx: Context): Promise<void>;
-    disposeLayers(layers: MemoryLayer[], ctx: Context): Promise<void>;
+    storeLayers(layers: ContextLayer[], response: LLMResponse, ctx: Context): Promise<void>;
+    disposeLayers(layers: ContextLayer[], ctx: Context): Promise<void>;
     /**
      * Snapshot the execution state at a checkpoint boundary.
      *
@@ -272,7 +276,7 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
      * checkpoint via `CheckpointStore.clear()` and start a fresh execution.
      *
      * `opts` is the `createContext`-shaped wiring the host attached to the
-     * original context (broadcaster, parent, state, memory overrides). A
+     * original context (broadcaster, parent, state, context overrides). A
      * snapshot recovers data, not live objects — pass the same wiring here or
      * the resumed run gets an undecorated context and whatever depended on that
      * wiring (event streaming, mid-turn injection) stops working without
@@ -300,7 +304,7 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
     clearCheckpoint(executionId: string): Promise<void>;
     /**
      * Cancel an execution: abort `ctx` and every live descendant context, then
-     * run the memory-layer teardown for each (spec 09, Cancellation).
+     * run the context-layer teardown for each (spec 09, Cancellation).
      *
      * The abort itself fans out top-down and synchronously — `ctx.abort()`
      * cascades into every live fork path and spawn child, so no corner of the
@@ -327,10 +331,10 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
     createSpan(name: string, parent: Span | null): Span;
     getLayerState<T>(executionId: string, layerId: string): T | undefined;
     setLayerState<T>(executionId: string, layerId: string, state: T): void;
-    beforeToolCall(layers: MemoryLayer[], toolName: string, toolArgs: unknown, ctx: Context): Promise<SteeringDecision>;
-    afterModelCall(layers: MemoryLayer[], response: LLMResponse, ctx: Context): Promise<SteeringDecision>;
-    projectHistory(layers: MemoryLayer[], items: ReadonlyArray<Item>, ctx: Context): Promise<ReadonlyArray<Item>>;
-    runAppendPipeline(layers: MemoryLayer[], items: Item[], ctx: Context): Promise<{
+    beforeToolCall(layers: ContextLayer[], toolName: string, toolArgs: unknown, ctx: Context): Promise<SteeringDecision>;
+    afterModelCall(layers: ContextLayer[], response: LLMResponse, ctx: Context): Promise<SteeringDecision>;
+    projectHistory(layers: ContextLayer[], items: ReadonlyArray<Item>, ctx: Context): Promise<ReadonlyArray<Item>>;
+    runAppendPipeline(layers: ContextLayer[], items: Item[], ctx: Context): Promise<{
         items: Item[];
         rerenderRequests: {
             layerId: string;
@@ -344,7 +348,7 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
         slot: number;
         timing: 'immediate' | 'batched';
         scope: 'self' | 'slot-after' | 'all';
-    }[], layers: MemoryLayer[], ctx: Context, budgets: Map<string, number>, query?: string): Promise<{
+    }[], layers: ContextLayer[], ctx: Context, budgets: Map<string, number>, query?: string): Promise<{
         layerId: string;
         items: Item[];
         tokenCount: number;