@botbotgo/agent-harness 0.0.95 → 0.0.96

package/dist/config/workflows/runtime-profiles.yaml

@@ -0,0 +1,94 @@
+# agent-harness feature: schema version for this declarative config object.
+apiVersion: agent-harness/v1alpha1
+# agent-harness feature: catalog of reusable runtime entry profiles layered on workflow resources.
+kind: RuntimeProfiles
+spec:
+  - id: coding-runtime
+    workflowRef: langgraph-workflow/coding-loop
+    defaults:
+      approvalPolicy: safe-default
+      memoryPolicy: project-facts-only
+      directAnswerFirst: false
+      watchGithubActionsAfterPush: true
+      allowPushToMaster: false
+      closeGithubIssueOnSuccess: false
+    requiredAgents:
+      - coderAgent
+    optionalAgents:
+      - verifierAgent
+  - id: personal-assistant
+    workflowRef: langgraph-workflow/assistant-loop
+    defaults:
+      approvalPolicy: human-before-side-effects
+      memoryPolicy: user-preferences-and-routines
+      directAnswerFirst: true
+      persistDurableMemory: true
+    optionalAgents:
+      - defaultResearchAgent
+      - defaultWritingAgent
+      - defaultSchedulingAgent
+      - defaultWorkerAgent
+  - id: research-runtime
+    workflowRef: langgraph-workflow/research-loop
+    defaults:
+      approvalPolicy: minimal
+      memoryPolicy: report-summary-only
+      requireSourceGrounding: true
+      requireCoverageReview: true
+    requiredAgents:
+      - gathererAgent
+      - analystAgent
+    optionalAgents:
+      - synthesizerAgent
+  - id: approval-review-runtime
+    workflowRef: langgraph-workflow/approval-review-loop
+    defaults:
+      approvalPolicy: always-required
+      memoryPolicy: none
+      executeAfterApproval: true
+      auditTrail: full
+    requiredAgents:
+      - preparerAgent
+    optionalAgents:
+      - reviewerAgent
+  - id: claw-style-assistant
+    workflowRef: langgraph-workflow/assistant-loop
+    defaults:
+      approvalPolicy: human-before-side-effects
+      memoryPolicy: user-preferences-and-stable-context
+      channelFirst: true
+      attachmentAware: true
+      sessionMemory: thread-scoped
+    optionalAgents:
+      - defaultWorkerAgent
+  - id: chat-operator
+    workflowRef: langgraph-workflow/chat-router-loop
+    defaults:
+      approvalPolicy: route-dependent
+      memoryPolicy: thread-only
+      directAnswerFirst: true
+    optionalAgents:
+      - codingAgent
+      - researchAgent
+      - assistantAgent
+      - approvalAgent
+  - id: copilot-sidecar
+    workflowRef: langgraph-workflow/coding-lite-loop
+    defaults:
+      approvalPolicy: no-push
+      memoryPolicy: repo-context-only
+      directAnswerFirst: false
+      allowRepositoryEdits: true
+      allowPushToMaster: false
+      runIntegrationVerification: false
+    requiredAgents:
+      - coderAgent
+  - id: task-delegation-hub
+    workflowRef: langgraph-workflow/delegation-loop
+    defaults:
+      approvalPolicy: worker-dependent
+      memoryPolicy: task-summary-only
+      routingStrategy: planner-first
+      reviewerEnabled: true
+    optionalAgents:
+      - defaultWorkerFallback

package/dist/contracts/types.d.ts

@@ -320,10 +320,81 @@ export type RunResult = {
     artifacts?: ArtifactRecord[];
     metadata?: Record<string, unknown>;
 };
-export type RunListeners = {
+export type NormalizedUpstreamEvent = {
+    kind: "text-delta";
+    source: "model" | "state";
+    text: string;
+    ns?: string[];
+    nodeName?: string;
+} | {
+    kind: "reasoning-delta";
+    text: string;
+    ns?: string[];
+    nodeName?: string;
+} | {
+    kind: "tool-start";
+    toolName: string;
+    input?: unknown;
+    ns?: string[];
+    nodeName?: string;
+} | {
+    kind: "tool-end";
+    toolName: string;
+    output?: unknown;
+    isError?: boolean;
+    ns?: string[];
+    nodeName?: string;
+} | {
+    kind: "agent-step";
+    label: string;
+    ns?: string[];
+    nodeName?: string;
+} | {
+    kind: "interrupt";
+    interrupt: unknown;
+    ns?: string[];
+    nodeName?: string;
+} | {
+    kind: "run-event";
+    eventName: string;
+    data?: Record<string, unknown>;
+    ns?: string[];
+    nodeName?: string;
+};
+export type CompatibleStreamPart = {
+    type: "messages";
+    ns: string[];
+    data: [unknown, Record<string, unknown>];
+} | {
+    type: "updates";
+    ns: string[];
+    data: Record<string, unknown>;
+} | {
+    type: "custom";
+    ns: string[];
+    data: unknown;
+};
+export type UpstreamRuntimeEvent = {
+    format: "langgraph-v2";
+    /** @deprecated Prefer streamPart plus raw/event/name/data/ns for upstream-aligned consumption. */
+    normalized: NormalizedUpstreamEvent;
+    streamPart: CompatibleStreamPart;
+    raw: unknown;
+    event?: string;
+    name?: string;
+    runType?: string;
+    data?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    tags?: string[];
+    ns?: string[];
+};
+export type RuntimeListeners = {
+    onEvent?: (event: HarnessEvent) => void | Promise<void>;
+};
+export type FrontendStreamListeners = {
     onChunk?: (chunk: string) => void | Promise<void>;
     onContentBlocks?: (blocks: unknown[]) => void | Promise<void>;
-    onEvent?: (event: HarnessEvent) => void | Promise<void>;
+    onUpstreamEvent?: (event: UpstreamRuntimeEvent) => void | Promise<void>;
     onReasoning?: (chunk: string) => void | Promise<void>;
     onStep?: (step: string) => void | Promise<void>;
     onToolResult?: (item: {
@@ -332,6 +403,7 @@ export type RunListeners = {
         isError?: boolean;
     }) => void | Promise<void>;
 };
+export type RunListeners = RuntimeListeners & FrontendStreamListeners;
 export type MessageContentPart = {
     type: "text";
     text: string;
@@ -353,6 +425,8 @@ export type RunStartOptions = {
     priority?: number;
     invocation?: InvocationEnvelope;
     listeners?: RunListeners;
+    runtimeListeners?: RuntimeListeners;
+    frontendListeners?: FrontendStreamListeners;
 };
 export type RunDecisionOptions = {
     threadId: string;
@@ -361,11 +435,19 @@ export type RunDecisionOptions = {
     decision: "approve" | "edit" | "reject";
     editedInput?: Record<string, unknown>;
     listeners?: RunListeners;
+    runtimeListeners?: RuntimeListeners;
+    frontendListeners?: FrontendStreamListeners;
 };
 export type RunOptions = RunStartOptions | RunDecisionOptions;
 export type HarnessStreamItem = {
     type: "event";
     event: HarnessEvent;
+} | {
+    type: "upstream-event";
+    threadId: string;
+    runId: string;
+    agentId: string;
+    event: UpstreamRuntimeEvent;
 } | {
     type: "result";
     result: RunResult;

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.94";
+export declare const AGENT_HARNESS_VERSION = "0.0.95";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.94";
+export const AGENT_HARNESS_VERSION = "0.0.95";

package/dist/runtime/agent-runtime-adapter.js

@@ -13,7 +13,7 @@ import { tools as openAIProviderTools } from "@langchain/openai";
 import { createAgent, humanInTheLoopMiddleware, initChatModel } from "langchain";
 import { z } from "zod";
 import { extractEmptyAssistantMessageFailure, extractContentBlocks, extractOutputContent, extractReasoningText, extractToolFallbackContext, extractVisibleOutput, salvageToolArgs, isLikelyToolArgsObject, isToolCallParseFailure, STRICT_TOOL_JSON_INSTRUCTION, sanitizeVisibleText, tryParseJson, wrapResolvedModel, } from "./parsing/output-parsing.js";
-import { computeIncrementalOutput, extractAgentStep, extractInterruptPayload, extractReasoningStreamOutput, extractStateStreamOutput, extractVisibleStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, } from "./parsing/stream-event-parsing.js";
+import { computeIncrementalOutput, extractAgentStep, extractInterruptPayload, normalizeUpstreamRuntimeEvent, extractReasoningStreamOutput, extractStateStreamOutput, extractVisibleStreamOutput, extractTerminalStreamOutput, extractToolResult, normalizeTerminalOutputKey, readStreamDelta, } from "./parsing/stream-event-parsing.js";
 import { wrapToolForExecution } from "./tool-hitl.js";
 import { resolveDeclaredMiddleware } from "./declared-middleware.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
@@ -1333,13 +1333,13 @@ export class AgentRuntimeAdapter {
             .map((edge) => this.normalizeLangGraphWorkflowEdge(edge))
             .filter((edge) => edge !== null);
     }
-    shouldFollowLangGraphEdge(edge, state, executorResult) {
+    shouldFollowLangGraphEdge(edge, state, currentResult) {
         const condition = edge.when?.toLowerCase().trim();
         if (!condition || condition === "always") {
             return true;
         }
         const review = state.review?.toLowerCase() ?? "";
-        const hasResult = Boolean(executorResult);
+        const hasResult = Boolean(currentResult);
         switch (condition) {
             case "has_plan":
                 return Boolean(state.plan?.trim());
@@ -1365,9 +1365,9 @@ export class AgentRuntimeAdapter {
                 return false;
         }
     }
-    listLangGraphWorkflowNextNodes(workflow, nodeId, state, executorResult) {
+    listLangGraphWorkflowNextNodes(workflow, nodeId, state, currentResult) {
         return this.listLangGraphWorkflowEdges(workflow)
-            .filter((edge) => edge.from === nodeId && this.shouldFollowLangGraphEdge(edge, state, executorResult))
+            .filter((edge) => edge.from === nodeId && this.shouldFollowLangGraphEdge(edge, state, currentResult))
             .map((edge) => edge.to);
     }
     extractInvocationRequestText(request) {
@@ -1631,7 +1631,7 @@ export class AgentRuntimeAdapter {
             `User request:\n${userInputText}`,
             ...(workflowState.plan ? ["", `Workflow plan:\n${workflowState.plan}`] : []),
             ...(workflowState.review ? ["", `Workflow review:\n${workflowState.review}`] : []),
-            ...(activeResult ? ["", `Current executor result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`] : []),
+            ...(activeResult ? ["", `Current result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`] : []),
             "",
             "Complete the delegated subagent work and return concise results.",
         ].join("\n");
@@ -1746,7 +1746,7 @@ export class AgentRuntimeAdapter {
                             workflowState.review = await this.invokeWorkflowNodeModel(reviewerModel, reviewerPrompt, [
                                 `User request:\n${userInputText}`,
                                 "",
-                                `Executor result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`,
+                                `Current result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`,
                             ].join("\n"));
                         }
                         else if ((nodeRole === "finalizer" || nodeRole === "final") && activeResult) {
@@ -1988,7 +1988,7 @@ export class AgentRuntimeAdapter {
                     workflowState.review = await this.invokeWorkflowNodeModel(reviewerModel, reviewerPrompt, [
                         `User request:\n${userInputText}`,
                         "",
-                        `Executor result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`,
+                        `Current result:\n${extractVisibleOutput(activeResult) || JSON.stringify(activeResult, null, 2)}`,
                     ].join("\n"));
                     if (workflowState.review) {
                         yield { kind: "reasoning", content: workflowState.review };
@@ -2541,6 +2541,7 @@ export class AgentRuntimeAdapter {
                 const seenTerminalOutputs = new Set();
                 let lastStep = "";
                 for await (const event of this.iterateWithTimeout(events, streamIdleTimeoutMs, "agent streamEvents", streamDeadlineAt, invokeTimeoutMs)) {
+                    yield { kind: "upstream-event", event: normalizeUpstreamRuntimeEvent(event) };
                     const interruptPayload = extractInterruptPayload(event);
                     if (interruptPayload) {
                         yield { kind: "interrupt", content: interruptPayload };

package/dist/runtime/harness.d.ts

@@ -118,6 +118,7 @@ export declare class AgentHarnessRuntime {
     private acquireRunSlot;
     private dropPendingRunSlot;
     private dispatchRunListeners;
+    private resolveRunListeners;
     run(options: RunOptions): Promise<RunResult>;
     streamEvents(options: RunStartOptions): AsyncGenerator<HarnessStreamItem>;
     resume(options: ResumeOptions): Promise<RunResult>;

package/dist/runtime/harness.js

@@ -2,6 +2,7 @@ import { AUTO_AGENT_ID } from "../contracts/types.js";
 import { SqlitePersistence } from "../persistence/sqlite-store.js";
 import { createPersistentId } from "../utils/id.js";
 import { AGENT_INTERRUPT_SENTINEL_PREFIX, AgentRuntimeAdapter, RuntimeOperationTimeoutError } from "./agent-runtime-adapter.js";
+import { normalizeUpstreamRuntimeEvent } from "./parsing/stream-event-parsing.js";
 import { createResourceBackendResolver, createResourceToolResolver } from "../resource/resource.js";
 import { EventBus } from "./event-bus.js";
 import { PolicyEngine } from "./policy-engine.js";
@@ -1031,6 +1032,10 @@ export class AgentHarnessRuntime {
                 await this.notifyListener(listeners.onEvent, item.event);
                 continue;
             }
+            if (item.type === "upstream-event") {
+                await this.notifyListener(listeners.onUpstreamEvent, item.event);
+                continue;
+            }
             if (item.type === "result") {
                 latestResult = item.result;
                 continue;
@@ -1084,6 +1089,19 @@ export class AgentHarnessRuntime {
             pendingActionId: thread.pendingDecision?.pendingActionId,
         };
     }
+    resolveRunListeners(options) {
+        const runtimeListeners = "runtimeListeners" in options ? options.runtimeListeners : undefined;
+        const frontendListeners = "frontendListeners" in options ? options.frontendListeners : undefined;
+        const listeners = options.listeners;
+        if (!listeners && !runtimeListeners && !frontendListeners) {
+            return undefined;
+        }
+        return {
+            ...(runtimeListeners ?? {}),
+            ...(frontendListeners ?? {}),
+            ...(listeners ?? {}),
+        };
+    }
     async run(options) {
         if (this.isDecisionRun(options)) {
             const resumeOptions = {
@@ -1095,8 +1113,9 @@ export class AgentHarnessRuntime {
             };
             return this.resume(resumeOptions);
         }
-        if (options.listeners) {
-            return this.dispatchRunListeners(this.streamEvents(options), options.listeners);
+        const resolvedListeners = this.resolveRunListeners(options);
+        if (resolvedListeners) {
+            return this.dispatchRunListeners(this.streamEvents(options), resolvedListeners);
         }
         const invocation = this.normalizeInvocationEnvelope(options);
         const selectedAgentId = await this.resolveSelectedAgentId(options.input, options.agentId, options.threadId);
@@ -1191,6 +1210,18 @@ export class AgentHarnessRuntime {
                                 ? { kind: "interrupt", content: chunk.slice(AGENT_INTERRUPT_SENTINEL_PREFIX.length) }
                                 : { kind: "content", content: chunk }
                             : chunk;
+                        if (normalizedChunk.kind === "upstream-event") {
+                            yield {
+                                type: "upstream-event",
+                                threadId,
+                                runId,
+                                agentId: selectedAgentId,
+                                event: normalizedChunk.event.format === "langgraph-v2"
+                                    ? normalizedChunk.event
+                                    : normalizeUpstreamRuntimeEvent(normalizedChunk.event.raw ?? normalizedChunk.event),
+                            };
+                            continue;
+                        }
                         if (normalizedChunk.kind === "interrupt") {
                             const checkpointRef = `checkpoints/${threadId}/${runId}/cp-1`;
                             const waitingEvent = await this.setRunStateAndEmit(threadId, runId, 6, "waiting_for_approval", {

package/dist/runtime/langgraph-presets.js

@@ -27,135 +27,135 @@ export function resolveLangGraphPresetWorkflow(presetName, options = {}) {
             return undefined;
         case "react":
             return {
-                entryNode: "executor",
+                entryNode: "step1",
                 nodes: [
-                    { id: "executor", kind: "agent" },
+                    { id: "step1", kind: "agent" },
                 ],
                 edges: [],
             };
         case "prompt-chaining":
         case "plan-execute":
             return {
-                entryNode: "planner",
+                entryNode: "step1",
                 nodes: [
-                    { id: "planner", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
-                    { id: "executor", kind: "agent" },
-                    { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                    { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "step2", kind: "agent" },
+                    { id: "step3", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
                 ],
                 edges: [
-                    { from: "planner", to: "executor" },
-                    { from: "executor", to: "finalizer", when: "has_result" },
+                    { from: "step1", to: "step2" },
+                    { from: "step2", to: "step3", when: "has_result" },
                 ],
             };
         case "routing": {
             const agent = requireAgent("routing", options);
             return {
-                entryNode: "planner",
+                entryNode: "step1",
                 nodes: [
-                    { id: "planner", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
-                    { id: "worker", kind: "agent", agent },
-                    { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                    { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "step2", kind: "agent", agent },
+                    { id: "step3", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
                 ],
                 edges: [
-                    { from: "planner", to: "worker" },
-                    { from: "worker", to: "finalizer", when: "has_result" },
+                    { from: "step1", to: "step2" },
+                    { from: "step2", to: "step3", when: "has_result" },
                 ],
             };
         }
         case "parallelization": {
             const agent = requireAgent("parallelization", options);
             return {
-                entryNode: "planner",
+                entryNode: "step1",
                 nodes: [
-                    { id: "planner", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
-                    { id: "worker", kind: "agent", agent },
-                    { id: "reviewer", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
-                    { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                    { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "step2", kind: "agent", agent },
+                    { id: "step3", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+                    { id: "step4", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
                 ],
                 edges: [
-                    { from: "planner", to: "worker" },
-                    { from: "worker", to: "reviewer", when: "has_result" },
-                    { from: "reviewer", to: "finalizer", when: "review_ok" },
+                    { from: "step1", to: "step2" },
+                    { from: "step2", to: "step3", when: "has_result" },
+                    { from: "step3", to: "step4", when: "review_ok" },
                 ],
             };
         }
         case "review-loop":
             return {
-                entryNode: "planner",
+                entryNode: "step1",
                 nodes: [
-                    { id: "planner", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
-                    { id: "executor", kind: "agent" },
-                    { id: "reviewer", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
-                    { id: "replanner", kind: "llm", role: "replanner", prompt: DEFAULT_REPLANNER_PROMPT },
-                    { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                    { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "step2", kind: "agent" },
+                    { id: "step3", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+                    { id: "step4", kind: "llm", role: "replanner", prompt: DEFAULT_REPLANNER_PROMPT },
+                    { id: "step5", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
                 ],
                 edges: [
-                    { from: "planner", to: "executor" },
-                    { from: "executor", to: "reviewer", when: "has_result" },
-                    { from: "reviewer", to: "finalizer", when: "review_ok" },
-                    { from: "reviewer", to: "replanner", when: "review_incomplete" },
-                    { from: "replanner", to: "executor", when: "has_plan" },
+                    { from: "step1", to: "step2" },
+                    { from: "step2", to: "step3", when: "has_result" },
+                    { from: "step3", to: "step5", when: "review_ok" },
+                    { from: "step3", to: "step4", when: "review_incomplete" },
+                    { from: "step4", to: "step2", when: "has_plan" },
                 ],
             };
         case "evaluator-optimizer":
             return {
-                entryNode: "executor",
+                entryNode: "step1",
                 nodes: [
-                    { id: "executor", kind: "agent" },
-                    { id: "reviewer", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
-                    { id: "replanner", kind: "llm", role: "replanner", prompt: DEFAULT_REPLANNER_PROMPT },
-                    { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                    { id: "step1", kind: "agent" },
+                    { id: "step2", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+                    { id: "step3", kind: "llm", role: "replanner", prompt: DEFAULT_REPLANNER_PROMPT },
+                    { id: "step4", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
                 ],
                 edges: [
-                    { from: "executor", to: "reviewer", when: "has_result" },
-                    { from: "reviewer", to: "finalizer", when: "review_ok" },
-                    { from: "reviewer", to: "replanner", when: "review_incomplete" },
-                    { from: "replanner", to: "executor", when: "has_plan" },
+                    { from: "step1", to: "step2", when: "has_result" },
+                    { from: "step2", to: "step4", when: "review_ok" },
+                    { from: "step2", to: "step3", when: "review_incomplete" },
+                    { from: "step3", to: "step1", when: "has_plan" },
                 ],
             };
         case "approval-gate":
             return {
-                entryNode: "planner",
+                entryNode: "step1",
                 nodes: [
-                    { id: "planner", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
-                    { id: "approval", kind: "approval" },
-                    { id: "executor", kind: "agent" },
-                    { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                    { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "step2", kind: "approval" },
+                    { id: "step3", kind: "agent" },
+                    { id: "step4", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
                 ],
                 edges: [
-                    { from: "planner", to: "approval" },
-                    { from: "approval", to: "executor", when: "approval_approved" },
-                    { from: "approval", to: "executor", when: "approval_edited" },
-                    { from: "executor", to: "finalizer", when: "has_result" },
+                    { from: "step1", to: "step2" },
+                    { from: "step2", to: "step3", when: "approval_approved" },
+                    { from: "step2", to: "step3", when: "approval_edited" },
+                    { from: "step3", to: "step4", when: "has_result" },
                 ],
             };
         case "handoff": {
             const agent = requireAgent("handoff", options);
             return {
-                entryNode: "worker",
+                entryNode: "step1",
                 nodes: [
-                    { id: "worker", kind: "agent", agent },
-                    { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                    { id: "step1", kind: "agent", agent },
+                    { id: "step2", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
                 ],
                 edges: [
-                    { from: "worker", to: "finalizer", when: "has_result" },
+                    { from: "step1", to: "step2", when: "has_result" },
                 ],
             };
         }
         case "orchestrator-workers": {
             const agent = requireAgent("orchestrator-workers", options);
             return {
-                entryNode: "planner",
+                entryNode: "step1",
                 nodes: [
-                    { id: "planner", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
-                    { id: "worker", kind: "agent", agent },
-                    { id: "reviewer", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
-                    { id: "finalizer", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
+                    { id: "step1", kind: "llm", role: "planner", prompt: DEFAULT_PLANNER_PROMPT },
+                    { id: "step2", kind: "agent", agent },
+                    { id: "step3", kind: "llm", role: "reviewer", prompt: DEFAULT_REVIEWER_PROMPT },
+                    { id: "step4", kind: "llm", role: "finalizer", prompt: DEFAULT_FINALIZER_PROMPT },
                 ],
                 edges: [
-                    { from: "planner", to: "worker" },
-                    { from: "worker", to: "reviewer", when: "has_result" },
-                    { from: "reviewer", to: "finalizer", when: "review_ok" },
+                    { from: "step1", to: "step2" },
+                    { from: "step2", to: "step3", when: "has_result" },
+                    { from: "step3", to: "step4", when: "review_ok" },
                 ],
             };
         }