@noetic-tools/core 5.3.0 → 5.4.0

package/dist/interpreter/execute-control.js

@@ -1,5 +1,5 @@
 /**
- * Control-flow step handlers: branch, fork, loop, every.
+ * Control-flow step handlers: conditional, inParallel, loop, schedule.
  */
 import { createMessage, frameworkCast, isNoeticError, NoeticErrorImpl } from '@noetic-tools/types';
 import { ContextImpl } from '../runtime/context-impl.js';
@@ -7,18 +7,18 @@ import { snapshotCwdState } from '../runtime/cwd-helpers.js';
 import { contextToExecCtx, returnLayers, spawnLayers } from './action-deps.js';
 import { cloneWithGuard } from './clone-guard.js';
 import { getContextChannelStore, isContextImpl, isMutableContext } from './typeguards.js';
-//#region branch
-export async function executeBranch(step, input, ctx, executeStep) {
+//#region conditional
+export async function executeConditional(step, input, ctx, executeStep) {
     const selected = await step.route(input, ctx);
     if (selected === null) {
-        // Requires I assignable to O for null route — when no branch is selected,
+        // Requires I assignable to O for null route — when no route is selected,
         // the input passes through. Callers must ensure I is compatible with O.
         return frameworkCast(input);
     }
     return executeStep(selected, input, ctx);
 }
 //#endregion
-//#region fork
+//#region inParallel
 function createChildContexts(ctx, count, stepId) {
     const threadId = isContextImpl(ctx) ? ctx.threadId : crypto.randomUUID();
     const resourceId = isContextImpl(ctx) ? ctx.resourceId : undefined;
@@ -43,8 +43,8 @@ function createChildContexts(ctx, count, stepId) {
         resourceId,
         channelStore,
         cwdState: snapshotCwdState(ctx),
-        // Layers and the harness tool pool cross the fork boundary: without
-        // them an `llm` step inside a path would run with no context
+        // Layers and the harness tool pool cross the inParallel boundary: without
+        // them a `callModel` step inside a path would run with no context
         // projection and no layer tools, and a nested `spawn` would have no
         // parent layers to inherit. Per-path layer STATE is still isolated —
         // see `createForkLayerBridge`.
@@ -93,7 +93,7 @@ function createForkLayerBridge({ ctx, childContexts, opts, }) {
 }
 /**
  * Wraps the interpreter's `executeStep` so every forked path runs inside the
- * layer child boundary. Contexts that are not one of this fork's children
+ * layer child boundary. Contexts that are not one of this inParallel's children
  * (nested steps within a path) pass straight through.
  */
 function withForkLayers(executeStep, childContexts, bridge) {
@@ -119,7 +119,7 @@ function withForkLayers(executeStep, childContexts, bridge) {
         }
     };
 }
-export async function executeFork(step, input, ctx, rawExecuteStep, opts) {
+export async function executeInParallel(step, input, ctx, rawExecuteStep, opts) {
     const baseCtx = frameworkCast(ctx);
     const paths = step.paths(input, ctx);
     if (paths.length === 0) {
@@ -156,7 +156,7 @@ export async function executeFork(step, input, ctx, rawExecuteStep, opts) {
                 throw new NoeticErrorImpl({
                     kind: 'step_failed',
                     stepId: 'unknown',
-                    cause: new Error('Unknown fork mode'),
+                    cause: new Error('Unknown inParallel mode'),
                     retriesExhausted: false,
                 });
             }
@@ -242,7 +242,7 @@ async function executeAll(step, paths, _input, ctx, childContexts, executeStep,
         if (firstFailureSeen) {
             throw new NoeticErrorImpl({
                 kind: 'cancelled',
-                reason: `fork '${step.id}' sibling failed`,
+                reason: `inParallel '${step.id}' sibling failed`,
             });
         }
         try {
@@ -254,7 +254,7 @@ async function executeAll(step, paths, _input, ctx, childContexts, executeStep,
                 firstFailureSeen = true;
                 for (let j = 0; j < childContexts.length; j++) {
                     if (j !== i) {
-                        childContexts[j].abort(`fork '${step.id}' sibling failed`);
+                        childContexts[j].abort(`inParallel '${step.id}' sibling failed`);
                     }
                 }
             }
@@ -263,7 +263,7 @@ async function executeAll(step, paths, _input, ctx, childContexts, executeStep,
     });
     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 —
+    // If the PARENT context was aborted mid-inParallel, the whole inParallel is cancelled —
     // surface 'cancelled', not a partial-failure shape (spec 09, item 3).
     if (ctx.aborted) {
         throw new NoeticErrorImpl({
@@ -344,7 +344,7 @@ async function executeRace(step, paths, input, ctx, childContexts, executeStep,
 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
+    // Parent aborted mid-inParallel: the inParallel is cancelled, merge never runs
     // (spec 09, Cancellation item 3 — same rule as mode 'all').
     if (ctx.aborted) {
         throw new NoeticErrorImpl({
@@ -454,7 +454,7 @@ export async function executeLoop(step, input, ctx, executeStep) {
             }
             // 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.
+            // guard as executeSchedule's 'continue' policy below.
             if (e.noeticError.kind === 'cancelled') {
                 throw e;
             }
@@ -554,7 +554,7 @@ function nextParkMs(ms, jitter) {
     return value;
 }
 /**
- * Parks for `ms` ms, returning early if `wakeOn` receives a message or the
+ * Parks for `ms` ms, returning early if `inbox` receives a message or the
  * context is aborted. Always resolves; never throws (cancellation surfaces on
  * the next iteration's abort check).
  */
@@ -591,7 +591,7 @@ function park(parkCtx) {
                 settle();
             }
         }, 5);
-        if (!parkCtx.wakeOn) {
+        if (!parkCtx.inbox) {
             return;
         }
         const { channelStore } = parkCtx;
@@ -599,13 +599,13 @@ function park(parkCtx) {
             // Non-consuming subscription so the body still observes the message that
             // woke us — `recv()` would dequeue queue-mode messages and leave the
             // body's drain loop empty.
-            wakeUnsub = channelStore.subscribeWake(parkCtx.wakeOn, settle);
+            wakeUnsub = channelStore.subscribeWake(parkCtx.inbox, settle);
             return;
         }
         // Contexts without a ContextImpl/channel store have no body draining the
         // channel anyway; the destructive `recv` is acceptable in that edge case.
         parkCtx.ctx
-            .recv(parkCtx.wakeOn, {
+            .recv(parkCtx.inbox, {
             timeout: Math.max(duration, 1) + 1e2,
         })
             .then(settle)
@@ -617,7 +617,7 @@ function park(parkCtx) {
 function recordIterationError(ctx, error) {
     const message = error instanceof Error ? error.message : String(error);
     const stack = error instanceof Error && error.stack ? error.stack : '';
-    ctx.span.addEvent('every.iteration.error', {
+    ctx.span.addEvent('schedule.iteration.error', {
         message,
         stack,
     });
@@ -629,18 +629,18 @@ function throwCancelled(reason) {
     });
 }
 /**
- * Executes an `every` step: runs the body step forever, paced by `ms ± jitter`,
- * woken early by `wakeOn`. Throws `cancelled` when the context is aborted.
+ * Executes a `schedule` step: runs the body step forever, paced by `ms ± jitter`,
+ * woken early by `inbox`. Throws `cancelled` when the context is aborted.
  *
  * On body throw, behavior depends on `onError`:
- * - `'continue'` (default): emit `every.iteration.error` span event and proceed
+ * - `'continue'` (default): emit `schedule.iteration.error` span event and proceed
  *   to the park step as if no error occurred.
  * - `'fail'`: re-throw, terminating the operator.
  *
- * The body's output is discarded — `every` runs forever and does not accumulate
+ * The body's output is discarded — `schedule` runs forever and does not accumulate
  * iteration outputs. Only ever returns by throwing on cancellation or `fail`.
  */
-export async function executeEvery(step, input, ctx, executeStep) {
+export async function executeSchedule(step, input, ctx, executeStep) {
     const onError = step.onError ?? 'continue';
     const jitter = step.jitter ?? 0;
     // Resolve once — the channel store reference is stable for the lifetime
@@ -668,9 +668,9 @@ export async function executeEvery(step, input, ctx, executeStep) {
             throwCancelled(ctx.abortReason);
         }
         await park({
-            ms: step.ms,
+            ms: step.interval,
             jitter,
-            wakeOn: step.wakeOn,
+            inbox: step.inbox,
             ctx,
             channelStore,
         });

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

@@ -2,7 +2,7 @@
  * SubHarness step handler: drives an external coding-agent harness
  * (Claude Code, Codex, opencode, pi) for one agentic turn and folds its output
  * back into the Noetic execution context — the harness analogue of
- * `executeLLM`.
+ * `executeCallModel`.
  */
 import type { Context, StepSubHarness } from '@noetic-tools/types';
 export declare function executeSubHarness<TContext, I, O>(step: StepSubHarness<TContext, I, O>, input: I, ctx: Context<TContext>): Promise<O>;

package/dist/interpreter/execute-sub-harness.js

@@ -2,12 +2,12 @@
  * SubHarness step handler: drives an external coding-agent harness
  * (Claude Code, Codex, opencode, pi) for one agentic turn and folds its output
  * back into the Noetic execution context — the harness analogue of
- * `executeLLM`.
+ * `executeCallModel`.
  */
 import { createMessage, extractAssistantText, frameworkCast, NoeticConfigError, NoeticErrorImpl, } from '@noetic-tools/types';
-import { ZodError } from 'zod';
 import { resolveLazy } from './execute-action.js';
 import { trackUsage } from './message-helpers.js';
+import { parseStructuredOutput } from './structured-output.js';
 import { SubHarnessEventBridge } from './sub-harness-events.js';
 import { isContextImpl, isFunctionCall, isMutableContext } from './typeguards.js';
 //#endregion
@@ -211,30 +211,11 @@ export async function executeSubHarness(step, input, ctx) {
     await finalizeSession(resolution, step.session, baseCtx);
     const lastText = result.text.length > 0 ? result.text : extractAssistantText(result.items);
     if (step.output) {
-        try {
-            const parsed = JSON.parse(lastText);
-            return step.output.parse(parsed);
-        }
-        catch (e) {
-            if (e instanceof SyntaxError || e instanceof ZodError) {
-                throw new NoeticErrorImpl({
-                    kind: 'llm_parse_error',
-                    stepId: step.id,
-                    raw: lastText,
-                    schema: step.output,
-                    zodError: e instanceof ZodError
-                        ? e
-                        : new ZodError([
-                            {
-                                code: 'custom',
-                                message: `Invalid JSON: ${e.message}`,
-                                path: [],
-                            },
-                        ]),
-                });
-            }
-            throw e;
-        }
+        return parseStructuredOutput({
+            schema: step.output,
+            rawText: lastText,
+            stepId: step.id,
+        });
     }
     return frameworkCast(lastText);
 }

package/dist/interpreter/execute.d.ts

@@ -4,7 +4,7 @@ import type { Context, Step } from '@noetic-tools/types';
  * @internal
  * Dispatch a step at the per-kind handler level without adapter routing.
  *
- * Used as the top-level `_localExecutor` for `StepRun` / `StepSpawn`
+ * Used as the top-level `_localExecutor` for `StepRunCode` / `StepSpawn`
  * dispatches: the outer adapter call already recorded the request, so
  * running the handler directly avoids a re-entrant adapter round-trip
  * inside the same logical step. Nested step dispatches (e.g. `executeSpawn`

package/dist/interpreter/execute.js

@@ -1,9 +1,9 @@
 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 { executeLLM, executeProvide, executeRun, executeSpawn, executeTool, } from './execute-action.js';
-import { executeBranch, executeEvery, executeFork, executeLoop } from './execute-control.js';
+import { DetachedHandleImpl } from '../util/detached-handle.js';
+import { executeCallModel, executeInvokeTool, executeRunCode, executeSpawn, executeWithContext, } from './execute-action.js';
+import { executeConditional, executeInParallel, executeLoop, executeSchedule, } from './execute-control.js';
 import { executeSubHarness } from './execute-sub-harness.js';
 import { isMutableContext } from './typeguards.js';
 //#region Constants
@@ -31,11 +31,11 @@ function buildSpawnOpts(ctx) {
     };
 }
 /**
- * Resolve the per-step framework-event emit option. Both `llm` and the harness
+ * Resolve the per-step framework-event emit option. Both `callModel` and the harness
  * step kinds carry an `emit` field; every other kind defaults to enabled.
  */
 function resolveStepEmit(step) {
-    if (step.kind === 'llm' ||
+    if (step.kind === 'callModel' ||
         step.kind === 'claude-code' ||
         step.kind === 'codex' ||
         step.kind === 'opencode' ||
@@ -50,7 +50,7 @@ function resolveStepEmit(step) {
  * `detachedSpawn` overrides layer above this in the harness itself.
  */
 function resolveStepAdapter(step, ctx) {
-    if ((step.kind === 'run' || step.kind === 'spawn') && step.subprocess) {
+    if ((step.kind === 'runCode' || step.kind === 'spawn') && step.subprocess) {
         return step.subprocess;
     }
     return ctx.harness.subprocess;
@@ -90,7 +90,7 @@ async function dispatchViaAdapter(step, input, ctx, executor) {
  * @internal
  * Dispatch a step at the per-kind handler level without adapter routing.
  *
- * Used as the top-level `_localExecutor` for `StepRun` / `StepSpawn`
+ * Used as the top-level `_localExecutor` for `StepRunCode` / `StepSpawn`
  * dispatches: the outer adapter call already recorded the request, so
  * running the handler directly avoids a re-entrant adapter round-trip
  * inside the same logical step. Nested step dispatches (e.g. `executeSpawn`
@@ -100,13 +100,14 @@ async function dispatchViaAdapter(step, input, ctx, executor) {
  */
 export async function executeNoAdapter(step, input, ctx) {
     switch (step.kind) {
-        case 'run':
-            return executeRun(step, input, ctx);
+        case 'runCode':
+            return executeRunCode(step, input, ctx);
         case 'spawn':
             return executeSpawn(step, input, ctx, (s, i, c) => execute(s, i, c), buildSpawnOpts(ctx));
         default:
-            // Kinds that don't currently route through the adapter (llm, tool,
-            // branch, fork, provide, loop, every). Delegate back to `execute()`
+            // Kinds that don't currently route through the adapter (callModel,
+            // invokeTool, conditional, inParallel, withContext, loop, schedule).
+            // Delegate back to `execute()`
             // so they exercise the normal dispatch table, framework-event emits,
             // abort checks, and depth guard.
             return execute(step, input, ctx);
@@ -251,11 +252,11 @@ export async function execute(step, input, ctx) {
     let result;
     try {
         switch (step.kind) {
-            case 'run':
-                result = await dispatchViaAdapter(step, input, ctx, () => executeRun(step, input, ctx));
+            case 'runCode':
+                result = await dispatchViaAdapter(step, input, ctx, () => executeRunCode(step, input, ctx));
                 break;
-            case 'llm':
-                result = await executeLLM(step, input, ctx, baseCtx.layers);
+            case 'callModel':
+                result = await executeCallModel(step, input, ctx, baseCtx.layers);
                 break;
             case 'claude-code':
             case 'codex':
@@ -263,14 +264,14 @@ export async function execute(step, input, ctx) {
             case 'pi':
                 result = await executeSubHarness(step, input, ctx);
                 break;
-            case 'tool':
-                result = await executeTool(step, input, ctx, baseCtx.harness);
+            case 'invokeTool':
+                result = await executeInvokeTool(step, input, ctx, baseCtx.harness);
                 break;
-            case 'branch':
-                result = await executeBranch(step, input, ctx, (s, i, c) => execute(s, i, c));
+            case 'conditional':
+                result = await executeConditional(step, input, ctx, (s, i, c) => execute(s, i, c));
                 break;
-            case 'fork':
-                result = await executeFork(step, input, ctx, (s, i, c) => execute(s, i, c), {
+            case 'inParallel':
+                result = await executeInParallel(step, input, ctx, (s, i, c) => execute(s, i, c), {
                     // Fork paths are child executions: the layer store lets their
                     // `onSpawn`/`onReturn` boundary run (see `createForkLayerBridge`).
                     layerStore: harnessWithLayerStore(baseCtx).layerStateStore,
@@ -280,14 +281,14 @@ export async function execute(step, input, ctx) {
             case 'spawn':
                 result = await dispatchViaAdapter(step, input, ctx, () => executeSpawn(step, input, ctx, (s, i, c) => execute(s, i, c), buildSpawnOpts(ctx)));
                 break;
-            case 'provide':
-                result = await executeProvide(step, input, ctx, (s, i, c) => execute(s, i, c));
+            case 'withContext':
+                result = await executeWithContext(step, input, ctx, (s, i, c) => execute(s, i, c));
                 break;
             case 'loop':
                 result = await executeLoop(step, input, ctx, (s, i, c) => execute(s, i, c));
                 break;
-            case 'every':
-                result = await executeEvery(step, input, ctx, (s, i, c) => execute(s, i, c));
+            case 'schedule':
+                result = await executeSchedule(step, input, ctx, (s, i, c) => execute(s, i, c));
                 break;
             default: {
                 const _exhaustive = step;

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

@@ -4,7 +4,7 @@ import type { Context, DetachedHandle, Step, SubprocessAdapter } from '@noetic-t
  * Resolve the subprocess adapter used for a given step dispatch.
  *
  * Precedence: `detachedSpawn-overrides.subprocess ?? step.subprocess ??
- * harness.subprocess`. Only `StepRun` and `StepSpawn` currently carry a
+ * harness.subprocess`. Only `StepRunCode` and `StepSpawn` currently carry a
  * `subprocess` field — other variants always fall through to the harness
  * default.
  *

package/dist/interpreter/step-dispatcher.js

@@ -1,11 +1,11 @@
-import { DetachedHandleImpl } from '../runtime/detached-handle.js';
+import { DetachedHandleImpl } from '../util/detached-handle.js';
 import { executeNoAdapter } from './execute.js';
 //#region Adapter resolution
 /**
  * Resolve the subprocess adapter used for a given step dispatch.
  *
  * Precedence: `detachedSpawn-overrides.subprocess ?? step.subprocess ??
- * harness.subprocess`. Only `StepRun` and `StepSpawn` currently carry a
+ * harness.subprocess`. Only `StepRunCode` and `StepSpawn` currently carry a
  * `subprocess` field — other variants always fall through to the harness
  * default.
  *
@@ -15,7 +15,7 @@ export function resolveStepAdapter(step, callOverride, fallback) {
     if (callOverride) {
         return callOverride;
     }
-    if ((step.kind === 'run' || step.kind === 'spawn') && step.subprocess) {
+    if ((step.kind === 'runCode' || step.kind === 'spawn') && step.subprocess) {
         return step.subprocess;
     }
     return fallback;

package/dist/interpreter/structured-output.d.ts

@@ -0,0 +1,14 @@
+import type { StandardSchemaV1 } from '@noetic-tools/types';
+/**
+ * JSON-parse + validate assistant text against a Standard Schema, raising
+ * `model_parse_error`. Shared by the LLM step and sub-harness step handlers.
+ *
+ * Zod schemas keep the original `safeParse` error; other vendors' Standard
+ * Schema issues are adapted into a synthetic `ZodError` of `custom` issues so
+ * `model_parse_error.zodError` stays a single error surface.
+ */
+export declare function parseStructuredOutput<O>(params: {
+    schema: StandardSchemaV1;
+    rawText: string;
+    stepId: string;
+}): Promise<O>;

package/dist/interpreter/structured-output.js

@@ -0,0 +1,40 @@
+import { frameworkCast, NoeticErrorImpl, standardIssuesToZodError, validateSchema, } from '@noetic-tools/types';
+/**
+ * JSON-parse + validate assistant text against a Standard Schema, raising
+ * `model_parse_error`. Shared by the LLM step and sub-harness step handlers.
+ *
+ * Zod schemas keep the original `safeParse` error; other vendors' Standard
+ * Schema issues are adapted into a synthetic `ZodError` of `custom` issues so
+ * `model_parse_error.zodError` stays a single error surface.
+ */
+export async function parseStructuredOutput(params) {
+    const { schema, rawText, stepId } = params;
+    let parsed;
+    try {
+        parsed = JSON.parse(rawText);
+    }
+    catch (e) {
+        throw new NoeticErrorImpl({
+            kind: 'model_parse_error',
+            stepId,
+            raw: rawText,
+            schema,
+            zodError: standardIssuesToZodError([
+                {
+                    message: `Invalid JSON: ${e instanceof Error ? e.message : String(e)}`,
+                },
+            ]),
+        });
+    }
+    const result = await validateSchema(schema, parsed);
+    if (!result.success) {
+        throw new NoeticErrorImpl({
+            kind: 'model_parse_error',
+            stepId,
+            raw: rawText,
+            schema,
+            zodError: result.zodError,
+        });
+    }
+    return frameworkCast(result.value);
+}

package/dist/interpreter/typeguards.d.ts

@@ -9,7 +9,7 @@ export declare function isContextImpl(ctx: Context<ContextData>): ctx is Context
 /**
  * Co-located with `isContextImpl` so the import of `ContextImpl` flows through
  * the same module other interpreters pull it from, sidestepping a circular
- * TDZ when this helper is used by `executeEvery` in `execute-control.ts`.
+ * TDZ when this helper is used by `executeSchedule` in `execute-control.ts`.
  */
 export declare function getContextChannelStore<TContext>(ctx: Context<TContext>): ChannelStore | undefined;
 export declare function isFunctionCall(item: Item): item is FunctionCallItem;

package/dist/interpreter/typeguards.js

@@ -16,7 +16,7 @@ export function isContextImpl(ctx) {
 /**
  * Co-located with `isContextImpl` so the import of `ContextImpl` flows through
  * the same module other interpreters pull it from, sidestepping a circular
- * TDZ when this helper is used by `executeEvery` in `execute-control.ts`.
+ * TDZ when this helper is used by `executeSchedule` in `execute-control.ts`.
  */
 export function getContextChannelStore(ctx) {
     if (ctx instanceof ContextImpl) {

package/dist/portable/builders.d.ts

@@ -1,12 +1,12 @@
 /** @public */
-export { branch, fork } from '../builders/control-flow-builders.js';
+export { conditional, inParallel } from '../builders/control-flow-builders.js';
 /** @public */
-export { layerData, layerFn } from '../builders/layer-provides-builders.js';
+export { layerData, layerFunction } from '../builders/layer-provides-builders.js';
 /** @public */
 export { loop } from '../builders/loop-builder.js';
 /** @public */
 export { spawn } from '../builders/spawn-builder.js';
 /** @public */
-export { step } from '../builders/step-builders.js';
+export { callModel, invokeTool, runCode, step } from '../builders/step-builders.js';
 /** @public */
 export { tool, toolWithGenerator } from '../builders/tool-builder.js';

package/dist/portable/builders.js

@@ -1,14 +1,15 @@
 /** @public */
-export { branch, fork } from '../builders/control-flow-builders.js';
+export { conditional, inParallel } from '../builders/control-flow-builders.js';
 /** @public */
-export { layerData, layerFn } from '../builders/layer-provides-builders.js';
+export { layerData, layerFunction } from '../builders/layer-provides-builders.js';
 /** @public */
 export { loop } from '../builders/loop-builder.js';
 /** @public */
 export { spawn } from '../builders/spawn-builder.js';
-// The base namespace, without `step.workflow` — the portable surface stays
-// free of the hydrator so restricted runtimes don't pull it in.
+// The base builders plus the sub-harness `step` namespace, without
+// `workflow` — the portable surface stays free of the hydrator so
+// restricted runtimes don't pull it in.
 /** @public */
-export { step } from '../builders/step-builders.js';
+export { callModel, invokeTool, runCode, step } from '../builders/step-builders.js';
 /** @public */
 export { tool, toolWithGenerator } from '../builders/tool-builder.js';

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

@@ -5,4 +5,4 @@
 /** @public */
 /** @public */
 /** @public */
-export { durableTaskState, historyWindow, observationalContext, planContext, temporalContext, toolContextLayer, workingMemoryContext, } from '@noetic-tools/context';
+export { history, observations, plan, scratchpad, taskState, temporal, toolCalls, } from '@noetic-tools/context';

package/dist/portable/context-layers.js

@@ -5,4 +5,4 @@
 /** @public */
 /** @public */
 /** @public */
-export { durableTaskState, historyWindow, observationalContext, planContext, temporalContext, toolContextLayer, workingMemoryContext, } from '@noetic-tools/context';
+export { history, observations, plan, scratchpad, taskState, temporal, toolCalls, } from '@noetic-tools/context';

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

@@ -7,7 +7,7 @@ export type EmitOption = boolean | ((eventType: string, data: Record<string, unk
  *
  * When `emit` is `undefined` (the default for non-LLM steps where the
  * field does not exist on the Step type), events are always emitted.
- * Only StepLLM exposes `emit` for opt-out or filtering.
+ * Only StepCallModel exposes `emit` for opt-out or filtering.
  *
  * @internal
  */

package/dist/runtime/broadcaster-utils.js

@@ -5,7 +5,7 @@
  *
  * When `emit` is `undefined` (the default for non-LLM steps where the
  * field does not exist on the Step type), events are always emitted.
- * Only StepLLM exposes `emit` for opt-out or filtering.
+ * Only StepCallModel exposes `emit` for opt-out or filtering.
  *
  * @internal
  */

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

@@ -31,8 +31,8 @@ export declare class ContextImpl implements Context<ContextData> {
     private readonly _createdAt;
     /**
      * Shared channel store for cross-context communication. Inherited by
-     * `fork` / `spawn` children so channels published by a sibling are visible
-     * to peers — see `executeFork` and `executeSpawn` in `interpreter/execute-action.ts`
+     * `inParallel` / `spawn` children so channels published by a sibling are visible
+     * to peers — see `executeInParallel` and `executeSpawn` in `interpreter/execute-action.ts`
      * and `interpreter/execute-control.ts`.
      * @internal
      */
@@ -46,14 +46,14 @@ export declare class ContextImpl implements Context<ContextData> {
      * 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
+     * their timeout (spec 09, Cancellation item 2). Each inParallel/spawn child
      * constructs its own ContextImpl and therefore its own controller —
      * aborting a child never rejects the parent's waiters, while aborting a
      * parent DOES cascade down to every live child (see `_children`).
      */
     private readonly _abortController;
     /**
-     * Live child contexts (fork paths, spawn children) registered for the abort
+     * Live child contexts (inParallel paths, spawn children) registered for the abort
      * cascade. A child adds itself at construction and removes itself via
      * `detachFromParent()` when its execution settles, so a long-lived parent
      * driving a loop of spawns does not accumulate finished children.
@@ -77,7 +77,7 @@ export declare class ContextImpl implements Context<ContextData> {
      */
     private readonly _segments;
     /**
-     * Path this context's steps hang under. Empty on a root context; a fork/spawn child
+     * Path this context's steps hang under. Empty on a root context; an inParallel/spawn child
      * inherits its parent's current path plus a discriminator, so a path key stays unique
      * across the whole step tree rather than restarting per child context.
      * @internal
@@ -91,7 +91,7 @@ export declare class ContextImpl implements Context<ContextData> {
     private readonly _occurrences;
     /**
      * Completion ledger for the execution this context belongs to. Shared by reference
-     * with fork/spawn children — one execution, one ledger.
+     * with inParallel/spawn children — one execution, one ledger.
      * @internal
      */
     readonly ledger?: StepLedger;
@@ -105,7 +105,7 @@ export declare class ContextImpl implements Context<ContextData> {
         span?: Span;
         channelStore?: ChannelStore;
         checkpointFn?: (ctx: Context) => Promise<void>;
-        /** Path this context's steps hang under (fork/spawn children inherit one). */
+        /** Path this context's steps hang under (inParallel/spawn children inherit one). */
         pathPrefix?: string;
         /** The execution's completion ledger, shared with children by reference. */
         ledger?: StepLedger;
@@ -134,7 +134,7 @@ export declare class ContextImpl implements Context<ContextData> {
     /**
      * @internal
      * Leave the parent's abort cascade. Called by the interpreter when a spawn
-     * child or fork path settles — a finished child has nothing left to cancel,
+     * child or inParallel path settles — a finished child has nothing left to cancel,
      * and holding it would leak for the remaining life of the parent.
      */
     detachFromParent(): void;
@@ -150,8 +150,6 @@ export declare class ContextImpl implements Context<ContextData> {
     get shell(): AgentHarnessContract['shell'];
     get subprocess(): AgentHarnessContract['subprocess'];
     get context(): ContextData;
-    /** @deprecated Renamed to `context`. Returns the same object. */
-    get memory(): ContextData;
     recv<T>(ch: Channel<T>, opts?: {
         timeout?: number;
     }): Promise<T>;