@oxygen-agent/cli 1.750.4 → 1.766.0

package/node_modules/@oxygen/shared/dist/provider-funding-errors.js

@@ -0,0 +1,81 @@
+/**
+ * One vocabulary for "the provider refused because of money".
+ *
+ * A provider 402 has reached customers wearing four different costumes:
+ *   - `provider_credits_exhausted`        (tool runner, managed pool)
+ *   - `connection_credits_exhausted`      (tool runner, BYOK connection)
+ *   - `provider_insufficient_credits`     (enrichment column runner + waterfall)
+ *   - `provider_credit_exhausted`         (worker lane exclusion, singular)
+ * plus `provider_plan_limit` for the adjacent "your plan does not include this"
+ * refusal, which is also a money problem and also not retryable.
+ *
+ * Only the first two were known to the run-bottleneck classifier. The others
+ * fell through to a `/rate|limit|429/` test — which `provider_plan_limit`
+ * matches on the substring "limit" — or to the deferral branch, so a hard 402
+ * surfaced to the customer as `bottlenecks: [provider_rate_limit]`. That reads
+ * as "wait and retry": a partner agency spent hours lowering concurrency against
+ * an account that was simply out of credits, and the real 402 was only visible
+ * through a different command.
+ *
+ * The distinction that matters operationally: a rate limit clears by waiting, a
+ * funding failure never does. Anything that decides "should the customer wait?"
+ * must ask this predicate, not a regex over the code string.
+ */
+/** Codes meaning the provider refused for funding/entitlement reasons. Never retryable by waiting. */
+export const PROVIDER_FUNDING_ERROR_CODES = [
+    "provider_credits_exhausted",
+    "provider_credits_exhausted_deferred",
+    "connection_credits_exhausted",
+    "provider_insufficient_credits",
+    "provider_credit_exhausted",
+    "provider_plan_limit",
+    "blocked_provider_funding",
+];
+const FUNDING_CODE_SET = new Set(PROVIDER_FUNDING_ERROR_CODES);
+/**
+ * True when the code means "this failed over money", in any of its spellings.
+ *
+ * Matches on the exact code first, then falls back to a narrow shape test so a
+ * provider-specific variant (`peopledatalabs_credits_exhausted`) is still
+ * classified as funding rather than silently treated as retryable. Deliberately
+ * does NOT match on "limit" alone — `rate_limit_exceeded` is a real rate limit.
+ */
+export function isProviderFundingErrorCode(code) {
+    if (!code)
+        return false;
+    const normalized = code.trim().toLowerCase();
+    if (!normalized)
+        return false;
+    if (FUNDING_CODE_SET.has(normalized))
+        return true;
+    if (/_credits?_exhausted(_deferred)?$/.test(normalized))
+        return true;
+    if (/insufficient_credits?$/.test(normalized))
+        return true;
+    if (/^blocked_provider_funding/.test(normalized))
+        return true;
+    return /(?:payment_required|plan_limit|quota_exceeded)$/.test(normalized);
+}
+/**
+ * True for a genuine rate limit — one that clears by waiting.
+ *
+ * A funding failure always wins: `provider_plan_limit` contains "limit" and
+ * would otherwise read as retryable.
+ */
+export function isProviderRateLimitErrorCode(code) {
+    if (!code)
+        return false;
+    if (isProviderFundingErrorCode(code))
+        return false;
+    return /rate|limit|429|capacity_deferred/i.test(code);
+}
+/** The customer-facing next step for a funding refusal, by credential ownership. */
+export function providerFundingNextStep(credentialMode) {
+    if (credentialMode === "byok") {
+        return "Top up or upgrade the provider account behind your connected key, then retry. Waiting will not clear this.";
+    }
+    if (credentialMode === "managed") {
+        return "This is OXYGEN's managed provider account, not your credit balance — contact support. Waiting will not clear this; route the run to another provider in the meantime.";
+    }
+    return "Check the provider account's balance and plan entitlement, then retry. Waiting will not clear this.";
+}

package/node_modules/@oxygen/shared/dist/publishing-limits.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Broadcast character caps, in one place.
+ *
+ * These were defined three times — the web composer, the tenant-db lint, and an
+ * implicit `maxLength` on the MCP tool schema — and the MCP copy had drifted to
+ * 20,000. An X Premium account may post 25,000 characters, so a post between the
+ * two numbers was rejected by OXYGEN's own schema before X ever saw it, with an
+ * error that blamed the length rather than our stale constant. A customer hit
+ * exactly that after we told them the Premium cap was supported.
+ *
+ * `PUBLISHING_CONTENT_MAX_CHARS` is the outermost bound any surface should
+ * enforce: it must be >= the largest per-channel cap, because per-channel
+ * validation is where a too-long post gets an accurate, channel-specific error.
+ */
+/** X free tier. */
+export declare const X_FREE_MAX_CHARS = 280;
+/** X Premium. The largest single-post cap across every supported channel. */
+export declare const X_PREMIUM_MAX_CHARS = 25000;
+/**
+ * Outermost content bound for any publishing surface (CLI/MCP schema, API).
+ * Never set a surface's cap below this — let the per-channel lint produce the
+ * specific error instead of a generic schema rejection.
+ */
+export declare const PUBLISHING_CONTENT_MAX_CHARS = 25000;

package/node_modules/@oxygen/shared/dist/publishing-limits.js

@@ -0,0 +1,24 @@
+/**
+ * Broadcast character caps, in one place.
+ *
+ * These were defined three times — the web composer, the tenant-db lint, and an
+ * implicit `maxLength` on the MCP tool schema — and the MCP copy had drifted to
+ * 20,000. An X Premium account may post 25,000 characters, so a post between the
+ * two numbers was rejected by OXYGEN's own schema before X ever saw it, with an
+ * error that blamed the length rather than our stale constant. A customer hit
+ * exactly that after we told them the Premium cap was supported.
+ *
+ * `PUBLISHING_CONTENT_MAX_CHARS` is the outermost bound any surface should
+ * enforce: it must be >= the largest per-channel cap, because per-channel
+ * validation is where a too-long post gets an accurate, channel-specific error.
+ */
+/** X free tier. */
+export const X_FREE_MAX_CHARS = 280;
+/** X Premium. The largest single-post cap across every supported channel. */
+export const X_PREMIUM_MAX_CHARS = 25_000;
+/**
+ * Outermost content bound for any publishing surface (CLI/MCP schema, API).
+ * Never set a surface's cap below this — let the per-channel lint produce the
+ * specific error instead of a generic schema rejection.
+ */
+export const PUBLISHING_CONTENT_MAX_CHARS = X_PREMIUM_MAX_CHARS;

package/node_modules/@oxygen/shared/dist/spend-safety.d.ts

@@ -54,13 +54,34 @@ export declare function resolveByokProviderDailyCapEnforcementMode(configured?:
 /**
  * Implicit org-level DAILY budget guard, evaluated only when the org has no
  * explicit org-scope daily budget policy and the plan has finite positive
- * monthly credits. Warn when one rolling day spends past WARN_PCT of the
- * monthly grant; hard-block at BLOCK_PCT (a loop burning a whole month in a
- * day is near-certainly runaway — this also protects large top-up balances).
- * Setting any explicit org-daily policy fully suppresses the implicit pair.
+ * monthly credits. Expressed as a MULTIPLE of the plan's monthly grant spent in
+ * one UTC day: warn past WARN_MULTIPLE, hard-block at BLOCK_MULTIPLE. Setting
+ * any explicit org-daily policy fully suppresses the implicit pair.
+ *
+ * This is a runaway-loop backstop, NOT a spend ceiling. The available balance is
+ * the real bound on what a workspace can spend, and legitimate single-day work
+ * routinely exceeds a month's grant: standing up cold-email infrastructure
+ * (a managed domain plus three warmed inboxes is ~31k credits, so a full sending
+ * estate is hundreds of thousands in an afternoon) and large enrichment bursts
+ * funded by a top-up are both deliberate purchases, not loops. Raised 20x on
+ * 2026-08-17 for exactly that reason — at the previous 1x the guard refused a
+ * customer who had already paid for the credits, and the refusal was invisible
+ * on every surface. 20x still stops an unattended loop within hours.
+ */
+export declare const DEFAULT_ORG_DAILY_SPEND_WARN_MULTIPLE = 5;
+export declare const DEFAULT_ORG_DAILY_SPEND_BLOCK_MULTIPLE = 20;
+/** Resolved credit thresholds of the implicit org-daily guard for one plan. */
+export type OrgDailySpendGuard = {
+    warnCredits: number;
+    blockCredits: number;
+};
+/**
+ * Resolve the implicit guard's thresholds from a plan's monthly grant. `null`
+ * means the guard is suppressed because the plan has no finite positive grant to
+ * scale from (free at 0, enterprise/custom at null) — the single place that
+ * decision is made, so enforcement and the read surfaces cannot drift apart.
  */
-export declare const DEFAULT_ORG_DAILY_SPEND_WARN_PCT = 0.25;
-export declare const DEFAULT_ORG_DAILY_SPEND_BLOCK_PCT = 1;
+export declare function resolveOrgDailySpendGuard(monthlyCredits: number | null | undefined): OrgDailySpendGuard | null;
 export declare function resolveDefaultTriggerRunCreditCeiling(tier: PlanTier): number | null;
 export declare function resolveDefaultAutoRunBatchCreditCeiling(tier: PlanTier): number | null;
 export declare function resolveDefaultByokColumnRunMaxRows(tier: PlanTier): number | null;

package/node_modules/@oxygen/shared/dist/spend-safety.js

@@ -71,13 +71,41 @@ export function resolveByokProviderDailyCapEnforcementMode(configured = process.
 /**
  * Implicit org-level DAILY budget guard, evaluated only when the org has no
  * explicit org-scope daily budget policy and the plan has finite positive
- * monthly credits. Warn when one rolling day spends past WARN_PCT of the
- * monthly grant; hard-block at BLOCK_PCT (a loop burning a whole month in a
- * day is near-certainly runaway — this also protects large top-up balances).
- * Setting any explicit org-daily policy fully suppresses the implicit pair.
+ * monthly credits. Expressed as a MULTIPLE of the plan's monthly grant spent in
+ * one UTC day: warn past WARN_MULTIPLE, hard-block at BLOCK_MULTIPLE. Setting
+ * any explicit org-daily policy fully suppresses the implicit pair.
+ *
+ * This is a runaway-loop backstop, NOT a spend ceiling. The available balance is
+ * the real bound on what a workspace can spend, and legitimate single-day work
+ * routinely exceeds a month's grant: standing up cold-email infrastructure
+ * (a managed domain plus three warmed inboxes is ~31k credits, so a full sending
+ * estate is hundreds of thousands in an afternoon) and large enrichment bursts
+ * funded by a top-up are both deliberate purchases, not loops. Raised 20x on
+ * 2026-08-17 for exactly that reason — at the previous 1x the guard refused a
+ * customer who had already paid for the credits, and the refusal was invisible
+ * on every surface. 20x still stops an unattended loop within hours.
  */
-export const DEFAULT_ORG_DAILY_SPEND_WARN_PCT = 0.25;
-export const DEFAULT_ORG_DAILY_SPEND_BLOCK_PCT = 1;
+export const DEFAULT_ORG_DAILY_SPEND_WARN_MULTIPLE = 5;
+export const DEFAULT_ORG_DAILY_SPEND_BLOCK_MULTIPLE = 20;
+/**
+ * Resolve the implicit guard's thresholds from a plan's monthly grant. `null`
+ * means the guard is suppressed because the plan has no finite positive grant to
+ * scale from (free at 0, enterprise/custom at null) — the single place that
+ * decision is made, so enforcement and the read surfaces cannot drift apart.
+ */
+export function resolveOrgDailySpendGuard(monthlyCredits) {
+    if (typeof monthlyCredits !== "number" || !Number.isFinite(monthlyCredits) || monthlyCredits <= 0) {
+        return null;
+    }
+    return {
+        warnCredits: roundCredits(monthlyCredits * DEFAULT_ORG_DAILY_SPEND_WARN_MULTIPLE),
+        blockCredits: roundCredits(monthlyCredits * DEFAULT_ORG_DAILY_SPEND_BLOCK_MULTIPLE),
+    };
+}
+/** Credits carry 3 decimals everywhere (control-DB numeric(18,3)). */
+function roundCredits(value) {
+    return Math.round(value * 1000) / 1000;
+}
 export function resolveDefaultTriggerRunCreditCeiling(tier) {
     return DEFAULT_TRIGGER_RUN_CREDIT_CEILING[tier];
 }

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

@@ -1,4 +1,4 @@
-export declare const OXYGEN_VERSION = "1.750.4";
+export declare const OXYGEN_VERSION = "1.766.0";
 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.750.4";
+export const OXYGEN_VERSION = "1.766.0";
 // 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:
@@ -26,8 +26,11 @@ export const OXYGEN_VERSION = "1.750.4";
 // (oxygen sequences|inbox|senders, /api/cli/{sequences,inbox,senders}) and
 // removed the old /api/cli/linkedin/* routes — older CLIs would 404.
 export const OXYGEN_MINIMUM_CLI_VERSION = "1.181.0";
-// Per-surface floor for the whitelabel/managed-inbox purchase path, enforced only
-// by /api/cli/managed-inboxes/subscribe.
+// Per-surface floor for the whitelabel/managed-inbox purchase path, enforced by
+// BOTH paid inbox routes: /api/cli/managed-inboxes/subscribe and
+// /api/cli/managed-inboxes/[domain]/mailboxes. (The comment used to say subscribe
+// only; the expansion route has enforced it too since it shipped, and three
+// separate reads of this file have since reasoned from the wrong half.)
 //
 // 1.326.2: Pricing Model 2.0 (2026-07-14) moved whitelabel inbox subscribe from the
 // USD Stripe rail back to Oxygen credits: the preview now returns

package/node_modules/@oxygen/shared/package.json

@@ -61,6 +61,11 @@
       "import": "./dist/object-storage.js",
       "default": "./dist/object-storage.js"
     },
+    "./person-name": {
+      "types": "./dist/person-name.d.ts",
+      "import": "./dist/person-name.js",
+      "default": "./dist/person-name.js"
+    },
     "./select-options": {
       "types": "./dist/select-options.d.ts",
       "import": "./dist/select-options.js",
@@ -145,6 +150,11 @@
       "types": "./dist/schedule-label.d.ts",
       "import": "./dist/schedule-label.js",
       "default": "./dist/schedule-label.js"
+    },
+    "./publishing-limits": {
+      "types": "./dist/publishing-limits.d.ts",
+      "import": "./dist/publishing-limits.js",
+      "default": "./dist/publishing-limits.js"
     }
   },
   "dependencies": {}

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

@@ -52,6 +52,33 @@ export declare function topologicalOrder(graph: WorkflowGraphManifest): string[]
  * execution order and the existing topological analysis.
  */
 export declare function dominatingNodeIds(graph: WorkflowGraphManifest, targetNodeId: string): Set<string>;
+export type WorkflowGraphNodeTestPlanIssueCode = "workflow_test_target_not_found" | "workflow_test_target_is_trigger" | "workflow_test_target_disabled" | "workflow_test_target_unreachable";
+export type WorkflowGraphNodeTestPlan = {
+    targetNodeId: string;
+    /** Original manifest order, suitable for a durable receipt and UI highlight. */
+    nodeIds: string[];
+    /** Transient execution view; the immutable run manifest remains unchanged. */
+    manifest: WorkflowGraphManifest;
+};
+export type WorkflowGraphNodeTestPlanResult = {
+    ok: true;
+    plan: WorkflowGraphNodeTestPlan;
+} | {
+    ok: false;
+    code: WorkflowGraphNodeTestPlanIssueCode;
+    message: string;
+};
+/**
+ * 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 declare function planWorkflowGraphNodeTest(graph: WorkflowGraphManifest, targetNodeId: string): WorkflowGraphNodeTestPlanResult;
 /**
  * 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/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,26 @@ 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[];
+};
 export declare const RESERVED_NODE_IDS: ReadonlySet<string>;
 /**
  * Named Code inputs and declared output fields become dotted scope paths and

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.

package/package.json

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