@noetic-tools/types 2.2.0 → 3.0.0

package/dist/types/context.d.ts

@@ -2,13 +2,13 @@ import type { ZodType } from 'zod';
 import type { ItemSchemaRegistry } from '../schemas/item.js';
 import type { Channel, ChannelHandle, ExternalChannel } from './channel.js';
 import type { LLMResponse, ModelParams, StepMeta, TokenUsage } from './common.js';
+import type { ContextData, ContextLayer, ProjectionPolicy, StorageAdapter } from './context-layer.js';
 import type { ItemLog } from './context-parts/item-log.js';
 import type { LastLayerUsage } from './context-parts/layer-usage.js';
 import type { DetachedHandle } from './detached.js';
 import type { FsAdapter } from './fs-adapter.js';
 import type { HarnessResponse, StreamEvent, StreamingItem } from './harness-result.js';
 import type { ExecuteInput } from './items.js';
-import type { ContextMemory, MemoryLayer, ProjectionPolicy, StorageAdapter } from './memory.js';
 import type { Span, TraceExporter } from './observability.js';
 import type { ShellAdapter } from './shell-adapter.js';
 import type { SteeringDecision } from './steering.js';
@@ -47,7 +47,7 @@ interface ContextCallModelRequestBase {
 interface ContextCallModelRequestWithTools extends ContextCallModelRequestBase {
     tools: Tool[];
     ctx: Context;
-    layers?: MemoryLayer[];
+    layers?: ContextLayer[];
     allowedToolNames?: string[];
 }
 interface ContextCallModelRequestWithoutTools extends ContextCallModelRequestBase {
@@ -84,8 +84,10 @@ export interface RestoreContextOptions {
     parent?: Context;
     /** Opaque per-execution state, same as `createContext({ state })`. */
     state?: unknown;
-    /** Memory layers for the restored context. Defaults to the harness's configured layers. */
-    memory?: MemoryLayer[];
+    /** Context layers for the restored context. Defaults to the harness's configured layers. */
+    context?: ContextLayer[];
+    /** @deprecated Renamed to `context`. */
+    memory?: ContextLayer[];
 }
 export interface ContextRerenderRequest {
     layerId: string;
@@ -102,10 +104,10 @@ export interface ContextRecallLayerOutput {
     items: import('./items.js').Item[];
     tokenCount: number;
 }
-export type ContextStep<TMemory = ContextMemory, I = unknown, O = unknown> = {
+export type ContextStep<TContext = ContextData, I = unknown, O = unknown> = {
     readonly kind: 'run';
     readonly id: string;
-    readonly execute: (input: I, ctx: Context<TMemory>) => Promise<O>;
+    readonly execute: (input: I, ctx: Context<TContext>) => Promise<O>;
 } | {
     readonly kind: 'llm';
     readonly id: string;
@@ -113,8 +115,8 @@ export type ContextStep<TMemory = ContextMemory, I = unknown, O = unknown> = {
 } | {
     readonly kind: 'loop';
     readonly id: string;
-    readonly steps: ReadonlyArray<ContextStep<TMemory, I, O>>;
-    readonly prepareNext?: (output: O, verdict: unknown, ctx: Context<TMemory>) => I;
+    readonly steps: ReadonlyArray<ContextStep<TContext, I, O>>;
+    readonly prepareNext?: (output: O, verdict: unknown, ctx: Context<TContext>) => I;
 } | {
     readonly kind: string;
     readonly id: string;
@@ -138,7 +140,7 @@ export interface ContextHarness {
     getTextStream(scope?: unknown): AsyncIterable<string>;
     getReasoningStream(scope?: unknown): AsyncIterable<string>;
     getFullStream(scope?: unknown): AsyncIterable<StreamEvent>;
-    run<I, O>(step: ContextStep<ContextMemory, I, O>, input: I, ctx: Context): Promise<O>;
+    run<I, O>(step: ContextStep<ContextData, I, O>, input: I, ctx: Context): Promise<O>;
     detachedSpawn<I, O>(step: unknown, input: I, parentCtx: Context, overrides?: ContextDetachedSpawnOverrides): DetachedHandle<O>;
     createContext(opts?: {
         parent?: Context;
@@ -146,20 +148,22 @@ export interface ContextHarness {
         state?: unknown;
         threadId?: string;
         resourceId?: string;
-        memory?: MemoryLayer[];
+        context?: ContextLayer[];
+        /** @deprecated Renamed to `context`. */
+        memory?: ContextLayer[];
         cwdInit?: string;
     }): Context;
     setRootCwd(nextCwd: string): void;
     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>;
-    runAppendPipeline(layers: MemoryLayer[], items: import('./items.js').Item[], ctx: Context): Promise<ContextAppendPipelineResult>;
-    recallLayers(layers: MemoryLayer[], input: string, ctx: Context): Promise<ContextRecallLayerOutput[]>;
-    recallLayersAtomic(layers: MemoryLayer[], input: string, ctx: Context, budgets: Map<string, number>): Promise<ContextRecallLayerOutput[]>;
-    recallLayersEventual(layers: MemoryLayer[], input: string, ctx: Context, budgets: Map<string, number>): Promise<ContextRecallLayerOutput[]>;
-    projectHistory(layers: MemoryLayer[], items: ReadonlyArray<import('./items.js').Item>, ctx: Context): Promise<ReadonlyArray<import('./items.js').Item>>;
-    storeLayers(layers: MemoryLayer[], response: LLMResponse, ctx: Context): Promise<void>;
+    beforeToolCall(layers: ContextLayer[], toolName: string, toolArgs: unknown, ctx: Context): Promise<SteeringDecision>;
+    afterModelCall(layers: ContextLayer[], response: LLMResponse, ctx: Context): Promise<SteeringDecision>;
+    runAppendPipeline(layers: ContextLayer[], items: import('./items.js').Item[], ctx: Context): Promise<ContextAppendPipelineResult>;
+    recallLayers(layers: ContextLayer[], input: string, ctx: Context): Promise<ContextRecallLayerOutput[]>;
+    recallLayersAtomic(layers: ContextLayer[], input: string, ctx: Context, budgets: Map<string, number>): Promise<ContextRecallLayerOutput[]>;
+    recallLayersEventual(layers: ContextLayer[], input: string, ctx: Context, budgets: Map<string, number>): Promise<ContextRecallLayerOutput[]>;
+    projectHistory(layers: ContextLayer[], items: ReadonlyArray<import('./items.js').Item>, ctx: Context): Promise<ReadonlyArray<import('./items.js').Item>>;
+    storeLayers(layers: ContextLayer[], response: LLMResponse, ctx: Context): Promise<void>;
     previewRequestItems(scope?: unknown): Promise<ReadonlyArray<import('./items.js').Item>>;
     /**
      * Internal-sender channel write. Resolves immediately unless the target
@@ -173,13 +177,15 @@ export interface ContextHarness {
     }): Promise<T>;
     tryRecv<T>(channel: Channel<T>, ctx: Context): T | null;
     getChannelHandle<T>(channel: ExternalChannel<T>, executionId: string): ChannelHandle<T>;
-    initLayers(layers: MemoryLayer[], ctx: Context, storage: StorageAdapter): Promise<void>;
-    disposeLayers(layers: MemoryLayer[], ctx: Context): Promise<void>;
+    /** Read-side counterpart to `getChannelHandle` — see `AgentHarnessContract.getChannelStream`. */
+    getChannelStream<T>(channel: ExternalChannel<T>, executionId: string): AsyncIterable<T>;
+    initLayers(layers: ContextLayer[], ctx: Context, storage: StorageAdapter): Promise<void>;
+    disposeLayers(layers: ContextLayer[], ctx: Context): Promise<void>;
     checkpoint(ctx: Context): Promise<void>;
     restore(executionId: string, opts?: RestoreContextOptions): Promise<Context | null>;
     /**
      * Cancel an execution: abort `ctx` and every live descendant context, then
-     * run memory-layer teardown (`onComplete` with `outcome: 'aborted'`, then
+     * run context-layer teardown (`onComplete` with `outcome: 'aborted'`, then
      * `dispose`) bottom-up. A no-op on an already-cancelled context.
      */
     cancel(ctx: Context, reason?: string): Promise<void>;
@@ -190,17 +196,17 @@ export interface ContextHarness {
     getStatus(scope?: unknown): ContextHarnessStatus;
     getQueueSize(scope?: unknown): number;
     seedSessionHistory(threadId: string, items: ReadonlyArray<import('./items.js').Item>): void;
-    executeRerender(requests: ContextRerenderRequest[], layers: MemoryLayer[], ctx: Context, budgets: Map<string, number>, query?: string): Promise<ContextRecallLayerOutput[]>;
+    executeRerender(requests: ContextRerenderRequest[], layers: ContextLayer[], ctx: Context, budgets: Map<string, number>, query?: string): Promise<ContextRecallLayerOutput[]>;
 }
 /** @public Execution context threaded through every step, carrying state, metrics, and channels. */
-export interface Context<TMemory = ContextMemory, TState = unknown> {
+export interface Context<TContext = ContextData, TState = unknown> {
     readonly id: string;
     readonly stepCount: number;
     readonly tokens: TokenUsage;
     readonly elapsed: number;
     readonly cost: number;
     state: TState;
-    readonly parent: Context<ContextMemory> | null;
+    readonly parent: Context<ContextData> | null;
     readonly depth: number;
     readonly span: Span;
     readonly threadId: string;
@@ -222,9 +228,17 @@ export interface Context<TMemory = ContextMemory, TState = unknown> {
      * agent `cd` propagates to subsequent tool calls.
      */
     readonly cwdState: CwdState;
-    readonly layers?: MemoryLayer[];
-    /** Layer provides keyed by layer ID. Access data/functions via `ctx.memory['layerId'].prop`. */
-    readonly memory: TMemory;
+    readonly layers?: ContextLayer[];
+    /** Layer provides keyed by layer ID. Access data/functions via `ctx.context['layerId'].prop`. */
+    readonly context: TContext;
+    /**
+     * @deprecated Renamed to `context`. Reads through to the same object.
+     *
+     * Required, not optional: pre-rename code does `ctx.memory['layerId']`, and an
+     * optional field would make that a `possibly undefined` compile error — which
+     * is exactly the break this alias exists to prevent.
+     */
+    readonly memory: TContext;
     /** Unified tool set collected from all LLM steps in the step tree before execution. */
     readonly unifiedTools?: ReadonlyArray<Tool>;
     /** Runtime item schema registry active for this context. */
@@ -256,7 +270,7 @@ export interface Context<TMemory = ContextMemory, TState = unknown> {
      * Aborting rejects operations blocked on the context (channel `recv` waiters,
      * parked back-pressure senders) with `cancelled`, cuts short the in-flight
      * model call or sub-harness turn, and makes the next step boundary throw
-     * `cancelled`. Memory-layer teardown is NOT run — use
+     * `cancelled`. Context-layer teardown is NOT run — use
      * `harness.cancel(ctx, reason)` for that.
      */
     abort(reason?: string): void;

package/dist/types/harness-result.d.ts

@@ -34,7 +34,7 @@ export interface HarnessResponse {
     };
     readonly cost?: number;
     readonly text: string;
-    /** Per-memory-layer context window breakdown captured at the last callModel of this execution. */
+    /** Per-context-layer context window breakdown captured at the last callModel of this execution. */
     readonly lastLayerUsage?: LastLayerUsage;
 }
 /** @public An Item snapshot with a completion flag, emitted from getItemStream(). */

package/dist/types/items.d.ts

@@ -97,9 +97,9 @@ export interface FunctionCallOutputItem {
     readonly callId: string;
     readonly output: string;
 }
-/** @public Item produced by an extension schema registered by a tool, memory layer, or harness. */
+/** @public Item produced by an extension schema registered by a tool, context layer, or harness. */
 export type ExtensionItem = ItemBase & Record<string, unknown>;
-/** @public Developer-role message item refined by a memory-layer extension schema. */
+/** @public Developer-role message item refined by a context-layer extension schema. */
 export type DeveloperMessageExtensionItem = InputMessageItem & {
     readonly role: 'developer';
 } & Record<string, unknown>;
@@ -111,7 +111,7 @@ export type ToolResultExtensionItem = FunctionCallOutputItem & Record<string, un
 export interface ItemSchemaExtensions {
     /** Harness-wide schemas. Any item matching one of these schemas is accepted. */
     readonly items?: ReadonlyArray<ZodTypeAny>;
-    /** Schemas for memory-layer developer message items. */
+    /** Schemas for context-layer developer message items. */
     readonly developerMessages?: ReadonlyArray<ZodTypeAny>;
     /** Schemas for tool call items emitted by the model or a harness adapter. */
     readonly toolCalls?: ReadonlyArray<ZodTypeAny>;

package/dist/types/observability.d.ts

@@ -11,8 +11,8 @@ export interface Span {
 export interface TraceExporter {
     export(spans: Span[]): Promise<void>;
 }
-/** @public Diagnostic span recording a single memory layer hook invocation and its outcome. */
-export interface MemoryTraceSpan {
+/** @public Diagnostic span recording a single context layer hook invocation and its outcome. */
+export interface LayerTraceSpan {
     layerId: string;
     hook: 'init' | 'recall' | 'store' | 'onSpawn' | 'onReturn' | 'onComplete' | 'dispose';
     durationMs: number;

package/dist/types/output-codec.d.ts

@@ -5,7 +5,7 @@
  * `StepLLM.output`: instead of JSON-parsing the assistant text once at turn
  * end, a codec is fed each text delta as it streams and produces a typed
  * value when the turn finishes. OpenUI Lang is one dialect; the contract
- * lives here — next to `MemoryLayer` and `SubHarness` — so `core` and
+ * lives here — next to `ContextLayer` and `SubHarness` — so `core` and
  * dialect packages both depend on it without forming a cycle.
  */
 /**

package/dist/types/output-codec.js

@@ -5,7 +5,7 @@
  * `StepLLM.output`: instead of JSON-parsing the assistant text once at turn
  * end, a codec is fed each text delta as it streams and produces a typed
  * value when the turn finishes. OpenUI Lang is one dialect; the contract
- * lives here — next to `MemoryLayer` and `SubHarness` — so `core` and
+ * lives here — next to `ContextLayer` and `SubHarness` — so `core` and
  * dialect packages both depend on it without forming a cycle.
  */
 /**

package/dist/types/runtime.d.ts

@@ -2,11 +2,11 @@ import type { ZodType } from 'zod';
 import type { Channel, ChannelHandle, ExternalChannel } from './channel.js';
 import type { LLMResponse, ModelParams, ServerToolSpec } from './common.js';
 import type { Context, CwdState, RestoreContextOptions } from './context.js';
+import type { ContextData, ContextLayer, ProjectionPolicy, StorageAdapter } from './context-layer.js';
 import type { DetachedHandle } from './detached.js';
 import type { FsAdapter } from './fs-adapter.js';
 import type { HarnessResponse, StreamEvent, StreamingItem } from './harness-result.js';
 import type { ExecuteInput, Item, ItemSchemaExtensions } from './items.js';
-import type { ContextMemory, MemoryLayer, ProjectionPolicy, StorageAdapter } from './memory.js';
 import type { Span, TraceExporter } from './observability.js';
 import type { ShellAdapter } from './shell-adapter.js';
 import type { SteeringDecision } from './steering.js';
@@ -18,7 +18,7 @@ export interface AgentHooks {
     beforeStep?: (step: Step, ctx: Context) => Promise<void>;
     afterStep?: (step: Step, result: unknown, ctx: Context) => Promise<void>;
 }
-/** @public Top-level configuration object that defines an agent's model, tools, memory, and behavior. */
+/** @public Top-level configuration object that defines an agent's model, tools, context, and behavior. */
 export interface AgentConfig<TParams extends Record<string, unknown> = Record<string, unknown>> {
     name: string;
     storage?: StorageAdapter;
@@ -84,7 +84,7 @@ interface CallModelRequestBase {
 interface CallModelRequestWithTools extends CallModelRequestBase {
     tools: Tool[];
     ctx: Context;
-    layers?: MemoryLayer[];
+    layers?: ContextLayer[];
     /** When set, restricts which tools the model may invoke for this call. */
     allowedToolNames?: string[];
 }
@@ -102,8 +102,10 @@ export interface ExecuteOptions {
     threadId?: string;
     resourceId?: string;
     state?: unknown;
-    /** Memory layers to apply to the execution context. Overrides harness-level memory if provided. */
-    memory?: MemoryLayer[];
+    /** Context layers to apply to the execution context. Overrides harness-level layers if provided. */
+    context?: ContextLayer[];
+    /** @deprecated Renamed to `context`. */
+    memory?: ContextLayer[];
     /** Override the harness's default delivery mode for this message only. */
     deliveryMode?: DeliveryMode;
     /**
@@ -130,7 +132,7 @@ export type HarnessStatus = {
 export interface SessionScope {
     threadId?: string;
 }
-/** @public Type-level contract for the agent runtime. Used for type annotations throughout the interpreter, memory layers, and context. Implemented by `AgentHarness`. */
+/** @public Type-level contract for the agent runtime. Used for type annotations throughout the interpreter, context layers, and context. Implemented by `AgentHarness`. */
 export interface AgentHarnessContract<TParams extends Record<string, unknown> = Record<string, unknown>> {
     readonly config: AgentConfig<TParams>;
     /** Filesystem adapter for virtual or real filesystem access. */
@@ -182,7 +184,7 @@ export interface AgentHarnessContract<TParams extends Record<string, unknown> =
      * already exist. Replaces any previously-accumulated items for the session.
      */
     seedSessionHistory(threadId: string, items: ReadonlyArray<Item>): void;
-    run<I, O>(step: Step<ContextMemory, I, O>, input: I, ctx: Context): Promise<O>;
+    run<I, O>(step: Step<ContextData, I, O>, input: I, ctx: Context): Promise<O>;
     /**
      * Launch `step` as a fire-and-forget background execution.
      *
@@ -194,11 +196,11 @@ export interface AgentHarnessContract<TParams extends Record<string, unknown> =
      *
      * @param step Step to execute in a fresh child context.
      * @param input Initial input passed to `step`.
-     * @param parentCtx Parent context (the child inherits memory layers and,
+     * @param parentCtx Parent context (the child inherits context layers and,
      * by default, threadId/resourceId).
      * @param overrides Optional: override threadId or resourceId on the child.
      */
-    detachedSpawn<I, O>(step: Step<ContextMemory, I, O>, input: I, parentCtx: Context, overrides?: {
+    detachedSpawn<I, O>(step: Step<ContextData, I, O>, input: I, parentCtx: Context, overrides?: {
         threadId?: string;
         resourceId?: string;
         /** Override the child's initial cwd. Used by worktree isolation to root the child at the worktree path. */
@@ -210,7 +212,9 @@ export interface AgentHarnessContract<TParams extends Record<string, unknown> =
         state?: unknown;
         threadId?: string;
         resourceId?: string;
-        memory?: MemoryLayer[];
+        context?: ContextLayer[];
+        /** @deprecated Renamed to `context`. */
+        memory?: ContextLayer[];
         /** Override the new context's initial cwd. */
         cwdInit?: string;
     }): Context;
@@ -230,20 +234,31 @@ export interface AgentHarnessContract<TParams extends Record<string, unknown> =
     }): Promise<T>;
     tryRecv<T>(channel: Channel<T>, ctx: Context): T | null;
     getChannelHandle<T>(channel: ExternalChannel<T>, executionId: string): ChannelHandle<T>;
-    initLayers(layers: MemoryLayer[], ctx: Context, storage: StorageAdapter): Promise<void>;
-    recallLayers(layers: MemoryLayer[], input: string, ctx: Context): Promise<RecallLayerOutput[]>;
+    /**
+     * Read-side counterpart to `getChannelHandle`: subscribe to values the agent
+     * sends on an external channel. Delivery is CHANNEL-scoped (state is keyed
+     * by channel name per harness) — `executionId` bounds only the
+     * subscription's lifetime: the iterable ends when that root execution
+     * completes (success, failure, or cancellation), draining buffered values
+     * first. An id no execution runs under never closes, giving a
+     * harness-lifetime stream ended via `iterator.return()`. The returned
+     * iterable owns a single iterator; subscribe again for a second consumer.
+     */
+    getChannelStream<T>(channel: ExternalChannel<T>, executionId: string): AsyncIterable<T>;
+    initLayers(layers: ContextLayer[], ctx: Context, storage: StorageAdapter): Promise<void>;
+    recallLayers(layers: ContextLayer[], input: string, ctx: Context): Promise<RecallLayerOutput[]>;
     /** Recall only atomic layers (or all layers when the harness forces atomic recall). Blocks until complete. */
-    recallLayersAtomic(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[]>;
     /** Recall eventual layers from cache (non-blocking); returns nothing when the harness forces atomic recall. */
-    recallLayersEventual(layers: MemoryLayer[], 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 that would be sent to the model on the next turn for a
-     * session — its accumulated history plus the harness's memory-layer recall
+     * session — its accumulated history plus the harness's context-layer recall
      * outputs assembled in the same order `executeLLM` 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>;
     checkpoint(ctx: Context): Promise<void>;
     /**
      * Rebuild a `Context` from a persisted snapshot. `opts` carries the wiring
@@ -253,7 +268,7 @@ export interface AgentHarnessContract<TParams extends Record<string, unknown> =
     restore(executionId: string, opts?: RestoreContextOptions): Promise<Context | null>;
     /**
      * Cancel an execution. Aborts `ctx` and — cascading down the execution tree —
-     * every live fork path and spawn child, then runs memory-layer teardown
+     * every live fork path and spawn child, then runs context-layer teardown
      * (`onComplete` with `outcome: 'aborted'`, then `dispose`) bottom-up.
      *
      * Blocked channel operations reject with `cancelled`, the in-flight model
@@ -267,27 +282,27 @@ export interface AgentHarnessContract<TParams extends Record<string, unknown> =
     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>;
+    beforeToolCall(layers: ContextLayer[], toolName: string, toolArgs: unknown, ctx: Context): Promise<SteeringDecision>;
+    afterModelCall(layers: ContextLayer[], response: LLMResponse, ctx: Context): Promise<SteeringDecision>;
     /**
      * Project the history items through every layer's `projectHistory` hook in
      * slot order. Pure read-side projection — `itemLog` is never mutated.
      * Returns the input unchanged if no layer registers the hook.
      */
-    projectHistory(layers: MemoryLayer[], items: ReadonlyArray<Item>, ctx: Context): Promise<ReadonlyArray<Item>>;
+    projectHistory(layers: ContextLayer[], items: ReadonlyArray<Item>, ctx: Context): Promise<ReadonlyArray<Item>>;
     /**
      * Run items through the onItemAppend pipeline before appending.
      * Each layer can filter, transform, or inject items.
      * Returns final items to append and any re-render requests.
      */
-    runAppendPipeline(layers: MemoryLayer[], items: Item[], ctx: Context): Promise<AppendPipelineResult>;
+    runAppendPipeline(layers: ContextLayer[], items: Item[], ctx: Context): Promise<AppendPipelineResult>;
     /**
      * Execute re-render based on collected requests.
      * Determines which layers need re-recall based on scope and runs them.
      */
-    executeRerender(requests: RerenderRequest[], layers: MemoryLayer[], ctx: Context, budgets: Map<string, number>, query?: string): Promise<RecallLayerOutput[]>;
+    executeRerender(requests: RerenderRequest[], layers: ContextLayer[], ctx: Context, budgets: Map<string, number>, query?: string): Promise<RecallLayerOutput[]>;
 }
-/** @public Output from a single memory layer's recall phase, including items and token budget used. */
+/** @public Output from a single context layer's recall phase, including items and token budget used. */
 export interface RecallLayerOutput {
     layerId: string;
     items: Item[];

package/dist/types/steering.d.ts

@@ -1,5 +1,5 @@
 import type { LLMResponse } from './common.js';
-import type { ExecutionContext, MemoryScope } from './memory-context.js';
+import type { ContextScope, ExecutionContext } from './context-scope.js';
 /** @public Enumeration of actions a steering rule can take on a tool call or model response. */
 export declare const SteeringAction: {
     Allow: string;
@@ -77,7 +77,7 @@ export interface SteeringConfig {
     rules: SteeringRule[];
     maxLedgerEntries?: number;
     maxRetries?: number;
-    scope?: MemoryScope;
+    scope?: ContextScope;
 }
 /** @public Mutable runtime state maintained by the steering layer across an execution. */
 export interface SteeringState {