@noetic-tools/core 3.1.0 → 4.0.0

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

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

package/dist/interpreter/typeguards.d.ts

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

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

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

package/dist/patterns/dynamic-workflow.js

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

package/dist/patterns/interview.d.ts

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

package/dist/patterns/plans.d.ts

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

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

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

package/dist/patterns/react.d.ts

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

package/dist/patterns/react.js

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

package/dist/portable/builders.js

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

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

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

package/dist/portable/context-layers.js

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

package/dist/portable.d.ts

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

package/dist/portable.js

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

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,12 +1,19 @@
-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';
-export declare class ContextImpl implements Context<ContextMemory> {
+/**
+ * @internal
+ * The cancellation tree rooted at `ctx`, in pre-order (a parent before its
+ * children). Reverse it to walk deepest-first. Only framework contexts track
+ * children, so a foreign `Context` implementation yields just itself.
+ */
+export declare function collectContextTree(ctx: Context): Context[];
+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;
@@ -15,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;
@@ -41,10 +48,19 @@ export declare class ContextImpl implements Context<ContextMemory> {
      * reject promptly with `{ kind: 'cancelled' }` instead of hanging until
      * their timeout (spec 09, Cancellation item 2). Each fork/spawn child
      * constructs its own ContextImpl and therefore its own controller —
-     * aborting a child never rejects the parent's waiters.
+     * aborting a child never rejects the parent's waiters, while aborting a
+     * parent DOES cascade down to every live child (see `_children`).
      */
     private readonly _abortController;
-    private _memory?;
+    /**
+     * Live child contexts (fork paths, spawn children) registered for the abort
+     * cascade. A child adds itself at construction and removes itself via
+     * `detachFromParent()` when its execution settles, so a long-lived parent
+     * driving a loop of spawns does not accumulate finished children.
+     * @internal
+     */
+    private readonly _children;
+    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
@@ -93,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;
@@ -102,17 +118,40 @@ 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;
     });
+    /**
+     * @internal
+     * Register `child` for the abort cascade. A child constructed under an
+     * already-aborted parent is aborted immediately — otherwise a spawn issued
+     * in the window between `abort()` and the interpreter noticing would run a
+     * whole sub-agent that nothing can stop.
+     */
+    private adoptChild;
+    /**
+     * @internal
+     * Leave the parent's abort cascade. Called by the interpreter when a spawn
+     * child or fork path settles — a finished child has nothing left to cancel,
+     * and holding it would leak for the remaining life of the parent.
+     */
+    detachFromParent(): void;
+    /**
+     * @internal
+     * Live child contexts, in registration order. Consumed by
+     * `AgentHarness.cancel` to walk the execution tree depth-first.
+     */
+    get children(): ReadonlyArray<ContextImpl>;
     get elapsed(): number;
     get aborted(): boolean;
     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();
@@ -9,6 +9,24 @@ class NoopSpan {
     addEvent(_name, _attributes) { }
     end() { }
 }
+/**
+ * @internal
+ * The cancellation tree rooted at `ctx`, in pre-order (a parent before its
+ * children). Reverse it to walk deepest-first. Only framework contexts track
+ * children, so a foreign `Context` implementation yields just itself.
+ */
+export function collectContextTree(ctx) {
+    const tree = [
+        ctx,
+    ];
+    if (!(ctx instanceof ContextImpl)) {
+        return tree;
+    }
+    for (const child of ctx.children) {
+        tree.push(...collectContextTree(child));
+    }
+    return tree;
+}
 export class ContextImpl {
     id;
     stepCount = 0;
@@ -54,10 +72,19 @@ export class ContextImpl {
      * reject promptly with `{ kind: 'cancelled' }` instead of hanging until
      * their timeout (spec 09, Cancellation item 2). Each fork/spawn child
      * constructs its own ContextImpl and therefore its own controller —
-     * aborting a child never rejects the parent's waiters.
+     * aborting a child never rejects the parent's waiters, while aborting a
+     * parent DOES cascade down to every live child (see `_children`).
      */
     _abortController = new AbortController();
-    _memory;
+    /**
+     * Live child contexts (fork paths, spawn children) registered for the abort
+     * cascade. A child adds itself at construction and removes itself via
+     * `detachFromParent()` when its execution settles, so a long-lived parent
+     * driving a loop of spawns does not accumulate finished children.
+     * @internal
+     */
+    _children = new Set();
+    _contextData;
     /**
      * Stack of steps currently in flight on this context, most-recent last.
      * Pushed by `enterStep` at the top of `execute()` and popped by
@@ -120,6 +147,46 @@ export class ContextImpl {
             }
         }
         this.itemLog = log;
+        // Join the parent's abort cascade last, so the child is fully constructed
+        // before an already-aborted parent aborts it.
+        if (this.parent instanceof ContextImpl) {
+            this.parent.adoptChild(this);
+        }
+    }
+    /**
+     * @internal
+     * Register `child` for the abort cascade. A child constructed under an
+     * already-aborted parent is aborted immediately — otherwise a spawn issued
+     * in the window between `abort()` and the interpreter noticing would run a
+     * whole sub-agent that nothing can stop.
+     */
+    adoptChild(child) {
+        if (this._aborted) {
+            child.abort(this._abortReason ?? 'parent context aborted');
+            return;
+        }
+        this._children.add(child);
+    }
+    /**
+     * @internal
+     * Leave the parent's abort cascade. Called by the interpreter when a spawn
+     * child or fork path settles — a finished child has nothing left to cancel,
+     * and holding it would leak for the remaining life of the parent.
+     */
+    detachFromParent() {
+        if (this.parent instanceof ContextImpl) {
+            this.parent._children.delete(this);
+        }
+    }
+    /**
+     * @internal
+     * Live child contexts, in registration order. Consumed by
+     * `AgentHarness.cancel` to walk the execution tree depth-first.
+     */
+    get children() {
+        return [
+            ...this._children,
+        ];
     }
     get elapsed() {
         return Date.now() - this._createdAt;
@@ -136,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) {
@@ -184,12 +255,26 @@ export class ContextImpl {
         return this._abortReason;
     }
     abort(reason) {
+        if (this._aborted) {
+            // Idempotent (spec 09): the first abort owns the reason, and the signal
+            // has already fired — re-firing it would be a no-op anyway.
+            return;
+        }
         this._aborted = true;
         this._abortReason = reason;
         // Reject everything blocked on this context (channel recv waiters,
-        // parked back-pressure senders) with { kind: 'cancelled' }. Idempotent —
-        // a second abort() leaves the already-aborted signal untouched.
+        // parked back-pressure senders) with { kind: 'cancelled' }.
         this._abortController.abort(reason ?? 'context aborted');
+        // Cascade to live children (fork paths, spawn children). The registry is
+        // cleared first so a child's own `detachFromParent()` during its unwind
+        // cannot mutate the set we are iterating.
+        const children = [
+            ...this._children,
+        ];
+        this._children.clear();
+        for (const child of children) {
+            child.abort(reason ?? 'parent context aborted');
+        }
     }
     /**
      * @internal

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,8 +1,8 @@
-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';
-import type { StepLedgerStore } from './step-ledger.js';
+import type { StepLedgerRetention, StepLedgerStore } from './step-ledger.js';
 /**
  * Host wiring forwarded into the context `restoreFromCheckpoint` builds.
  * `RestoreContextOptions` covers the portable fields; core widens it with the
@@ -26,9 +26,9 @@ export type RestoreCheckpointOptions = RestoreContextOptions & {
 export interface CheckpointHarnessHandle {
     readonly checkpointStore?: CheckpointStore;
     readonly stepLedgerStore?: StepLedgerStore;
+    readonly stepLedgerRetention?: StepLedgerRetention;
     readonly layerStateStore: LayerStateStore;
     readonly itemSchemas: ItemSchemaRegistry;
-    readonly _memory?: MemoryLayer[];
     createContext(opts?: RestoreCheckpointOptions & {
         items?: Item[];
         threadId?: string;
@@ -51,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
@@ -68,3 +68,16 @@ export declare function captureCheckpoint(h: CheckpointHarnessHandle, ctx: Conte
  * @internal
  */
 export declare function restoreFromCheckpoint(h: CheckpointHarnessHandle, executionId: string, opts?: RestoreCheckpointOptions): Promise<Context | null>;
+/**
+ * Discard every recovery record for one execution: the snapshot and the completion
+ * ledger. Clearing the snapshot alone would strand the ledger's shards under
+ * `execution:<id>:ledger:*` forever, since nothing else enumerates them.
+ *
+ * This is the operation a host performs when resume is no longer valid — most often
+ * because the workflow changed. Replay happens at the coarsest completed granularity,
+ * so a step edited *beneath* a recorded parent is invisible to divergence detection and
+ * the old output would be replayed over the new tree. Clear, then start fresh.
+ *
+ * @internal
+ */
+export declare function clearCheckpoint(h: CheckpointHarnessHandle, executionId: string): Promise<void>;

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', {
@@ -123,6 +122,7 @@ export async function restoreFromCheckpoint(h, executionId, opts) {
                     executionId,
                     store: h.stepLedgerStore,
                     recovered,
+                    retention: h.stepLedgerRetention,
                 }),
                 configurable: false,
                 writable: false,
@@ -133,3 +133,21 @@ export async function restoreFromCheckpoint(h, executionId, opts) {
     return ctx;
 }
 //#endregion
+//#region clearCheckpoint
+/**
+ * Discard every recovery record for one execution: the snapshot and the completion
+ * ledger. Clearing the snapshot alone would strand the ledger's shards under
+ * `execution:<id>:ledger:*` forever, since nothing else enumerates them.
+ *
+ * This is the operation a host performs when resume is no longer valid — most often
+ * because the workflow changed. Replay happens at the coarsest completed granularity,
+ * so a step edited *beneath* a recorded parent is invisible to divergence detection and
+ * the old output would be replayed over the new tree. Clear, then start fresh.
+ *
+ * @internal
+ */
+export async function clearCheckpoint(h, executionId) {
+    await h.checkpointStore?.clear(executionId);
+    await h.stepLedgerStore?.clear(executionId);
+}
+//#endregion