@noetic-tools/core 5.8.0 → 5.9.0

package/dist/adapters/openrouter.d.ts

@@ -77,6 +77,7 @@ export declare function executeToolCall(params: ExecuteToolCallParams): Promise<
  * @param apiKey - OpenRouter API key.
  * @param embeddingModel - Model identifier (default: `'openai/text-embedding-3-small'`).
  * @returns An `EmbedFn` that produces embedding vectors for the given texts.
+ * @throws `NoeticConfigError` with code `MISSING_API_KEY` if `apiKey` is empty or omitted.
  */
 export declare function createOpenRouterEmbed(apiKey?: string, embeddingModel?: string): EmbedFn;
 export {};

package/dist/adapters/openrouter.js

@@ -407,6 +407,7 @@ export async function executeToolCall(params) {
  * @param apiKey - OpenRouter API key.
  * @param embeddingModel - Model identifier (default: `'openai/text-embedding-3-small'`).
  * @returns An `EmbedFn` that produces embedding vectors for the given texts.
+ * @throws `NoeticConfigError` with code `MISSING_API_KEY` if `apiKey` is empty or omitted.
  */
 export function createOpenRouterEmbed(apiKey, embeddingModel) {
     if (!apiKey) {

package/dist/builders/provide-builder.d.ts

@@ -12,6 +12,7 @@ import type { Step, StepReplay, StepWithContext } from '@noetic-tools/types';
  * @returns A `StepWithContext` step.
  * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
  * @throws `NoeticConfigError` with code `MISSING_CHILD_STEP` if `child` is not provided.
+ * @throws `NoeticConfigError` with code `MISSING_CONTEXT_LAYERS` if `context` is not provided.
  */
 export declare function withContext<TContext = ContextData, I = unknown, O = unknown>(opts: {
     id: string;

package/dist/builders/provide-builder.js

@@ -12,6 +12,7 @@ import { getDefaultRegistrar } from '../types/step-registrar.js';
  * @returns A `StepWithContext` step.
  * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
  * @throws `NoeticConfigError` with code `MISSING_CHILD_STEP` if `child` is not provided.
+ * @throws `NoeticConfigError` with code `MISSING_CONTEXT_LAYERS` if `context` is not provided.
  */
 export function withContext(opts) {
     if (!opts.id?.trim()) {

package/dist/builders/spawn-builder.d.ts

@@ -26,7 +26,6 @@ interface SpawnOpts<TContext, I, O> extends StepReplay<TContext, I> {
  *   can dispatch either by id.
  * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
  * @throws `NoeticConfigError` with code `MISSING_CHILD_STEP` if `child` is not provided.
- * @throws `NoeticConfigError` with code `DUPLICATE_STEP_ID` if another step with the same id is already registered.
  */
 export declare function spawn<TContext = ContextData, I = unknown, O = unknown>(opts: SpawnOpts<TContext, I, O>): StepSpawn<TContext, I, O>;
 export {};

package/dist/builders/spawn-builder.js

@@ -16,7 +16,6 @@ import { getDefaultRegistrar } from '../types/step-registrar.js';
  *   can dispatch either by id.
  * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
  * @throws `NoeticConfigError` with code `MISSING_CHILD_STEP` if `child` is not provided.
- * @throws `NoeticConfigError` with code `DUPLICATE_STEP_ID` if another step with the same id is already registered.
  */
 export function spawn(opts) {
     if (!opts.id?.trim()) {

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

@@ -83,7 +83,6 @@ export interface StepAcpAgentOpts<TContext, O, I = unknown> extends StepReplay<T
  *   adapter can dispatch it by id.
  * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
  * @throws `NoeticConfigError` with code `MISSING_EXECUTE_FUNCTION` if `execute` is not provided.
- * @throws `NoeticConfigError` with code `DUPLICATE_STEP_ID` if another step with the same id is already registered with a different body.
  */
 export declare function runCode<TContext = ContextData, I = unknown, O = unknown>(opts: RunCodeOpts<TContext, I, O>): StepRunCode<TContext, I, O>;
 /**

package/dist/builders/step-builders.js

@@ -46,7 +46,6 @@ function validateAcpAgentOpts(opts) {
  *   adapter can dispatch it by id.
  * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
  * @throws `NoeticConfigError` with code `MISSING_EXECUTE_FUNCTION` if `execute` is not provided.
- * @throws `NoeticConfigError` with code `DUPLICATE_STEP_ID` if another step with the same id is already registered with a different body.
  */
 export function runCode(opts) {
     if (!opts.id || opts.id.trim() === '') {

package/dist/builders/tool-builder.d.ts

@@ -51,6 +51,8 @@ type GeneratorToolConfig<I extends StandardSchemaV1, E extends StandardSchemaV1,
  * Accepts Zod, Valibot, or any Standard Schema v1 implementation.
  *
  * @public
+ * @throws `NoeticConfigError` with code `EMPTY_TOOL_NAME` if `name` is empty.
+ * @throws `NoeticConfigError` with code `MISSING_EXECUTE_FUNCTION` if `execute` is not provided.
  */
 export declare function tool<I extends StandardSchemaV1, O extends StandardSchemaV1>(config: ToolConfig<I, O>): Tool<I, O>;
 /**

package/dist/builders/tool-builder.js

@@ -24,6 +24,8 @@ function validateToolConfig(name, execute) {
  * Accepts Zod, Valibot, or any Standard Schema v1 implementation.
  *
  * @public
+ * @throws `NoeticConfigError` with code `EMPTY_TOOL_NAME` if `name` is empty.
+ * @throws `NoeticConfigError` with code `MISSING_EXECUTE_FUNCTION` if `execute` is not provided.
  */
 export function tool(config) {
     validateToolConfig(config.name, config.execute);

package/dist/builders/workflow-hydrator.js

@@ -16,6 +16,7 @@ import { loop } from './loop-builder.js';
 import { withContext } from './provide-builder.js';
 import { spawn } from './spawn-builder.js';
 import { callModel, runCode, step } from './step-builders.js';
+import { workflowReplayKey } from './workflow-replay-key.js';
 //#endregion
 //#region Until Predicate Hydration
 function hydrateUntilPredicate(pred) {
@@ -99,13 +100,15 @@ function hydrateCallModelNode(node, ctx) {
  * runtime still returns the codec's real value. This is the same erasure the
  * rest of the hydrator applies via `frameworkCast`.
  */
-function availableLibraries(ctx) {
-    if (!ctx.uiLibraries || ctx.uiLibraries.size === 0) {
-        return '(none)';
+/** A complete sentence naming what is registered, for a hint. */
+function registeredSentence(noun, names) {
+    const list = [
+        ...names,
+    ];
+    if (list.length === 0) {
+        return `No ${noun} are registered.`;
     }
-    return [
-        ...ctx.uiLibraries.keys(),
-    ].join(', ');
+    return `Registered ${noun}: ${list.join(', ')}.`;
 }
 function resolveOutputCodec(ref, nodeId, ctx) {
     if (!ref) {
@@ -118,7 +121,7 @@ function resolveOutputCodec(ref, nodeId, ctx) {
     throw new NoeticConfigError({
         code: 'UNKNOWN_UI_LIBRARY_REFERENCE',
         message: `UI library '${ref.library}' referenced in workflow node '${nodeId}' is not registered.`,
-        hint: `Pass output codecs via HydrationContext.uiLibraries, e.g. new Map([['${ref.library}', openUi(myLibrary)]]) from @noetic-tools/openui. Available: ${availableLibraries(ctx)}`,
+        hint: `Pass output codecs via HydrationContext.uiLibraries, e.g. new Map([['${ref.library}', openUi(myLibrary)]]) from @noetic-tools/openui. ${registeredSentence('UI libraries', ctx.uiLibraries?.keys() ?? [])}`,
     });
 }
 function hydrateInvokeToolNode(node, ctx) {
@@ -130,9 +133,7 @@ function hydrateInvokeToolNode(node, ctx) {
         throw new NoeticConfigError({
             code: 'UNKNOWN_TOOL_REFERENCE',
             message: `Tool '${node.toolName}' referenced in workflow node '${node.id}' is not registered.`,
-            hint: `Available tools: ${[
-                ...ctx.tools.keys(),
-            ].join(', ') || '(none)'}`,
+            hint: `Register '${node.toolName}' in HydrationContext.tools before hydrating. ${registeredSentence('tools', ctx.tools.keys())}`,
         });
     }
     return frameworkCast(runCode({
@@ -533,9 +534,7 @@ function resolveTools(toolNames, registry) {
             throw new NoeticConfigError({
                 code: 'UNKNOWN_TOOL_REFERENCE',
                 message: `Tool '${name}' referenced in workflow is not registered.`,
-                hint: `Available tools: ${[
-                    ...registry.keys(),
-                ].join(', ') || '(none)'}`,
+                hint: `Register '${name}' in HydrationContext.tools before hydrating. ${registeredSentence('tools', registry.keys())}`,
             });
         }
         return resolved;
@@ -772,6 +771,9 @@ export function hydrateNode(node, ctx) {
     if (node.durable !== undefined) {
         hydrated.durable = node.durable;
     }
+    if (node.replayKey !== undefined) {
+        hydrated.replayKey = workflowReplayKey(node.id, node.replayKey);
+    }
     return hydrated;
 }
 /**

package/dist/builders/workflow-replay-key.d.ts

@@ -0,0 +1,15 @@
+import type { WorkflowReplayKey } from '@noetic-tools/types';
+/**
+ * Build the `replayKey` function a JSON node's declarative `replayKey` describes
+ * (spec 26 § Replay keys). The key is `<node id>:<hash of the selected input>`: the
+ * node id keeps two different nodes that read the same input from fighting over one
+ * ledger entry, while nodes that share an id — the same worker leaf written into
+ * several paths — share entries by design.
+ *
+ * The interpreter turns a throwing `replayKey` into a warning and runs the step
+ * without replay, so the step itself never fails.
+ *
+ * @throws `NoeticConfigError` with code `INVALID_REPLAY_KEY_INPUT` from the returned
+ * function, when `from` meets an input that is not a JSON object.
+ */
+export declare function workflowReplayKey(nodeId: string, spec: WorkflowReplayKey): (input: string) => string;

package/dist/builders/workflow-replay-key.js

@@ -0,0 +1,46 @@
+import { hashString, NoeticConfigError } from '@noetic-tools/types';
+/**
+ * Build the `replayKey` function a JSON node's declarative `replayKey` describes
+ * (spec 26 § Replay keys). The key is `<node id>:<hash of the selected input>`: the
+ * node id keeps two different nodes that read the same input from fighting over one
+ * ledger entry, while nodes that share an id — the same worker leaf written into
+ * several paths — share entries by design.
+ *
+ * The interpreter turns a throwing `replayKey` into a warning and runs the step
+ * without replay, so the step itself never fails.
+ *
+ * @throws `NoeticConfigError` with code `INVALID_REPLAY_KEY_INPUT` from the returned
+ * function, when `from` meets an input that is not a JSON object.
+ */
+export function workflowReplayKey(nodeId, spec) {
+    if (spec === true) {
+        return (input) => `${nodeId}:${hashString(asText(input))}`;
+    }
+    return (input) => {
+        const fields = inputObject(input, nodeId);
+        return `${nodeId}:${hashString(JSON.stringify(spec.from.map((key) => fields[key] ?? null)))}`;
+    };
+}
+/** JSON nodes pass strings, but a `decide` answer can arrive as an object. */
+function asText(input) {
+    return typeof input === 'string' ? input : JSON.stringify(input);
+}
+function inputObject(input, nodeId) {
+    const parsed = typeof input === 'string' ? parseJson(input) : input;
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new NoeticConfigError({
+            code: 'INVALID_REPLAY_KEY_INPUT',
+            message: `Node '${nodeId}' keys replay on input properties, but its input is not a JSON object.`,
+            hint: 'Use `"replayKey": true` to key on the whole input, or feed the node a JSON object.',
+        });
+    }
+    return Object.fromEntries(Object.entries(parsed));
+}
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -223,6 +223,12 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
     private readonly initializedExecutions;
     /** Executions restored from a checkpoint: their first layer init keeps the restored state. */
     private readonly restoredExecutions;
+    /**
+     * Layer hooks still running per context. `cancel()` waits for them before
+     * `onComplete`/`dispose`, so teardown never races a half-finished `store`
+     * or `recall`. Each hook is bounded by its own timeout.
+     */
+    private readonly runningHooks;
     readonly traceExporter: TraceExporter;
     /**
      * Long-lived shared cwd state. The same reference is seeded into every
@@ -261,6 +267,13 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
     decide(request: DecideRequest): Promise<DecideResponse>;
     notifyDecision(layers: ContextLayer[], record: DecisionRecord, ctx: Context): Promise<void>;
     run<I, O>(s: Step<ContextData, I, O>, input: I, ctx: Context): Promise<O>;
+    /**
+     * Whether `step` calls a model this harness has no credentials for. Checked
+     * before any step runs so a missing provider fails fast instead of after
+     * earlier steps' side effects. Steps the walk cannot see (dynamic branches)
+     * still hit the same error lazily at their model call.
+     */
+    private lacksModelFor;
     /** Run all layer `init` hooks before the first step executes. Per spec 11,
      *  init MUST complete before any recall fires so layer state is populated. */
     private initAndRun;
@@ -353,8 +366,11 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
      */
     checkpoint(ctx: Context): Promise<void>;
     /**
-     * Rebuild a `Context` from a previously-persisted snapshot. Returns `null`
-     * if no snapshot is recorded for `executionId`. Surface a typed
+     * Rebuild a `Context` from what a previous run of `executionId` recorded: its
+     * checkpoint snapshot, its step-completion ledger, or both. Without a snapshot the
+     * context starts empty (no item log or layer state) but keeps the execution id and
+     * ledger, so recorded steps replay and the rest run fresh. Returns `null` when
+     * neither is recorded — start a fresh execution. Surface a typed
      * `NoeticConfigError(CHECKPOINT_SCHEMA_MISMATCH)` when the snapshot's
      * schema version is unrecognised — the caller is expected to discard the
      * checkpoint via `CheckpointStore.clear()` and start a fresh execution.
@@ -401,15 +417,16 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
      * `cancelled`.
      *
      * Cancellation is cooperative: a layer hook already in flight is allowed to
-     * settle, and step code that ignores `ctx.aborted` between `await`s runs to
+     * settle (up to its timeout) before that context's teardown, and step code that ignores `ctx.aborted` between `await`s runs to
      * its next boundary. Calling `cancel()` on an already-cancelled context is a
      * no-op.
      */
     cancel(ctx: Context, reason?: string): Promise<void>;
     /**
-     * Run the layer lifecycle's abort path for one cancelled context:
-     * `onComplete` with `outcome: 'aborted'`, then `dispose`. Both always run
-     * under cancellation (spec 09, Cancellation item 5).
+     * Run the layer lifecycle's abort path for one cancelled context: wait for
+     * its in-flight layer hooks to settle, then `onComplete` with
+     * `outcome: 'aborted'`, then `dispose`. Both always run under cancellation
+     * (spec 09, Cancellation item 6).
      */
     private teardownCancelledContext;
     /**
@@ -425,6 +442,8 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
     setLayerState<T>(executionId: string, layerId: string, state: T): void;
     beforeToolCall(layers: ContextLayer[], toolName: string, toolArgs: unknown, ctx: Context, callId?: string): Promise<SteeringDecision>;
     afterModelCall(layers: ContextLayer[], response: LLMResponse, ctx: Context): Promise<SteeringDecision>;
+    /** Record `hook` as running on `ctx` until it settles (see `runningHooks`). */
+    private trackHook;
     projectHistory(layers: ContextLayer[], items: ReadonlyArray<Item>, ctx: Context): Promise<ReadonlyArray<Item>>;
     runAppendPipeline(layers: ContextLayer[], items: Item[], ctx: Context): Promise<{
         items: Item[];

package/dist/harness/agent-harness.js

@@ -6,10 +6,10 @@ import { AcpSessionStore } from '../runtime/acp-session-store.js';
 import { callDecide } from './decide-call.js';
 import { createInMemoryFsAdapter, createInMemoryShellAdapter, createInMemorySubprocessAdapter, OpenRouter, OpenRouterSdk, } from './deps/adapters.js';
 import { afterModelCallLayers, allocateBudgets, assembleView, beforeToolCallLayers, completeLayers, contextToExecCtx, createContextCacheStore, createLayerStateStore, createRecallCache, DEFAULT_PROJECTION, disposeLayers, executeRerender, initLayers, notifyDecision, projectHistoryLayers, recallLayers, recallLayersAtomic, recallLayersEventual, resolveLayerTools, runAppendPipeline, storeLayers, } from './deps/context.js';
-import { collectAllTools, deduplicateTools, dispatchStepThroughAdapter, execute, prepareBandedView, } from './deps/interpreter.js';
+import { collectAllTools, deduplicateTools, dispatchStepThroughAdapter, execute, prepareBandedView, someStep, } from './deps/interpreter.js';
 import { buildItemStream, ChannelStore, ContextImpl, captureCheckpoint, clearCheckpoint, collectContextTree, createInMemoryStorage, createStepLedgerStore, filterReasoningStream, filterTextStream, resolveStepLedgerRetention, restoreFromCheckpoint, rootIdOf, SessionRunner, StepLedger, snapshotCwdState, warnToConsole, } from './deps/runtime.js';
 import { SteeringAction } from './deps/types.js';
-import { AgentHarnessModelCaller } from './model-call.js';
+import { AgentHarnessModelCaller, noLlmProviderError } from './model-call.js';
 export { createStreamIdleWatchdog } from './model-call.js';
 import { buildItemSchemaRegistry } from './model-schema.js';
 //#endregion
@@ -275,6 +275,12 @@ export class AgentHarness {
     initializedExecutions = new Set();
     /** Executions restored from a checkpoint: their first layer init keeps the restored state. */
     restoredExecutions = new Set();
+    /**
+     * Layer hooks still running per context. `cancel()` waits for them before
+     * `onComplete`/`dispose`, so teardown never races a half-finished `store`
+     * or `recall`. Each hook is bounded by its own timeout.
+     */
+    runningHooks = new WeakMap();
     traceExporter;
     /**
      * Long-lived shared cwd state. The same reference is seeded into every
@@ -363,6 +369,9 @@ export class AgentHarness {
                 hint: 'Pass `agentGraph` in constructor options, or use run() directly.',
             }));
         }
+        if (this.lacksModelFor(this.agentGraph)) {
+            return Promise.reject(noLlmProviderError());
+        }
         const threadId = options?.threadId ?? DEFAULT_THREAD_ID;
         const deliveryMode = options?.deliveryMode ?? this.defaultDeliveryMode;
         const session = this.getOrCreateSession(threadId);
@@ -552,16 +561,19 @@ export class AgentHarness {
         });
     }
     async notifyDecision(layers, record, ctx) {
-        await notifyDecision({
+        await this.trackHook(ctx, notifyDecision({
             layers,
             record,
             ctx: this.toExecCtx(ctx),
             store: this.layerStateStore,
             recallCache: this.recallCache,
-        });
+        }));
     }
     //#endregion
     async run(s, input, ctx) {
+        if (this.lacksModelFor(s)) {
+            throw noLlmProviderError();
+        }
         // Populate the unified tool pool when an embedder drives a step directly on
         // a bare `createContext()` context (the turn pipeline does this per turn).
         // Without it, steps that resolve tools dynamically from `ctx.unifiedTools`
@@ -578,6 +590,18 @@ export class AgentHarness {
         await this.ensureLayersInit(ctx);
         return this.executeClosingChannels(s, input, ctx);
     }
+    /**
+     * Whether `step` calls a model this harness has no credentials for. Checked
+     * before any step runs so a missing provider fails fast instead of after
+     * earlier steps' side effects. Steps the walk cannot see (dynamic branches)
+     * still hit the same error lazily at their model call.
+     */
+    lacksModelFor(step) {
+        if (this.client || this.callModelOverride) {
+            return false;
+        }
+        return someStep(frameworkCast(step), (s) => s.kind === 'callModel' || (s.kind === 'decide' && !this.decideOverride));
+    }
     /** Run all layer `init` hooks before the first step executes. Per spec 11,
      *  init MUST complete before any recall fires so layer state is populated. */
     async initAndRun(s, input, ctx) {
@@ -746,7 +770,7 @@ export class AgentHarness {
         });
     }
     async recallLayers(layers, input, ctx) {
-        return recallLayers({
+        return this.trackHook(ctx, recallLayers({
             layers,
             query: input,
             ctx: this.toExecCtx(ctx),
@@ -754,7 +778,7 @@ export class AgentHarness {
             budgets: this.layerBudgets(layers),
             store: this.layerStateStore,
             itemSchemas: this.itemSchemas,
-        });
+        }));
     }
     /** Allocate per-layer recall budgets from the harness projection policy. */
     layerBudgets(layers) {
@@ -771,7 +795,7 @@ export class AgentHarness {
         ]));
     }
     async recallLayersAtomic(layers, input, ctx, budgets, opts) {
-        return recallLayersAtomic({
+        return this.trackHook(ctx, recallLayersAtomic({
             layers,
             query: input,
             ctx: this.toExecCtx(ctx),
@@ -781,10 +805,10 @@ export class AgentHarness {
             itemSchemas: this.itemSchemas,
             forceAtomic: this.config.forceAtomicRecall,
             peek: opts?.peek,
-        });
+        }));
     }
     async recallLayersEventual(layers, input, ctx, budgets, opts) {
-        return recallLayersEventual({
+        return this.trackHook(ctx, recallLayersEventual({
             layers,
             query: input,
             ctx: this.toExecCtx(ctx),
@@ -795,7 +819,7 @@ export class AgentHarness {
             forceAtomic: this.config.forceAtomicRecall,
             cache: this.recallCache,
             peek: opts?.peek,
-        });
+        }));
     }
     /**
      * Compute the items array that would be sent to the model on the next turn —
@@ -870,7 +894,7 @@ export class AgentHarness {
         if (!storage) {
             return;
         }
-        await storeLayers({
+        await this.trackHook(ctx, storeLayers({
             layers,
             response,
             ctx: this.toExecCtx(ctx),
@@ -878,7 +902,7 @@ export class AgentHarness {
             store: this.layerStateStore,
             storage,
             recallCache: this.recallCache,
-        });
+        }));
     }
     async disposeLayers(layers, ctx) {
         // Drop the init guard so a deliberate dispose→run cycle re-hydrates from
@@ -914,8 +938,11 @@ export class AgentHarness {
         return captureCheckpoint(this, ctx);
     }
     /**
-     * Rebuild a `Context` from a previously-persisted snapshot. Returns `null`
-     * if no snapshot is recorded for `executionId`. Surface a typed
+     * Rebuild a `Context` from what a previous run of `executionId` recorded: its
+     * checkpoint snapshot, its step-completion ledger, or both. Without a snapshot the
+     * context starts empty (no item log or layer state) but keeps the execution id and
+     * ledger, so recorded steps replay and the rest run fresh. Returns `null` when
+     * neither is recorded — start a fresh execution. Surface a typed
      * `NoeticConfigError(CHECKPOINT_SCHEMA_MISMATCH)` when the snapshot's
      * schema version is unrecognised — the caller is expected to discard the
      * checkpoint via `CheckpointStore.clear()` and start a fresh execution.
@@ -933,11 +960,14 @@ export class AgentHarness {
      * whose `id` is already the original `executionId`.
      */
     async restore(executionId, opts) {
-        const ctx = await restoreFromCheckpoint(this, executionId, opts);
-        if (ctx) {
-            this.restoredExecutions.add(ctx.id);
+        const restored = await restoreFromCheckpoint(this, executionId, opts);
+        if (!restored) {
+            return null;
+        }
+        if (restored.fromSnapshot) {
+            this.restoredExecutions.add(executionId);
         }
-        return ctx;
+        return restored.ctx;
     }
     /**
      * Discard everything `restore(executionId)` would have used — the snapshot *and* the
@@ -971,7 +1001,7 @@ export class AgentHarness {
      * `cancelled`.
      *
      * Cancellation is cooperative: a layer hook already in flight is allowed to
-     * settle, and step code that ignores `ctx.aborted` between `await`s runs to
+     * settle (up to its timeout) before that context's teardown, and step code that ignores `ctx.aborted` between `await`s runs to
      * its next boundary. Calling `cancel()` on an already-cancelled context is a
      * no-op.
      */
@@ -993,15 +1023,17 @@ export class AgentHarness {
         }
     }
     /**
-     * Run the layer lifecycle's abort path for one cancelled context:
-     * `onComplete` with `outcome: 'aborted'`, then `dispose`. Both always run
-     * under cancellation (spec 09, Cancellation item 5).
+     * Run the layer lifecycle's abort path for one cancelled context: wait for
+     * its in-flight layer hooks to settle, then `onComplete` with
+     * `outcome: 'aborted'`, then `dispose`. Both always run under cancellation
+     * (spec 09, Cancellation item 6).
      */
     async teardownCancelledContext(ctx) {
         const layers = ctx.layers ?? [];
         if (layers.length === 0) {
             return;
         }
+        await Promise.allSettled(this.runningHooks.get(ctx) ?? []);
         await completeLayers({
             layers: [
                 ...layers,
@@ -1054,14 +1086,14 @@ export class AgentHarness {
                 action: SteeringAction.Allow,
             };
         }
-        return beforeToolCallLayers({
+        return this.trackHook(ctx, beforeToolCallLayers({
             layers,
             toolName,
             toolArgs,
             callId,
             ctx: this.toExecCtx(ctx),
             store: this.layerStateStore,
-        });
+        }));
     }
     async afterModelCall(layers, response, ctx) {
         const hasHook = layers.some((l) => l.hooks.afterModelCall);
@@ -1070,12 +1102,26 @@ export class AgentHarness {
                 action: SteeringAction.Allow,
             };
         }
-        return afterModelCallLayers({
+        return this.trackHook(ctx, afterModelCallLayers({
             layers,
             response,
             ctx: this.toExecCtx(ctx),
             store: this.layerStateStore,
-        });
+        }));
+    }
+    /** Record `hook` as running on `ctx` until it settles (see `runningHooks`). */
+    trackHook(ctx, hook) {
+        let running = this.runningHooks.get(ctx);
+        if (!running) {
+            running = new Set();
+            this.runningHooks.set(ctx, running);
+        }
+        running.add(hook);
+        const forget = () => {
+            running.delete(hook);
+        };
+        hook.then(forget, forget);
+        return hook;
     }
     async projectHistory(layers, items, ctx) {
         const hasHook = layers.some((l) => l.hooks.projectHistory);

package/dist/harness/deps/interpreter.d.ts

@@ -3,4 +3,5 @@ export { prepareBandedView } from '../../interpreter/context-assembly.js';
 export { execute } from '../../interpreter/execute.js';
 export type { DetachedSpawnOverrides } from '../../interpreter/step-dispatcher.js';
 export { dispatchStepThroughAdapter } from '../../interpreter/step-dispatcher.js';
+export { someStep } from '../../interpreter/step-walk.js';
 export { isFunctionCall } from '../../interpreter/typeguards.js';

package/dist/harness/deps/interpreter.js

@@ -2,4 +2,5 @@ export { collectAllTools, deduplicateTools } from '../../interpreter/collect-too
 export { prepareBandedView } from '../../interpreter/context-assembly.js';
 export { execute } from '../../interpreter/execute.js';
 export { dispatchStepThroughAdapter } from '../../interpreter/step-dispatcher.js';
+export { someStep } from '../../interpreter/step-walk.js';
 export { isFunctionCall } from '../../interpreter/typeguards.js';

package/dist/harness/model-call.d.ts

@@ -1,4 +1,5 @@
 import type { AgentHarnessContract, CallModelRequest, ItemSchemaRegistry, LLMResponse, TraceExporter } from '@noetic-tools/types';
+import { NoeticConfigError } from '@noetic-tools/types';
 import type { OpenRouter } from '@openrouter/agent';
 import type { MessageQueue } from '../runtime/message-queue.js';
 interface StreamIdleWatchdog {
@@ -7,6 +8,8 @@ interface StreamIdleWatchdog {
     /** Clear the pending timer. Safe to call multiple times. */
     stop: () => void;
 }
+/** @internal The error for a model call on a harness with no LLM credentials. */
+export declare function noLlmProviderError(): NoeticConfigError;
 /** @internal Create a watchdog that aborts `controller` when no
  *  {@link StreamIdleWatchdog.reset reset} is called within `timeoutMs`. When
  *  `timeoutMs <= 0`, returns an inert no-op so callers can always call `.reset()`

package/dist/harness/model-call.js

@@ -133,6 +133,14 @@ async function pipeStreamEventsToBroadcaster(opts) {
         throw err;
     }
 }
+/** @internal The error for a model call on a harness with no LLM credentials. */
+export function noLlmProviderError() {
+    return new NoeticConfigError({
+        code: 'NO_LLM_PROVIDER',
+        message: 'No LLM provider configured on this harness.',
+        hint: 'Pass `callModelDefaults: { apiKey: "..." }` (defaults to the Noetic platform) or set NOETIC_API_KEY. For direct OpenRouter, use `callModelDefaults: { provider: "openrouter", apiKey: "..." }` or set OPENROUTER_API_KEY.',
+    });
+}
 /** @internal Create a watchdog that aborts `controller` when no
  *  {@link StreamIdleWatchdog.reset reset} is called within `timeoutMs`. When
  *  `timeoutMs <= 0`, returns an inert no-op so callers can always call `.reset()`
@@ -354,11 +362,7 @@ export class AgentHarnessModelCaller {
         if (this.opts.client) {
             return this.opts.client;
         }
-        throw new NoeticConfigError({
-            code: 'NO_LLM_PROVIDER',
-            message: 'No LLM provider configured on this harness.',
-            hint: 'Pass `callModelDefaults: { apiKey: "..." }` (defaults to the Noetic platform) or set NOETIC_API_KEY. For direct OpenRouter, use `callModelDefaults: { provider: "openrouter", apiKey: "..." }` or set OPENROUTER_API_KEY.',
-        });
+        throw noLlmProviderError();
     }
     async callModel(request) {
         if (this.opts.callModelOverride) {

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

@@ -3,6 +3,6 @@ export { allocateBudgets, assembleView, churnFor, churnRate, commitLayerUsage, c
 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 { ContextImpl, laneBase } from '../runtime/context-impl.js';
 export { snapshotCwdState } from '../runtime/cwd-helpers.js';
 export { buildToolExecutionContext } from '../runtime/tool-context.js';

package/dist/interpreter/action-deps.js

@@ -1,6 +1,6 @@
 export { allocateBudgets, assembleView, churnFor, churnRate, commitLayerUsage, computeLayerUsage, contextToExecCtx, createContextCacheStore, DECISION_PROJECTION, DEFAULT_PROJECTION, lineageKey, noteCacheOutcome, openEpoch, pin, pinKey, reanchorReason, resolveCacheConfig, 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 { ContextImpl, laneBase } from '../runtime/context-impl.js';
 export { snapshotCwdState } from '../runtime/cwd-helpers.js';
 export { buildToolExecutionContext } from '../runtime/tool-context.js';