@noetic-tools/core 3.1.0 → 4.0.0

package/dist/index.js

@@ -12,6 +12,8 @@ export { createOpenRouterEmbed } from './adapters/openrouter.js';
 /** @public */
 export { channel } from './builders/channel-builder.js';
 /** @public */
+export { context } from './builders/context-builder.js';
+/** @public */
 export { branch, fork } from './builders/control-flow-builders.js';
 /** @public */
 export { every } from './builders/every.js';
@@ -20,18 +22,16 @@ export { layerData, layerFn } from './builders/layer-provides-builders.js';
 /** @public */
 export { loop } from './builders/loop-builder.js';
 /** @public */
-export { memory } from './builders/memory-builder.js';
-/** @public */
 export { provide } from './builders/provide-builder.js';
 /** @public */
 export { spawn } from './builders/spawn-builder.js';
 /** @public */
-export { step } from './builders/step-builders.js';
-/** @public */
 export { tool, toolWithGenerator } from './builders/tool-builder.js';
 /** @public */
 export { hydrateNode, hydrateWorkflow } from './builders/workflow-hydrator.js';
 /** @public */
+export { step } from './builders/workflow-step.js';
+/** @public */
 export { aiCondition, allCondition, anyCondition, embeddingMatch, otherwise, semanticRoute, semanticSwitch, when, } from './conditions/conditions.js';
 /** @public */
 export { cosineSimilarity } from './conditions/cosine-similarity.js';
@@ -58,7 +58,7 @@ export { execute } from './interpreter/execute.js';
 /** @public */
 /** @public */
 /** @public */
-export { durableTaskState, fileReference, findFunctionCall, historyWindow, observationalMemory, PlanPhase, planMemory, staticContent, steering, storageGetMany, stripUnresolvedToolCalls, temporalMemory, toolMemoryLayer, workingMemory, } from '@noetic-tools/memory';
+export { durableTaskState, fileReference, findFunctionCall, historyWindow, observationalContext, PlanPhase, planContext, staticContent, steering, storageGetMany, stripUnresolvedToolCalls, temporalContext, toolContextLayer, workingMemoryContext, } from '@noetic-tools/context';
 //#endregion
 //#region Message Utilities
 /** @public */
@@ -74,8 +74,6 @@ export { createInMemoryStorage } from './runtime/in-memory-storage.js';
 /** @public */
 export { dynamicWorkflow, parseAndRunWorkflow } from './patterns/dynamic-workflow.js';
 /** @public */
-export { FlowSchema, flowDepth, validateFlow, walkFlow } from './patterns/flow.js';
-/** @public */
 export { interview } from './patterns/interview.js';
 /** @public */
 export { adaptivePlan, compilePlan, PlanNodeSchema } from './patterns/plans.js';
@@ -88,7 +86,7 @@ export { react } from './patterns/react.js';
 /** @public */
 export { AgentHarness } from './harness/agent-harness.js';
 /** @public */
-export { CheckpointKeys, createCheckpointStore, createDetachedSignal, createNudgeMessage, createStallNudgeHook, DEFAULT_NUDGE_MESSAGE_TEXT, runnableLoop, seedFromItems, } from './runtime/durable/index.js';
+export { CheckpointKeys, createCheckpointStore, createDetachedSignal, createNudgeMessage, createStallNudgeHook, DEFAULT_NUDGE_MESSAGE_TEXT, DEFAULT_STEP_LEDGER_RETENTION, runnableLoop, seedFromItems, } from './runtime/durable/index.js';
 /** @public */
 export { getRegistry, lookupStep, registerStep } from './runtime/step-registry.js';
 //#endregion
@@ -106,7 +104,7 @@ export { DetachedStatus } from '@noetic-tools/types';
 /** @public */
 export { CheckpointSchemaVersion, CheckpointSnapshotSchema, CwdSnapshotSchema, FrontierFrameSchema, ItemLogSnapshotSchema, PendingAskUserSnapshotSchema, } from './types/checkpoint.js';
 /** @public */
-export { Slot } from '@noetic-tools/memory';
+export { Slot } from '@noetic-tools/context';
 /** @public */
 export { LedgerEntryKind, SteeringAction } from '@noetic-tools/types';
 /** @public */
@@ -122,3 +120,11 @@ export { all, any } from './until/combinators.js';
 /** @public */
 export { until } from './until/predicates.js';
 //#endregion
+//#region Deprecated aliases
+/**
+ * Pre-rename names for the context layer system — `MemoryLayer`, `memory()`,
+ * `workingMemory`, and friends. Each carries its own `@deprecated` pointer to
+ * its replacement in `./deprecated`. Removed in the next major.
+ */
+export * from './deprecated.js';
+//#endregion

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

@@ -1,8 +1,8 @@
-export type { LayerStateStore } from '@noetic-tools/memory';
-export { allocateBudgets, assembleView, commitLayerUsage, computeLayerUsage, contextToExecCtx, DEFAULT_PROJECTION, resolveLayerTools, returnLayers, spawnLayers, } from '@noetic-tools/memory';
+export type { LayerStateStore } from '@noetic-tools/context';
+export { allocateBudgets, assembleView, commitLayerUsage, computeLayerUsage, contextToExecCtx, DEFAULT_PROJECTION, resolveLayerTools, returnLayers, spawnLayers, } from '@noetic-tools/context';
 export type { ItemSchemaRegistry } from '@noetic-tools/types';
 export { defaultItemSchemaRegistry } from '@noetic-tools/types';
 export { emitFrameworkEvent, getBroadcaster, shouldEmit } from '../runtime/broadcaster-utils.js';
 export { ContextImpl } from '../runtime/context-impl.js';
 export { snapshotCwdState } from '../runtime/cwd-helpers.js';
-export { buildToolExecutionContext } from '../runtime/tool-memory.js';
+export { buildToolExecutionContext } from '../runtime/tool-context.js';

package/dist/interpreter/action-deps.js

@@ -1,6 +1,6 @@
-export { allocateBudgets, assembleView, commitLayerUsage, computeLayerUsage, contextToExecCtx, DEFAULT_PROJECTION, resolveLayerTools, returnLayers, spawnLayers, } from '@noetic-tools/memory';
+export { allocateBudgets, assembleView, commitLayerUsage, computeLayerUsage, contextToExecCtx, DEFAULT_PROJECTION, resolveLayerTools, returnLayers, spawnLayers, } from '@noetic-tools/context';
 export { defaultItemSchemaRegistry } from '@noetic-tools/types';
 export { emitFrameworkEvent, getBroadcaster, shouldEmit } from '../runtime/broadcaster-utils.js';
 export { ContextImpl } from '../runtime/context-impl.js';
 export { snapshotCwdState } from '../runtime/cwd-helpers.js';
-export { buildToolExecutionContext } from '../runtime/tool-memory.js';
+export { buildToolExecutionContext } from '../runtime/tool-context.js';

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

@@ -1,3 +1,3 @@
-export type { ContextMemory, ExecutionContext, MemoryConfig, MemoryLayer, } from '@noetic-tools/memory';
+export type { ContextConfig, ContextData, ContextLayer, ExecutionContext, } from '@noetic-tools/context';
 export type { AgentHarnessContract, Context, ContextRerenderRequest, ExecuteStepFn, FunctionCallItem, Item, ProjectionPolicy, RecallLayerOutput, RetryPolicy, ServerToolSpec, StepLLM, StepMeta, StepProvide, StepRun, StepSpawn, StepTool, Tool, } from '@noetic-tools/types';
 export { isServerToolSpec, SteeringAction } from '@noetic-tools/types';

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

@@ -9,7 +9,7 @@ import { isServerToolSpec, SteeringAction } from './action-types.js';
 import { cloneWithGuard } from './clone-guard.js';
 import { collectAllTools, deduplicateTools } from './collect-tools.js';
 import { trackUsage } from './message-helpers.js';
-import { getContextChannelStore, isFunctionCall, isMutableContext } from './typeguards.js';
+import { getContextChannelStore, isContextImpl, isFunctionCall, isMutableContext, } from './typeguards.js';
 //#region run
 export async function executeRun(step, input, ctx) {
     const retry = step.retry;
@@ -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({
@@ -400,6 +400,11 @@ export async function executeLLM(step, input, ctx, layers) {
                     ];
         }
         const _serverTools = serverToolSpecs.length > 0 ? serverToolSpecs : undefined;
+        // Cancellation reaches INSIDE the model call, not just the step boundary:
+        // the caller's abort signal stops the stream and the tool-round loop mid
+        // flight, so `ctx.abort()` / `harness.cancel()` don't wait out a long
+        // generation before taking effect (spec 09, Cancellation item 2).
+        const signal = isContextImpl(baseCtx) ? baseCtx.abortSignal : undefined;
         const request = resolvedTools
             ? {
                 model: resolvedModel,
@@ -415,6 +420,7 @@ export async function executeLLM(step, input, ctx, layers) {
                 allowedToolNames,
                 nodeId: step.id,
                 parentSpan: baseCtx.span,
+                signal,
             }
             : {
                 model: resolvedModel,
@@ -426,6 +432,7 @@ export async function executeLLM(step, input, ctx, layers) {
                 _serverTools,
                 nodeId: step.id,
                 parentSpan: baseCtx.span,
+                signal,
             };
         const response = await baseCtx.harness.callModel(request);
         // Track tokens/cost for EVERY model call, including responses steering
@@ -433,6 +440,15 @@ export async function executeLLM(step, input, ctx, layers) {
         // real, and until.maxCost / HarnessResponse.usage must see it (spec 07:
         // tokens accumulate across all LLM calls).
         trackUsage(baseCtx, response);
+        // An abort that landed mid-call returns whatever rounds completed before
+        // the signal fired. The spend is charged above, but a truncated generation
+        // is not this step's output — surface cancellation instead.
+        if (baseCtx.aborted) {
+            throw new NoeticErrorImpl({
+                kind: 'cancelled',
+                reason: baseCtx.abortReason ?? 'context aborted',
+            });
+        }
         if (hasLayers) {
             const decision = await baseCtx.harness.afterModelCall(layers, response, baseCtx);
             if (decision.action === SteeringAction.Deny) {
@@ -493,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({
@@ -547,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) {
@@ -578,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,
@@ -624,17 +640,20 @@ export async function executeSpawn(step, input, ctx, executeStep, opts) {
         if (hasLayers) {
             layerStore.cleanup(childExecutionCtx.executionId);
         }
+        // The child is settled: leave the parent's abort cascade so a parent that
+        // outlives many spawns does not retain every finished child.
+        childCtx.detachFromParent();
     }
 }
 //#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) {
@@ -649,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`.
@@ -143,21 +143,30 @@ export async function executeFork(step, input, ctx, rawExecuteStep, opts) {
         childContexts,
         opts,
     }));
-    switch (step.mode) {
-        case 'all':
-            return executeAll(step, paths, input, ctx, childContexts, executeStep, concurrency);
-        case 'race':
-            return executeRace(step, paths, input, ctx, childContexts, executeStep, concurrency);
-        case 'settle':
-            return executeSettle(step, paths, input, ctx, childContexts, executeStep, concurrency);
-        default: {
-            const _exhaustive = step;
-            throw new NoeticErrorImpl({
-                kind: 'step_failed',
-                stepId: 'unknown',
-                cause: new Error('Unknown fork mode'),
-                retriesExhausted: false,
-            });
+    try {
+        switch (step.mode) {
+            case 'all':
+                return await executeAll(step, paths, input, ctx, childContexts, executeStep, concurrency);
+            case 'race':
+                return await executeRace(step, paths, input, ctx, childContexts, executeStep, concurrency);
+            case 'settle':
+                return await executeSettle(step, paths, input, ctx, childContexts, executeStep, concurrency);
+            default: {
+                const _exhaustive = step;
+                throw new NoeticErrorImpl({
+                    kind: 'step_failed',
+                    stepId: 'unknown',
+                    cause: new Error('Unknown fork mode'),
+                    retriesExhausted: false,
+                });
+            }
+        }
+    }
+    finally {
+        // Every path has settled (or been abandoned in `race`): leave the parent's
+        // abort cascade so it retains only children that are still cancellable.
+        for (const child of childContexts) {
+            child.detachFromParent();
         }
     }
 }

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-sub-harness.js

@@ -9,7 +9,7 @@ import { ZodError } from 'zod';
 import { resolveLazy } from './execute-action.js';
 import { trackUsage } from './message-helpers.js';
 import { SubHarnessEventBridge } from './sub-harness-events.js';
-import { isFunctionCall, isMutableContext } from './typeguards.js';
+import { isContextImpl, isFunctionCall, isMutableContext } from './typeguards.js';
 //#endregion
 //#region Helpers
 function sessionStore(ctx) {
@@ -39,6 +39,14 @@ function resolveTurnText(resolvedPrompt, input) {
     }
     return typeof input === 'string' ? input : '';
 }
+/**
+ * Abort signal of the executing context, when it is a framework context. Handed
+ * to the adapter so `ctx.abort()` / `harness.cancel()` stops the coding agent's
+ * in-flight turn instead of leaving a sub-process running until it finishes.
+ */
+function abortSignalOf(ctx) {
+    return isContextImpl(ctx) ? ctx.abortSignal : undefined;
+}
 function buildRunContext(ctx) {
     return {
         cwd: ctx.cwdState.cwd,
@@ -46,6 +54,7 @@ function buildRunContext(ctx) {
         shell: ctx.shell,
         subprocess: ctx.subprocess,
         threadId: ctx.threadId,
+        signal: abortSignalOf(ctx),
     };
 }
 function toLlmResponse(result) {
@@ -108,6 +117,7 @@ async function startOrReuseSession(step, harness, ctx, baseCtx, history) {
         instructions: await resolveLazy(step.instructions, ctx),
         history,
         ctx: buildRunContext(baseCtx),
+        signal: abortSignalOf(baseCtx),
     });
     if (reuseKey) {
         store.set(reuseKey, session);
@@ -167,6 +177,9 @@ export async function executeSubHarness(step, input, ctx) {
         result = await resolution.session.doPromptTurn({
             prompt: turnText,
             emit: (part) => bridge.forward(part),
+            // Per-turn signal, so a session reused across turns is cancelled by the
+            // context running the CURRENT turn rather than the one that started it.
+            signal: abortSignalOf(baseCtx),
         });
     }
     catch (e) {
@@ -178,6 +191,14 @@ export async function executeSubHarness(step, input, ctx) {
         if (e instanceof NoeticErrorImpl) {
             throw e;
         }
+        // An adapter interrupted by the abort signal rejects with whatever its SDK
+        // throws; the context is the authority on why the turn ended.
+        if (baseCtx.aborted) {
+            throw new NoeticErrorImpl({
+                kind: 'cancelled',
+                reason: baseCtx.abortReason ?? 'context aborted',
+            });
+        }
         throw new NoeticErrorImpl({
             kind: 'step_failed',
             stepId: step.id,

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>;