@oxygen-agent/cli 1.750.4 → 1.782.1

package/node_modules/@oxygen/workflows/dist/graph/topology.js

@@ -282,6 +282,101 @@ export function dominatingNodeIds(graph, targetNodeId) {
     }
     return dominators.get(targetNodeId) ?? new Set();
 }
+/** Add every forward-graph predecessor of `startIds` to `selected`. */
+function addForwardAncestors(startIds, incoming, selected) {
+    const queue = [...startIds];
+    let changed = false;
+    while (queue.length > 0) {
+        const current = queue.pop();
+        if (current === undefined || selected.has(current))
+            continue;
+        selected.add(current);
+        changed = true;
+        for (const predecessor of incoming.get(current) ?? [])
+            queue.push(predecessor);
+    }
+    return changed;
+}
+/**
+ * Plan a safe selected-node test over the canonical graph.
+ *
+ * The slice contains the target and every possible predecessor, not every node
+ * that happens to appear earlier in topological order. Legal loop back-edges are
+ * ignored while finding predecessors so selecting a node halfway through a loop
+ * does not accidentally pull later body nodes into the test. Conversely, when a
+ * completed loop is upstream of the target (or is itself the target), its whole
+ * body is required because the loop's output includes those executions.
+ */
+export function planWorkflowGraphNodeTest(graph, targetNodeId) {
+    const nodes = nodeIndex(graph);
+    const target = nodes.get(targetNodeId);
+    if (!target) {
+        return {
+            ok: false,
+            code: "workflow_test_target_not_found",
+            message: `Workflow node '${targetNodeId}' does not exist in this revision.`,
+        };
+    }
+    if (isTriggerNode(target)) {
+        return {
+            ok: false,
+            code: "workflow_test_target_is_trigger",
+            message: "Choose an executable workflow step, not the trigger node.",
+        };
+    }
+    if (target.disabled === true) {
+        return {
+            ok: false,
+            code: "workflow_test_target_disabled",
+            message: `Workflow node '${targetNodeId}' is disabled and cannot be tested.`,
+        };
+    }
+    if (!reachableNodeIds(graph).has(targetNodeId)) {
+        return {
+            ok: false,
+            code: "workflow_test_target_unreachable",
+            message: `Workflow node '${targetNodeId}' is not reachable from the trigger.`,
+        };
+    }
+    const forward = forwardOutgoing(graph);
+    const incoming = new Map();
+    for (const id of nodes.keys())
+        incoming.set(id, []);
+    for (const [source, edges] of forward) {
+        for (const edge of edges)
+            incoming.get(edge.target)?.push(source);
+    }
+    const selected = new Set();
+    addForwardAncestors([targetNodeId], incoming, selected);
+    const loopBodies = graph.nodes
+        .filter(isLoopNode)
+        .map((loop) => ({ loop, body: loopBodyNodeIds(graph, loop.id) }));
+    let expanded = true;
+    while (expanded) {
+        expanded = false;
+        for (const { loop, body } of loopBodies) {
+            if (!selected.has(loop.id) || body.has(targetNodeId))
+                continue;
+            if (addForwardAncestors(body, incoming, selected))
+                expanded = true;
+        }
+    }
+    const nodeIds = graph.nodes
+        .map((node) => node.id)
+        .filter((id) => selected.has(id));
+    return {
+        ok: true,
+        plan: {
+            targetNodeId,
+            nodeIds,
+            manifest: {
+                ...graph,
+                nodes: graph.nodes.filter((node) => selected.has(node.id)),
+                edges: graph.edges.filter((edge) => selected.has(edge.source) && selected.has(edge.target)),
+            },
+        },
+    };
+}
 /**
  * Illegal cycles: one entry per strongly connected component that still contains
  * a cycle once legal loop back-edges are removed.

package/node_modules/@oxygen/workflows/dist/graph/types.d.ts

@@ -3,6 +3,32 @@ export declare const WORKFLOW_GRAPH_MANIFEST_VERSION = 2;
 export declare const WORKFLOW_GRAPH_COMPILER_VERSION = "oxygen-workflows-v2";
 export declare const PORTABLE_WORKFLOW_DEFINITION_VERSION = 1;
 export declare const PORTABLE_WORKFLOW_DEFINITION_COMPILER_VERSION = "oxygen-workflow-definition-v1";
+/** Source-run metadata key for the exact non-live graph scope a test executed. */
+export declare const WORKFLOW_TEST_SCOPE_METADATA_KEY = "workflow_test_scope";
+/**
+ * Optional execution scope for a non-live Workflow call.
+ *
+ * Omission keeps the historic whole-workflow behavior. A node scope is a
+ * server-planned backward slice of the same immutable graph revision; callers
+ * never submit a second graph or a list of nodes to trust.
+ */
+export type WorkflowTestScope = {
+    type: "workflow";
+} | {
+    type: "node";
+    node_id: string;
+};
+/** Durable evidence recorded on the source run after the server plans a test. */
+export type WorkflowTestScopeReceipt = WorkflowTestScope & {
+    source_hash: string;
+    planned_node_ids: string[];
+    /**
+     * The nodes this scope deliberately excludes. Recorded so "the downstream step
+     * did not run" is something the product states, not something a reader infers
+     * from a missing row in the step list.
+     */
+    excluded_node_ids?: string[];
+};
 export declare const RESERVED_NODE_IDS: ReadonlySet<string>;
 /**
  * Named Code inputs and declared output fields become dotted scope paths and
@@ -356,13 +382,7 @@ export type WorkflowGraphNode =
     request?: Record<string, WorkflowValueRef>;
 })
 /** Legacy source, imported durable recipe, or typed oxygen-js-v1 code. */
- | WorkflowGraphCodeNode
-/** Calls another workflow as a child run. */
- | (WorkflowGraphNodeBase & {
-    kind: "workflow";
-    workflow_id: string;
-    input: Record<string, WorkflowValueRef>;
-});
+ | WorkflowGraphCodeNode;
 export type WorkflowGraphNodeKind = WorkflowGraphNode["kind"];
 /** Narrow a node union member by its `kind` discriminant. */
 export type WorkflowGraphNodeOfKind<K extends WorkflowGraphNodeKind> = Extract<WorkflowGraphNode, {
@@ -455,5 +475,4 @@ export declare function isTriggerNode(node: WorkflowGraphNode): node is Workflow
 export declare function isToolNode(node: WorkflowGraphNode): node is WorkflowGraphNodeOfKind<"tool">;
 export declare function isSwitchNode(node: WorkflowGraphNode): node is WorkflowGraphNodeOfKind<"switch">;
 export declare function isLoopNode(node: WorkflowGraphNode): node is WorkflowGraphNodeOfKind<"loop">;
-export declare function isWorkflowSubgraphNode(node: WorkflowGraphNode): node is WorkflowGraphNodeOfKind<"workflow">;
 export {};

package/node_modules/@oxygen/workflows/dist/graph/types.js

@@ -2,6 +2,8 @@ export const WORKFLOW_GRAPH_MANIFEST_VERSION = 2;
 export const WORKFLOW_GRAPH_COMPILER_VERSION = "oxygen-workflows-v2";
 export const PORTABLE_WORKFLOW_DEFINITION_VERSION = 1;
 export const PORTABLE_WORKFLOW_DEFINITION_COMPILER_VERSION = "oxygen-workflow-definition-v1";
+/** Source-run metadata key for the exact non-live graph scope a test executed. */
+export const WORKFLOW_TEST_SCOPE_METADATA_KEY = "workflow_test_scope";
 // Node ids become keys on the runtime scope object (`steps.<id>.output`), exactly
 // as v1 step ids become keys on ctx.steps. The same JavaScript-internals collision
 // applies: a node named `__proto__` would silently lose its output.
@@ -63,7 +65,6 @@ export const MAX_WORKFLOW_LOOP_ITERATIONS = 1_000;
  */
 export const BILLABLE_WORKFLOW_GRAPH_NODE_KINDS = new Set([
     "tool",
-    "workflow",
 ]);
 /** Whether a v2 node of this kind draws an automation action when it executes. */
 export function workflowGraphNodeKindBills(kind) {
@@ -159,6 +160,3 @@ export function isSwitchNode(node) {
 export function isLoopNode(node) {
     return isNodeOfKind(node, "loop");
 }
-export function isWorkflowSubgraphNode(node) {
-    return isNodeOfKind(node, "workflow");
-}

package/node_modules/@oxygen/workflows/dist/index.js

@@ -1938,7 +1938,6 @@ export function workflowManifestCanInvokeTool(manifest) {
         && manifest.tools_used.some((toolId) => isNonEmptyString(toolId));
     const viaGraph = Array.isArray(manifest.nodes)
         && manifest.nodes.some((node) => isRecord(node) && (node.kind === "tool"
-            || node.kind === "workflow"
             || (isRecord(node.recipe)
                 && Array.isArray(node.recipe.tools_used)
                 && node.recipe.tools_used.some((toolId) => isNonEmptyString(toolId)))));

package/node_modules/@oxygen/workflows/dist/portable.js

@@ -69,13 +69,6 @@ function portableNodeIssue(node, index) {
             message: "Legacy execution context cannot be represented as a portable editable graph.",
         };
     }
-    if (node.kind === "workflow") {
-        return {
-            path: `$.graph.nodes.${index}`,
-            code: "workflow_node_not_portable",
-            message: "Child-workflow nodes are not executable yet and cannot be exported as a portable definition.",
-        };
-    }
     return null;
 }
 function valueRefUsesWorkspaceAsset(ref) {
@@ -114,8 +107,6 @@ function nodeUsesWorkspaceAsset(node) {
             return node.code !== undefined
                 ? Object.values(node.code.inputs).some(valueRefUsesWorkspaceAsset)
                 : Object.values(node.configuration ?? {}).some(valueRefUsesWorkspaceAsset);
-        case "workflow":
-            return Object.values(node.input).some(valueRefUsesWorkspaceAsset);
         case "trigger":
         case "merge":
             return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.750.4",
+  "version": "1.782.1",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",