@noetic-tools/core 5.3.0 → 5.4.1

package/dist/builders/workflow-hydrator.js

@@ -1,20 +1,20 @@
 /**
  * Converts a validated `WorkflowDocument` into a live `Step` tree.
  *
- * Each node kind maps to the corresponding builder (`step.llm`, `fork`,
+ * Each node kind maps to the corresponding builder (`callModel`, `inParallel`,
  * `loop`, etc.) so hydrated steps are indistinguishable from programmatic
  * ones — they register in the step registry, carry retry policies, etc.
  */
 import { frameworkCast, isServerToolSpec, NoeticConfigError } from '@noetic-tools/types';
-import { DetachedHandleImpl } from '../runtime/detached-handle.js';
 import { all, any } from '../until/combinators.js';
 import { until } from '../until/predicates.js';
-import { branch, fork } from './control-flow-builders.js';
-import { every } from './every.js';
+import { DetachedHandleImpl } from '../util/detached-handle.js';
+import { conditional, inParallel } from './control-flow-builders.js';
+import { schedule } from './every.js';
 import { loop } from './loop-builder.js';
-import { provide } from './provide-builder.js';
+import { withContext } from './provide-builder.js';
 import { spawn } from './spawn-builder.js';
-import { step } from './step-builders.js';
+import { callModel, runCode, step } from './step-builders.js';
 //#endregion
 //#region Until Predicate Hydration
 function hydrateUntilPredicate(pred) {
@@ -24,9 +24,11 @@ function hydrateUntilPredicate(pred) {
         case 'maxCost':
             return until.maxCost(pred.usd);
         case 'maxDuration':
-            return until.maxDuration(pred.ms);
+            return until.maxDuration(pred.duration);
         case 'noToolCalls':
             return until.noToolCalls();
+        case 'never':
+            return until.never();
         case 'outputContains':
             return until.outputContains(pred.marker);
         case 'outputEquals':
@@ -43,7 +45,7 @@ function hydrateUntilPredicate(pred) {
             throw new NoeticConfigError({
                 code: 'UNKNOWN_UNTIL_PREDICATE',
                 message: `Unknown until predicate kind: '${frameworkCast(pred).kind}'.`,
-                hint: 'Supported kinds: maxSteps, maxCost, maxDuration, noToolCalls, outputContains, outputEquals, converged, any, all.',
+                hint: 'Supported kinds: maxSteps, maxCost, maxDuration, noToolCalls, never, outputContains, outputEquals, converged, any, all.',
             });
     }
 }
@@ -58,7 +60,7 @@ function hydrateUntilPredicate(pred) {
  * kinds combine into one `tools` array; the interpreter partitions them again
  * at execution.
  */
-function resolveLlmTools(entries, registry) {
+function resolveCallModelTools(entries, registry) {
     const toolNames = [];
     const serverSpecs = [];
     for (const entry of entries ?? []) {
@@ -74,12 +76,12 @@ function resolveLlmTools(entries, registry) {
         ...serverSpecs,
     ];
 }
-function hydrateLlmNode(node, ctx) {
-    if (node.kind !== 'llm') {
+function hydrateCallModelNode(node, ctx) {
+    if (node.kind !== 'callModel') {
         return frameworkCast(undefined);
     }
-    const combined = resolveLlmTools(node.tools, ctx.tools);
-    return step.llm({
+    const combined = resolveCallModelTools(node.tools, ctx.tools);
+    return callModel({
         id: node.id,
         model: node.model ?? 'openai/gpt-4o',
         instructions: node.instructions,
@@ -89,7 +91,7 @@ function hydrateLlmNode(node, ctx) {
     });
 }
 /**
- * Resolve an `llm` node's `output` codec reference to a live `OutputCodec`.
+ * Resolve a `callModel` node's `output` codec reference to a live `OutputCodec`.
  *
  * Hydrated steps are typed `<string, string>` (the JSON boundary erases output
  * types), so the resolved codec is cast to the step's erased output type — the
@@ -118,8 +120,8 @@ function resolveOutputCodec(ref, nodeId, ctx) {
         hint: `Pass output codecs via HydrationContext.uiLibraries, e.g. new Map([['${ref.library}', openUi(myLibrary)]]) from @noetic-tools/openui. Available: ${availableLibraries(ctx)}`,
     });
 }
-function hydrateToolNode(node, ctx) {
-    if (node.kind !== 'tool') {
+function hydrateInvokeToolNode(node, ctx) {
+    if (node.kind !== 'invokeTool') {
         return frameworkCast(undefined);
     }
     const resolved = ctx.tools.get(node.toolName);
@@ -132,7 +134,7 @@ function hydrateToolNode(node, ctx) {
             ].join(', ') || '(none)'}`,
         });
     }
-    return frameworkCast(step.run({
+    return frameworkCast(runCode({
         id: node.id,
         execute: async (_input, execCtx) => {
             const args = node.args ?? {};
@@ -156,12 +158,6 @@ function hydrateToolNode(node, ctx) {
                 fs: execCtx.fs,
                 shell: execCtx.shell,
                 context: layerState,
-                // Deprecated alias — the same accessor object, as
-                // `buildToolExecutionContext` does. `Tool.execute` takes its second
-                // argument as `unknown`, so nothing here is structurally checked
-                // against `ToolExecutionContext`; the annotation above is what makes
-                // a missing field a compile error instead of a runtime `undefined`.
-                memory: layerState,
                 assembledView: execCtx.itemLog.items,
                 lastStepMeta: execCtx.lastStepMeta,
             };
@@ -170,13 +166,13 @@ function hydrateToolNode(node, ctx) {
         },
     }));
 }
-function hydrateRunNode(node, ctx) {
-    if (node.kind !== 'run') {
+function hydrateRunCodeNode(node, ctx) {
+    if (node.kind !== 'runCode') {
         return frameworkCast(undefined);
     }
     const code = node.execute;
     const subprocessRef = node.subprocess;
-    return frameworkCast(step.run({
+    return frameworkCast(runCode({
         id: node.id,
         retry: node.retry,
         execute: async (input, execCtx) => {
@@ -195,8 +191,8 @@ function hydrateRunNode(node, ctx) {
         },
     }));
 }
-function hydrateBranchNode(node, ctx) {
-    if (node.kind !== 'branch') {
+function hydrateConditionalNode(node, ctx) {
+    if (node.kind !== 'conditional') {
         return frameworkCast(undefined);
     }
     const hydratedRoutes = node.routes.map((r) => ({
@@ -208,7 +204,7 @@ function hydrateBranchNode(node, ctx) {
     if (defaultTarget) {
         allTargets.push(defaultTarget);
     }
-    return branch({
+    return conditional({
         id: node.id,
         route: (input) => {
             const trimmed = input.trim().toLowerCase();
@@ -222,12 +218,12 @@ function hydrateBranchNode(node, ctx) {
         _optimizable: frameworkCast(allTargets),
     });
 }
-function hydrateForkNode(node, ctx) {
-    if (node.kind !== 'fork') {
+function hydrateInParallelNode(node, ctx) {
+    if (node.kind !== 'inParallel') {
         return frameworkCast(undefined);
     }
-    // Static fork: paths are known at hydration time and feed the optimizer.
-    // Dynamic fork (`each`): paths are produced per fork-input at runtime, one
+    // Static inParallel: paths are known at hydration time and feed the optimizer.
+    // Dynamic inParallel (`each`): paths are produced per inParallel-input at runtime, one
     // child per array item, so they cannot be pre-computed or optimized.
     const dynamic = node.each !== undefined;
     const eachTemplate = node.each;
@@ -247,7 +243,7 @@ function hydrateForkNode(node, ctx) {
     };
     const optimizable = dynamic ? undefined : frameworkCast(staticPaths);
     if (node.mode === 'race') {
-        return fork({
+        return inParallel({
             id: node.id,
             mode: 'race',
             paths: pathsFactory,
@@ -257,7 +253,7 @@ function hydrateForkNode(node, ctx) {
     }
     const mergeFn = buildMerge(node.merge ?? 'last');
     if (node.mode === 'settle') {
-        return fork({
+        return inParallel({
             id: node.id,
             mode: 'settle',
             paths: pathsFactory,
@@ -269,7 +265,7 @@ function hydrateForkNode(node, ctx) {
             _optimizable: optimizable,
         });
     }
-    return fork({
+    return inParallel({
         id: node.id,
         mode: 'all',
         paths: pathsFactory,
@@ -279,7 +275,7 @@ function hydrateForkNode(node, ctx) {
     });
 }
 /**
- * Resolves layer names declared on a `provide` / `spawn` node against the
+ * Resolves layer names declared on a `withContext` / `spawn` node against the
  * registry on `HydrationContext.layers`. Returns `[]` when no registry was
  * supplied — the host runs with its harness-default layers in that case.
  */
@@ -322,16 +318,16 @@ function hydrateSpawnNode(node, ctx) {
         context: resolvedLayers,
     });
 }
-function hydrateProvideNode(node, ctx) {
-    if (node.kind !== 'provide') {
+function hydrateWithContextNode(node, ctx) {
+    if (node.kind !== 'withContext') {
         return frameworkCast(undefined);
     }
-    return provide({
+    return withContext({
         id: node.id,
         child: hydrateNode(node.child, ctx),
         context: resolveNamedLayers({
             names: node.layers,
-            nodeKind: 'provide',
+            nodeKind: 'withContext',
             nodeId: node.id,
             ctx,
         }),
@@ -355,7 +351,7 @@ function hydrateSequenceNode(node, ctx) {
         return frameworkCast(undefined);
     }
     const children = node.steps.map((s) => hydrateNode(s, ctx));
-    return frameworkCast(step.run({
+    return frameworkCast(runCode({
         id: node.id,
         execute: async (input, execCtx) => {
             let current = input;
@@ -367,44 +363,39 @@ function hydrateSequenceNode(node, ctx) {
         },
     }));
 }
-function hydrateEveryNode(node, ctx) {
-    if (node.kind !== 'every') {
+function hydrateScheduleNode(node, ctx) {
+    if (node.kind !== 'schedule') {
         return frameworkCast(undefined);
     }
-    return every({
+    return schedule({
         id: node.id,
         step: hydrateNode(node.step, ctx),
-        ms: node.ms,
+        interval: node.interval,
         onError: node.onError,
     });
 }
-const SUB_HARNESS_BUILDERS = {
-    'claude-code': (opts) => step.claudeCode(opts),
-    codex: (opts) => step.codex(opts),
-    opencode: (opts) => step.opencode(opts),
-    pi: (opts) => step.pi(opts),
-};
-function hydrateSubHarnessNode(node, ctx) {
-    if (node.kind !== 'claude-code' &&
-        node.kind !== 'codex' &&
-        node.kind !== 'opencode' &&
-        node.kind !== 'pi') {
+function hydrateAcpAgentNode(node, ctx) {
+    if (node.kind !== 'acp-agent') {
         return frameworkCast(undefined);
     }
-    const harness = ctx.subHarnesses?.get(node.kind);
-    if (!harness) {
+    const agent = ctx.acpAgents?.get(node.agent);
+    if (!agent) {
         throw new NoeticConfigError({
-            code: 'UNKNOWN_SUB_HARNESS_REFERENCE',
-            message: `SubHarness '${node.kind}' referenced in workflow node '${node.id}' is not registered.`,
-            hint: `Pass harness adapters via HydrationContext.subHarnesses, e.g. new Map([['${node.kind}', ${node.kind.replace(/-([a-z])/g, (_, c) => c.toUpperCase())}({ model })]]).`,
+            code: 'UNKNOWN_ACP_AGENT_REFERENCE',
+            message: `ACP agent '${node.agent}' referenced in workflow node '${node.id}' is not registered.`,
+            hint: 'Pass agent adapters via HydrationContext.acpAgents, e.g. createAcpAgentRegistry(claudeCode()) from @noetic-tools/acp.',
         });
     }
-    return SUB_HARNESS_BUILDERS[node.kind]({
+    return step.acpAgent({
         id: node.id,
-        harness,
+        agent,
         prompt: node.prompt,
-        instructions: node.instructions,
-        settings: node.settings,
+        cwd: node.cwd,
+        mode: node.mode,
+        model: node.model,
+        mcpServers: node.mcpServers,
+        permissions: node.permissions,
+        clientCapabilities: node.clientCapabilities,
         session: node.session,
     });
 }
@@ -427,7 +418,7 @@ function hydrateSubflowNode(node, ctx) {
         }
         return cached;
     };
-    return frameworkCast(step.run({
+    return frameworkCast(runCode({
         id: node.id,
         execute: async (input, execCtx) => {
             const child = resolve();
@@ -480,21 +471,18 @@ function resolveSubflowDocument(node, ctx) {
 //#endregion
 //#region Handler Registry
 const NODE_HYDRATORS = {
-    llm: hydrateLlmNode,
-    tool: hydrateToolNode,
-    run: hydrateRunNode,
-    branch: hydrateBranchNode,
-    fork: hydrateForkNode,
+    callModel: hydrateCallModelNode,
+    invokeTool: hydrateInvokeToolNode,
+    runCode: hydrateRunCodeNode,
+    conditional: hydrateConditionalNode,
+    inParallel: hydrateInParallelNode,
     spawn: hydrateSpawnNode,
-    provide: hydrateProvideNode,
+    withContext: hydrateWithContextNode,
     loop: hydrateLoopNode,
     sequence: hydrateSequenceNode,
-    every: hydrateEveryNode,
+    schedule: hydrateScheduleNode,
     subflow: hydrateSubflowNode,
-    'claude-code': hydrateSubHarnessNode,
-    codex: hydrateSubHarnessNode,
-    opencode: hydrateSubHarnessNode,
-    pi: hydrateSubHarnessNode,
+    'acp-agent': hydrateAcpAgentNode,
 };
 //#endregion
 //#region Helpers
@@ -537,7 +525,7 @@ function stringifyResult(value) {
 //#endregion
 //#region Dynamic Fork Helpers
 /**
- * Parses the fork input (a JSON string) and locates the array to fan out over.
+ * Parses the inParallel input (a JSON string) and locates the array to fan out over.
  * When `over` is set, reads that property off the parsed object; otherwise the
  * parsed value itself must be an array.
  */
@@ -549,15 +537,15 @@ function selectArray(input, over, nodeId) {
     catch {
         throw new NoeticConfigError({
             code: 'INVALID_FORK_INPUT',
-            message: `Dynamic fork '${nodeId}' could not parse its input as JSON.`,
-            hint: 'A dynamic fork (with `each`) expects its input to be a JSON array (or a JSON object when `over` is set).',
+            message: `Dynamic inParallel '${nodeId}' could not parse its input as JSON.`,
+            hint: 'A dynamic inParallel (with `each`) expects its input to be a JSON array (or a JSON object when `over` is set).',
         });
     }
     const candidate = over === undefined ? parsed : frameworkCast(parsed)?.[over];
     if (!Array.isArray(candidate)) {
         throw new NoeticConfigError({
             code: 'INVALID_FORK_INPUT',
-            message: `Dynamic fork '${nodeId}' did not resolve an array${over ? ` at key '${over}'` : ''}.`,
+            message: `Dynamic inParallel '${nodeId}' did not resolve an array${over ? ` at key '${over}'` : ''}.`,
             hint: over
                 ? `Ensure the input JSON object has an array at '${over}'.`
                 : 'Ensure the input is a JSON array, or set `over` to select an array property.',
@@ -566,15 +554,15 @@ function selectArray(input, over, nodeId) {
     return candidate;
 }
 /**
- * Builds one fork path for a single dynamic-fork item. The item is injected as
- * the body's input (forks pass the same fork-input to every path), and the
+ * Builds one inParallel path for a single dynamic fan-out item. The item is injected as
+ * the body's input (inParallel steps pass the same input to every path), and the
  * template's node ids are suffixed with `-${i}` so each instantiation has
  * unique ids for tracing and step-registry uniqueness.
  */
 function buildPerItemStep(opts) {
     const { forkId, eachTemplate, item, index, ctx } = opts;
     const hydratedEach = hydrateNode(suffixNodeIds(eachTemplate, `-${index}`), ctx);
-    return frameworkCast(step.run({
+    return frameworkCast(runCode({
         id: `${forkId}-item-${index}`,
         execute: async (_input, execCtx) => {
             const itemInput = JSON.stringify(item);
@@ -621,7 +609,7 @@ function suffixNodeIds(node, suffix) {
 //#endregion
 //#region Run Node Helpers
 /**
- * Resolves the subprocess adapter for a `run` node. When the node names an
+ * Resolves the subprocess adapter for a `runCode` node. When the node names an
  * adapter ref, the host must supply a `resolveSubprocess` resolver; otherwise
  * the step falls back to the harness adapter on the execution context.
  */
@@ -641,7 +629,7 @@ function resolveSubprocessAdapter(opts) {
     return resolved;
 }
 /**
- * Dispatches a `run` node's code string through a subprocess adapter: ships the
+ * Dispatches a `runCode` node's code string through a subprocess adapter: ships the
  * code plus the JSON-stringified input as a process request (input on stdin),
  * waits for the handle to settle, and returns the captured stdout as the step
  * output. A non-zero exit / failed handle surfaces as a thrown error.

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

@@ -1,31 +1,30 @@
 /**
- * `step.workflow` — runs a `WorkflowDocument` as a single composable step.
+ * `workflow` — runs a `WorkflowDocument` as a single composable step.
  *
  * Lives beside `step-builders.ts` (rather than inside it) because the hydrator
- * imports the base `step` object; adding a hydrating builder there would create
- * an import cycle. This module composes the public `step` namespace instead.
+ * imports the base builders; adding a hydrating builder there would create an
+ * import cycle.
  */
 import type { ContextData, ContextLayer } from '@noetic-tools/context';
-import type { OutputCodec, StepRun, SubHarness, SubHarnessKind, SubprocessAdapter, Tool, WorkflowDocument } from '@noetic-tools/types';
-import * as stepBuilders from './step-builders.js';
-/** @public Options for `step.workflow`. */
-export interface StepWorkflowOpts {
+import type { AcpAgent, OutputCodec, StepRunCode, SubprocessAdapter, Tool, WorkflowDocument } from '@noetic-tools/types';
+/** @public Options for `workflow`. */
+export interface WorkflowOpts {
     id: string;
     /** Inline workflow document. Mutually exclusive with `ref`. */
     document?: WorkflowDocument;
     /** Named workflow resolved from `workflows`. Mutually exclusive with `document`. */
     ref?: string;
-    /** Client tools the document's `llm`/`tool` nodes may reference by name. Default: none. */
+    /** Client tools the document's `callModel`/`invokeTool` nodes may reference by name. Default: none. */
     tools?: Tool[];
-    /** Named context layers for `provide`/`spawn` nodes. */
+    /** Named context layers for `withContext`/`spawn` nodes. */
     layers?: ReadonlyMap<string, ContextLayer>;
     /** Named sub-workflows for `subflow` nodes — and for resolving `ref` itself. */
     workflows?: ReadonlyMap<string, WorkflowDocument>;
-    /** SubHarness adapters for `claude-code`/`codex`/`opencode`/`pi` nodes. */
-    subHarnesses?: ReadonlyMap<SubHarnessKind, SubHarness>;
-    /** Output codecs for `llm` nodes' `output` codec references. */
+    /** ACP agent adapters, keyed by `agentId`, for `acp-agent` nodes. */
+    acpAgents?: ReadonlyMap<string, AcpAgent>;
+    /** Output codecs for `callModel` nodes' `output` codec references. */
     uiLibraries?: ReadonlyMap<string, OutputCodec>;
-    /** Resolver for named subprocess adapters on `run` nodes. */
+    /** Resolver for named subprocess adapters on `runCode` nodes. */
     resolveSubprocess?: (ref: string) => SubprocessAdapter | undefined;
     /** `'inherit'` (default) runs in the caller's session; `'spawn'` isolates via `spawn()`. */
     isolation?: 'inherit' | 'spawn';
@@ -40,22 +39,11 @@ export interface StepWorkflowOpts {
  * workflow fails with `WORKFLOW_CYCLE` instead of recursing forever.
  *
  * @public
- * @param opts - See `StepWorkflowOpts`.
- * @returns A `StepRun` executing the workflow via the harness on the context.
+ * @param opts - See `WorkflowOpts`.
+ * @returns A `StepRunCode` executing the workflow via the harness on the context.
  * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
  * @throws `NoeticConfigError` with code `INVALID_WORKFLOW_SOURCE` unless exactly one of `document`/`ref` is set.
  * @throws `NoeticConfigError` with code `MISSING_HARNESS_CONTEXT` (at execution) without `ctx.harness`.
  * @throws `NoeticConfigError` with code `UNKNOWN_WORKFLOW_REFERENCE` (at execution) if `ref` names no registered workflow.
  */
-export declare function stepWorkflow(opts: StepWorkflowOpts): StepRun<ContextData, string, string>;
-/** @public The step builder namespace: the base builders plus `workflow`. */
-export declare const step: {
-    readonly run: <TContext = Readonly<Record<string, Record<string, unknown>>>, I = unknown, O = unknown>(opts: stepBuilders.StepRunOpts<TContext, I, O>) => StepRun<TContext, I, O>;
-    readonly llm: <TContext = Readonly<Record<string, Record<string, unknown>>>, I = unknown, O = unknown>(opts: stepBuilders.StepLLMOpts<TContext, O>) => import("@noetic-tools/types").StepLLM<TContext, I, O>;
-    readonly tool: <TContext = Readonly<Record<string, Record<string, unknown>>>, I = unknown, O = unknown>(opts: stepBuilders.StepToolOpts<I, O>) => import("@noetic-tools/types").StepTool<TContext, I, O>;
-    readonly claudeCode: <TContext = Readonly<Record<string, Record<string, unknown>>>, I = unknown, O = unknown>(opts: stepBuilders.StepSubHarnessOpts<TContext, O>) => import("@noetic-tools/types").StepSubHarness<TContext, I, O>;
-    readonly codex: <TContext = Readonly<Record<string, Record<string, unknown>>>, I = unknown, O = unknown>(opts: stepBuilders.StepSubHarnessOpts<TContext, O>) => import("@noetic-tools/types").StepSubHarness<TContext, I, O>;
-    readonly opencode: <TContext = Readonly<Record<string, Record<string, unknown>>>, I = unknown, O = unknown>(opts: stepBuilders.StepSubHarnessOpts<TContext, O>) => import("@noetic-tools/types").StepSubHarness<TContext, I, O>;
-    readonly pi: <TContext = Readonly<Record<string, Record<string, unknown>>>, I = unknown, O = unknown>(opts: stepBuilders.StepSubHarnessOpts<TContext, O>) => import("@noetic-tools/types").StepSubHarness<TContext, I, O>;
-    readonly workflow: typeof stepWorkflow;
-};
+export declare function workflow(opts: WorkflowOpts): StepRunCode<ContextData, string, string>;

package/dist/builders/workflow-step.js

@@ -1,13 +1,13 @@
 /**
- * `step.workflow` — runs a `WorkflowDocument` as a single composable step.
+ * `workflow` — runs a `WorkflowDocument` as a single composable step.
  *
  * Lives beside `step-builders.ts` (rather than inside it) because the hydrator
- * imports the base `step` object; adding a hydrating builder there would create
- * an import cycle. This module composes the public `step` namespace instead.
+ * imports the base builders; adding a hydrating builder there would create an
+ * import cycle.
  */
 import { frameworkCast, NoeticConfigError } from '@noetic-tools/types';
 import { spawn } from './spawn-builder.js';
-import * as stepBuilders from './step-builders.js';
+import { runCode } from './step-builders.js';
 import { hydrateWorkflow } from './workflow-hydrator.js';
 //#endregion
 //#region Builder
@@ -21,25 +21,25 @@ import { hydrateWorkflow } from './workflow-hydrator.js';
  * workflow fails with `WORKFLOW_CYCLE` instead of recursing forever.
  *
  * @public
- * @param opts - See `StepWorkflowOpts`.
- * @returns A `StepRun` executing the workflow via the harness on the context.
+ * @param opts - See `WorkflowOpts`.
+ * @returns A `StepRunCode` executing the workflow via the harness on the context.
  * @throws `NoeticConfigError` with code `EMPTY_STEP_ID` if `id` is empty.
  * @throws `NoeticConfigError` with code `INVALID_WORKFLOW_SOURCE` unless exactly one of `document`/`ref` is set.
  * @throws `NoeticConfigError` with code `MISSING_HARNESS_CONTEXT` (at execution) without `ctx.harness`.
  * @throws `NoeticConfigError` with code `UNKNOWN_WORKFLOW_REFERENCE` (at execution) if `ref` names no registered workflow.
  */
-export function stepWorkflow(opts) {
+export function workflow(opts) {
     if (!opts.id || opts.id.trim() === '') {
         throw new NoeticConfigError({
             code: 'EMPTY_STEP_ID',
-            message: 'step.workflow() requires a non-empty id.',
-            hint: 'Pass a unique string as the id field, e.g. step.workflow({ id: "verify", ... }).',
+            message: 'workflow() requires a non-empty id.',
+            hint: 'Pass a unique string as the id field, e.g. workflow({ id: "verify", ... }).',
         });
     }
     if ((opts.document === undefined) === (opts.ref === undefined)) {
         throw new NoeticConfigError({
             code: 'INVALID_WORKFLOW_SOURCE',
-            message: `step.workflow('${opts.id}') requires exactly one of 'document' (inline) or 'ref' (named).`,
+            message: `workflow('${opts.id}') requires exactly one of 'document' (inline) or 'ref' (named).`,
             hint: "Pass document: { version: 1, root: ... } or ref: '<name>' with a workflows registry.",
         });
     }
@@ -48,14 +48,14 @@ export function stepWorkflow(opts) {
     // across sessions re-hydrates when it runs under a different harness
     // instead of routing nested steps through the first one.
     let cached;
-    return stepBuilders.step.run({
+    return runCode({
         id: opts.id,
         execute: async (input, ctx) => {
             const harness = ctx.harness;
             if (!harness) {
                 throw new NoeticConfigError({
                     code: 'MISSING_HARNESS_CONTEXT',
-                    message: 'step.workflow requires a harness on the execution context.',
+                    message: 'workflow requires a harness on the execution context.',
                     hint: 'Execute this step via AgentHarness.run() or ensure ctx.harness is set.',
                 });
             }
@@ -70,11 +70,6 @@ export function stepWorkflow(opts) {
         },
     });
 }
-/** @public The step builder namespace: the base builders plus `workflow`. */
-export const step = {
-    ...stepBuilders.step,
-    workflow: stepWorkflow,
-};
 //#endregion
 //#region Helpers
 function hydrate(opts, executeStep) {
@@ -82,7 +77,7 @@ function hydrate(opts, executeStep) {
     if (!doc) {
         throw new NoeticConfigError({
             code: 'UNKNOWN_WORKFLOW_REFERENCE',
-            message: `Workflow '${opts.ref}' referenced by step.workflow('${opts.id}') is not registered.`,
+            message: `Workflow '${opts.ref}' referenced by workflow('${opts.id}') is not registered.`,
             hint: `Pass named workflows via the workflows option. Available: ${[
                 ...(opts.workflows?.keys() ?? []),
             ].join(', ') || '(none)'}.`,
@@ -96,7 +91,7 @@ function hydrate(opts, executeStep) {
         executeStep,
         layers: opts.layers,
         workflows: opts.workflows,
-        subHarnesses: opts.subHarnesses,
+        acpAgents: opts.acpAgents,
         uiLibraries: opts.uiLibraries,
         resolveSubprocess: opts.resolveSubprocess,
         subflowAncestry: opts.ref

package/dist/conditions/conditions.d.ts

@@ -35,7 +35,7 @@ export declare function otherwise<TContext = ContextData, I = unknown, O = unkno
  *
  * @public
  * @param clauses - Ordered `WhenClause` and optional trailing `OtherwiseClause`.
- * @returns A route function suitable for `branch({ route })`.
+ * @returns A route function suitable for `conditional({ route })`.
  */
 export declare function semanticRoute<TContext = ContextData, I = unknown, O = unknown>(...clauses: Clause<TContext, I, O>[]): (input: I, ctx: Context) => Promise<Step<TContext, I, O> | null>;
 interface SemanticSwitchSimple<TContext, I, O> {
@@ -60,7 +60,7 @@ interface SemanticSwitchAdvanced<TContext, I, O> {
  *
  * @public
  * @param opts - Simple form with `Record<string, Step>` cases, or advanced form with multi-label cases.
- * @returns A route function suitable for `branch({ route })`.
+ * @returns A route function suitable for `conditional({ route })`.
  */
 export declare function semanticSwitch<TContext = ContextData, I = unknown, O = unknown>(opts: SemanticSwitchSimple<TContext, I, O>): (input: I, ctx: Context) => Promise<Step<TContext, I, O> | null>;
 /** @public */

package/dist/conditions/conditions.js

@@ -85,7 +85,7 @@ function isOtherwise(clause) {
  *
  * @public
  * @param clauses - Ordered `WhenClause` and optional trailing `OtherwiseClause`.
- * @returns A route function suitable for `branch({ route })`.
+ * @returns A route function suitable for `conditional({ route })`.
  */
 export function semanticRoute(...clauses) {
     return async (input, ctx) => {