@noetic-tools/core 5.2.0 → 5.4.0

package/dist/interpreter/execute-control.d.ts

@@ -1,26 +1,26 @@
 /**
- * Control-flow step handlers: branch, fork, loop, every.
+ * Control-flow step handlers: conditional, inParallel, loop, schedule.
  */
-import type { Context, ExecuteStepFn, StepBranch, StepEvery, StepFork, StepLoop } from '@noetic-tools/types';
+import type { Context, ExecuteStepFn, StepConditional, StepInParallel, StepLoop, StepSchedule } from '@noetic-tools/types';
 import type { ItemSchemaRegistry, LayerStateStore } from './action-deps.js';
-export declare function executeBranch<TContext, I, O>(step: StepBranch<TContext, I, O>, input: I, ctx: Context<TContext>, executeStep: ExecuteStepFn): Promise<O>;
+export declare function executeConditional<TContext, I, O>(step: StepConditional<TContext, I, O>, input: I, ctx: Context<TContext>, executeStep: ExecuteStepFn): Promise<O>;
 /** Layer-boundary wiring supplied by the interpreter (see `buildSpawnOpts`). */
 export interface ExecuteForkOpts {
     layerStore?: LayerStateStore;
     itemSchemas?: ItemSchemaRegistry;
 }
-export declare function executeFork<TContext, I, O>(step: StepFork<TContext, I, O>, input: I, ctx: Context<TContext>, rawExecuteStep: ExecuteStepFn, opts?: ExecuteForkOpts): Promise<O>;
+export declare function executeInParallel<TContext, I, O>(step: StepInParallel<TContext, I, O>, input: I, ctx: Context<TContext>, rawExecuteStep: ExecuteStepFn, opts?: ExecuteForkOpts): Promise<O>;
 export declare function executeLoop<TContext, I, O>(step: StepLoop<TContext, I, O>, input: I, ctx: Context<TContext>, executeStep: ExecuteStepFn): Promise<O>;
 /**
- * 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 declare function executeEvery<TContext, I, O>(step: StepEvery<TContext, I, O>, input: I, ctx: Context<TContext>, executeStep: ExecuteStepFn): Promise<O>;
+export declare function executeSchedule<TContext, I, O>(step: StepSchedule<TContext, I, O>, input: I, ctx: Context<TContext>, executeStep: ExecuteStepFn): Promise<O>;

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/observability/genai-attributes.d.ts

@@ -3,6 +3,10 @@ export declare const GenAI: {
     readonly REQUEST_MODEL: 'gen_ai.request.model';
     readonly USAGE_INPUT_TOKENS: 'gen_ai.usage.input_tokens';
     readonly USAGE_OUTPUT_TOKENS: 'gen_ai.usage.output_tokens';
+    /** Prompt tokens served from the provider's cache. Absent if unreported. */
+    readonly USAGE_CACHED_INPUT_TOKENS: 'gen_ai.usage.cached_input_tokens';
+    /** Prompt tokens written into the provider's cache. Absent if unreported. */
+    readonly USAGE_CACHE_WRITE_TOKENS: 'gen_ai.usage.cache_write_tokens';
     readonly COST: 'gen_ai.cost';
 };
 export declare const ToolAttr: {
@@ -30,4 +34,20 @@ export declare const NoeticAttr: {
     readonly SESSION_ID: 'noetic.session.id';
     /** Resource the session is scoped to (the run's `ctx.resourceId`), when set. */
     readonly RESOURCE_ID: 'noetic.resource.id';
+    /** Id of the anchoring epoch the assembled view belongs to. */
+    readonly CONTEXT_EPOCH_ID: 'noetic.context.epoch.id';
+    /** Assemblies served by the current epoch, including this one. */
+    readonly CONTEXT_EPOCH_AGE: 'noetic.context.epoch.age';
+    /** Why the epoch re-anchored on this assembly, when it did. */
+    readonly CONTEXT_REANCHOR_REASON: 'noetic.context.reanchor_reason';
+    /** Tokens in the anchor band (the cache-stable prefix). */
+    readonly CONTEXT_ANCHOR_TOKENS: 'noetic.context.anchor_tokens';
+    /** Tokens in the live band (rendered after history). */
+    readonly CONTEXT_LIVE_TOKENS: 'noetic.context.live_tokens';
+    /** Tokens spent superseding stale anchors. */
+    readonly CONTEXT_DELTA_TOKENS: 'noetic.context.delta_tokens';
+    /** JSON array of `{ id, placement, served }` per contributing layer. */
+    readonly CONTEXT_LAYER_PLACEMENTS: 'noetic.context.layer_placements';
+    /** JSON array of `{ id, rate, rebillTokens }` per contributing layer. */
+    readonly CONTEXT_LAYER_CHURN: 'noetic.context.layer_churn';
 };

package/dist/observability/genai-attributes.js

@@ -4,6 +4,10 @@ export const GenAI = {
     REQUEST_MODEL: 'gen_ai.request.model',
     USAGE_INPUT_TOKENS: 'gen_ai.usage.input_tokens',
     USAGE_OUTPUT_TOKENS: 'gen_ai.usage.output_tokens',
+    /** Prompt tokens served from the provider's cache. Absent if unreported. */
+    USAGE_CACHED_INPUT_TOKENS: 'gen_ai.usage.cached_input_tokens',
+    /** Prompt tokens written into the provider's cache. Absent if unreported. */
+    USAGE_CACHE_WRITE_TOKENS: 'gen_ai.usage.cache_write_tokens',
     COST: 'gen_ai.cost',
 };
 export const ToolAttr = {
@@ -33,4 +37,20 @@ export const NoeticAttr = {
     SESSION_ID: 'noetic.session.id',
     /** Resource the session is scoped to (the run's `ctx.resourceId`), when set. */
     RESOURCE_ID: 'noetic.resource.id',
+    /** Id of the anchoring epoch the assembled view belongs to. */
+    CONTEXT_EPOCH_ID: 'noetic.context.epoch.id',
+    /** Assemblies served by the current epoch, including this one. */
+    CONTEXT_EPOCH_AGE: 'noetic.context.epoch.age',
+    /** Why the epoch re-anchored on this assembly, when it did. */
+    CONTEXT_REANCHOR_REASON: 'noetic.context.reanchor_reason',
+    /** Tokens in the anchor band (the cache-stable prefix). */
+    CONTEXT_ANCHOR_TOKENS: 'noetic.context.anchor_tokens',
+    /** Tokens in the live band (rendered after history). */
+    CONTEXT_LIVE_TOKENS: 'noetic.context.live_tokens',
+    /** Tokens spent superseding stale anchors. */
+    CONTEXT_DELTA_TOKENS: 'noetic.context.delta_tokens',
+    /** JSON array of `{ id, placement, served }` per contributing layer. */
+    CONTEXT_LAYER_PLACEMENTS: 'noetic.context.layer_placements',
+    /** JSON array of `{ id, rate, rebillTokens }` per contributing layer. */
+    CONTEXT_LAYER_CHURN: 'noetic.context.layer_churn',
 };

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';