@smithers-orchestrator/components 0.21.0 → 0.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/components",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "React components for Smithers workflows",
   "type": "module",
   "sideEffects": false,
@@ -24,15 +24,15 @@
     "react": "^19.2.5",
     "react-dom": "^19.2.5",
     "zod": "^4.3.6",
-    "@smithers-orchestrator/db": "0.21.0",
-    "@smithers-orchestrator/errors": "0.21.0",
-    "@smithers-orchestrator/graph": "0.21.0",
-    "@smithers-orchestrator/memory": "0.21.0",
-    "@smithers-orchestrator/observability": "0.21.0",
-    "@smithers-orchestrator/react-reconciler": "0.21.0",
-    "@smithers-orchestrator/agents": "0.21.0",
-    "@smithers-orchestrator/scheduler": "0.21.0",
-    "@smithers-orchestrator/driver": "0.21.0"
+    "@smithers-orchestrator/agents": "0.23.0",
+    "@smithers-orchestrator/errors": "0.23.0",
+    "@smithers-orchestrator/graph": "0.23.0",
+    "@smithers-orchestrator/memory": "0.23.0",
+    "@smithers-orchestrator/driver": "0.23.0",
+    "@smithers-orchestrator/observability": "0.23.0",
+    "@smithers-orchestrator/react-reconciler": "0.23.0",
+    "@smithers-orchestrator/scheduler": "0.23.0",
+    "@smithers-orchestrator/db": "0.23.0"
   },
   "devDependencies": {
     "@tanstack/react-query": "^5.99.1",

package/src/components/Approval.js

@@ -123,16 +123,18 @@ export function Approval(props) {
     if ((mode === "select" || mode === "rank") && (!options || options.length === 0)) {
         throw new SmithersError("APPROVAL_OPTIONS_REQUIRED", `Approval ${props.id} requires options when mode="${mode}".`);
     }
+    const conditionMet = props.autoApprove
+        ? evaluateBooleanCallback(props.autoApprove.condition, ctx)
+        : undefined;
+    const revertOnMet = props.autoApprove
+        ? evaluateBooleanCallback(props.autoApprove.revertOn, ctx)
+        : undefined;
     const autoApprove = props.autoApprove
         ? {
             ...(typeof props.autoApprove.after === "number" ? { after: props.autoApprove.after } : {}),
             audit: props.autoApprove.audit !== false,
-            ...(evaluateBooleanCallback(props.autoApprove.condition, ctx) !== undefined
-                ? { conditionMet: evaluateBooleanCallback(props.autoApprove.condition, ctx) }
-                : {}),
-            ...(evaluateBooleanCallback(props.autoApprove.revertOn, ctx) !== undefined
-                ? { revertOnMet: evaluateBooleanCallback(props.autoApprove.revertOn, ctx) }
-                : {}),
+            ...(conditionMet !== undefined ? { conditionMet } : {}),
+            ...(revertOnMet !== undefined ? { revertOnMet } : {}),
         }
         : undefined;
     const requestMeta = {
@@ -177,7 +179,7 @@ export function Approval(props) {
             approved: approval?.status === "approved",
             note: approval?.note ?? null,
             decidedBy: approval?.decidedBy ?? null,
-            decidedAt: null,
+            decidedAt: approval?.decidedAtMs != null ? new Date(approval.decidedAtMs).toISOString() : null,
         };
     };
     return React.createElement("smithers:task", {

package/src/components/CheckSuite.js

@@ -3,11 +3,46 @@
 // @smithers-type-exports-end
 
 import React from "react";
+import { SmithersContext } from "@smithers-orchestrator/react-reconciler/context";
 import { Sequence } from "./Sequence.js";
 import { Parallel } from "./Parallel.js";
 import { Task } from "./Task.js";
 /** @typedef {import("./CheckConfig.ts").CheckConfig} CheckConfig */
 
+/**
+ * Whether a single check's output row counts as a pass. A missing row (the
+ * check never produced output) or an explicit failure signal counts as a fail.
+ * @param {unknown} row
+ * @returns {boolean}
+ */
+function checkPassed(row) {
+    if (row == null)
+        return false;
+    if (typeof row === "object") {
+        const r = /** @type {Record<string, unknown>} */ (row);
+        if (r.passed === false || r.ok === false || r.failed === true)
+            return false;
+        if (r.error != null && r.error !== false)
+            return false;
+    }
+    return true;
+}
+
+/**
+ * Resolve the overall pass/fail verdict from the per-check pass count.
+ * @param {"all-pass" | "majority" | "any-pass"} strategy
+ * @param {number} passCount
+ * @param {number} total
+ * @returns {boolean}
+ */
+function resolveVerdict(strategy, passCount, total) {
+    if (strategy === "any-pass")
+        return passCount > 0;
+    if (strategy === "majority")
+        return passCount * 2 > total;
+    return total > 0 && passCount === total;
+}
+
 /**
  * @param {CheckConfig[] | Record<string, Omit<CheckConfig, "id">>} checks
  * @returns {CheckConfig[]}
@@ -29,6 +64,7 @@ function normalizeChecks(checks) {
 export function CheckSuite(props) {
     if (props.skipIf)
         return null;
+    const ctx = React.useContext(SmithersContext);
     const { id, checks, verdictOutput, strategy = "all-pass", maxConcurrency, continueOnFail = true, } = props;
     const prefix = id ?? "checksuite";
     const normalized = normalizeChecks(checks);
@@ -51,21 +87,38 @@ export function CheckSuite(props) {
         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.";
+    // The verdict depends on every check. We use dependsOn (the mechanism the
+    // graph extractor honors) so the verdict only runs once all checks have
+    // produced output — a `needs` map alone is ignored when no `deps` are set.
+    const checkIds = normalized.map((check) => `${prefix}-${check.id}`);
+    // Compute the aggregate verdict from the per-check outputs. Reads are taken
+    // from the workflow context at render time and captured in the closure; the
+    // component re-renders reactively as each check's output becomes available,
+    // and the engine defers execution until every dependency has completed.
     const verdictTask = React.createElement(Task, {
         id: `${prefix}-verdict`,
         output: verdictOutput,
-        needs,
-    }, `Aggregate check results into a pass/fail verdict.\n\nStrategy: ${strategyDesc}`);
+        dependsOn: checkIds,
+        label: "verdict",
+    }, () => {
+        let passCount = 0;
+        const results = {};
+        for (const check of normalized) {
+            const checkId = `${prefix}-${check.id}`;
+            const row = ctx?.outputMaybe(verdictOutput, { nodeId: checkId });
+            const passed = checkPassed(row);
+            results[check.id] = passed;
+            if (passed)
+                passCount += 1;
+        }
+        const total = normalized.length;
+        return {
+            passed: resolveVerdict(strategy, passCount, total),
+            passCount,
+            total,
+            strategy,
+            results,
+        };
+    });
     return React.createElement(Sequence, null, parallelEl, verdictTask);
 }

package/src/components/EscalationChain.js

@@ -4,10 +4,42 @@
 // @smithers-type-exports-end
 
 import React from "react";
+import { SmithersContext } from "@smithers-orchestrator/react-reconciler/context";
 import { Sequence } from "./Sequence.js";
 import { Branch } from "./Branch.js";
 import { Task } from "./Task.js";
 import { Approval } from "./Approval.js";
+/**
+ * Default escalation predicate: escalate when the previous level has no result
+ * yet, or its result signals a failure (`error`/`failed` truthy or `ok === false`).
+ * @param {unknown} result
+ * @returns {boolean}
+ */
+function defaultEscalateIf(result) {
+    if (result == null)
+        return true;
+    if (typeof result === "object") {
+        const row = /** @type {Record<string, unknown>} */ (result);
+        if (row.error != null && row.error !== false)
+            return true;
+        if (row.failed === true)
+            return true;
+        if (row.ok === false)
+            return true;
+    }
+    return false;
+}
+/**
+ * Resolve whether the previous level escalated by invoking its `escalateIf`
+ * predicate (or the default) against its actual result.
+ * @param {EscalationLevel} prevLevel
+ * @param {unknown} prevResult
+ * @returns {boolean}
+ */
+function didEscalate(prevLevel, prevResult) {
+    const predicate = prevLevel.escalateIf ?? defaultEscalateIf;
+    return Boolean(predicate(prevResult));
+}
 /**
  * Escalation chain: tries agents in order, escalating on failure or when
  * `escalateIf` returns `true`. Optionally ends with a human approval fallback.
@@ -18,6 +50,7 @@ import { Approval } from "./Approval.js";
 export function EscalationChain(props) {
     if (props.skipIf)
         return null;
+    const ctx = React.useContext(SmithersContext);
     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
@@ -43,14 +76,14 @@ export function EscalationChain(props) {
         }
         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.
+            // previous level needs escalation. The chain re-renders reactively as
+            // outputs become available, so we read the previous level's actual
+            // result from the workflow context and run its `escalateIf` predicate
+            // (or the default failure predicate) to decide whether this level runs.
+            const prevLevel = levels[i - 1];
+            const prevLevelId = `${prefix}-level-${i - 1}`;
+            const prevResult = ctx?.outputMaybe(prevLevel.output, { nodeId: prevLevelId });
+            const escalated = didEscalate(prevLevel, prevResult);
             const checkId = `${prefix}-check-${i - 1}`;
             const checkTask = React.createElement(Task, {
                 id: checkId,
@@ -58,40 +91,51 @@ export function EscalationChain(props) {
                 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.
+                    // Record the escalation decision for the prior level so it is
+                    // visible in the escalation output stream.
                     return {
-                        escalated: true,
+                        escalated,
                         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.
+            // Gate the current level on the previous level's escalation decision:
+            // it only mounts when the prior level actually escalated.
             const gatedLevel = React.createElement(Branch, {
-                if: true,
+                if: escalated,
                 then: taskEl,
             });
             levelElements.push(checkTask);
             levelElements.push(gatedLevel);
         }
     }
-    // Append human fallback if requested.
-    if (humanFallback) {
+    // Append human fallback if requested. It only mounts when every automated
+    // level escalated (i.e. all automated levels were exhausted). A single
+    // level resolving without escalation stops the chain and the fallback, even
+    // if later levels never ran and therefore have no recorded result.
+    if (humanFallback && levels.length > 0) {
         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, {
+        const allEscalated = levels.every((level, idx) => {
+            const levelResult = ctx?.outputMaybe(level.output, {
+                nodeId: `${prefix}-level-${idx}`,
+            });
+            return didEscalate(level, levelResult);
+        });
+        const approvalEl = React.createElement(Approval, {
             id: humanId,
             output: escalationOutput,
             request,
             continueOnFail: true,
             label: request.title,
+        });
+        levelElements.push(React.createElement(Branch, {
+            if: allEscalated,
+            then: approvalEl,
         }));
     }
     return React.createElement(Sequence, {}, ...levelElements);

package/src/components/ScanFixVerify.js

@@ -53,6 +53,7 @@ export function ScanFixVerify(props) {
     const reportTask = React.createElement(Task, {
         id: `${prefix}-report`,
         output: props.reportOutput,
+        agent: props.verifier,
         dependsOn: [`${prefix}-verify`],
         children: "Produce a final summary report of all scan-fix-verify cycles, including what was found, what was fixed, and the final verification status.",
     });

package/src/components/Supervisor.js

@@ -78,6 +78,7 @@ export function Supervisor(props) {
     const finalTask = React.createElement(Task, {
         id: `${prefix}-final`,
         output: props.finalOutput,
+        agent: props.boss,
         needs: { review: `${prefix}-review`, plan: `${prefix}-plan` },
         label: "Supervisor summary",
         children: "Summarize the overall results from all delegation cycles.",

package/src/components/TaskProps.ts

@@ -31,6 +31,14 @@ export type TaskProps<Row, Output extends OutputTarget = OutputTarget, D extends
 	needs?: Record<string, string>;
 	/** Render-time typed dependencies. Keys resolve from task ids of the same name, or from matching `needs` entries. */
 	deps?: D;
+	/**
+	 * Start this agent task from a copy of another task's final agent session context.
+	 * The fork source becomes an implicit dependency: this task waits for it to complete,
+	 * then copies its conversation snapshot into a fresh, independent session and submits
+	 * its own prompt. The source is never mutated. Inside a `<Loop>`, resolves to the
+	 * latest completed snapshot for that task id. Requires an agent task.
+	 */
+	fork?: string;
 	skipIf?: boolean;
 	needsApproval?: boolean;
 	/** When paired with `needsApproval`, do not block unrelated downstream flow while the approval is pending. */

package/src/index.d.ts

@@ -135,6 +135,14 @@ type TaskProps$2<Row, Output extends OutputTarget$1 = OutputTarget$1, D extends
     needs?: Record<string, string>;
     /** Render-time typed dependencies. Keys resolve from task ids of the same name, or from matching `needs` entries. */
     deps?: D;
+    /**
+     * Start this agent task from a copy of another task's final agent session context.
+     * The fork source becomes an implicit dependency: this task waits for it to complete,
+     * then copies its conversation snapshot into a fresh, independent session and submits
+     * its own prompt. The source is never mutated. Inside a `<Loop>`, resolves to the
+     * latest completed snapshot for that task id. Requires an agent task.
+     */
+    fork?: string;
     skipIf?: boolean;
     needsApproval?: boolean;
     /** When paired with `needsApproval`, do not block unrelated downstream flow while the approval is pending. */