@oxygen-agent/cli 1.766.0 → 1.799.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.799.1

package/dist/index.js

@@ -6998,7 +6998,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--label <label>", "Display label for the new column. Required unless --prompt-key supplies a default title.")
         .option("--key <key>", "Optional stable column key. Defaults to a normalized label.")
         .option("--data-type <type>", "Column data type: text, numeric, boolean, jsonb, or timestamptz.")
-        .option("--kind <kind>", "Column kind: manual, research, ai, formula, enrichment, tool, bind, or lookup. Defaults to manual. Use research for anything you would look up on the web.")
+        .option("--kind <kind>", "Column kind: manual, research, ai, formula, enrichment, tool, bind, or lookup. Defaults to manual. Use research for anything you would look up on the web. `lookup` reads a value out of another table; to LINK two tables row-to-row use `oxygen tables relate` instead \u2014 relation columns are two-sided and cannot be added here.")
         .option("--semantic-type <type>", "Optional semantic type such as company_domain.")
         .option("--definition-json <json>", "Optional JSON object with column definition metadata.")
         .option("--prompt <text-or-file>", "AI or research column prompt, or a path to a prompt file — a value that resolves to a readable file is read as one, matching --prompt everywhere else in this CLI. On its own it sets kind=ai and picks the data type (text, or jsonb with an output schema); pair it with --kind research to search the web per row instead. Reference other columns inline as {{column_key}} — no --input-mapping needed; unknown keys are rejected here instead of failing per row. Merges into --definition-json (the escape hatch for everything else); a `prompt` in both is an error.")
@@ -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 } : {}),
                 },
@@ -14720,13 +14722,21 @@ Run completion:
         .description("List workflow automations.")
         .addOption(new Option("--include-archived", "Deprecated no-op retained for compatibility.").hideHelp())
         .option("--tag <tag>", "Only workflows carrying this workspace tag (see `oxygen tags list`).")
+        .option("--node-testable", "Only canonical graph workflows, the ones `workflows call --node` can scope a test to. Legacy recipes and v1 step lists own their own execution order and are excluded.")
+        .option("--search <text>", "Match on name, slug, trigger event, or an integration the workflow uses — so \"meeting\" or \"hubspot\" finds it without knowing what someone named it.")
         .option("--json", "Print a JSON envelope.")
+        .addHelpText("after", "\nEach row carries `format` (graph, recipe or steps) and `nodeTestable`, so you can tell which workflows support single-step testing without opening them.\n")
         .action(async (options) => {
         await handleAsyncAction("workflows list", options, async () => {
             const params = new URLSearchParams();
             const tag = readOption(options.tag);
             if (tag)
                 params.set("tag", tag);
+            if (options.nodeTestable)
+                params.set("node_testable", "true");
+            const search = readOption(options.search);
+            if (search)
+                params.set("search", search);
             const qs = params.toString() ? `?${params.toString()}` : "";
             const data = await requestOxygen(`/api/cli/workflows${qs}`);
             if (!options.json)
@@ -14783,39 +14793,52 @@ Run completion:
         }), options));
     }))
         .addCommand(new Command("call")
-        .description("Enqueue a workflow run asynchronously and directly without simulating its trigger. Follow the returned run_id with `oxygen workflows tail <run_id>`.")
+        .description("Run a workflow — or preview it first. `--preview` shows every step that leaves Oxygen, the accounts it would use, and what one run costs, without running anything. Enqueues asynchronously without simulating the trigger; follow the returned run_id with `oxygen workflows tail <run_id>`.")
         .argument("[workflow]", "Workflow id, slug, or name.")
         .option("--workflow <workflow>", "Workflow id, slug, or name.")
         .option("--workflow-id <workflow_id>", "Workflow id or slug.")
         .option("--workflow-name <workflow_name>", "Workflow name.")
         .option("--input-json <json>", "Workflow input object. Defaults to {}.")
-        .requiredOption("--mode <mode>", "Execution mode. smoke-test/dry-run: 0 credits, no paid provider calls or external writes; internal reads still execute. live: may spend/write and requires approval + cap.")
+        .option("--mode <mode>", "Execution mode. smoke-test/dry-run: 0 credits, no paid provider calls or external writes; internal reads still execute. live: may spend/write and requires approval + cap. Not needed with --preview, which runs nothing.")
         .option("--idempotency-key <key>", "Optional idempotency key.")
         .option("--max-credits <n>", "Required credit ceiling for live calls.")
         .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 minimum number of billable steps and credits it would cost — without running anything. AI and enrichment steps bill per row and can cost more than that floor. Needs no --mode: it always describes a live run.")
         .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")
         .action(async (workflowArg, options) => {
         const maxCredits = readPositiveNumber(options.maxCredits);
         const revisionVersion = readPositiveNumber(options.revision);
-        await handleAsyncAction("workflows call", options, async () => prepareWorkflowCliOutput(await requestOxygen("/api/cli/workflows/call", {
-            method: "POST",
-            body: {
-                workflow: readOption(workflowArg) ?? readOption(options.workflow),
-                ...(readOption(options.workflowId) ? { workflow_id: readOption(options.workflowId) } : {}),
-                ...(readOption(options.workflowName) ? { workflow_name: readOption(options.workflowName) } : {}),
-                input: options.inputJson ? parseJsonObject(options.inputJson) : {},
-                ...(readOption(options.mode) ? { mode: readOption(options.mode) } : {}),
-                ...(readOption(options.idempotencyKey) ? { idempotency_key: readOption(options.idempotencyKey) } : {}),
-                ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
-                ...(options.approved ? { approved: true } : {}),
-                ...(revisionVersion !== undefined ? { revision_version: revisionVersion } : {}),
-                ...(readOption(options.node) ? { test_node_id: readOption(options.node) } : {}),
-            },
-        }), options));
+        await handleAsyncAction("workflows call", options, async () => {
+            // --mode stopped being a commander requiredOption so that --preview,
+            // which executes nothing, no longer forces the caller to pick a mode
+            // the server then discards. A real call still needs one. Thrown
+            // INSIDE handleAsyncAction so it prints the CLI's error envelope and
+            // exits 2 like any other usage error — thrown outside, it escaped as
+            // an unhandled rejection and showed the user a Node stack trace.
+            if (!options.preview && !readOption(options.mode)) {
+                throw new OxygenError("invalid_request", "--mode is required. Use smoke-test, dry-run, or live. To see what a live run would do without running it, use --preview — it runs nothing and needs no mode.", { exitCode: 2 });
+            }
+            return prepareWorkflowCliOutput(await requestOxygen("/api/cli/workflows/call", {
+                method: "POST",
+                body: {
+                    workflow: readOption(workflowArg) ?? readOption(options.workflow),
+                    ...(readOption(options.workflowId) ? { workflow_id: readOption(options.workflowId) } : {}),
+                    ...(readOption(options.workflowName) ? { workflow_name: readOption(options.workflowName) } : {}),
+                    input: options.inputJson ? parseJsonObject(options.inputJson) : {},
+                    ...(readOption(options.mode) ? { mode: readOption(options.mode) } : {}),
+                    ...(readOption(options.idempotencyKey) ? { idempotency_key: readOption(options.idempotencyKey) } : {}),
+                    ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
+                    ...(options.approved ? { approved: true } : {}),
+                    ...(revisionVersion !== undefined ? { revision_version: revisionVersion } : {}),
+                    ...(readOption(options.node) ? { test_node_id: readOption(options.node) } : {}),
+                    ...(options.preview ? { preview: true } : {}),
+                },
+            }), options);
+        });
     }))
         .addCommand(new Command("webhooks")
         .description("Workflow webhook trigger utilities.")
@@ -15014,9 +15037,12 @@ Full trigger schema: oxygen workflows schema --subject trigger --json
         .option("--workflow <workflow>", "Workflow id, slug, or name.")
         .option("--workflow-id <workflow_id>", "Workflow id or slug.")
         .option("--status <status>", "Filter by queued, running, waiting, awaiting_approval, completed, failed, canceling, or canceled.")
+        .option("--mode <mode>", "Filter by execution mode: smoke_test, dry_run, or live.")
+        .option("--cursor <cursor>", "Continue from a previous page. Pass the nextCursor the last response returned.")
         .option("--limit <n>", "Maximum runs to return. Defaults to 50.")
         .option("--include-bundle", "Include durable recipe bundles in JSON output.")
         .option("--json", "Print a JSON envelope.")
+        .addHelpText("after", "\nPaging is anchored to the exact last run of the previous page, so runs arriving while you page are never skipped or repeated. A null nextCursor means the history ended.\n")
         .action(async (options) => {
         await handleAsyncAction("workflows runs", options, async () => {
             const query = new URLSearchParams();
@@ -15025,6 +15051,10 @@ Full trigger schema: oxygen workflows schema --subject trigger --json
                 query.set("workflow", workflow);
             if (readOption(options.status))
                 query.set("status", readOption(options.status) ?? "");
+            if (readOption(options.mode))
+                query.set("mode", readOption(options.mode) ?? "");
+            if (readOption(options.cursor))
+                query.set("cursor", readOption(options.cursor) ?? "");
             const limit = readPositiveInt(options.limit);
             if (limit)
                 query.set("limit", String(limit));
@@ -15094,11 +15124,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/error-redaction.d.ts

@@ -78,6 +78,24 @@ export declare function readWorkflowStepFailure(error: unknown): WorkflowStepFai
  */
 export declare const AUTOMATION_ACTIONS_EXCEEDED_ERROR_CODE = "automation_actions_exceeded";
 export declare function isAutomationUsageQuotaError(error: unknown): boolean;
+/**
+ * The credit-era sibling of the code above, and the one most callers actually want.
+ *
+ * `automation_actions_exceeded` can only be thrown when the plan carries a non-null
+ * `monthlyAutomationActions`. Pricing Model 2.0 ([v1.330.0]) set that field to null on
+ * every base plan, so on current plans the admission gate in captureAutomationActions()
+ * is unreachable and assertAutomationActionsAvailable() refuses with `insufficient_credits`
+ * instead — actions bill AUTOMATION_ACTION_CREDITS each out of the one credit pool.
+ *
+ * Both codes mean the same thing to a caller: "this automation work was REFUSED admission,
+ * the customer must feel it, and the run must stop cleanly." Anything else is a metering
+ * write that failed and must be stepped over. Matching only the quota code is how a
+ * credit-exhausted cron ends up rethrowing out of the scheduler's enqueue loop instead of
+ * taking the graceful pause path — abandoning the lease and every remaining due trigger
+ * for that tenant's sweep.
+ */
+export declare const AUTOMATION_INSUFFICIENT_CREDITS_ERROR_CODE = "insufficient_credits";
+export declare function isAutomationAdmissionRefusal(error: unknown): boolean;
 /**
  * Node network primitives bury the actionable failure in `error.cause`: undici's
  * fetch rejects with a bare TypeError "fetch failed" and puts the real

package/node_modules/@oxygen/shared/dist/error-redaction.js

@@ -215,6 +215,30 @@ export function isAutomationUsageQuotaError(error) {
         && typeof error === "object"
         && error.code === AUTOMATION_ACTIONS_EXCEEDED_ERROR_CODE;
 }
+/**
+ * The credit-era sibling of the code above, and the one most callers actually want.
+ *
+ * `automation_actions_exceeded` can only be thrown when the plan carries a non-null
+ * `monthlyAutomationActions`. Pricing Model 2.0 ([v1.330.0]) set that field to null on
+ * every base plan, so on current plans the admission gate in captureAutomationActions()
+ * is unreachable and assertAutomationActionsAvailable() refuses with `insufficient_credits`
+ * instead — actions bill AUTOMATION_ACTION_CREDITS each out of the one credit pool.
+ *
+ * Both codes mean the same thing to a caller: "this automation work was REFUSED admission,
+ * the customer must feel it, and the run must stop cleanly." Anything else is a metering
+ * write that failed and must be stepped over. Matching only the quota code is how a
+ * credit-exhausted cron ends up rethrowing out of the scheduler's enqueue loop instead of
+ * taking the graceful pause path — abandoning the lease and every remaining due trigger
+ * for that tenant's sweep.
+ */
+export const AUTOMATION_INSUFFICIENT_CREDITS_ERROR_CODE = "insufficient_credits";
+export function isAutomationAdmissionRefusal(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const code = error.code;
+    return code === AUTOMATION_ACTIONS_EXCEEDED_ERROR_CODE
+        || code === AUTOMATION_INSUFFICIENT_CREDITS_ERROR_CODE;
+}
 const MAX_CAUSE_DEPTH = 4;
 const MAX_CAUSE_MESSAGE_LENGTH = 200;
 export function errorCauseChain(error, maxDepth = MAX_CAUSE_DEPTH) {

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.799.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.799.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/node_modules/@oxygen/workflows/dist/usage-estimate.d.ts

@@ -14,6 +14,9 @@ export type CronCadenceAssessment = {
     floorActionsPer30Days: number;
     includedActions: number;
     floorShareOfIncluded: number;
+    basis: "plan_action_quota" | "plan_monthly_credits";
+    includedCredits: number | null;
+    floorCreditsPer30Days: number | null;
     minimumViableIntervalMinutes: number | null;
     verdict: "fits" | "impossible";
 };
@@ -22,6 +25,8 @@ export declare function assessCronCadenceViability(input: {
     cron: string | null | undefined;
     includedActions: number | null;
     overageEnabled: boolean;
+    includedCredits?: number | null;
+    creditsPerAction?: number | null;
 }): CronCadenceAssessment | null;
 export type CronAggressiveness = {
     level: "aggressive" | "very_aggressive";

package/node_modules/@oxygen/workflows/dist/usage-estimate.js

@@ -287,26 +287,53 @@ const MINUTES_PER_30_DAYS = 43_200;
 // enabled (the org has opted into paying past the cap, so a cadence that
 // overruns it bills instead of failing).
 export function assessCronCadenceViability(input) {
-    if (!input.cron || input.includedActions === null || input.overageEnabled)
+    if (!input.cron || input.overageEnabled)
         return null;
-    if (!Number.isFinite(input.includedActions) || input.includedActions <= 0)
+    const creditsPerAction = typeof input.creditsPerAction === "number"
+        && Number.isFinite(input.creditsPerAction)
+        && input.creditsPerAction > 0
+        ? input.creditsPerAction
+        : null;
+    const includedCredits = typeof input.includedCredits === "number"
+        && Number.isFinite(input.includedCredits)
+        && input.includedCredits > 0
+        ? input.includedCredits
+        : null;
+    // Prefer a real action quota when the plan still has one; otherwise derive the
+    // equivalent action budget from monthly credits.
+    const basis = input.includedActions === null
+        ? "plan_monthly_credits"
+        : "plan_action_quota";
+    const includedActions = basis === "plan_action_quota"
+        ? input.includedActions
+        : (includedCredits !== null && creditsPerAction !== null
+            ? Math.floor(includedCredits / creditsPerAction)
+            : null);
+    if (includedActions === null)
+        return null;
+    if (!Number.isFinite(includedActions) || includedActions <= 0)
         return null;
     const scheduledRunsPer30Days = estimateCronRunsPer30Days(input.cron);
     if (scheduledRunsPer30Days === null)
         return null;
     const actionsPerRunFloor = estimateWorkflowRunAutomationActionsFloor(input.manifest);
     const floorActionsPer30Days = scheduledRunsPer30Days * actionsPerRunFloor;
-    const runsAllowedPer30Days = Math.floor(input.includedActions / actionsPerRunFloor);
+    const runsAllowedPer30Days = Math.floor(includedActions / actionsPerRunFloor);
     return {
         scheduledRunsPer30Days,
         actionsPerRunFloor,
         floorActionsPer30Days,
-        includedActions: input.includedActions,
-        floorShareOfIncluded: floorActionsPer30Days / input.includedActions,
+        includedActions,
+        floorShareOfIncluded: floorActionsPer30Days / includedActions,
+        basis,
+        includedCredits: basis === "plan_monthly_credits" ? includedCredits : null,
+        floorCreditsPer30Days: basis === "plan_monthly_credits" && creditsPerAction !== null
+            ? Math.round(floorActionsPer30Days * creditsPerAction * 1000) / 1000
+            : null,
         minimumViableIntervalMinutes: runsAllowedPer30Days > 0
             ? Math.ceil(MINUTES_PER_30_DAYS / runsAllowedPer30Days)
             : null,
-        verdict: floorActionsPer30Days > input.includedActions ? "impossible" : "fits",
+        verdict: floorActionsPer30Days > includedActions ? "impossible" : "fits",
     };
 }
 // Warn (never block) below this cadence; the billing gate above stays the

package/package.json

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