@noetic-tools/core 0.2.1 → 1.0.0

package/dist/interpreter/execute-control.js

@@ -1,11 +1,9 @@
 /**
  * Control-flow step handlers: branch, fork, loop, every.
  */
-import { isNoeticError, NoeticErrorImpl } from '../errors/noetic-error.js';
+import { createMessage, frameworkCast, isNoeticError, NoeticErrorImpl } from '@noetic-tools/types';
 import { ContextImpl } from '../runtime/context-impl.js';
 import { snapshotCwdState } from '../runtime/cwd-helpers.js';
-import { frameworkCast } from '../util/framework-cast.js';
-import { createMessage } from '../util/message-helpers.js';
 import { cloneWithGuard } from './clone-guard.js';
 import { getContextChannelStore, isContextImpl, isMutableContext } from './typeguards.js';
 //#region branch
@@ -137,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',
@@ -210,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 {
@@ -227,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;
@@ -244,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;
     }
@@ -309,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/interpreter/execute.d.ts

@@ -1,6 +1,5 @@
-import type { Context } from '../types/context.js';
-import type { ContextMemory } from '../types/memory.js';
-import type { Step } from '../types/step.js';
+import type { ContextMemory } from '@noetic-tools/memory';
+import type { Context, Step } from '@noetic-tools/types';
 /**
  * @internal
  * Dispatch a step at the per-kind handler level without adapter routing.

package/dist/interpreter/execute.js

@@ -1,8 +1,7 @@
-import { NoeticErrorImpl } from '../errors/noetic-error.js';
+import { frameworkCast, NoeticErrorImpl } from '@noetic-tools/types';
 import { emitFrameworkEvent, getBroadcaster, shouldEmit } from '../runtime/broadcaster-utils.js';
 import { ContextImpl } from '../runtime/context-impl.js';
 import { DetachedHandleImpl } from '../runtime/detached-handle.js';
-import { frameworkCast } from '../util/framework-cast.js';
 import { executeLLM, executeProvide, executeRun, executeSpawn, executeTool, } from './execute-action.js';
 import { executeBranch, executeEvery, executeFork, executeLoop } from './execute-control.js';
 import { isMutableContext } from './typeguards.js';

package/dist/interpreter/message-helpers.d.ts

@@ -1 +1 @@
-export { trackUsage } from '../util/message-helpers.js';
+export { trackUsage } from '@noetic-tools/types';

package/dist/interpreter/message-helpers.js

@@ -1 +1 @@
-export { trackUsage } from '../util/message-helpers.js';
+export { trackUsage } from '@noetic-tools/types';

package/dist/interpreter/step-dispatcher.d.ts

@@ -1,8 +1,5 @@
-import type { Context } from '../types/context.js';
-import type { DetachedHandle } from '../types/detached.js';
-import type { ContextMemory } from '../types/memory.js';
-import type { Step } from '../types/step.js';
-import type { SubprocessAdapter } from '../types/subprocess-adapter.js';
+import type { ContextMemory } from '@noetic-tools/memory';
+import type { Context, DetachedHandle, Step, SubprocessAdapter } from '@noetic-tools/types';
 /**
  * Resolve the subprocess adapter used for a given step dispatch.
  *

package/dist/interpreter/typeguards.d.ts

@@ -1,10 +1,9 @@
+import type { ContextMemory } from '@noetic-tools/memory';
+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 { Context } from '../types/context.js';
-import type { FunctionCallItem, Item } from '../types/items.js';
-import type { ContextMemory } from '../types/memory.js';
 import type { MutableContext } from '../types/mutable-context.js';
-export { isAssistantMessage, isOutputText, isUserMessage } from '../util/message-helpers.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;
 /**

package/dist/interpreter/typeguards.js

@@ -1,6 +1,6 @@
 import { ContextImpl } from '../runtime/context-impl.js';
 // Re-exports for backward compatibility; the pure variants live in util/.
-export { isAssistantMessage, isOutputText, isUserMessage } from '../util/message-helpers.js';
+export { isAssistantMessage, isOutputText, isUserMessage } from '@noetic-tools/types';
 export function isMutableContext(ctx) {
     // Check if the context has writable mutable fields (ContextImpl or compatible mock)
     if (ctx instanceof ContextImpl) {

package/dist/observability/span-impl.d.ts

@@ -1,4 +1,4 @@
-import type { Span } from '../types/observability.js';
+import type { Span } from '@noetic-tools/types';
 export declare class SpanImpl implements Span {
     readonly traceId: string;
     readonly spanId: string;

package/dist/observability/trace-exporter.d.ts

@@ -1,4 +1,4 @@
-import type { Span, TraceExporter } from '../types/observability.js';
+import type { Span, TraceExporter } from '@noetic-tools/types';
 import { SpanImpl } from './span-impl.js';
 /** @public No-op trace exporter that silently discards all spans. */
 export declare class NoopExporter implements TraceExporter {

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

@@ -2,11 +2,8 @@
  * Pattern that lets an LLM generate a workflow as JSON during execution,
  * then hydrates and runs it within the same harness session.
  */
-import type { Context } from '../types/context.js';
-import type { ContextMemory } from '../types/memory.js';
-import type { AgentHarnessContract } from '../types/runtime.js';
-import type { Step } from '../types/step.js';
-import type { Tool } from '../types/tool.js';
+import type { ContextMemory } from '@noetic-tools/memory';
+import type { AgentHarnessContract, Context, Step, Tool } from '@noetic-tools/types';
 /** @public Options for creating a dynamic workflow step. */
 export interface DynamicWorkflowOpts {
     model?: string;

package/dist/patterns/dynamic-workflow.js

@@ -2,11 +2,10 @@
  * Pattern that lets an LLM generate a workflow as JSON during execution,
  * then hydrates and runs it within the same harness session.
  */
+import { frameworkCast, NoeticConfigError } from '@noetic-tools/types';
 import { step } from '../builders/step-builders.js';
 import { hydrateWorkflow } from '../builders/workflow-hydrator.js';
-import { NoeticConfigError } from '../errors/noetic-config-error.js';
 import { WorkflowDocumentSchema, workflowDepth } from '../schemas/workflow.js';
-import { frameworkCast } from '../util/framework-cast.js';
 //#endregion
 //#region Constants
 const DEFAULT_MAX_DEPTH = 5;

package/dist/patterns/flow.d.ts

@@ -1,2 +1,2 @@
-export type { FlowNode, ForkFlowNode, LlmFlowNode, SequenceFlowNode, SpawnFlowNode, SubagentFlowNode, } from '../memory/flow-schema.js';
-export { FlowSchema, flowDepth, validateFlow, walkFlow } from '../memory/flow-schema.js';
+export type { FlowNode, ForkFlowNode, LlmFlowNode, SequenceFlowNode, SpawnFlowNode, SubagentFlowNode, } from '@noetic-tools/memory';
+export { FlowSchema, flowDepth, validateFlow, walkFlow } from '@noetic-tools/memory';

package/dist/patterns/flow.js

@@ -1 +1 @@
-export { FlowSchema, flowDepth, validateFlow, walkFlow } from '../memory/flow-schema.js';
+export { FlowSchema, flowDepth, validateFlow, walkFlow } from '@noetic-tools/memory';

package/dist/patterns/interview.d.ts

@@ -1,6 +1,6 @@
+import type { ContextMemory } from '@noetic-tools/memory';
+import type { Step } from '@noetic-tools/types';
 import type { ZodType } from 'zod';
-import type { ContextMemory } from '../types/memory.js';
-import type { Step } from '../types/step.js';
 /** @public Answer captured by the host for a single interview question. */
 export interface InterviewQuestionAnswer {
     questionId: string;

package/dist/patterns/interview.js

@@ -1,9 +1,9 @@
+import { frameworkCast } from '@noetic-tools/types';
 import { z } from 'zod';
 import { loop } from '../builders/loop-builder.js';
 import { step } from '../builders/step-builders.js';
 import { any } from '../until/combinators.js';
 import { until } from '../until/predicates.js';
-import { frameworkCast } from '../util/framework-cast.js';
 //#endregion
 //#region Helpers
 const DEFAULT_MAX_QUESTIONS = 8;

package/dist/patterns/plans.d.ts

@@ -1,7 +1,6 @@
+import type { ContextMemory } from '@noetic-tools/memory';
+import type { Context, ExecuteStepFn, Step } from '@noetic-tools/types';
 import { z } from 'zod';
-import type { Context } from '../types/context.js';
-import type { ContextMemory } from '../types/memory.js';
-import type { ExecuteStepFn, Step } from '../types/step.js';
 export interface PlanNode {
     id: string;
     description: string;

package/dist/patterns/plans.js

@@ -1,6 +1,6 @@
+import { frameworkCast } from '@noetic-tools/types';
 import { z } from 'zod';
 import { fork } from '../builders/control-flow-builders.js';
-import { frameworkCast } from '../util/framework-cast.js';
 // PlanNode schema — the variable annotation provides the recursive type;
 // z.lazy() returns a compatible type that TypeScript checks against it.
 /** @public Zod schema for recursive `PlanNode` validation. */

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

@@ -1,6 +1,5 @@
-import type { ContextMemory } from '../types/memory.js';
-import type { StepLoop } from '../types/step.js';
-import type { Tool } from '../types/tool.js';
+import type { ContextMemory } from '@noetic-tools/memory';
+import type { StepLoop, Tool } from '@noetic-tools/types';
 import type { VerifyFn } from '../until/predicates.js';
 /**
  * Creates a retry-with-feedback loop wrapping a ReAct agent. Each iteration spawns an inner agent

package/dist/patterns/react.d.ts

@@ -1,6 +1,5 @@
-import type { ContextMemory, MemoryConfig, MemoryLayer } from '../types/memory.js';
-import type { StepLoop, StepSpawn } from '../types/step.js';
-import type { Tool } from '../types/tool.js';
+import type { ContextMemory, MemoryConfig, MemoryLayer } from '@noetic-tools/memory';
+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.
  *

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

@@ -1,14 +1,8 @@
 /** @public */
-export { durableTaskState } from '../memory/layers/durable-task-state.js';
 /** @public */
-export { historyWindow } from '../memory/layers/history-window.js';
 /** @public */
-export { observationalMemory } from '../memory/layers/observational-memory.js';
 /** @public */
-export { planMemory } from '../memory/layers/plan.js';
 /** @public */
-export { temporalMemory } from '../memory/layers/temporal.js';
 /** @public */
-export { toolMemoryLayer } from '../memory/layers/tool-memory-layer.js';
 /** @public */
-export { workingMemory } from '../memory/layers/working-memory.js';
+export { durableTaskState, historyWindow, observationalMemory, planMemory, temporalMemory, toolMemoryLayer, workingMemory, } from '@noetic-tools/memory';

package/dist/portable/memory-layers.js

@@ -1,14 +1,8 @@
 /** @public */
-export { durableTaskState } from '../memory/layers/durable-task-state.js';
 /** @public */
-export { historyWindow } from '../memory/layers/history-window.js';
 /** @public */
-export { observationalMemory } from '../memory/layers/observational-memory.js';
 /** @public */
-export { planMemory } from '../memory/layers/plan.js';
 /** @public */
-export { temporalMemory } from '../memory/layers/temporal.js';
 /** @public */
-export { toolMemoryLayer } from '../memory/layers/tool-memory-layer.js';
 /** @public */
-export { workingMemory } from '../memory/layers/working-memory.js';
+export { durableTaskState, historyWindow, observationalMemory, planMemory, temporalMemory, toolMemoryLayer, workingMemory, } from '@noetic-tools/memory';

package/dist/portable.d.ts

@@ -1,8 +1,8 @@
+/** @public */
+export { Slot } from '@noetic-tools/memory';
 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/runtime.js';
 export * from './portable/until.js';
-/** @public */
-export { Slot } from './types/memory.js';

package/dist/portable.js

@@ -1,8 +1,8 @@
+/** @public */
+export { Slot } from '@noetic-tools/memory';
 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/runtime.js';
 export * from './portable/until.js';
-/** @public */
-export { Slot } from './types/memory.js';

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

@@ -1,4 +1,4 @@
-import type { Context } from '../types/context.js';
+import type { Context } from '@noetic-tools/types';
 import type { EventBroadcaster } from './event-broadcaster.js';
 /** @internal Option controlling framework event emission on a step or callModel request. */
 export type EmitOption = boolean | ((eventType: string, data: Record<string, unknown>) => boolean);

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

@@ -1,4 +1,14 @@
-import type { Channel, ChannelHandle, ExternalChannel } from '../types/channel.js';
+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;
 }