@noetic-tools/core 0.3.0 → 1.0.0

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

@@ -152,8 +152,8 @@ export declare class AgentHarness<TParams extends Record<string, unknown> = Reco
         cwdInit?: string;
         _broadcaster?: EventBroadcaster;
     }): Context;
-    send<T>(channel: Channel<T>, value: T, _ctx: Context): void;
-    recv<T>(channel: Channel<T>, _ctx: Context, opts?: {
+    send<T>(channel: Channel<T>, value: T, ctx: Context): Promise<void>;
+    recv<T>(channel: Channel<T>, ctx: Context, opts?: {
         timeout?: number;
     }): Promise<T>;
     tryRecv<T>(channel: Channel<T>, _ctx: Context): T | null;

package/dist/harness/agent-harness.js

@@ -137,7 +137,11 @@ export class AgentHarness {
         this.client = opts._testCallModel ? undefined : createClient(opts.llm);
         this.channelStore = new ChannelStore();
         this.traceExporter = opts.traceExporter ?? new NoopExporter();
-        this.layerStateStore = opts.layerStateStore ?? createLayerStateStore();
+        this.layerStateStore =
+            opts.layerStateStore ??
+                createLayerStateStore((layerId, hook, error) => {
+                    console.warn(`[noetic] memory layer '${layerId}' ${hook} error:`, error);
+                });
         this.recallCache = createRecallCache();
         this.defaultDeliveryMode = opts.defaultDeliveryMode ?? 'next-turn';
         this.streamIdleTimeoutMs = opts.streamIdleTimeoutMs ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS;
@@ -366,11 +370,19 @@ export class AgentHarness {
             cwdState: resolveContextCwdState(this.rootCwdState, opts?.parent, cwdInit),
         });
     }
-    send(channel, value, _ctx) {
-        this.channelStore.send(channel, value);
+    send(channel, value, ctx) {
+        // Internal sender: back-pressured on full queue channels. The calling
+        // context's abort signal rejects a parked send with 'cancelled'.
+        const signal = ctx instanceof ContextImpl ? ctx.abortSignal : undefined;
+        return this.channelStore.send(channel, value, {
+            signal,
+        });
     }
-    recv(channel, _ctx, opts) {
-        return this.channelStore.recv(channel, opts?.timeout);
+    recv(channel, ctx, opts) {
+        // Wire the calling context's abort signal so ctx.abort() rejects a
+        // pending recv with { kind: 'cancelled' } instead of hanging.
+        const signal = ctx instanceof ContextImpl ? ctx.abortSignal : undefined;
+        return this.channelStore.recv(channel, opts?.timeout, signal);
     }
     tryRecv(channel, _ctx) {
         return this.channelStore.tryRecv(channel);

package/dist/harness/model-call.js

@@ -400,7 +400,6 @@ export class AgentHarnessModelCaller {
             await this.executeToolRound({
                 functionCalls,
                 request,
-                roundItemSchemas,
                 allItems,
                 conversationInput,
                 round,
@@ -517,7 +516,7 @@ export class AgentHarnessModelCaller {
         };
     }
     async executeToolRound(params) {
-        const { functionCalls, request, roundItemSchemas, allItems, conversationInput } = params;
+        const { functionCalls, request, allItems, conversationInput } = params;
         params.emitIfAllowed('tool_round_started', {
             round: params.round,
             toolCount: functionCalls.length,
@@ -538,7 +537,6 @@ export class AgentHarnessModelCaller {
             await this.executeFunctionCall({
                 fc,
                 request,
-                roundItemSchemas,
                 allItems,
                 conversationInput,
                 emitIfAllowed: params.emitIfAllowed,
@@ -550,7 +548,7 @@ export class AgentHarnessModelCaller {
         });
     }
     async executeFunctionCall(params) {
-        const { fc, request, roundItemSchemas, allItems, conversationInput } = params;
+        const { fc, request, allItems, conversationInput } = params;
         params.emitIfAllowed('tool_call_started', {
             name: fc.name,
             callId: fc.callId,
@@ -563,7 +561,6 @@ export class AgentHarnessModelCaller {
             this.recordMalformedToolCall({
                 fc,
                 request,
-                roundItemSchemas,
                 allItems,
                 conversationInput,
                 emitIfAllowed: params.emitIfAllowed,
@@ -582,10 +579,13 @@ export class AgentHarnessModelCaller {
             harness: this.opts.harness,
             layers: request.layers,
         });
+        // Owner-scoped result validation: a tool's `toolResults` schemas apply
+        // only to that tool's own result items. Harness-level `opts.itemSchemas`
+        // stay global by design; sibling tools' schemas never reject this item.
         const outputItem = createToolResultItem({
             output: toolResult.output,
             callId: fc.callId,
-            roundItemSchemas,
+            roundItemSchemas: this.opts.itemSchemas.extend(toolForCall?.itemSchemas),
             tool: toolForCall,
             callItem: fc,
             args: parsedArgs,
@@ -605,13 +605,14 @@ export class AgentHarnessModelCaller {
         });
     }
     recordMalformedToolCall(params) {
-        const { fc, request, roundItemSchemas, allItems, conversationInput } = params;
+        const { fc, request, allItems, conversationInput } = params;
         const errorOutput = `Error: malformed JSON in tool arguments: ${fc.arguments}`;
         const toolForCall = request.tools?.find((tool) => tool.name === fc.name);
+        // Owner-scoped result validation (see executeFunctionCall).
         const outputItem = createToolResultItem({
             output: errorOutput,
             callId: fc.callId,
-            roundItemSchemas,
+            roundItemSchemas: this.opts.itemSchemas.extend(toolForCall?.itemSchemas),
             tool: toolForCall,
             callItem: fc,
             error: true,

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

@@ -5,6 +5,14 @@ export declare function buildItemSchemaRegistry({ base, layers, tools, }: {
     layers?: ReadonlyArray<MemoryLayer>;
     tools?: ReadonlyArray<Tool>;
 }): ItemSchemaRegistry;
+/**
+ * Build and validate a `function_call_output` item for a tool result.
+ *
+ * `roundItemSchemas` must be the OWNER-SCOPED registry for the called tool
+ * (harness base extended with only that tool's `itemSchemas`), so one tool's
+ * `toolResults` schemas never reject a sibling tool's result items. Tools
+ * without `itemSchemas` fall back to the base structural parse.
+ */
 export declare function createToolResultItem({ output, callId, roundItemSchemas, tool, callItem, args, result, error, }: {
     output: string;
     callId: string;

package/dist/harness/model-schema.js

@@ -24,6 +24,14 @@ export function buildItemSchemaRegistry({ base, layers, tools, }) {
         .extend(collectLayerItemSchemaExtensions(layers))
         .extend(collectToolItemSchemaExtensions(tools));
 }
+/**
+ * Build and validate a `function_call_output` item for a tool result.
+ *
+ * `roundItemSchemas` must be the OWNER-SCOPED registry for the called tool
+ * (harness base extended with only that tool's `itemSchemas`), so one tool's
+ * `toolResults` schemas never reject a sibling tool's result items. Tools
+ * without `itemSchemas` fall back to the base structural parse.
+ */
 export function createToolResultItem({ output, callId, roundItemSchemas, tool, callItem, args, result, error, }) {
     const baseItem = {
         id: crypto.randomUUID(),

package/dist/index.d.ts

@@ -55,7 +55,7 @@ export { execute } from './interpreter/execute.js';
 /** @public */
 /** @public */
 /** @public */
-export type { DurableTaskState, DurableTaskStateConfig, FactExtractor, FactSearcher, HistoryWindowConfig, ObservationalMemoryConfig, ObservationalState, PlanEnterSessionCallback, PlanExecutionEntry, PlanExitCallback, PlanMemoryConfig, PlanState, TemporalFact, TemporalMemoryConfig, TemporalSearchResult, WorkingMemoryConfig, WorkingMemoryState, } from '@noetic-tools/memory';
+export type { DurableTaskState, FactExtractor, FactSearcher, HistoryWindowConfig, ObservationalMemoryConfig, ObservationalState, PlanEnterSessionCallback, PlanExecutionEntry, PlanExitCallback, PlanMemoryConfig, PlanState, TemporalFact, TemporalMemoryConfig, TemporalSearchResult, WorkingMemoryConfig, WorkingMemoryState, } from '@noetic-tools/memory';
 /** @public */
 /** @public */
 /** @public */

package/dist/interpreter/execute-action.js

@@ -1,7 +1,7 @@
 /**
  * Action step handlers: run, llm, spawn, provide, tool.
  */
-import { createMessage, estimateTokens, extractAssistantText, frameworkCast, NoeticConfigError, NoeticErrorImpl, } from '@noetic-tools/types';
+import { createMessage, estimateTokens, extractAssistantText, frameworkCast, isNoeticError, NoeticConfigError, NoeticErrorImpl, } from '@noetic-tools/types';
 import { ZodError } from 'zod';
 import { allocateBudgets, assembleView, buildToolExecutionContext, ContextImpl, commitLayerUsage, computeLayerUsage, contextToExecCtx, DEFAULT_PROJECTION, defaultItemSchemaRegistry, emitFrameworkEvent, getBroadcaster, resolveLayerTools, returnLayers, snapshotCwdState, spawnLayers, } from './action-deps.js';
 import { SteeringAction } from './action-types.js';
@@ -15,10 +15,23 @@ export async function executeRun(step, input, ctx) {
     const maxAttempts = retry?.maxAttempts ?? 1;
     let lastError = new Error('No attempts executed');
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        // Cancellation is not a retriable error (spec 09) — an abort that
+        // arrived between attempts must stop the loop before re-executing.
+        if (ctx.aborted) {
+            throw new NoeticErrorImpl({
+                kind: 'cancelled',
+                reason: ctx.abortReason ?? 'context aborted',
+            });
+        }
         try {
             return await step.execute(input, ctx);
         }
         catch (e) {
+            // Rethrow cancellation immediately — retrying it would re-run side
+            // effects after abort and bury the 'cancelled' kind under step_failed.
+            if (isNoeticError(e) && e.noeticError.kind === 'cancelled') {
+                throw e;
+            }
             lastError = e instanceof Error ? e : new Error(String(e));
             if (attempt < maxAttempts - 1 && retry) {
                 const delay = computeDelay(retry, attempt);
@@ -290,6 +303,11 @@ export async function executeLLM(step, input, ctx, layers) {
                 emit: step.emit,
             };
         const response = await baseCtx.harness.callModel(request);
+        // Track tokens/cost for EVERY model call, including responses steering
+        // subsequently rejects (Deny throw / Guide retry below) — the spend is
+        // real, and until.maxCost / HarnessResponse.usage must see it (spec 07:
+        // tokens accumulate across all LLM calls).
+        trackUsage(baseCtx, response);
         if (hasLayers) {
             const decision = await baseCtx.harness.afterModelCall(layers, response, baseCtx);
             if (decision.action === SteeringAction.Deny) {
@@ -320,7 +338,6 @@ export async function executeLLM(step, input, ctx, layers) {
         if (isMutableContext(baseCtx)) {
             baseCtx.lastStepMeta = meta;
         }
-        trackUsage(baseCtx, response);
         commitLayerUsage(baseCtx, computeLayerUsage({
             ctx: baseCtx,
             modelId: resolvedModel,

package/dist/interpreter/execute-control.js

@@ -135,9 +135,46 @@ function classifyResults(settled, paths) {
     };
 }
 async function executeAll(step, paths, _input, ctx, childContexts, executeStep, concurrency) {
-    const tasks = paths.map((path, i) => () => executeStep(path, _input, frameworkCast(childContexts[i])));
+    // Fail-fast (specs 03/09): the first genuine path failure aborts every
+    // sibling child context. Cancellation is cooperative — in-flight siblings
+    // are still awaited (they stop at their next step boundary / blocked
+    // channel op) so fork_partial's succeeded/failed stay accurate; paths
+    // still queued behind the concurrency limit are skipped outright. Skipped
+    // and aborted paths appear in `failed` with kind 'cancelled'.
+    let firstFailureSeen = false;
+    const tasks = paths.map((path, i) => async () => {
+        if (firstFailureSeen) {
+            throw new NoeticErrorImpl({
+                kind: 'cancelled',
+                reason: `fork '${step.id}' sibling failed`,
+            });
+        }
+        try {
+            return await executeStep(path, _input, frameworkCast(childContexts[i]));
+        }
+        catch (e) {
+            const isCancellation = isNoeticError(e) && e.noeticError.kind === 'cancelled';
+            if (!isCancellation && !firstFailureSeen) {
+                firstFailureSeen = true;
+                for (let j = 0; j < childContexts.length; j++) {
+                    if (j !== i) {
+                        childContexts[j].abort(`fork '${step.id}' sibling failed`);
+                    }
+                }
+            }
+            throw e;
+        }
+    });
     const settled = await runWithConcurrency(tasks, concurrency);
     const { succeeded, failed } = classifyResults(settled, paths);
+    // If the PARENT context was aborted mid-fork, the whole fork is cancelled —
+    // surface 'cancelled', not a partial-failure shape (spec 09, item 3).
+    if (ctx.aborted) {
+        throw new NoeticErrorImpl({
+            kind: 'cancelled',
+            reason: ctx.abortReason ?? 'context aborted',
+        });
+    }
     if (failed.length > 0) {
         throw new NoeticErrorImpl({
             kind: 'fork_partial',
@@ -208,9 +245,17 @@ async function executeRace(step, paths, input, ctx, childContexts, executeStep,
         }
     });
 }
-async function executeSettle(step, paths, input, _ctx, childContexts, executeStep, concurrency) {
+async function executeSettle(step, paths, input, ctx, childContexts, executeStep, concurrency) {
     const tasks = paths.map((path, i) => () => executeStep(path, input, frameworkCast(childContexts[i])));
     const settled = await runWithConcurrency(tasks, concurrency);
+    // Parent aborted mid-fork: the fork is cancelled, merge never runs
+    // (spec 09, Cancellation item 3 — same rule as mode 'all').
+    if (ctx.aborted) {
+        throw new NoeticErrorImpl({
+            kind: 'cancelled',
+            reason: ctx.abortReason ?? 'context aborted',
+        });
+    }
     const results = settled.map((result, i) => {
         if (result.status === 'fulfilled') {
             return {
@@ -225,7 +270,7 @@ async function executeSettle(step, paths, input, _ctx, childContexts, executeSte
             error: toNoeticError(result.reason, paths[i].id),
         };
     });
-    return step.merge(results, _ctx);
+    return step.merge(results, ctx);
 }
 function hasTextField(value) {
     return typeof value === 'object' && value !== null && 'text' in value;
@@ -242,7 +287,11 @@ async function recvInboxWithTimeout(ctx, step) {
             timeout: step.parkTimeout,
         });
     }
-    catch {
+    catch (e) {
+        // Cancellation must terminate the loop, not read as "no message".
+        if (isNoeticError(e) && e.noeticError.kind === 'cancelled') {
+            throw e;
+        }
         // Expected: channel_timeout error when parkTimeout expires with no message.
         return null;
     }
@@ -307,6 +356,12 @@ export async function executeLoop(step, input, ctx, executeStep) {
             if (!step.onError || !isNoeticError(e)) {
                 throw e;
             }
+            // Cancellation is not a retriable error (spec 09): it must terminate
+            // the loop promptly rather than be consumed by 'retry'/'skip'. Same
+            // guard as executeEvery's 'continue' policy below.
+            if (e.noeticError.kind === 'cancelled') {
+                throw e;
+            }
             const action = step.onError(e.noeticError, ctx);
             if (action === 'retry') {
                 continue;

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

@@ -1,4 +1,14 @@
 import type { Channel, ChannelHandle, ExternalChannel } from '@noetic-tools/types';
+/** Options accepted by internal (back-pressured) `send`. */
+export interface ChannelSendOpts {
+    /**
+     * How long a sender may stay parked on a full queue before rejecting with
+     * `channel_timeout`. Default 30s; `0` disables the timeout.
+     */
+    timeout?: number;
+    /** Abort signal — rejects a parked sender with `cancelled`. */
+    signal?: AbortSignal;
+}
 export declare class ChannelStore {
     private channels;
     private closedExecutions;
@@ -9,10 +19,40 @@ export declare class ChannelStore {
      * an `unsubscribe` so the caller can detach if it cancels first.
      */
     subscribeWake<T>(channel: Channel<T>, callback: () => void): () => void;
-    send<T>(channel: Channel<T>, value: T): void;
-    recv<T>(channel: Channel<T>, timeout?: number): Promise<T>;
+    /**
+     * Internal-sender write with back-pressure (spec 06). Delivery is
+     * synchronous when possible; the returned promise only parks when a queue
+     * channel is at capacity:
+     *
+     * - **value**: store last-write-wins value, drain ALL parked recv waiters,
+     *   resolve immediately.
+     * - **queue**: hand off to a parked recv waiter or push below capacity —
+     *   resolve immediately. At capacity, park the sender FIFO until a consumer
+     *   dequeues an item; reject `channel_timeout` after `opts.timeout`
+     *   (default 30s) or `cancelled` when `opts.signal` aborts.
+     * - **topic**: deliver to current subscribers, resolve immediately.
+     *
+     * External callers use `ChannelHandle.send` (sync, drop-oldest) instead.
+     */
+    send<T>(channel: Channel<T>, value: T, opts?: ChannelSendOpts): Promise<void>;
+    /** Park an internal sender on a full queue until a slot frees (FIFO). */
+    private parkSender;
+    /**
+     * A dequeue freed a queue slot — shift the oldest parked sender's value
+     * into it (FIFO) and resolve that sender's promise.
+     */
+    private promotePendingSender;
+    /** Fire-and-reset the one-shot wake subscribers for a channel state. */
+    private fireWakes;
+    recv<T>(channel: Channel<T>, timeout?: number, signal?: AbortSignal): Promise<T>;
     tryRecv<T>(channel: Channel<T>): T | null;
     private waitWithTimeout;
+    /**
+     * External-sender write: synchronous, never back-pressured (spec 06,
+     * External Sender Back-Pressure). At capacity the OLDEST queued item is
+     * dropped (with a warning) so external callers never block.
+     */
+    private sendExternal;
     getHandle<T>(channel: ExternalChannel<T>, executionId: string): ChannelHandle<T>;
     closeExecution(executionId: string): void;
 }

package/dist/runtime/channel-store.js

@@ -1,8 +1,14 @@
 import { frameworkCast, NoeticErrorImpl } from '@noetic-tools/types';
-function isExternalChannel(ch) {
-    return 'external' in ch && ch.external === true;
-}
 const MAX_TOPIC_TIMEOUT = 300_000; // 5 minutes
+const DEFAULT_SEND_TIMEOUT = 30_000;
+const RESOLVED = Promise.resolve();
+/** Build the `cancelled` error a blocked channel operation rejects with on abort. */
+function cancelledError(signal) {
+    return new NoeticErrorImpl({
+        kind: 'cancelled',
+        reason: typeof signal.reason === 'string' ? signal.reason : undefined,
+    });
+}
 export class ChannelStore {
     channels = new Map();
     closedExecutions = new Set();
@@ -16,6 +22,7 @@ export class ChannelStore {
                 queue: [],
                 capacity: channel.capacity ?? 1_000,
                 queueWaiters: [],
+                pendingSenders: [],
                 topicSubscribers: new Set(),
                 wakeSubscribers: new Set(),
             };
@@ -39,14 +46,38 @@ export class ChannelStore {
             subscribers.delete(callback);
         };
     }
-    send(channel, value) {
+    /**
+     * Internal-sender write with back-pressure (spec 06). Delivery is
+     * synchronous when possible; the returned promise only parks when a queue
+     * channel is at capacity:
+     *
+     * - **value**: store last-write-wins value, drain ALL parked recv waiters,
+     *   resolve immediately.
+     * - **queue**: hand off to a parked recv waiter or push below capacity —
+     *   resolve immediately. At capacity, park the sender FIFO until a consumer
+     *   dequeues an item; reject `channel_timeout` after `opts.timeout`
+     *   (default 30s) or `cancelled` when `opts.signal` aborts.
+     * - **topic**: deliver to current subscribers, resolve immediately.
+     *
+     * External callers use `ChannelHandle.send` (sync, drop-oldest) instead.
+     */
+    send(channel, value, opts) {
         const state = this.getOrCreate(channel);
+        let result = RESOLVED;
         switch (state.mode) {
             case 'value':
                 state.currentValue = value;
                 state.hasValue = true;
+                // Value-mode reads are non-consuming (last-write-wins), so once
+                // hasValue flips true EVERY parked waiter must be drained — waking
+                // only one would strand the rest until channel_timeout while new
+                // recv calls succeed instantly. Splice in place: timeout timers and
+                // abort listeners close over the array identity.
                 if (state.valueWaiters.length > 0) {
-                    state.valueWaiters.shift().resolve(value);
+                    const drained = state.valueWaiters.splice(0, state.valueWaiters.length);
+                    for (const waiter of drained) {
+                        waiter.resolve(value);
+                    }
                 }
                 break;
             case 'queue':
@@ -57,13 +88,8 @@ export class ChannelStore {
                     state.queue.push(value);
                 }
                 else {
-                    // At capacity
-                    console.warn(`[noetic] Channel '${channel.name}': queue at capacity (${state.capacity}), dropping message.`);
-                    if (isExternalChannel(channel)) {
-                        state.queue.shift();
-                        state.queue.push(value);
-                    }
-                    // For internal, drop the new value
+                    // At capacity — park the sender (back-pressure).
+                    result = this.parkSender(state, channel.name, value, opts);
                 }
                 break;
             case 'topic':
@@ -72,30 +98,128 @@ export class ChannelStore {
                 }
                 break;
         }
-        if (state.wakeSubscribers.size > 0) {
-            // Swap in a fresh set before firing so a callback that re-subscribes
-            // (typical for `every` re-arming on its next iteration) lands on the
-            // new set and survives until the next send.
-            const wakers = state.wakeSubscribers;
-            state.wakeSubscribers = new Set();
-            for (const wake of wakers) {
-                wake();
+        this.fireWakes(state);
+        return result;
+    }
+    /** Park an internal sender on a full queue until a slot frees (FIFO). */
+    parkSender(state, channelName, value, opts) {
+        const timeout = opts?.timeout ?? DEFAULT_SEND_TIMEOUT;
+        const signal = opts?.signal;
+        if (signal?.aborted) {
+            return Promise.reject(cancelledError(signal));
+        }
+        return new Promise((resolve, reject) => {
+            let timer = null;
+            let removeAbortListener = null;
+            const cleanup = () => {
+                if (timer) {
+                    clearTimeout(timer);
+                }
+                removeAbortListener?.();
+            };
+            const entry = {
+                value,
+                resolve: () => {
+                    cleanup();
+                    resolve();
+                },
+                reject: (e) => {
+                    cleanup();
+                    reject(e);
+                },
+            };
+            state.pendingSenders.push(entry);
+            const removeEntry = () => {
+                const idx = state.pendingSenders.indexOf(entry);
+                if (idx < 0) {
+                    return false;
+                }
+                state.pendingSenders.splice(idx, 1);
+                return true;
+            };
+            if (timeout > 0) {
+                timer = setTimeout(() => {
+                    if (removeEntry()) {
+                        entry.reject(new NoeticErrorImpl({
+                            kind: 'channel_timeout',
+                            channelName,
+                            timeout,
+                        }));
+                    }
+                }, timeout);
             }
+            if (signal) {
+                const onAbort = () => {
+                    if (removeEntry()) {
+                        entry.reject(cancelledError(signal));
+                    }
+                };
+                signal.addEventListener('abort', onAbort, {
+                    once: true,
+                });
+                removeAbortListener = () => {
+                    signal.removeEventListener('abort', onAbort);
+                };
+            }
+        });
+    }
+    /**
+     * A dequeue freed a queue slot — shift the oldest parked sender's value
+     * into it (FIFO) and resolve that sender's promise.
+     */
+    promotePendingSender(state) {
+        if (state.pendingSenders.length === 0) {
+            return;
+        }
+        if (state.queue.length >= state.capacity) {
+            return;
+        }
+        const sender = state.pendingSenders.shift();
+        state.queue.push(sender.value);
+        sender.resolve();
+    }
+    /** Fire-and-reset the one-shot wake subscribers for a channel state. */
+    fireWakes(state) {
+        if (state.wakeSubscribers.size === 0) {
+            return;
+        }
+        // Swap in a fresh set before firing so a callback that re-subscribes
+        // (typical for `every` re-arming on its next iteration) lands on the
+        // new set and survives until the next send.
+        const wakers = state.wakeSubscribers;
+        state.wakeSubscribers = new Set();
+        for (const wake of wakers) {
+            wake();
         }
     }
-    async recv(channel, timeout = 30_000) {
+    async recv(channel, timeout = 30_000, signal) {
+        // An already-aborted context must reject promptly rather than park a
+        // waiter that nothing will ever wake (spec 09, Cancellation item 2).
+        if (signal?.aborted) {
+            throw cancelledError(signal);
+        }
         const state = this.getOrCreate(channel);
         switch (state.mode) {
             case 'value':
                 if (state.hasValue) {
                     return state.currentValue;
                 }
-                return this.waitWithTimeout(state.valueWaiters, channel.name, timeout);
-            case 'queue':
+                return this.waitWithTimeout(state.valueWaiters, channel.name, timeout, signal);
+            case 'queue': {
                 if (state.queue.length > 0) {
-                    return state.queue.shift();
+                    const head = state.queue.shift();
+                    this.promotePendingSender(state);
+                    return head;
                 }
-                return this.waitWithTimeout(state.queueWaiters, channel.name, timeout);
+                // capacity-0 edge: senders can be parked while the queue is empty —
+                // hand the oldest parked value straight to this receiver.
+                if (state.pendingSenders.length > 0) {
+                    const sender = state.pendingSenders.shift();
+                    sender.resolve();
+                    return sender.value;
+                }
+                return this.waitWithTimeout(state.queueWaiters, channel.name, timeout, signal);
+            }
             case 'topic': {
                 // Clamp timeout to prevent indefinite subscriber leaks
                 let effectiveTimeout = timeout;
@@ -104,8 +228,10 @@ export class ChannelStore {
                     effectiveTimeout = MAX_TOPIC_TIMEOUT;
                 }
                 return new Promise((resolve, reject) => {
+                    let removeAbortListener = null;
                     const timer = setTimeout(() => {
                         state.topicSubscribers.delete(handler);
+                        removeAbortListener?.();
                         reject(new NoeticErrorImpl({
                             kind: 'channel_timeout',
                             channelName: channel.name,
@@ -115,9 +241,23 @@ export class ChannelStore {
                     const handler = (value) => {
                         clearTimeout(timer);
                         state.topicSubscribers.delete(handler);
+                        removeAbortListener?.();
                         resolve(value);
                     };
                     state.topicSubscribers.add(handler);
+                    if (signal) {
+                        const onAbort = () => {
+                            clearTimeout(timer);
+                            state.topicSubscribers.delete(handler);
+                            reject(cancelledError(signal));
+                        };
+                        signal.addEventListener('abort', onAbort, {
+                            once: true,
+                        });
+                        removeAbortListener = () => {
+                            signal.removeEventListener('abort', onAbort);
+                        };
+                    }
                 });
             }
         }
@@ -127,32 +267,55 @@ export class ChannelStore {
         switch (state.mode) {
             case 'value':
                 return state.hasValue ? state.currentValue : null;
-            case 'queue':
-                return state.queue.length > 0 ? state.queue.shift() : null;
+            case 'queue': {
+                if (state.queue.length > 0) {
+                    const head = state.queue.shift();
+                    this.promotePendingSender(state);
+                    return head;
+                }
+                return null;
+            }
             case 'topic':
                 return null;
         }
     }
-    waitWithTimeout(waiters, channelName, timeout) {
+    waitWithTimeout(waiters, channelName, timeout, signal) {
         return new Promise((resolve, reject) => {
             let timer = null;
-            const wrappedResolve = (v) => {
+            let removeAbortListener = null;
+            // Symmetric cleanup: whichever path settles the waiter (delivery,
+            // timeout, abort) must release both the timer and the abort listener.
+            const cleanup = () => {
                 if (timer) {
                     clearTimeout(timer);
                 }
+                removeAbortListener?.();
+            };
+            const wrappedResolve = (v) => {
+                cleanup();
                 resolve(v);
             };
+            const wrappedReject = (e) => {
+                cleanup();
+                reject(e);
+            };
             const entry = {
                 resolve: wrappedResolve,
-                reject,
+                reject: wrappedReject,
             };
             waiters.push(entry);
+            const removeEntry = () => {
+                const idx = waiters.indexOf(entry);
+                if (idx < 0) {
+                    return false;
+                }
+                waiters.splice(idx, 1);
+                return true;
+            };
             if (timeout > 0) {
                 timer = setTimeout(() => {
-                    const idx = waiters.indexOf(entry);
-                    if (idx >= 0) {
-                        waiters.splice(idx, 1);
-                        reject(new NoeticErrorImpl({
+                    if (removeEntry()) {
+                        wrappedReject(new NoeticErrorImpl({
                             kind: 'channel_timeout',
                             channelName,
                             timeout,
@@ -160,8 +323,42 @@ export class ChannelStore {
                     }
                 }, timeout);
             }
+            if (signal) {
+                const onAbort = () => {
+                    if (removeEntry()) {
+                        wrappedReject(cancelledError(signal));
+                    }
+                };
+                signal.addEventListener('abort', onAbort, {
+                    once: true,
+                });
+                removeAbortListener = () => {
+                    signal.removeEventListener('abort', onAbort);
+                };
+            }
         });
     }
+    /**
+     * External-sender write: synchronous, never back-pressured (spec 06,
+     * External Sender Back-Pressure). At capacity the OLDEST queued item is
+     * dropped (with a warning) so external callers never block.
+     */
+    sendExternal(channel, value) {
+        const state = this.getOrCreate(channel);
+        const isFullQueue = state.mode === 'queue' &&
+            state.queueWaiters.length === 0 &&
+            state.queue.length >= state.capacity;
+        if (isFullQueue) {
+            console.warn(`[noetic] Channel '${channel.name}': queue at capacity (${state.capacity}), dropping oldest message (external sender).`);
+            state.queue.shift();
+            state.queue.push(value);
+            this.fireWakes(state);
+            return;
+        }
+        // Below capacity (or non-queue mode) the internal path resolves
+        // synchronously — nothing can park here.
+        void this.send(channel, value);
+    }
     getHandle(channel, executionId) {
         const store = this;
         return {
@@ -176,7 +373,7 @@ export class ChannelStore {
                         channelName: channel.name,
                     });
                 }
-                store.send(channel, value);
+                store.sendExternal(channel, value);
             },
         };
     }

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

@@ -34,6 +34,15 @@ export declare class ContextImpl implements Context<ContextMemory> {
     private _completed;
     private _aborted;
     private _abortReason?;
+    /**
+     * Per-context abort fan-out. `abort()` fires it so operations blocked on
+     * this context (channel `recv` waiters, parked back-pressure senders)
+     * 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.
+     */
+    private readonly _abortController;
     private _memory?;
     /**
      * Stack of steps currently in flight on this context, most-recent last.
@@ -77,7 +86,7 @@ export declare class ContextImpl implements Context<ContextMemory> {
     recv<T>(ch: Channel<T>, opts?: {
         timeout?: number;
     }): Promise<T>;
-    send<T>(ch: Channel<T>, value: T): void;
+    send<T>(ch: Channel<T>, value: T): Promise<void>;
     tryRecv<T>(ch: Channel<T>): T | null;
     checkpoint(): Promise<void>;
     complete<T>(value: T): void;
@@ -85,6 +94,13 @@ export declare class ContextImpl implements Context<ContextMemory> {
     get completionValue(): unknown;
     get abortReason(): string | undefined;
     abort(reason?: string): void;
+    /**
+     * @internal
+     * Abort signal scoped to this context. Channel operations register on it
+     * so `abort()` rejects them promptly. Not part of the public Context
+     * interface.
+     */
+    get abortSignal(): AbortSignal;
     /**
      * @internal
      * Push a frame onto the execution frontier. Called by `execute()` at the

package/dist/runtime/context-impl.js

@@ -48,6 +48,15 @@ export class ContextImpl {
     _completed = false;
     _aborted = false;
     _abortReason;
+    /**
+     * Per-context abort fan-out. `abort()` fires it so operations blocked on
+     * this context (channel `recv` waiters, parked back-pressure senders)
+     * 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.
+     */
+    _abortController = new AbortController();
     _memory;
     /**
      * Stack of steps currently in flight on this context, most-recent last.
@@ -110,13 +119,18 @@ export class ContextImpl {
         if (!this.channelStore) {
             return Promise.reject(new Error('No channel store configured'));
         }
-        return this.channelStore.recv(ch, opts?.timeout);
+        return this.channelStore.recv(ch, opts?.timeout, this._abortController.signal);
     }
     send(ch, value) {
         if (!this.channelStore) {
-            throw new Error('No channel store configured');
+            return Promise.reject(new Error('No channel store configured'));
         }
-        this.channelStore.send(ch, value);
+        // Internal sender: back-pressured on full queue channels (default 30s →
+        // channel_timeout); aborting this context rejects a parked send with
+        // 'cancelled' via the shared abort signal.
+        return this.channelStore.send(ch, value, {
+            signal: this._abortController.signal,
+        });
     }
     tryRecv(ch) {
         if (!this.channelStore) {
@@ -145,6 +159,19 @@ export class ContextImpl {
     abort(reason) {
         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.
+        this._abortController.abort(reason ?? 'context aborted');
+    }
+    /**
+     * @internal
+     * Abort signal scoped to this context. Channel operations register on it
+     * so `abort()` rejects them promptly. Not part of the public Context
+     * interface.
+     */
+    get abortSignal() {
+        return this._abortController.signal;
     }
     /**
      * @internal

package/dist/runtime/durable/stall-nudge.d.ts

@@ -5,11 +5,14 @@
  * and without the agent asking for external input — i.e. the agent
  * stopped without calling either a terminal tool or an ask-user-style
  * tool. That's a soft failure: rather than wait forever, we nudge the
- * agent once to remind it of its options. If the second turn also
- * ends in the same stalled shape we escalate: the caller-supplied
- * `onStall` callback records the escalation (task pause, metrics,
- * whatever the domain demands) and we settle the signal ourselves with
- * a canonical "stalled" outcome so the parent unwinds cleanly.
+ * agent once to remind it of its options and wait for the nudged turn
+ * to actually complete (`harness.execute` is enqueue-only, so the hook
+ * awaits `getAgentResponse` — raced against the signal — before
+ * re-checking). If the second turn also ends in the same stalled shape
+ * we escalate: the caller-supplied `onStall` callback records the
+ * escalation (task pause, metrics, whatever the domain demands) and we
+ * settle the signal ourselves with a canonical "stalled" outcome so
+ * the parent unwinds cleanly.
  *
  * The helper factors the state machine out of the loop so callers can
  * opt in per-runner. Task-specific concerns (how "pending external
@@ -74,9 +77,13 @@ export declare function createNudgeMessage(opts: CreateNudgeMessageOpts): InputM
  *   - the caller reports pending external input (`hasPendingExternal`
  *     returns true — e.g. an outstanding ask-user request).
  *
- * Otherwise it sends the nudge message via `harness.execute`, waits
- * for microtasks to flush, and re-checks the same two conditions. If
- * the agent still hasn't progressed, the hook fires `onStall` and
- * resolves the signal with `buildStalledOutcome()`.
+ * Otherwise it sends the nudge message via `harness.execute` and waits
+ * for the nudged turn to actually complete. `execute()` only enqueues
+ * the message — the turn runs asynchronously through the session
+ * runner — so the hook awaits `harness.getAgentResponse(threadId)`
+ * (raced against `signal.done` so a terminal tool that settles the
+ * signal mid-turn short-circuits the wait) before re-checking the same
+ * two conditions. If the agent still hasn't progressed, the hook fires
+ * `onStall` and resolves the signal with `buildStalledOutcome()`.
  */
 export declare function createStallNudgeHook<TOutcome>(opts: StallNudgeOpts<TOutcome>): (ctx: AfterFirstTurnContext) => Promise<void>;

package/dist/runtime/durable/stall-nudge.js

@@ -5,11 +5,14 @@
  * and without the agent asking for external input — i.e. the agent
  * stopped without calling either a terminal tool or an ask-user-style
  * tool. That's a soft failure: rather than wait forever, we nudge the
- * agent once to remind it of its options. If the second turn also
- * ends in the same stalled shape we escalate: the caller-supplied
- * `onStall` callback records the escalation (task pause, metrics,
- * whatever the domain demands) and we settle the signal ourselves with
- * a canonical "stalled" outcome so the parent unwinds cleanly.
+ * agent once to remind it of its options and wait for the nudged turn
+ * to actually complete (`harness.execute` is enqueue-only, so the hook
+ * awaits `getAgentResponse` — raced against the signal — before
+ * re-checking). If the second turn also ends in the same stalled shape
+ * we escalate: the caller-supplied `onStall` callback records the
+ * escalation (task pause, metrics, whatever the domain demands) and we
+ * settle the signal ourselves with a canonical "stalled" outcome so
+ * the parent unwinds cleanly.
  *
  * The helper factors the state machine out of the loop so callers can
  * opt in per-runner. Task-specific concerns (how "pending external
@@ -55,10 +58,14 @@ export function createNudgeMessage(opts) {
  *   - the caller reports pending external input (`hasPendingExternal`
  *     returns true — e.g. an outstanding ask-user request).
  *
- * Otherwise it sends the nudge message via `harness.execute`, waits
- * for microtasks to flush, and re-checks the same two conditions. If
- * the agent still hasn't progressed, the hook fires `onStall` and
- * resolves the signal with `buildStalledOutcome()`.
+ * Otherwise it sends the nudge message via `harness.execute` and waits
+ * for the nudged turn to actually complete. `execute()` only enqueues
+ * the message — the turn runs asynchronously through the session
+ * runner — so the hook awaits `harness.getAgentResponse(threadId)`
+ * (raced against `signal.done` so a terminal tool that settles the
+ * signal mid-turn short-circuits the wait) before re-checking the same
+ * two conditions. If the agent still hasn't progressed, the hook fires
+ * `onStall` and resolves the signal with `buildStalledOutcome()`.
  */
 export function createStallNudgeHook(opts) {
     return async (ctx) => {
@@ -72,7 +79,19 @@ export function createStallNudgeHook(opts) {
         await opts.harness.execute(opts.nudgeMessage, {
             threadId: opts.threadId,
         });
-        await Promise.resolve();
+        // Wait for the nudged turn to genuinely finish. A one-microtask wait
+        // would escalate before the agent's LLM round trip even starts —
+        // `execute()` resolves as soon as the message is enqueued. Errors from
+        // `getAgentResponse` are swallowed: a failed response fetch must not
+        // crash the hook, it just means we proceed to the stall re-check.
+        await Promise.race([
+            opts.harness
+                .getAgentResponse({
+                threadId: opts.threadId,
+            })
+                .catch(() => undefined),
+            opts.signal.done.then(() => undefined, () => undefined),
+        ]);
         if (ctx.signalSettled()) {
             return;
         }

package/dist/runtime/event-broadcaster.d.ts

@@ -45,7 +45,13 @@ export declare class EventBroadcaster {
 }
 declare class BroadcastIterator implements AsyncIterator<StreamEvent> {
     private cursor;
-    private waiter?;
+    /**
+     * Parked `next()` calls, FIFO. The AsyncIterator protocol allows pipelined
+     * `next()` calls (calling again before the previous promise settles), so a
+     * single waiter slot would orphan all but the latest call — the overwritten
+     * promises would never settle. `notify()` drains in arrival order.
+     */
+    private readonly waiters;
     private returned;
     private readonly broadcaster;
     constructor(broadcaster: EventBroadcaster);
@@ -54,6 +60,8 @@ declare class BroadcastIterator implements AsyncIterator<StreamEvent> {
     /** Called by the broadcaster when new data or completion is available. */
     notify(): void;
     next(): Promise<IteratorResult<StreamEvent>>;
+    /** Settle every parked waiter with `{ done: true }` — used on early exit. */
+    private settleWaiters;
     throw(err: Error): Promise<IteratorResult<StreamEvent>>;
     return(): Promise<IteratorResult<StreamEvent>>;
     private tryRead;

package/dist/runtime/event-broadcaster.js

@@ -101,7 +101,13 @@ export class EventBroadcaster {
 //#region BroadcastIterator
 class BroadcastIterator {
     cursor = 0;
-    waiter;
+    /**
+     * Parked `next()` calls, FIFO. The AsyncIterator protocol allows pipelined
+     * `next()` calls (calling again before the previous promise settles), so a
+     * single waiter slot would orphan all but the latest call — the overwritten
+     * promises would never settle. `notify()` drains in arrival order.
+     */
+    waiters = [];
     returned = false;
     broadcaster;
     constructor(broadcaster) {
@@ -113,20 +119,22 @@ class BroadcastIterator {
     }
     /** Called by the broadcaster when new data or completion is available. */
     notify() {
-        if (!this.waiter) {
-            return;
-        }
-        const w = this.waiter;
-        this.waiter = undefined;
-        try {
-            const result = this.tryRead();
-            if (result) {
-                w.resolve(result);
+        while (this.waiters.length > 0) {
+            let result;
+            try {
+                result = this.tryRead();
             }
-        }
-        catch (err) {
-            // Reject the waiter's promise so the error propagates through the async iterator
-            w.reject(err);
+            catch (err) {
+                // Reject so the error propagates through the async iterator. The
+                // broadcaster stays finished-with-error, so the loop drains every
+                // remaining waiter with the same rejection.
+                this.waiters.shift().reject(err);
+                continue;
+            }
+            if (!result) {
+                return;
+            }
+            this.waiters.shift().resolve(result);
         }
     }
     async next() {
@@ -136,25 +144,41 @@ class BroadcastIterator {
                 value: undefined,
             };
         }
-        const result = this.tryRead();
-        if (result) {
-            return result;
+        // Only read ahead when no one is parked — a pipelined next() must queue
+        // BEHIND earlier calls so events are handed out in FIFO order.
+        if (this.waiters.length === 0) {
+            const result = this.tryRead();
+            if (result) {
+                return result;
+            }
         }
         return new Promise((resolve, reject) => {
-            this.waiter = {
+            this.waiters.push({
                 resolve,
                 reject,
-            };
+            });
         });
     }
+    /** Settle every parked waiter with `{ done: true }` — used on early exit. */
+    settleWaiters() {
+        const drained = this.waiters.splice(0, this.waiters.length);
+        for (const waiter of drained) {
+            waiter.resolve({
+                done: true,
+                value: undefined,
+            });
+        }
+    }
     async throw(err) {
         this.returned = true;
         this.broadcaster.removeIterator(this);
+        this.settleWaiters();
         throw err;
     }
     async return() {
         this.returned = true;
         this.broadcaster.removeIterator(this);
+        this.settleWaiters();
         return {
             done: true,
             value: undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noetic-tools/core",
-  "version": "0.3.0",
+  "version": "1.0.0",
   "type": "module",
   "description": "Step primitives, interpreter, runtime, and memory layer contract for Noetic agents.",
   "license": "Apache-2.0",
@@ -64,15 +64,15 @@
     }
   },
   "dependencies": {
-    "@noetic-tools/memory": "^0.2.0",
-    "@noetic-tools/types": "^0.2.0",
+    "@noetic-tools/memory": "^1.0.1",
+    "@noetic-tools/types": "^1.0.0",
     "@openrouter/agent": "^0.6.0",
     "zod": "^4.0.0"
   },
   "scripts": {
     "build": "bunx tsc -p tsconfig.build.json && bun scripts/add-js-extensions.ts",
     "verify:esm": "bun scripts/verify-node-esm.ts",
-    "prepublishOnly": "rm -rf dist && bun run build && bun run verify:esm && bun scripts/pin-workspace-deps.ts",
+    "prepublishOnly": "rm -rf dist && bun run build && bun run verify:esm && bun scripts/pin-workspace-deps.ts && bun scripts/strip-dev-conditions.ts",
     "test": "bun test",
     "test:coverage": "bun test --coverage --coverage-reporter=text --coverage-reporter=lcov",
     "test:ci": "bun test --coverage --coverage-reporter=lcov",