@oxygen-agent/cli 1.766.0 → 1.782.1

package/README.md

@@ -34,4 +34,4 @@ oxygen update
 
 For product documentation, visit https://oxygen-agent.com/docs. For support, visit https://oxygen-agent.com.
 
-Version: 1.766.0
+Version: 1.782.1

package/dist/index.js

@@ -8216,7 +8216,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .command("limits")
         .description("Plan-tier limits, spend-safety defaults, and storage capacity posture.")
         .addCommand(new Command("show")
-        .description("Show effective plan-tier limits, spend-safety defaults, and uncapped-by-plan storage posture.")
+        .description("Show limits and Tables capacity usage: 3M rows/Table, 25M/workspace, and 20/30 GiB PostgreSQL warning/limit; S3 excluded. Recovery: https://oxygen-agent.com/docs/safety/billing.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("limits show", options, () => requestOxygen("/api/cli/limits"));
@@ -14645,6 +14645,7 @@ Run completion:
         .option("--approved", "Authorize autonomous tool calls for this revision.")
         .option("--max-credits <n>", "Optional explicit positive ceiling for each autonomous delivery; omit to use the plan-tier default.")
         .option("--draft", "Save without going live: keeps the running version serving every trigger. Publish later by applying again without --draft.")
+        .option("--review", "Show what publishing this would change against the version now serving triggers — added, removed and modified steps, what leaves Oxygen, the accounts used, and whether it needs standing authority. Writes nothing.")
         .option("--include-bundle", "Include durable recipe bundles in JSON output.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
@@ -14659,6 +14660,7 @@ Run completion:
                     // byte-identical to what every previous CLI sent, so behaviour
                     // against an older server is unchanged rather than merely equivalent.
                     ...(options.draft ? { publish: false } : {}),
+                    ...(options.review ? { review: true } : {}),
                     ...(options.approved ? { approved: true } : {}),
                     ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
                 },
@@ -14795,6 +14797,7 @@ Run completion:
         .option("--approved", "Required for live calls after inspecting a dry run.")
         .option("--revision <n>", "Run a specific saved version instead of the live one. Dry-run and smoke-test only: publish a version to run it live.")
         .option("--node <node_id>", "Test one node: runs that node plus only the predecessors it needs, from the same saved graph. Dry-run and smoke-test only.")
+        .option("--preview", "Show what a live run of this exact version would do — every step that leaves Oxygen, the accounts it would use, and the billable-step floor — without running anything.")
         .option("--include-bundle", "Include durable recipe bundles in JSON output.")
         .option("--json", "Print a JSON envelope.")
         .addHelpText("after", "\nSafety: smoke_test and dry_run share one boundary: 0 credits, no paid provider calls, no external writes. Oxygen internal reads use current workspace data, and oxygen.http_json_request may make a real outbound GET. Every mode creates an inspectable Workflow run record.\n\n--node scopes a test to one step. Oxygen plans the slice on the server from the exact saved version and records it on the run, so the run shows precisely which nodes were allowed to execute; you never submit a node list. Selecting the trigger, a disabled node, or a node unreachable from the trigger is refused with the reason. Only canonical graph workflows support it.\n")
@@ -14814,6 +14817,7 @@ Run completion:
                 ...(options.approved ? { approved: true } : {}),
                 ...(revisionVersion !== undefined ? { revision_version: revisionVersion } : {}),
                 ...(readOption(options.node) ? { test_node_id: readOption(options.node) } : {}),
+                ...(options.preview ? { preview: true } : {}),
             },
         }), options));
     }))
@@ -15094,11 +15098,16 @@ Full trigger schema: oxygen workflows schema --subject trigger --json
         .addCommand(new Command("cancel")
         .description("Cancel a queued or running workflow run.")
         .argument("<run_id>", "Workflow run UUID.")
+        .option("--preview", "Show what cancelling would and would not undo — steps in flight, and any external write already dispatched that cancelling cannot recall. Cancels nothing.")
         .option("--json", "Print a JSON envelope.")
+        .addHelpText("after", "\nCancelling stops further steps; it cannot recall a step already dispatched to a provider. Use --preview first when the run may be mid-write.\n")
         .action(async (runId, options) => {
         await handleAsyncAction("workflows cancel", options, () => requestOxygen("/api/cli/workflows/cancel", {
             method: "POST",
-            body: { run_id: runId },
+            body: {
+                run_id: runId,
+                ...(options.preview ? { preview: true } : {}),
+            },
         }));
     }))
         .addCommand(new Command("approvals")

package/node_modules/@oxygen/shared/dist/index.d.ts

@@ -57,6 +57,7 @@ export * from "./sequences.js";
 export * from "./suppression-entries.js";
 export * from "./dnc-identities.js";
 export * from "./table-limits.js";
+export * from "./table-capacity.js";
 export * from "./log.js";
 export * from "./axiom-field-budget.js";
 export { redactSecretsInString, sanitizeLogFields } from "./redaction.js";

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

@@ -57,6 +57,7 @@ export * from "./sequences.js";
 export * from "./suppression-entries.js";
 export * from "./dnc-identities.js";
 export * from "./table-limits.js";
+export * from "./table-capacity.js";
 export * from "./log.js";
 export * from "./axiom-field-budget.js";
 // Narrow, deliberate export (ADR 0014): lets telemetry emitters regression-test

package/node_modules/@oxygen/shared/dist/table-capacity.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Plan-independent infrastructure envelope for durable Workspace Tables.
+ * Plans do not sell different storage entitlements; every workspace gets the
+ * same safety boundary and plans continue to differ through operation/rate and
+ * credit limits.
+ */
+export declare const WORKSPACE_TABLE_CAPACITY: Readonly<{
+    tableRowLimit: 3000000;
+    workspaceRowLimit: 25000000;
+    workspaceDatabaseWarningBytes: number;
+    workspaceDatabaseLimitBytes: number;
+}>;
+export declare const WORKSPACE_TABLE_DATABASE_STORAGE_SCOPE: "postgres_workspace_tables_heap_indexes_toast";

package/node_modules/@oxygen/shared/dist/table-capacity.js

@@ -0,0 +1,14 @@
+const GIB = 1024 ** 3;
+/**
+ * Plan-independent infrastructure envelope for durable Workspace Tables.
+ * Plans do not sell different storage entitlements; every workspace gets the
+ * same safety boundary and plans continue to differ through operation/rate and
+ * credit limits.
+ */
+export const WORKSPACE_TABLE_CAPACITY = Object.freeze({
+    tableRowLimit: 3_000_000,
+    workspaceRowLimit: 25_000_000,
+    workspaceDatabaseWarningBytes: 20 * GIB,
+    workspaceDatabaseLimitBytes: 30 * GIB,
+});
+export const WORKSPACE_TABLE_DATABASE_STORAGE_SCOPE = "postgres_workspace_tables_heap_indexes_toast";

package/node_modules/@oxygen/shared/dist/version.d.ts

@@ -1,4 +1,4 @@
-export declare const OXYGEN_VERSION = "1.766.0";
+export declare const OXYGEN_VERSION = "1.782.1";
 export declare const OXYGEN_MINIMUM_CLI_VERSION = "1.181.0";
 export declare const MANAGED_INBOX_MINIMUM_CLI_VERSION = "1.326.2";
 export declare const SUPPORT_AGENT_REPLY_MINIMUM_CLI_VERSION = "1.747.0";

package/node_modules/@oxygen/shared/dist/version.js

@@ -1,4 +1,4 @@
-export const OXYGEN_VERSION = "1.766.0";
+export const OXYGEN_VERSION = "1.782.1";
 // The GLOBAL CLI compatibility floor: the oldest CLI allowed to call any
 // operational route. Raising it hard-rejects every older CLI from the entire
 // product, so it obeys one law, enforced by scripts/ci/cli-min-version-gate.mjs:

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

@@ -0,0 +1,33 @@
+import type { WorkflowGraphManifest } from "./types.js";
+/**
+ * What changed between the revision currently serving triggers and the one about
+ * to replace it.
+ *
+ * Publishing is the moment a workflow stops being a draft and starts acting on
+ * the world, and until now the author approved it having been shown a credit cap
+ * and nothing else. "Approve this" is not a review if the thing being approved
+ * is invisible. This is the comparison that makes the review honest.
+ *
+ * Canvas position is deliberately NOT a change. `ui` carries x/y, so dragging a
+ * node two pixels would otherwise report the graph as modified and train the
+ * author to skim a diff that cries wolf — which is worse than no diff, because
+ * it looks like diligence.
+ */
+export type WorkflowGraphNodeChange = {
+    nodeId: string;
+    /** The author's own step name, which is what the canvas shows. */
+    label: string;
+    change: "added" | "removed" | "modified";
+    /** For a modified node, the top-level fields that actually differ. */
+    changedFields?: string[];
+};
+export type WorkflowGraphDiff = {
+    triggerChanged: boolean;
+    inputSchemaChanged: boolean;
+    nodes: WorkflowGraphNodeChange[];
+    edgesAdded: number;
+    edgesRemoved: number;
+    /** True when nothing semantic differs — a re-publish of the same graph. */
+    unchanged: boolean;
+};
+export declare function diffWorkflowGraphManifests(before: WorkflowGraphManifest, after: WorkflowGraphManifest): WorkflowGraphDiff;

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

@@ -0,0 +1,75 @@
+function label(node) {
+    return node.name?.trim() || node.id;
+}
+/** Everything about a node except where it sits on the canvas. */
+function semanticNode(node) {
+    const { ui: _ui, ...rest } = node;
+    return rest;
+}
+function stable(value) {
+    if (value === undefined)
+        return "undefined";
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value) ?? "null";
+    if (Array.isArray(value))
+        return `[${value.map(stable).join(",")}]`;
+    const entries = Object.entries(value)
+        .filter(([, entry]) => entry !== undefined)
+        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0));
+    return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${stable(entry)}`).join(",")}}`;
+}
+function changedFields(before, after) {
+    const keys = new Set([...Object.keys(before), ...Object.keys(after)]);
+    return [...keys]
+        .filter((key) => stable(before[key]) !== stable(after[key]))
+        .sort();
+}
+function edgeKey(edge) {
+    return `${edge.source}->${edge.target}#${edge.source_handle ?? ""}`;
+}
+export function diffWorkflowGraphManifests(before, after) {
+    const beforeNodes = new Map(before.nodes.map((node) => [node.id, node]));
+    const afterNodes = new Map(after.nodes.map((node) => [node.id, node]));
+    const changes = [];
+    // Reported in the AFTER graph's order so the review reads like the canvas the
+    // author is looking at; removals are appended, since they have no position in it.
+    for (const node of after.nodes) {
+        const previous = beforeNodes.get(node.id);
+        if (!previous) {
+            changes.push({ nodeId: node.id, label: label(node), change: "added" });
+            continue;
+        }
+        const fields = changedFields(semanticNode(previous), semanticNode(node));
+        if (fields.length > 0) {
+            changes.push({
+                nodeId: node.id,
+                label: label(node),
+                change: "modified",
+                changedFields: fields,
+            });
+        }
+    }
+    for (const node of before.nodes) {
+        if (!afterNodes.has(node.id)) {
+            changes.push({ nodeId: node.id, label: label(node), change: "removed" });
+        }
+    }
+    const beforeEdges = new Set(before.edges.map(edgeKey));
+    const afterEdges = new Set(after.edges.map(edgeKey));
+    const edgesAdded = [...afterEdges].filter((key) => !beforeEdges.has(key)).length;
+    const edgesRemoved = [...beforeEdges].filter((key) => !afterEdges.has(key)).length;
+    const triggerChanged = stable(before.trigger) !== stable(after.trigger);
+    const inputSchemaChanged = stable(before.input_schema) !== stable(after.input_schema);
+    return {
+        triggerChanged,
+        inputSchemaChanged,
+        nodes: changes,
+        edgesAdded,
+        edgesRemoved,
+        unchanged: !triggerChanged
+            && !inputSchemaChanged
+            && changes.length === 0
+            && edgesAdded === 0
+            && edgesRemoved === 0,
+    };
+}

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

@@ -24,12 +24,28 @@ export class WorkflowValueCoercionError extends Error {
         this.name = "WorkflowValueCoercionError";
     }
 }
+/**
+ * Build the JSON that would satisfy an unresolved `trigger.input.*` path.
+ *
+ * The product already knows the exact dotted path it could not resolve, so
+ * printing only the path makes the reader reconstruct by hand what the error
+ * could have handed them. Only `trigger.input.*` is answerable this way — a
+ * `steps.*` ref is produced by an earlier node, not by the caller, so no input
+ * would fix it and suggesting one would send the reader down a dead end.
+ */
+function unresolvedRefRemedy(path) {
+    const parts = path.split(".");
+    if (parts.length < 3 || parts[0] !== "trigger" || parts[1] !== "input")
+        return "";
+    const skeleton = parts.slice(2).reduceRight((inner, key) => ({ [key]: inner }), "…");
+    return ` Supply it with --input-json '${JSON.stringify(skeleton)}'.`;
+}
 /** A direct mapping named data the run does not carry; sending undefined is never intentional. */
 export class WorkflowValueRefUnresolvedError extends Error {
     path;
     code = "workflow_value_ref_unresolved";
     constructor(path) {
-        super(`Mapped field '${path}' did not resolve in this run.`);
+        super(`Mapped field '${path}' did not resolve in this run.${unresolvedRefRemedy(path)}`);
         this.path = path;
         this.name = "WorkflowValueRefUnresolvedError";
     }

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

@@ -14,6 +14,7 @@
  */
 export * from "./types.js";
 export * from "./topology.js";
+export * from "./diff.js";
 export * from "./expression.js";
 export * from "./params.js";
 export * from "./remap.js";

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

@@ -14,6 +14,7 @@
  */
 export * from "./types.js";
 export * from "./topology.js";
+export * from "./diff.js";
 export * from "./expression.js";
 export * from "./params.js";
 export * from "./remap.js";

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

@@ -24,7 +24,6 @@ const NODE_KINDS = new Set([
     "wait",
     "approval",
     "code",
-    "workflow",
 ]);
 const MERGE_STRATEGIES = new Set(["append", "first", "wait_all"]);
 const STEP_EFFECTS = new Set(["none", "external_read", "external_write"]);
@@ -334,19 +333,6 @@ node, path, add, scope, options) {
         case "code":
             lintCodeNode(node, path, add, scope, options);
             return;
-        case "workflow":
-            if (!isNonEmptyString(node.workflow_id)) {
-                add(`${path}.workflow_id`, "invalid_workflow_ref", "Workflow node workflow_id is required.");
-            }
-            validateValueRefRecord(node.input, `${path}.input`, add, scope);
-            // Authoring-time refusal, not just a runtime one. A sub-workflow needs its
-            // own durable run, lease, spend ceiling and cancellation semantics, none of
-            // which exist yet — so the worker rejects the node terminally. Without this
-            // rule a user could save the graph, arm a cron trigger on it, and discover
-            // the refusal at 03:00 on every delivery instead of at `workflows apply`.
-            // Remove BOTH refusals together when child runs ship.
-            add(`${path}.kind`, "unsupported_node_kind", "Sub-workflow nodes cannot run yet. Inline the child workflow's nodes for now.");
-            return;
         default:
             return;
     }
@@ -886,6 +872,15 @@ function lintLoopNode(node, path, add, scope) {
     if (node.concurrency !== undefined && !isPositiveInteger(node.concurrency)) {
         add(`${path}.concurrency`, "invalid_loop_target", "Loop concurrency must be a positive integer.");
     }
+    else if (typeof node.concurrency === "number" && node.concurrency > 1) {
+        // First-release runtime cut (founder-approved 2026-08-17). The worker runs
+        // loop bodies sequentially and always has; `concurrency` was accepted and
+        // then ignored, which is the worst of both — the author reads a promise of
+        // parallelism, the run delivers none, and nothing says so. Refusing is the
+        // honest contract until parallel bodies can interleave lease renewal, spend
+        // accounting and per-iteration rows without getting the money wrong.
+        add(`${path}.concurrency`, "invalid_loop_target", "Loop bodies run one item at a time. Remove concurrency, or set it to 1.");
+    }
 }
 function lintSetNode(node, path, add, scope) {
     const fields = asArray(node.fields);
@@ -932,19 +927,31 @@ function lintApprovalNode(node, path, add, scope) {
 function lintWaitNode(node, path, add, scope) {
     const hasDuration = node.duration_seconds !== undefined;
     const hasUntil = node.until !== undefined;
-    if (hasDuration === hasUntil) {
-        add(path, "invalid_wait", "Wait node requires exactly one of duration_seconds or until.");
+    // First-release runtime cut (founder-approved 2026-08-17): duration waits only.
+    //
+    // `until` never did what its name promises. The worker re-evaluates it on a
+    // poll against the run's IMMUTABLE input, so it can only ever become true if it
+    // was already true — it cannot observe an event, a table write, or anything
+    // that happens after the run started. Offering it advertises a transition
+    // source that does not exist. Event-driven waits come back when there is a
+    // subscription behind them; until then a graph that needs one uses an approval
+    // node or a trigger.
+    //
+    // Existing revisions carrying `until` keep executing unchanged — this refuses
+    // the SAVE, not the historical run.
+    if (hasUntil) {
+        add(`${path}.until`, "invalid_wait", "Wait until is not available. Use a duration wait, or an approval node to pause for a decision.");
         return;
     }
-    if (hasDuration) {
-        if (typeof node.duration_seconds !== "number"
-            || !Number.isFinite(node.duration_seconds)
-            || node.duration_seconds <= 0) {
-            add(`${path}.duration_seconds`, "invalid_wait", "Wait duration_seconds must be a positive number.");
-        }
+    if (!hasDuration) {
+        add(path, "invalid_wait", "Wait node requires duration_seconds.");
         return;
     }
-    validateValueRef(node.until, `${path}.until`, add, scope);
+    if (typeof node.duration_seconds !== "number"
+        || !Number.isFinite(node.duration_seconds)
+        || node.duration_seconds <= 0) {
+        add(`${path}.duration_seconds`, "invalid_wait", "Wait duration_seconds must be a positive number.");
+    }
 }
 function isPositiveInteger(value) {
     return typeof value === "number" && Number.isInteger(value) && value > 0;
@@ -1092,11 +1099,6 @@ function graphNodeValueRefs(node, path) {
                 ref,
                 path: `${path}.configuration.${name}`,
             }));
-        case "workflow":
-            return Object.entries(node.input).map(([name, ref]) => ({
-                ref,
-                path: `${path}.input.${name}`,
-            }));
         default:
             return [];
     }

package/node_modules/@oxygen/workflows/dist/graph/manifest-schema.d.ts

@@ -204,7 +204,7 @@ export declare const workflowGraphManifestSchema: {
                         readonly type: "string";
                     };
                     readonly kind: {
-                        readonly enum: readonly ["trigger", "tool", "filter", "switch", "loop", "merge", "set", "wait", "approval", "code", "workflow"];
+                        readonly enum: readonly ["trigger", "tool", "filter", "switch", "loop", "merge", "set", "wait", "approval", "code"];
                     };
                     readonly ui: {
                         readonly type: "object";
@@ -994,7 +994,7 @@ export declare const portableWorkflowDefinitionSchema: {
                                 readonly type: "string";
                             };
                             readonly kind: {
-                                readonly enum: readonly ["trigger", "tool", "filter", "switch", "loop", "merge", "set", "wait", "approval", "code", "workflow"];
+                                readonly enum: readonly ["trigger", "tool", "filter", "switch", "loop", "merge", "set", "wait", "approval", "code"];
                             };
                             readonly ui: {
                                 readonly type: "object";

package/node_modules/@oxygen/workflows/dist/graph/manifest-schema.js

@@ -156,7 +156,7 @@ const nodeSchema = {
         name: { type: "string" },
         description: { type: "string" },
         kind: {
-            enum: ["trigger", "tool", "filter", "switch", "loop", "merge", "set", "wait", "approval", "code", "workflow"],
+            enum: ["trigger", "tool", "filter", "switch", "loop", "merge", "set", "wait", "approval", "code"],
         },
         ui: {
             type: "object",

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

@@ -185,11 +185,6 @@ export function remapNodeRefs(node, ids) {
             return node.until === undefined
                 ? node
                 : { ...node, until: remapValueRef(node.until, ids) };
-        case "workflow":
-            return {
-                ...node,
-                input: Object.fromEntries(Object.entries(node.input).map(([key, ref]) => [key, remapValueRef(ref, ids)])),
-            };
         // Missed when this module was first written, because the kind list was typed
         // from memory instead of read off the WorkflowGraphNode union — so a
         // duplicated approval node kept pointing at the original, silently, which is

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

@@ -22,6 +22,12 @@ export type WorkflowTestScope = {
 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>;
 /**
@@ -376,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, {
@@ -475,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

@@ -65,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) {
@@ -161,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.766.0",
+  "version": "1.782.1",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",