@noetic-tools/core 3.2.0 → 5.0.0

package/dist/runtime/channel-store.d.ts

@@ -12,6 +12,15 @@ export interface ChannelSendOpts {
 export declare class ChannelStore {
     private channels;
     private closedExecutions;
+    /**
+     * Ids a `ChannelHandle` was issued for. Handles have no dispose lifecycle,
+     * so these are the only ids whose closure must be durably recorded (for
+     * `handle.closed` / `channel_closed`). Streams are closed directly through
+     * `subscribersByExecution`, so stream-only ids never accumulate here — a
+     * session harness closing one root id per turn stays bounded.
+     */
+    private handleObserved;
+    private subscribersByExecution;
     private getOrCreate;
     /**
      * Subscribe to wake notifications on a channel without consuming any value.
@@ -53,6 +62,30 @@ export declare class ChannelStore {
      * dropped (with a warning) so external callers never block.
      */
     private sendExternal;
+    /**
+     * External-reader subscription (spec 06, External Subscriptions). Delivery
+     * by mode: `topic` is a persistent non-lossy tap (per-subscriber bounded
+     * buffer, no replay of pre-subscribe values), `queue` competes with internal
+     * `recv` waiters FIFO (external consumption frees parked senders), `value`
+     * yields the current value then conflated updates.
+     *
+     * Channel state is keyed by NAME — `executionId` bounds only the
+     * subscription's lifetime (it ends when `closeExecution(executionId)`
+     * runs; queued values present at close drain first), never which values
+     * are delivered. An id that is never closed yields an unbounded stream
+     * the caller ends with `iterator.return()`. External waiters never time
+     * out — they end via close instead. The returned iterable owns a single
+     * iterator (generator semantics): subscribe again for a second consumer.
+     */
+    subscribe<T>(channel: ExternalChannel<T>, executionId: string): AsyncIterable<T>;
+    /** Shift the queue head and promote the oldest parked sender into the freed slot. */
+    private dequeueHead;
     getHandle<T>(channel: ExternalChannel<T>, executionId: string): ChannelHandle<T>;
     closeExecution(executionId: string): void;
+    /**
+     * A root run is (re)starting on this execution id: clear any previous
+     * closure so checkpoint-restored and sequentially re-run root contexts get
+     * working channels again instead of a permanently poisoned id.
+     */
+    openExecution(executionId: string): void;
 }

package/dist/runtime/channel-store.js

@@ -12,6 +12,15 @@ function cancelledError(signal) {
 export class ChannelStore {
     channels = new Map();
     closedExecutions = new Set();
+    /**
+     * Ids a `ChannelHandle` was issued for. Handles have no dispose lifecycle,
+     * so these are the only ids whose closure must be durably recorded (for
+     * `handle.closed` / `channel_closed`). Streams are closed directly through
+     * `subscribersByExecution`, so stream-only ids never accumulate here — a
+     * session harness closing one root id per turn stays bounded.
+     */
+    handleObserved = new Set();
+    subscribersByExecution = new Map();
     getOrCreate(channel) {
         let state = frameworkCast(this.channels.get(channel.name));
         if (!state) {
@@ -25,6 +34,7 @@ export class ChannelStore {
                 pendingSenders: [],
                 topicSubscribers: new Set(),
                 wakeSubscribers: new Set(),
+                externalSubscribers: new Set(),
             };
             this.channels.set(channel.name, frameworkCast(state));
         }
@@ -79,6 +89,9 @@ export class ChannelStore {
                         waiter.resolve(value);
                     }
                 }
+                for (const sub of state.externalSubscribers) {
+                    sub.push(value);
+                }
                 break;
             case 'queue':
                 if (state.queueWaiters.length > 0) {
@@ -96,6 +109,9 @@ export class ChannelStore {
                 for (const sub of state.topicSubscribers) {
                     sub(value);
                 }
+                for (const sub of state.externalSubscribers) {
+                    sub.push(value);
+                }
                 break;
         }
         this.fireWakes(state);
@@ -206,10 +222,9 @@ export class ChannelStore {
                 }
                 return this.waitWithTimeout(state.valueWaiters, channel.name, timeout, signal);
             case 'queue': {
-                if (state.queue.length > 0) {
-                    const head = state.queue.shift();
-                    this.promotePendingSender(state);
-                    return head;
+                const head = this.dequeueHead(state);
+                if (head) {
+                    return head.value;
                 }
                 // capacity-0 edge: senders can be parked while the queue is empty —
                 // hand the oldest parked value straight to this receiver.
@@ -268,12 +283,10 @@ export class ChannelStore {
             case 'value':
                 return state.hasValue ? state.currentValue : null;
             case 'queue': {
-                if (state.queue.length > 0) {
-                    const head = state.queue.shift();
-                    this.promotePendingSender(state);
-                    return head;
-                }
-                return null;
+                // Explicit head check (not `?? null`): a stored `undefined` must come
+                // back as `undefined`, distinguishable from the empty-queue sentinel.
+                const head = this.dequeueHead(state);
+                return head ? head.value : null;
             }
             case 'topic':
                 return null;
@@ -359,7 +372,96 @@ export class ChannelStore {
         // synchronously — nothing can park here.
         void this.send(channel, value);
     }
+    /**
+     * External-reader subscription (spec 06, External Subscriptions). Delivery
+     * by mode: `topic` is a persistent non-lossy tap (per-subscriber bounded
+     * buffer, no replay of pre-subscribe values), `queue` competes with internal
+     * `recv` waiters FIFO (external consumption frees parked senders), `value`
+     * yields the current value then conflated updates.
+     *
+     * Channel state is keyed by NAME — `executionId` bounds only the
+     * subscription's lifetime (it ends when `closeExecution(executionId)`
+     * runs; queued values present at close drain first), never which values
+     * are delivered. An id that is never closed yields an unbounded stream
+     * the caller ends with `iterator.return()`. External waiters never time
+     * out — they end via close instead. The returned iterable owns a single
+     * iterator (generator semantics): subscribe again for a second consumer.
+     */
+    subscribe(channel, executionId) {
+        if (this.closedExecutions.has(executionId)) {
+            return CLOSED_ITERABLE;
+        }
+        const state = this.getOrCreate(channel);
+        const subscriber = new ExternalSubscriber({
+            channelName: channel.name,
+            conflate: state.mode === 'value',
+            takeShared: state.mode === 'queue'
+                ? () => {
+                    const head = this.dequeueHead(state);
+                    if (head) {
+                        return head;
+                    }
+                    // capacity-0 edge: hand a parked sender's value straight over.
+                    const sender = state.pendingSenders.shift();
+                    if (!sender) {
+                        return null;
+                    }
+                    sender.resolve();
+                    return {
+                        value: sender.value,
+                    };
+                }
+                : undefined,
+            parkShared: state.mode === 'queue'
+                ? (waiter) => {
+                    state.queueWaiters.push(waiter);
+                    return () => {
+                        const idx = state.queueWaiters.indexOf(waiter);
+                        if (idx >= 0) {
+                            state.queueWaiters.splice(idx, 1);
+                        }
+                    };
+                }
+                : undefined,
+            onFinish: () => {
+                state.externalSubscribers.delete(subscriber);
+                const byExecution = this.subscribersByExecution.get(executionId);
+                if (byExecution) {
+                    byExecution.delete(erased);
+                    if (byExecution.size === 0) {
+                        this.subscribersByExecution.delete(executionId);
+                    }
+                }
+            },
+        });
+        const erased = frameworkCast(subscriber);
+        if (state.mode !== 'queue') {
+            state.externalSubscribers.add(subscriber);
+        }
+        if (state.mode === 'value' && state.hasValue) {
+            subscriber.push(state.currentValue);
+        }
+        let byExecution = this.subscribersByExecution.get(executionId);
+        if (!byExecution) {
+            byExecution = new Set();
+            this.subscribersByExecution.set(executionId, byExecution);
+        }
+        byExecution.add(erased);
+        return subscriber;
+    }
+    /** Shift the queue head and promote the oldest parked sender into the freed slot. */
+    dequeueHead(state) {
+        if (state.queue.length === 0) {
+            return null;
+        }
+        const head = state.queue.shift();
+        this.promotePendingSender(state);
+        return {
+            value: head,
+        };
+    }
     getHandle(channel, executionId) {
+        this.handleObserved.add(executionId);
         const store = this;
         return {
             get closed() {
@@ -378,6 +480,190 @@ export class ChannelStore {
         };
     }
     closeExecution(executionId) {
-        this.closedExecutions.add(executionId);
+        // Closure is durably recorded only for ids with issued handles — see
+        // `handleObserved`. Consequence: a handle taken AFTER an execution
+        // completed reads `closed === false`, and a stream subscribed after a
+        // stream-only execution completed waits instead of ending; take handles
+        // and subscribe before running.
+        if (this.handleObserved.has(executionId)) {
+            this.closedExecutions.add(executionId);
+        }
+        const subscribers = this.subscribersByExecution.get(executionId);
+        if (!subscribers) {
+            return;
+        }
+        this.subscribersByExecution.delete(executionId);
+        for (const subscriber of subscribers) {
+            subscriber.close();
+        }
+    }
+    /**
+     * A root run is (re)starting on this execution id: clear any previous
+     * closure so checkpoint-restored and sequentially re-run root contexts get
+     * working channels again instead of a permanently poisoned id.
+     */
+    openExecution(executionId) {
+        this.closedExecutions.delete(executionId);
+    }
+}
+const MAX_EXTERNAL_BUFFER = 1_000;
+const CLOSED_ITERABLE = {
+    [Symbol.asyncIterator]() {
+        return this;
+    },
+    next() {
+        return Promise.resolve({
+            value: undefined,
+            done: true,
+        });
+    },
+};
+/**
+ * The iterator behind `ChannelStore.subscribe`. Topic/value subscribers are
+ * push-fed via `push()`; queue subscribers pull from the shared queue state so
+ * they compete fairly with internal `recv` waiters. `close()` (execution
+ * completed) lets already-buffered values drain before ending; `return()`
+ * (consumer walked away) drops them.
+ */
+class ExternalSubscriber {
+    opts;
+    buffer = [];
+    waiters = [];
+    parked = [];
+    done = false;
+    /** Consumer called return(): stop pulling from the shared queue. */
+    detached = false;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    /** Deliver a value to this subscriber (topic/value modes). */
+    push(value) {
+        if (this.done) {
+            return;
+        }
+        const waiter = this.waiters.shift();
+        if (waiter) {
+            waiter({
+                value,
+                done: false,
+            });
+            return;
+        }
+        if (this.opts.conflate) {
+            this.buffer = [
+                value,
+            ];
+            return;
+        }
+        if (this.buffer.length >= MAX_EXTERNAL_BUFFER) {
+            console.warn(`[noetic] Channel '${this.opts.channelName}': external subscriber buffer at capacity (${MAX_EXTERNAL_BUFFER}), dropping oldest value.`);
+            this.buffer.shift();
+        }
+        this.buffer.push(value);
+    }
+    next() {
+        if (this.buffer.length > 0) {
+            return Promise.resolve({
+                value: this.buffer.shift(),
+                done: false,
+            });
+        }
+        // Live shared-queue reads stop at close — close() snapshots the queue
+        // into this.buffer, so a closed iterator can never steal values sent to
+        // a later execution on the same channel name.
+        const taken = this.done ? null : this.opts.takeShared?.();
+        if (taken) {
+            return Promise.resolve({
+                value: taken.value,
+                done: false,
+            });
+        }
+        if (this.done) {
+            return Promise.resolve({
+                value: undefined,
+                done: true,
+            });
+        }
+        if (this.opts.parkShared) {
+            return this.parkInSharedQueue(this.opts.parkShared);
+        }
+        return new Promise((resolve) => {
+            this.waiters.push(resolve);
+        });
+    }
+    return() {
+        this.detached = true;
+        this.buffer = [];
+        this.close();
+        return Promise.resolve({
+            value: undefined,
+            done: true,
+        });
+    }
+    /** End the iterator: settle every pending `next()` and unregister. Buffered values still drain. */
+    close() {
+        if (this.done) {
+            return;
+        }
+        // Snapshot the shared queue's current contents into the private buffer
+        // ("buffered values drain first") — after this the iterator never touches
+        // live channel state again. A detached iterator (return()) walked away
+        // and drains nothing.
+        if (!this.detached && this.opts.takeShared) {
+            for (let taken = this.opts.takeShared(); taken; taken = this.opts.takeShared()) {
+                this.buffer.push(taken.value);
+            }
+        }
+        this.done = true;
+        this.opts.onFinish();
+        for (const entry of this.parked.splice(0)) {
+            entry.unpark();
+            entry.settleDone();
+        }
+        for (const waiter of this.waiters.splice(0)) {
+            waiter({
+                value: undefined,
+                done: true,
+            });
+        }
+    }
+    /**
+     * Queue mode: wait in the channel's shared waiter FIFO. No timer attaches,
+     * so external waiters never reject with `channel_timeout` — `close()` ends
+     * them instead.
+     */
+    parkInSharedQueue(parkShared) {
+        return new Promise((resolve) => {
+            const entry = {
+                unpark: () => { },
+                settleDone: () => resolve({
+                    value: undefined,
+                    done: true,
+                }),
+            };
+            const removeParked = () => {
+                const idx = this.parked.indexOf(entry);
+                if (idx >= 0) {
+                    this.parked.splice(idx, 1);
+                }
+            };
+            entry.unpark = parkShared({
+                resolve: (value) => {
+                    removeParked();
+                    resolve({
+                        value,
+                        done: false,
+                    });
+                },
+                reject: () => {
+                    removeParked();
+                    entry.settleDone();
+                },
+            });
+            this.parked.push(entry);
+        });
     }
 }

package/dist/runtime/context-deps.d.ts

@@ -1,4 +1,4 @@
-export { buildContextMemory } from '@noetic-tools/memory';
+export { buildContextData } from '@noetic-tools/context';
 export type { ItemSchemaRegistry } from '@noetic-tools/types';
 export { defaultItemSchemaRegistry } from '@noetic-tools/types';
-export type { AgentHarnessContract, Channel, ChannelStore, Context, ContextMemory, CwdState, EventBroadcaster, FrontierFrame, FsAdapter, Item, ItemLog, LastLayerUsage, MemoryLayer, Span, StepMeta, TokenUsage, Tool, } from './context-type-deps.js';
+export type { AgentHarnessContract, Channel, ChannelStore, Context, ContextData, ContextLayer, CwdState, EventBroadcaster, FrontierFrame, FsAdapter, Item, ItemLog, LastLayerUsage, Span, StepMeta, TokenUsage, Tool, } from './context-type-deps.js';

package/dist/runtime/context-deps.js

@@ -1,2 +1,2 @@
-export { buildContextMemory } from '@noetic-tools/memory';
+export { buildContextData } from '@noetic-tools/context';
 export { defaultItemSchemaRegistry } from '@noetic-tools/types';

package/dist/runtime/context-impl.d.ts

@@ -1,4 +1,4 @@
-import type { AgentHarnessContract, Channel, ChannelStore, Context, ContextMemory, CwdState, EventBroadcaster, FrontierFrame, FsAdapter, Item, ItemLog, ItemSchemaRegistry, LastLayerUsage, MemoryLayer, Span, StepMeta, TokenUsage, Tool } from './context-deps.js';
+import type { AgentHarnessContract, Channel, ChannelStore, Context, ContextData, ContextLayer, CwdState, EventBroadcaster, FrontierFrame, FsAdapter, Item, ItemLog, ItemSchemaRegistry, LastLayerUsage, Span, StepMeta, TokenUsage, Tool } from './context-deps.js';
 import type { StepLedger } from './durable/step-ledger.js';
 /**
  * @internal
@@ -7,13 +7,13 @@ import type { StepLedger } from './durable/step-ledger.js';
  * children, so a foreign `Context` implementation yields just itself.
  */
 export declare function collectContextTree(ctx: Context): Context[];
-export declare class ContextImpl implements Context<ContextMemory> {
+export declare class ContextImpl implements Context<ContextData> {
     readonly id: string;
     stepCount: number;
     tokens: TokenUsage;
     cost: number;
     state: unknown;
-    readonly parent: Context<ContextMemory> | null;
+    readonly parent: Context<ContextData> | null;
     readonly depth: number;
     readonly span: Span;
     readonly threadId: string;
@@ -22,7 +22,7 @@ export declare class ContextImpl implements Context<ContextMemory> {
     lastStepMeta: StepMeta | null;
     lastLayerUsage: LastLayerUsage | undefined;
     readonly harness: AgentHarnessContract;
-    readonly layers?: MemoryLayer[];
+    readonly layers?: ContextLayer[];
     unifiedTools?: ReadonlyArray<Tool>;
     readonly itemSchemas?: ItemSchemaRegistry;
     readonly cwdState: CwdState;
@@ -60,7 +60,7 @@ export declare class ContextImpl implements Context<ContextMemory> {
      * @internal
      */
     private readonly _children;
-    private _memory?;
+    private _contextData?;
     /**
      * Stack of steps currently in flight on this context, most-recent last.
      * Pushed by `enterStep` at the top of `execute()` and popped by
@@ -109,7 +109,7 @@ export declare class ContextImpl implements Context<ContextMemory> {
         pathPrefix?: string;
         /** The execution's completion ledger, shared with children by reference. */
         ledger?: StepLedger;
-        layers?: MemoryLayer[];
+        layers?: ContextLayer[];
         unifiedTools?: ReadonlyArray<Tool>;
         itemSchemas?: ItemSchemaRegistry;
         cwdState?: CwdState;
@@ -118,7 +118,7 @@ export declare class ContextImpl implements Context<ContextMemory> {
          * Pre-chosen context id. When set, the ContextImpl adopts this id instead
          * of generating a fresh UUID. Used by `executeSpawn` so the child's
          * `ctx.id` matches the `executionId` keyed into the layer-state store —
-         * otherwise writes via `ctx.memory[layerId].state` land on one id while
+         * otherwise writes via `ctx.context[layerId].state` land on one id while
          * spawn's `onReturn` reads from another, silently losing the update.
          */
         id?: string;
@@ -149,7 +149,9 @@ export declare class ContextImpl implements Context<ContextMemory> {
     get fs(): FsAdapter;
     get shell(): AgentHarnessContract['shell'];
     get subprocess(): AgentHarnessContract['subprocess'];
-    get memory(): ContextMemory;
+    get context(): ContextData;
+    /** @deprecated Renamed to `context`. Returns the same object. */
+    get memory(): ContextData;
     recv<T>(ch: Channel<T>, opts?: {
         timeout?: number;
     }): Promise<T>;

package/dist/runtime/context-impl.js

@@ -1,6 +1,6 @@
-import { buildContextMemory, defaultItemSchemaRegistry } from './context-deps.js';
+import { buildContextData, defaultItemSchemaRegistry } from './context-deps.js';
 import { ItemLogImpl } from './item-log-impl.js';
-const EMPTY_MEMORY = Object.freeze({});
+const EMPTY_CONTEXT = Object.freeze({});
 class NoopSpan {
     traceId = crypto.randomUUID();
     spanId = crypto.randomUUID();
@@ -84,7 +84,7 @@ export class ContextImpl {
      * @internal
      */
     _children = new Set();
-    _memory;
+    _contextData;
     /**
      * Stack of steps currently in flight on this context, most-recent last.
      * Pushed by `enterStep` at the top of `execute()` and popped by
@@ -203,11 +203,15 @@ export class ContextImpl {
     get subprocess() {
         return this.harness.subprocess;
     }
-    get memory() {
-        if (!this._memory) {
-            this._memory = this.layers ? buildContextMemory(this.layers, this) : EMPTY_MEMORY;
+    get context() {
+        if (!this._contextData) {
+            this._contextData = this.layers ? buildContextData(this.layers, this) : EMPTY_CONTEXT;
         }
-        return this._memory;
+        return this._contextData;
+    }
+    /** @deprecated Renamed to `context`. Returns the same object. */
+    get memory() {
+        return this.context;
     }
     recv(ch, opts) {
         if (!this.channelStore) {

package/dist/runtime/context-type-deps.d.ts

@@ -1,4 +1,4 @@
-export type { ContextMemory, MemoryLayer } from '@noetic-tools/memory';
+export type { ContextData, ContextLayer } from '@noetic-tools/context';
 export type { AgentHarnessContract, Channel, Context, CwdState, FsAdapter, Item, ItemLog, LastLayerUsage, Span, StepMeta, TokenUsage, Tool, } from '@noetic-tools/types';
 export type { FrontierFrame } from '../types/checkpoint.js';
 export type { ChannelStore } from './channel-store.js';

package/dist/runtime/durable/checkpoint-store.d.ts

@@ -1,4 +1,4 @@
-import type { StorageAdapter } from '@noetic-tools/memory';
+import type { StorageAdapter } from '@noetic-tools/context';
 import type { CheckpointSnapshot } from '../../types/checkpoint.js';
 export declare const CheckpointKeys: {
     readonly ExecPrefix: "execution:";

package/dist/runtime/durable/harness-checkpoints.d.ts

@@ -1,4 +1,4 @@
-import type { LayerStateStore, MemoryLayer } from '@noetic-tools/memory';
+import type { LayerStateStore } from '@noetic-tools/context';
 import type { Context, Item, ItemSchemaRegistry, RestoreContextOptions } from '@noetic-tools/types';
 import type { EventBroadcaster } from '../event-broadcaster.js';
 import type { CheckpointStore } from './checkpoint-store.js';
@@ -29,7 +29,6 @@ export interface CheckpointHarnessHandle {
     readonly stepLedgerRetention?: StepLedgerRetention;
     readonly layerStateStore: LayerStateStore;
     readonly itemSchemas: ItemSchemaRegistry;
-    readonly _memory?: MemoryLayer[];
     createContext(opts?: RestoreCheckpointOptions & {
         items?: Item[];
         threadId?: string;
@@ -52,7 +51,7 @@ export declare function captureCheckpoint(h: CheckpointHarnessHandle, ctx: Conte
  * `null` if no snapshot is recorded for `executionId`. Layer state is
  * replayed into `layerStateStore` keyed by the original executionId so
  * the restored context observes the pre-crash state through
- * `readLayerState` and the memory projectors.
+ * `readLayerState` and the context projectors.
  *
  * `opts` carries the host's own context wiring (broadcaster, parent, state,
  * layer overrides) into the rebuilt context. A snapshot cannot round-trip live

package/dist/runtime/durable/harness-checkpoints.js

@@ -63,7 +63,7 @@ export async function captureCheckpoint(h, ctx) {
  * `null` if no snapshot is recorded for `executionId`. Layer state is
  * replayed into `layerStateStore` keyed by the original executionId so
  * the restored context observes the pre-crash state through
- * `readLayerState` and the memory projectors.
+ * `readLayerState` and the context projectors.
  *
  * `opts` carries the host's own context wiring (broadcaster, parent, state,
  * layer overrides) into the rebuilt context. A snapshot cannot round-trip live
@@ -93,7 +93,7 @@ export async function restoreFromCheckpoint(h, executionId, opts) {
     }
     const items = h.itemSchemas.parseMany(snapshot.itemLog.items);
     const cwdInit = snapshot.cwd?.current ?? undefined;
-    /* Caller wiring first, snapshot second: a host may legitimately swap the memory
+    /* Caller wiring first, snapshot second: a host may legitimately swap the context
      * layers or hang the restored execution under a new parent, but it must never be
      * able to override the identity/history the snapshot is the record of. */
     const ctx = h.createContext({
@@ -102,7 +102,6 @@ export async function restoreFromCheckpoint(h, executionId, opts) {
         threadId: snapshot.threadId,
         resourceId: snapshot.resourceId,
         cwdInit,
-        memory: opts?.memory ?? h._memory,
     });
     if (ctx instanceof ContextImpl) {
         Object.defineProperty(ctx, 'id', {

package/dist/runtime/durable/step-ledger.d.ts

@@ -17,7 +17,7 @@
  * construction — a missing entry re-runs its step, which costs work rather than
  * correctness.
  */
-import type { StorageAdapter } from '@noetic-tools/memory';
+import type { StorageAdapter } from '@noetic-tools/context';
 import { z } from 'zod';
 /** @public One completed step, keyed by its execution path. */
 export declare const StepLedgerEntrySchema: z.ZodObject<{

package/dist/runtime/durable/step-ledger.js

@@ -17,7 +17,7 @@
  * construction — a missing entry re-runs its step, which costs work rather than
  * correctness.
  */
-import { storageGetMany } from '@noetic-tools/memory';
+import { storageGetMany } from '@noetic-tools/context';
 import { NoeticConfigError } from '@noetic-tools/types';
 import { z } from 'zod';
 //#region Entry

package/dist/runtime/in-memory-storage.d.ts

@@ -1,4 +1,4 @@
-import type { StorageAdapter } from '@noetic-tools/memory';
+import type { StorageAdapter } from '@noetic-tools/context';
 /**
  * @public Process-local, Map-backed StorageAdapter.
  *

package/dist/runtime/session-runner.d.ts

@@ -16,7 +16,7 @@ export interface TurnContext {
  *  (so the runner is the single point of ExecuteInput → Item[] conversion),
  *  plus the messages being delivered this turn so the harness can honour
  *  per-turn `ExecuteOptions` (the first message's options establish
- *  resourceId/state/memory for the turn). */
+ *  resourceId/state/context for the turn). */
 export type CreateContextFn = (items: ReadonlyArray<Item>, turnId: string, messages: ReadonlyArray<QueuedMessage>) => Context;
 export interface SessionRunnerOpts {
     readonly threadId: string;

package/dist/runtime/step-registry.d.ts

@@ -1,10 +1,10 @@
-import type { ContextMemory } from '@noetic-tools/memory';
+import type { ContextData } from '@noetic-tools/context';
 import type { Step } from '@noetic-tools/types';
 /** Registry-wide step type — stored at the widest generic parameters so
  *  callers can register steps with narrower input/output types without
  *  fighting variance. The public `Step` default already uses `unknown` for
  *  the input and output parameters, matching this shape. */
-type RegisteredStep = Step<ContextMemory, unknown, unknown>;
+type RegisteredStep = Step<ContextData, unknown, unknown>;
 /**
  * @public
  * Registers a step so the subprocess adapter can look it up by id.
@@ -18,7 +18,7 @@ type RegisteredStep = Step<ContextMemory, unknown, unknown>;
  * `clearRegistry` wiring is deferred — see the tracked follow-up task on
  * the team's board (strict-registry-plus-test-clear).
  */
-export declare function registerStep<TMemory, I, O>(step: Step<TMemory, I, O>): void;
+export declare function registerStep<TContext, I, O>(step: Step<TContext, I, O>): void;
 /**
  * @public
  * Looks up a registered step by id. Returns `null` when the id is not known

package/dist/runtime/{tool-memory.d.ts → tool-context.d.ts}

@@ -1,4 +1,3 @@
-import type { AgentHarnessContract, Context, ToolExecutionContext, ToolMemory } from '@noetic-tools/types';
+import type { AgentHarnessContract, Context, ToolExecutionContext } from '@noetic-tools/types';
 import type { TurnContext } from '@openrouter/agent';
-export declare function buildToolMemory(harness: AgentHarnessContract, ctx: Context): ToolMemory;
 export declare function buildToolExecutionContext(ctx: Context, harness: AgentHarnessContract, turnContext?: TurnContext): ToolExecutionContext;