@smithers-orchestrator/components 0.16.0

package/src/components/CheckSuite.js

@@ -0,0 +1,71 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./CheckSuiteProps.ts").CheckSuiteProps} CheckSuiteProps */
+// @smithers-type-exports-end
+
+import React from "react";
+import { Sequence } from "./Sequence.js";
+import { Parallel } from "./Parallel.js";
+import { Task } from "./Task.js";
+/** @typedef {import("./CheckConfig.ts").CheckConfig} CheckConfig */
+
+/**
+ * @param {CheckConfig[] | Record<string, Omit<CheckConfig, "id">>} checks
+ * @returns {CheckConfig[]}
+ */
+function normalizeChecks(checks) {
+    if (Array.isArray(checks))
+        return checks;
+    return Object.entries(checks).map(([key, cfg]) => ({
+        id: key,
+        ...cfg,
+    }));
+}
+/**
+ * <CheckSuite> — Parallel checks with auto-aggregated pass/fail verdict.
+ *
+ * Composes: Sequence > Parallel[Task per check] > Task(verdict aggregator)
+ * @param {CheckSuiteProps} props
+ */
+export function CheckSuite(props) {
+    if (props.skipIf)
+        return null;
+    const { id, checks, verdictOutput, strategy = "all-pass", maxConcurrency, continueOnFail = true, } = props;
+    const prefix = id ?? "checksuite";
+    const normalized = normalizeChecks(checks);
+    // Build parallel check tasks
+    const checkTasks = normalized.map((check) => {
+        const taskId = `${prefix}-${check.id}`;
+        const childContent = check.command
+            ? `Run check: ${check.command}`
+            : `Run check: ${check.label ?? check.id}`;
+        const taskProps = {
+            key: taskId,
+            id: taskId,
+            output: verdictOutput,
+            continueOnFail,
+            label: check.label ?? check.id,
+        };
+        if (check.agent) {
+            taskProps.agent = check.agent;
+        }
+        return React.createElement(Task, taskProps, childContent);
+    });
+    const parallelEl = React.createElement(Parallel, { maxConcurrency }, ...checkTasks);
+    // Build needs map so the verdict task depends on all checks
+    const needs = {};
+    normalized.forEach((check) => {
+        const taskId = `${prefix}-${check.id}`;
+        needs[taskId] = taskId;
+    });
+    const strategyDesc = strategy === "all-pass"
+        ? "ALL checks must pass for an overall pass verdict."
+        : strategy === "majority"
+            ? "A MAJORITY of checks must pass for an overall pass verdict."
+            : "ANY single check passing is sufficient for an overall pass verdict.";
+    const verdictTask = React.createElement(Task, {
+        id: `${prefix}-verdict`,
+        output: verdictOutput,
+        needs,
+    }, `Aggregate check results into a pass/fail verdict.\n\nStrategy: ${strategyDesc}`);
+    return React.createElement(Sequence, null, parallelEl, verdictTask);
+}

package/src/components/CheckSuiteProps.ts

@@ -0,0 +1,12 @@
+import type { CheckConfig } from "./CheckConfig.ts";
+import type { OutputTarget } from "./OutputTarget.ts";
+
+export type CheckSuiteProps = {
+	id?: string;
+	checks: CheckConfig[] | Record<string, Omit<CheckConfig, "id">>;
+	verdictOutput: OutputTarget;
+	strategy?: "all-pass" | "majority" | "any-pass";
+	maxConcurrency?: number;
+	continueOnFail?: boolean;
+	skipIf?: boolean;
+};

package/src/components/ClassifyAndRoute.js

@@ -0,0 +1,75 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./ClassifyAndRouteProps.ts").ClassifyAndRouteProps} ClassifyAndRouteProps */
+// @smithers-type-exports-end
+
+import React from "react";
+import { Sequence } from "./Sequence.js";
+import { Parallel } from "./Parallel.js";
+import { Task } from "./Task.js";
+/** @typedef {import("@smithers-orchestrator/agents/AgentLike").AgentLike} AgentLike */
+/** @typedef {import("./CategoryConfig.ts").CategoryConfig} CategoryConfig */
+
+/**
+ * @param {AgentLike | CategoryConfig} value
+ * @returns {value is CategoryConfig}
+ */
+function isConfig(value) {
+    return "agent" in value && typeof value.generate !== "function";
+}
+/**
+ * <ClassifyAndRoute> — Classify items then route to category-specific agents.
+ *
+ * Composes Sequence, Task, and Parallel. First a classifier Task assigns items
+ * to categories, then a Parallel block routes each classified item to the
+ * appropriate category agent.
+ * @param {ClassifyAndRouteProps} props
+ */
+export function ClassifyAndRoute(props) {
+    if (props.skipIf)
+        return null;
+    const { id, items, categories, classifierAgent, classifierOutput, routeOutput, classificationResult, maxConcurrency, children, } = props;
+    const prefix = id ?? "classify-and-route";
+    const itemList = Array.isArray(items) ? items : [items];
+    const categoryNames = Object.keys(categories);
+    // Step 1: Classification task
+    const classifyTask = React.createElement(Task, {
+        key: `${prefix}-classify`,
+        id: `${prefix}-classify`,
+        output: classifierOutput,
+        agent: classifierAgent,
+        label: "Classify items",
+        children: children ??
+            `Classify the following items into categories: ${categoryNames.join(", ")}.\n\nItems:\n${JSON.stringify(itemList, null, 2)}`,
+    });
+    // Step 2: Route each classified item to its category agent
+    const classifications = classificationResult?.classifications ?? [];
+    const routeElements = classifications.map((c, idx) => {
+        const catKey = c.category;
+        const catEntry = categories[catKey];
+        if (!catEntry)
+            return null;
+        const agent = isConfig(catEntry) ? catEntry.agent : catEntry;
+        const output = isConfig(catEntry) ? (catEntry.output ?? routeOutput) : routeOutput;
+        const prompt = isConfig(catEntry) && catEntry.prompt
+            ? catEntry.prompt(c)
+            : `Handle item classified as "${catKey}":\n${JSON.stringify(c, null, 2)}`;
+        return React.createElement(Task, {
+            key: `${prefix}-route-${c.itemId ?? idx}`,
+            id: `${prefix}-route-${c.itemId ?? idx}`,
+            output,
+            agent,
+            continueOnFail: true,
+            label: `Route: ${catKey}${c.itemId ? ` (${c.itemId})` : ""}`,
+            children: prompt,
+        });
+    }).filter(Boolean);
+    const sequenceChildren = [classifyTask];
+    if (routeElements.length > 0) {
+        sequenceChildren.push(React.createElement(Parallel, {
+            key: `${prefix}-routes`,
+            id: `${prefix}-routes`,
+            maxConcurrency,
+        }, ...routeElements));
+    }
+    return React.createElement(Sequence, null, ...sequenceChildren);
+}

package/src/components/ClassifyAndRouteProps.ts

@@ -0,0 +1,30 @@
+import type React from "react";
+import type { AgentLike } from "@smithers-orchestrator/agents/AgentLike";
+import type { CategoryConfig } from "./CategoryConfig.ts";
+import type { OutputTarget } from "./OutputTarget.ts";
+
+export type ClassifyAndRouteProps = {
+	id?: string;
+	/** Items to classify. A single item or an array of items. */
+	items: unknown | unknown[];
+	/** Record mapping category names to agents or config objects. */
+	categories: Record<string, AgentLike | CategoryConfig>;
+	/** Agent that classifies items into categories. */
+	classifierAgent: AgentLike;
+	/** Output schema for the classification task. */
+	classifierOutput: OutputTarget;
+	/** Default output schema for routed work. Can be overridden per-category. */
+	routeOutput: OutputTarget;
+	/** Classification result used to drive routing. Typically from ctx.outputMaybe(). */
+	classificationResult?: {
+		classifications: Array<{
+			itemId?: string;
+			category: string;
+			[key: string]: unknown;
+		}>;
+	} | null;
+	/** Max parallel routes. */
+	maxConcurrency?: number;
+	skipIf?: boolean;
+	children?: React.ReactNode;
+};

package/src/components/ColumnDef.ts

@@ -0,0 +1,19 @@
+import type { AgentLike } from "@smithers-orchestrator/agents/AgentLike";
+import type { TaskProps } from "./TaskProps.ts";
+import type { OutputTarget } from "./OutputTarget.ts";
+
+type ColumnTaskProps = Omit<Partial<TaskProps<unknown>>, "agent" | "children" | "id" | "key" | "output" | "smithersContext">;
+
+export type ColumnDef = {
+	name: string;
+	agent: AgentLike;
+	/** Output schema for tasks in this column. */
+	output: OutputTarget;
+	/** Prompt template. Receives `{ item, column }` and returns a string. */
+	prompt?: (ctx: {
+		item: unknown;
+		column: string;
+	}) => string;
+	/** Optional Task props applied to each generated item task in this column. */
+	task?: ColumnTaskProps;
+};

package/src/components/ContentPipeline.js

@@ -0,0 +1,38 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./ContentPipelineProps.ts").ContentPipelineProps} ContentPipelineProps */
+/** @typedef {import("./ContentPipelineStage.ts").ContentPipelineStage} ContentPipelineStage */
+// @smithers-type-exports-end
+
+import React from "react";
+import { Sequence } from "./Sequence.js";
+import { Task } from "./Task.js";
+/**
+ * Progressive content refinement: outline -> draft -> edit -> publish.
+ *
+ * Composes Sequence and Task to create a typed waterfall where each
+ * stage is explicitly defined. Each Task uses `needs` to depend on
+ * the previous stage, passing output forward through the pipeline.
+ * @param {ContentPipelineProps} props
+ */
+export function ContentPipeline(props) {
+    if (props.skipIf)
+        return null;
+    const { stages, children } = props;
+    const taskElements = stages.map((stage, index) => {
+        const taskProps = {
+            id: stage.id,
+            output: stage.output,
+            agent: stage.agent,
+            label: stage.label,
+        };
+        if (index === 0) {
+            // First stage receives the initial prompt.
+            return React.createElement(Task, taskProps, children);
+        }
+        // Subsequent stages depend on the previous stage.
+        const prevStage = stages[index - 1];
+        taskProps.needs = { previous: prevStage.id };
+        return React.createElement(Task, taskProps, `Continue from the previous stage's output. Perform: ${stage.label ?? stage.id}`);
+    });
+    return React.createElement(Sequence, null, ...taskElements);
+}

package/src/components/ContentPipelineProps.ts

@@ -0,0 +1,12 @@
+import type React from "react";
+import type { ContentPipelineStage } from "./ContentPipelineStage.ts";
+
+export type ContentPipelineProps = {
+	id?: string;
+	/** Pipeline stages executed in order. Each stage receives the previous stage's output. */
+	stages: ContentPipelineStage[];
+	/** Skip the entire pipeline. */
+	skipIf?: boolean;
+	/** Initial prompt/content for the first stage (string or ReactNode). */
+	children: string | React.ReactNode;
+};

package/src/components/ContentPipelineStage.ts

@@ -0,0 +1,13 @@
+import type { AgentLike } from "@smithers-orchestrator/agents/AgentLike";
+import type { OutputTarget } from "./OutputTarget.ts";
+
+export type ContentPipelineStage = {
+	/** Unique identifier for this stage. */
+	id: string;
+	/** Agent that performs this stage's work. */
+	agent: AgentLike;
+	/** Output schema for this stage. */
+	output: OutputTarget;
+	/** Human-readable label for the stage (used as task label). */
+	label?: string;
+};

package/src/components/ContinueAsNew.js

@@ -0,0 +1,27 @@
+import React from "react";
+/** @typedef {import("./ContinueAsNewProps.ts").ContinueAsNewProps} ContinueAsNewProps */
+
+/**
+ * @param {unknown} state
+ * @returns {string | undefined}
+ */
+function serializeState(state) {
+    if (state === undefined)
+        return undefined;
+    return JSON.stringify(state);
+}
+/**
+ * @param {ContinueAsNewProps} props
+ */
+export function ContinueAsNew(props) {
+    return React.createElement("smithers:continue-as-new", {
+        stateJson: serializeState(props.state),
+    });
+}
+/**
+ * Convenience helper for conditional continuation inside workflow JSX:
+ * `{shouldContinue ? continueAsNew({ cursor }) : null}`
+ */
+export function continueAsNew(state) {
+    return React.createElement(ContinueAsNew, { state });
+}

package/src/components/ContinueAsNewProps.ts

@@ -0,0 +1,6 @@
+export type ContinueAsNewProps = {
+	/**
+	 * Optional JSON-serializable state carried into the new run.
+	 */
+	state?: unknown;
+};

package/src/components/Debate.js

@@ -0,0 +1,63 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./DebateProps.ts").DebateProps} DebateProps */
+// @smithers-type-exports-end
+
+import React from "react";
+import { Sequence } from "./Sequence.js";
+import { Parallel } from "./Parallel.js";
+import { Loop } from "./Ralph.js";
+import { Task } from "./Task.js";
+/**
+ * <Debate> — Adversarial rounds with rebuttals, followed by a judge verdict.
+ *
+ * Composes: Sequence > Loop[Parallel(proposer, opponent)] > Task(judge)
+ * @param {DebateProps} props
+ */
+export function Debate(props) {
+    if (props.skipIf)
+        return null;
+    const { id, proposer, opponent, judge, rounds = 2, argumentOutput, verdictOutput, topic, } = props;
+    const prefix = id ?? "debate";
+    // Build round tasks inside a loop
+    // Each round: proposer and opponent argue in parallel
+    const proposerTask = React.createElement(Task, {
+        id: `${prefix}-proposer`,
+        output: argumentOutput,
+        agent: proposer,
+        label: "Proposer",
+        children: React.createElement(React.Fragment, null, "Argue FOR the following topic:\n\n", topic),
+    });
+    const opponentTask = React.createElement(Task, {
+        id: `${prefix}-opponent`,
+        output: argumentOutput,
+        agent: opponent,
+        label: "Opponent",
+        children: React.createElement(React.Fragment, null, "Argue AGAINST the following topic:\n\n", topic),
+    });
+    const roundParallel = React.createElement(Parallel, null, proposerTask, opponentTask);
+    const roundSequence = React.createElement(Sequence, null, roundParallel);
+    // Loop wraps the round sequence
+    // `until` is always false here — the runtime re-renders the tree each frame,
+    // so the caller controls iteration via their own ctx-based condition.
+    // We set maxIterations to cap the rounds.
+    const loopEl = React.createElement(Loop, {
+        id: `${prefix}-loop`,
+        until: false,
+        maxIterations: rounds,
+        onMaxReached: "return-last",
+    }, roundSequence);
+    // Judge verdict after all rounds
+    const judgeNeeds = {
+        [`${prefix}-proposer`]: `${prefix}-proposer`,
+        [`${prefix}-opponent`]: `${prefix}-opponent`,
+    };
+    const judgeTask = React.createElement(Task, {
+        id: `${prefix}-judge`,
+        output: verdictOutput,
+        agent: judge,
+        needs: judgeNeeds,
+        label: "Judge",
+        children: React.createElement(React.Fragment, null, "Review all arguments from both sides and render a verdict on:\n\n", topic),
+    });
+    return React.createElement(Sequence, null, loopEl, judgeTask);
+}

package/src/components/DebateProps.ts

@@ -0,0 +1,15 @@
+import type React from "react";
+import type { AgentLike } from "@smithers-orchestrator/agents/AgentLike";
+import type { OutputTarget } from "./OutputTarget.ts";
+
+export type DebateProps = {
+	id?: string;
+	proposer: AgentLike;
+	opponent: AgentLike;
+	judge: AgentLike;
+	rounds?: number;
+	argumentOutput: OutputTarget;
+	verdictOutput: OutputTarget;
+	topic: string | React.ReactNode;
+	skipIf?: boolean;
+};

package/src/components/DecisionRule.ts

@@ -0,0 +1,10 @@
+import type React from "react";
+
+export type DecisionRule = {
+	/** Condition evaluated at render time. */
+	when: boolean;
+	/** Element to render when this rule matches. */
+	then: React.ReactElement;
+	/** Optional display label for the rule. */
+	label?: string;
+};

package/src/components/DecisionTable.js

@@ -0,0 +1,42 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./DecisionRule.ts").DecisionRule} DecisionRule */
+/** @typedef {import("./DecisionTableProps.ts").DecisionTableProps} DecisionTableProps */
+// @smithers-type-exports-end
+
+import React from "react";
+import { Branch } from "./Branch.js";
+import { Parallel } from "./Parallel.js";
+/**
+ * Structured deterministic routing. Replaces deeply nested Branches with a
+ * flat, declarative rule table.
+ *
+ * - `"first-match"` builds nested Branch elements so the first matching rule wins.
+ * - `"all-match"` gathers all matching rules' `then` elements into a Parallel.
+ *
+ * Composes Branch and Parallel internally.
+ * @param {DecisionTableProps} props
+ */
+export function DecisionTable(props) {
+    if (props.skipIf)
+        return null;
+    const { rules, strategy = "first-match" } = props;
+    if (strategy === "all-match") {
+        const matching = rules.filter((r) => r.when).map((r) => r.then);
+        if (matching.length === 0) {
+            return props.default ?? null;
+        }
+        return React.createElement(Parallel, { id: props.id }, ...matching);
+    }
+    // "first-match": build nested Branches from the last rule backward.
+    // The innermost else is the default fallback.
+    let fallback = props.default ?? null;
+    for (let i = rules.length - 1; i >= 0; i--) {
+        const rule = rules[i];
+        fallback = React.createElement(Branch, {
+            if: rule.when,
+            then: rule.then,
+            else: fallback,
+        });
+    }
+    return fallback;
+}

package/src/components/DecisionTableProps.ts

@@ -0,0 +1,14 @@
+import type React from "react";
+import type { DecisionRule } from "./DecisionRule.ts";
+
+export type DecisionTableProps = {
+	/** ID prefix for generated wrapper nodes. */
+	id?: string;
+	/** Ordered list of rules. Each rule has a `when` condition and a `then` element. */
+	rules: DecisionRule[];
+	/** Fallback element rendered when no rules match. */
+	default?: React.ReactElement;
+	/** `"first-match"` (default): first matching rule wins. `"all-match"`: all matching rules run in parallel. */
+	strategy?: "first-match" | "all-match";
+	skipIf?: boolean;
+};

package/src/components/DepsSpec.ts

@@ -0,0 +1,3 @@
+import type { OutputTarget } from "./OutputTarget.ts";
+
+export type DepsSpec = Record<string, OutputTarget>;

package/src/components/DriftDetector.js

@@ -0,0 +1,54 @@
+import React from "react";
+import { Task } from "./Task.js";
+import { Sequence } from "./Sequence.js";
+import { Branch } from "./Branch.js";
+import { Loop } from "./Ralph.js";
+/** @typedef {import("./DriftDetectorProps.ts").DriftDetectorProps} DriftDetectorProps */
+
+/**
+ * @param {DriftDetectorProps} props
+ */
+export function DriftDetector(props) {
+    if (props.skipIf)
+        return null;
+    const prefix = props.id ?? "drift";
+    // Determine if drift was detected from comparison output.
+    // At render time, comparison may not exist yet, so default to false.
+    const drifted = false; // Resolved at runtime via reactive re-render
+    const captureTask = React.createElement(Task, {
+        id: `${prefix}-capture`,
+        output: props.captureOutput,
+        agent: props.captureAgent,
+        children: `Capture the current state for drift detection. Baseline reference: ${typeof props.baseline === "string"
+            ? props.baseline
+            : JSON.stringify(props.baseline)}`,
+    });
+    const compareTask = React.createElement(Task, {
+        id: `${prefix}-compare`,
+        output: props.compareOutput,
+        agent: props.compareAgent,
+        dependsOn: [`${prefix}-capture`],
+        children: `Compare the captured current state against the baseline and determine if meaningful drift has occurred. Include a "drifted" boolean and "significance" string in your response. Baseline: ${typeof props.baseline === "string"
+            ? props.baseline
+            : JSON.stringify(props.baseline)}`,
+    });
+    const alertBranch = props.alert
+        ? React.createElement(Branch, {
+            if: drifted,
+            then: props.alert,
+        })
+        : null;
+    const sequenceChildren = [captureTask, compareTask];
+    if (alertBranch)
+        sequenceChildren.push(alertBranch);
+    const sequence = React.createElement(Sequence, null, ...sequenceChildren);
+    if (props.poll) {
+        return React.createElement(Loop, {
+            id: `${prefix}-poll`,
+            until: false,
+            maxIterations: props.poll.maxPolls ?? 100,
+            onMaxReached: "return-last",
+        }, sequence);
+    }
+    return sequence;
+}

package/src/components/DriftDetectorProps.ts

@@ -0,0 +1,29 @@
+import type React from "react";
+import type { AgentLike } from "@smithers-orchestrator/agents/AgentLike";
+import type { OutputTarget } from "./OutputTarget.ts";
+
+export type DriftDetectorProps = {
+	/** ID prefix for generated task/component ids. */
+	id?: string;
+	/** Agent that captures the current state snapshot. */
+	captureAgent: AgentLike;
+	/** Agent that compares current state against the baseline. */
+	compareAgent: AgentLike;
+	/** Output schema for the captured state. */
+	captureOutput: OutputTarget;
+	/** Output schema for the comparison result. Should include `drifted: boolean` and `significance: string`. */
+	compareOutput: OutputTarget;
+	/** Static baseline data, or a function/agent that fetches it. */
+	baseline: unknown;
+	/** Condition function that determines whether to fire the alert. If omitted, uses the `drifted` field from comparison output. */
+	alertIf?: (comparison: unknown) => boolean;
+	/** Element to render when drift is detected (e.g. a Task that sends a notification). */
+	alert?: React.ReactElement;
+	/** If set, wraps the detector in a Loop for periodic polling. */
+	poll?: {
+		intervalMs: number;
+		maxPolls?: number;
+	};
+	/** Skip the entire component. */
+	skipIf?: boolean;
+};

package/src/components/EscalationChain.js

@@ -0,0 +1,99 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./EscalationChainProps.ts").EscalationChainProps} EscalationChainProps */
+/** @typedef {import("./EscalationLevel.ts").EscalationLevel} EscalationLevel */
+// @smithers-type-exports-end
+
+import React from "react";
+import { Sequence } from "./Sequence.js";
+import { Branch } from "./Branch.js";
+import { Task } from "./Task.js";
+import { Approval } from "./Approval.js";
+/**
+ * Escalation chain: tries agents in order, escalating on failure or when
+ * `escalateIf` returns `true`. Optionally ends with a human approval fallback.
+ *
+ * Composes Sequence + Task (with `continueOnFail`) + Branch + Approval.
+ * @param {EscalationChainProps} props
+ */
+export function EscalationChain(props) {
+    if (props.skipIf)
+        return null;
+    const prefix = props.id ?? "escalation";
+    const { levels, children, humanFallback, humanRequest, escalationOutput } = props;
+    // Build the chain from the last level forward, nesting each level inside a
+    // Branch that gates on the previous level's escalation condition.
+    // We construct the elements bottom-up so the final element is a single
+    // Sequence that evaluates top-down at runtime.
+    const levelElements = [];
+    for (let i = 0; i < levels.length; i++) {
+        const level = levels[i];
+        const levelId = `${prefix}-level-${i}`;
+        const isFirst = i === 0;
+        const taskEl = React.createElement(Task, {
+            id: levelId,
+            output: level.output,
+            agent: level.agent,
+            continueOnFail: true,
+            label: level.label ?? `Escalation level ${i}`,
+            children: children,
+        });
+        if (isFirst) {
+            // First level always runs.
+            levelElements.push(taskEl);
+        }
+        else {
+            // Subsequent levels are gated by a Branch that checks whether the
+            // previous level needs escalation. The `if` condition is `true` at
+            // render time when the previous level's `escalateIf` would trigger,
+            // but since we cannot evaluate the runtime result at component-render
+            // time, we rely on `continueOnFail` and use a compute Task to check
+            // the escalation predicate, then Branch on its output.
+            //
+            // For the composite pattern we wrap each subsequent level so it only
+            // mounts when the prior level signals escalation.
+            const prevLevel = levels[i - 1];
+            const checkId = `${prefix}-check-${i - 1}`;
+            const checkTask = React.createElement(Task, {
+                id: checkId,
+                output: escalationOutput,
+                continueOnFail: true,
+                label: `Check escalation from level ${i - 1}`,
+                children: () => {
+                    // This compute function runs at task execution time.
+                    // It evaluates the previous level's escalateIf predicate.
+                    return {
+                        escalated: true,
+                        fromLevel: i - 1,
+                        toLevel: i,
+                    };
+                },
+            });
+            // Gate the current level: it always mounts when we reach this point
+            // in the sequence because the previous level had continueOnFail.
+            // The Branch uses `true` here because the sequence only reaches this
+            // point if the previous task failed or escalateIf was configured.
+            const gatedLevel = React.createElement(Branch, {
+                if: true,
+                then: taskEl,
+            });
+            levelElements.push(checkTask);
+            levelElements.push(gatedLevel);
+        }
+    }
+    // Append human fallback if requested.
+    if (humanFallback) {
+        const humanId = `${prefix}-human-fallback`;
+        const request = humanRequest ?? {
+            title: "Escalation requires human review",
+            summary: `All ${levels.length} automated levels have been exhausted.`,
+        };
+        levelElements.push(React.createElement(Approval, {
+            id: humanId,
+            output: escalationOutput,
+            request,
+            continueOnFail: true,
+            label: request.title,
+        }));
+    }
+    return React.createElement(Sequence, {}, ...levelElements);
+}