@oxygen-agent/cli 1.142.4 → 1.146.1

package/README.md

@@ -34,4 +34,4 @@ oxygen update
 
 For product documentation and support, visit https://oxygen-agent.com.
 
-Version: 1.142.4
+Version: 1.146.1

package/dist/http-client.js

@@ -1,4 +1,4 @@
-import { OXYGEN_VERSION, OxygenError } from "@oxygen/shared";
+import { OXYGEN_VERSION, OxygenError, isVersionGreater } from "@oxygen/shared";
 import { randomUUID } from "node:crypto";
 import { defaultApiUrl, loadCredentials } from "./credentials.js";
 import { resolveCliUpdateGuidance } from "./runtime.js";
@@ -24,6 +24,9 @@ path, options = {}) {
     const headers = {
         Accept: "application/json",
         "X-Oxygen-Trace-Id": traceId,
+        // Advertise the CLI version so the server can enforce its minimum-CLI floor
+        // even against clients that predate the client-side envelope gate.
+        "X-Oxygen-Client-Version": OXYGEN_VERSION,
     };
     addVercelProtectionBypassHeader(apiUrl, headers);
     if (credentials?.token) {
@@ -225,31 +228,6 @@ function withTraceDetails(details, traceId, compatibility, apiUrl) {
         ...fields,
     };
 }
-function isVersionGreater(left, right) {
-    const leftParts = parseSemver(left);
-    const rightParts = parseSemver(right);
-    if (!leftParts || !rightParts)
-        return false;
-    for (let index = 0; index < leftParts.length; index += 1) {
-        const leftPart = leftParts[index] ?? 0;
-        const rightPart = rightParts[index] ?? 0;
-        if (leftPart > rightPart)
-            return true;
-        if (leftPart < rightPart)
-            return false;
-    }
-    return false;
-}
-function parseSemver(value) {
-    const match = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(value);
-    if (!match)
-        return null;
-    return [
-        Number(match[1]),
-        Number(match[2]),
-        Number(match[3]),
-    ];
-}
 function addVercelProtectionBypassHeader(apiUrl, headers) {
     const secret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();
     if (!secret)

package/dist/index.js

@@ -45,6 +45,10 @@ const OXYGEN_WORDMARK = [
 const LARGE_IMPORT_BACKGROUND_ROW_THRESHOLD = 500;
 const TABLE_ACTION_RUN_WAIT_DEFAULT_TIMEOUT_SECONDS = 600;
 const TABLE_ACTION_RUN_WAIT_DEFAULT_INTERVAL_SECONDS = 5;
+// Single-row paid runs are auto-backgrounded server-side; the CLI waits this
+// long for the cell to finish before handing back the queued run envelope.
+const SINGLE_ROW_COLUMN_RUN_WAIT_DEFAULT_TIMEOUT_SECONDS = 90;
+const SINGLE_ROW_COLUMN_RUN_WAIT_DEFAULT_INTERVAL_SECONDS = 2;
 const TABLE_INGESTION_WAIT_DEFAULT_TIMEOUT_SECONDS = 600;
 const TABLE_INGESTION_WAIT_DEFAULT_INTERVAL_SECONDS = 5;
 const WORKFLOW_TAIL_DEFAULT_TIMEOUT_SECONDS = 600;
@@ -74,9 +78,28 @@ async function handleAsyncAction(command, options, action) {
     catch (error) {
         const failure = toFailure(command, error);
         writeJson(failure);
+        writeMaxCreditsHint(error);
         process.exitCode = error instanceof OxygenError ? error.exitCode : 1;
     }
 }
+// Paid multi-row column runs require an explicit --max-credits spend cap; the
+// server rejects them with max_credits_required plus a recommended cap. Surface
+// that as a one-line stderr hint so users don't have to dig the value out of the
+// JSON envelope (stderr keeps --json stdout machine-clean).
+function writeMaxCreditsHint(error) {
+    if (!(error instanceof OxygenError) || error.code !== "max_credits_required")
+        return;
+    const recommended = readRecommendedMaxCredits(error.details);
+    if (recommended === null)
+        return;
+    process.stderr.write(`hint: re-run with --max-credits ${recommended} to approve the spend cap\n`);
+}
+function readRecommendedMaxCredits(details) {
+    if (!details || typeof details !== "object" || Array.isArray(details))
+        return null;
+    const value = details.recommended_max_credits;
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
 function parseJsonObject(value) {
     let parsed;
     try {
@@ -479,6 +502,32 @@ export function createProgram() {
                 },
             });
         });
+    }))
+        .addCommand(new Command("backfill-upsert-indexes")
+        .description("Create missing upsert-key secondary indexes on customer tables. Staff only; defaults to dry-run.")
+        .option("--dry-run", "Report the index backfill plan without creating indexes. This is the default.")
+        .option("--apply", "Create the missing indexes (CONCURRENTLY). Requires --confirm.")
+        .option("--confirm", "Confirm --apply for index creation.")
+        .option("--org <id>", "Limit the backfill to a single organization id.")
+        .option("--limit <n>", "Maximum ready tenants to inspect in this batch. Defaults to 25; hard cap is 200.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("db backfill-upsert-indexes", options, () => {
+            if (options.apply && !options.confirm) {
+                throw new OxygenError("confirmation_required", "Refusing to create upsert-key indexes without --confirm.", { exitCode: 1 });
+            }
+            const limit = readPositiveInt(options.limit);
+            return requestOxygen("/api/cli/db/backfill-upsert-indexes", {
+                method: "POST",
+                body: {
+                    apply: Boolean(options.apply),
+                    dry_run: !options.apply,
+                    confirm: Boolean(options.confirm),
+                    ...(options.org ? { organization_id: options.org } : {}),
+                    ...(limit !== undefined ? { limit } : {}),
+                },
+            });
+        });
     }))
         .addCommand(new Command("cost-policy")
         .description("Show tenant database cost controls and reconciliation status.")
@@ -2416,7 +2465,11 @@ export function createProgram() {
         .description("Redacted operation event commands for the current organization.")
         .addCommand(new Command("events")
         .description("List recent redacted operation events and failures.")
-        .option("--status <status>", "Filter by completed, queued, completed_with_errors, or failed.")
+        // Keep in sync with OBSERVABILITY_STATUS_FILTERS in
+        // apps/web/src/lib/observability.ts and the MCP tool enum in
+        // packages/mcp-server/src/tools/observability.ts. The API rejects any
+        // other value with invalid_request so a typo fails loudly.
+        .option("--status <status>", "Filter by success, error, completed, failed, completed_with_errors, queued, skipped, or blocked.")
         .option("--trace-id <trace_id>", "Filter by trace id.")
         .option("--run-id <run_id>", "Filter by workspace run id.")
         .option("--limit <n>", "Maximum events to return. Defaults to 50.")
@@ -3010,6 +3063,197 @@ export function createProgram() {
             });
         });
     }));
+    program
+        .command("linkedin")
+        .description("LinkedIn sender account management for the native LinkedIn sequencer (accounts, limits, usage).")
+        .addCommand(new Command("accounts")
+        .description("Manage the org's connected LinkedIn sender accounts: list, connect, sync, inspect, disconnect, and tune rate limits.")
+        .addCommand(new Command("list")
+        .description("List connected LinkedIn sender accounts with health status, rate limits, and today's usage.")
+        .option("--status <status>", "Filter by sender status: active, paused, disconnected, restricted, or credentials_required.")
+        .option("--no-usage", "Skip today's per-account usage counts for a faster, lighter response.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin accounts list", options, () => {
+            const params = new URLSearchParams();
+            if (options.usage !== false)
+                params.set("include_usage", "true");
+            const status = readOption(options.status);
+            if (status)
+                params.set("status", status);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/linkedin/accounts${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("connect")
+        .description("Get a Unipile hosted-auth URL to connect a new LinkedIn account (or reconnect with --reconnect). Open the URL in a browser to complete authentication.")
+        .option("--reconnect <connection_id>", "Reconnect an existing connection instead of creating a new one. Accepts a connection id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin accounts connect", options, () => {
+            const reconnect = readOption(options.reconnect);
+            return requestOxygen("/api/cli/linkedin/accounts/connect", {
+                method: "POST",
+                body: {
+                    ...(reconnect ? { reconnect_connection_id: reconnect } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("get")
+        .description("Get one LinkedIn sender account with status, limits, working hours, and usage. <id> accepts a sender account id, connection id, or Unipile account id.")
+        .argument("<id>", "Sender account id, connection id, or Unipile account id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("linkedin accounts get", options, async () => requestOxygen(`/api/cli/linkedin/accounts/${encodeURIComponent(id)}`));
+    }))
+        .addCommand(new Command("sync")
+        .description("Refresh LinkedIn account state (status, profile) from Unipile. Pass --connection-id to sync one account, or omit it to sync all.")
+        .option("--connection-id <id>", "Sync a specific connection id. Defaults to syncing all connected accounts.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin accounts sync", options, () => {
+            const connectionId = readOption(options.connectionId);
+            return requestOxygen("/api/cli/linkedin/accounts/sync", {
+                method: "POST",
+                body: {
+                    ...(connectionId ? { connection_id: connectionId } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("disconnect")
+        .description("Disconnect a LinkedIn sender account so it stops sending. <id> accepts a sender account id, connection id, or Unipile account id.")
+        .argument("<id>", "Sender account id, connection id, or Unipile account id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("linkedin accounts disconnect", options, async () => requestOxygen(`/api/cli/linkedin/accounts/${encodeURIComponent(id)}/disconnect`, {
+            method: "POST",
+        }));
+    }))
+        .addCommand(new Command("limits")
+        .description("View and adjust per-account daily action limits and working hours.")
+        .option("--json", "Print a JSON envelope.")
+        .addCommand(new Command("get")
+        .description("Show current limits, overrides, working hours, defaults, and safe maximums for an account. <id> accepts a sender account id, connection id, or Unipile account id.")
+        .argument("<id>", "Sender account id, connection id, or Unipile account id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("linkedin accounts limits get", options, async () => requestOxygen(`/api/cli/linkedin/accounts/${encodeURIComponent(id)}/limits`));
+    }))
+        .addCommand(new Command("set")
+        .description("Adjust per-account daily action limits and working hours. Values are clamped to safe maximums (e.g. max 80 invites/day). <id> accepts a sender account id, connection id, or Unipile account id.")
+        .argument("<id>", "Sender account id, connection id, or Unipile account id.")
+        .option("--invites-per-day <n>", "Daily LinkedIn connection invites cap.")
+        .option("--invites-per-week <n>", "Weekly LinkedIn connection invites cap.")
+        .option("--messages-per-day <n>", "Daily direct messages cap.")
+        .option("--inmails-per-day <n>", "Daily InMail cap.")
+        .option("--profile-views-per-day <n>", "Daily profile views cap.")
+        .option("--follows-per-day <n>", "Daily follows cap.")
+        .option("--likes-per-day <n>", "Daily likes cap.")
+        .option("--total-actions-per-day <n>", "Daily cap across all action types.")
+        .option("--min-spacing-seconds <n>", "Minimum seconds between actions.")
+        .option("--spacing-jitter-seconds <n>", "Random jitter seconds added to action spacing.")
+        .option("--timezone <tz>", "IANA timezone for working hours, e.g. America/New_York.")
+        .option("--working-days <days>", "Comma-separated ISO weekdays the account sends, e.g. 1,2,3,4,5 (1=Mon..7=Sun).")
+        .option("--working-start <HH:MM>", "Working hours start time, e.g. 09:00.")
+        .option("--working-end <HH:MM>", "Working hours end time, e.g. 17:00.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("linkedin accounts limits set", options, () => {
+            const body = buildLinkedinLimitsBody(options);
+            return requestOxygen(`/api/cli/linkedin/accounts/${encodeURIComponent(id)}/limits`, {
+                method: "PATCH",
+                body,
+            });
+        });
+    }))))
+        .addCommand(new Command("inbox")
+        .description("LinkedIn unified inbox (unibox): scan conversations across all sender accounts, read threads, and reply.")
+        .addCommand(new Command("list")
+        .description("List LinkedIn conversations across all connected accounts, newest first.")
+        .option("--account <id>", "Filter to one sender account (sender id, connection id, or Unipile account id).")
+        .option("--unread", "Only show conversations with unread messages.")
+        .option("--search <text>", "Filter by attendee name or last-message text.")
+        .option("--include-archived", "Include archived conversations.")
+        .option("--limit <n>", "Maximum conversations to return (1-200). Defaults to 50.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin inbox list", options, () => {
+            const params = new URLSearchParams();
+            const account = readOption(options.account);
+            if (account)
+                params.set("account", account);
+            if (options.unread)
+                params.set("unread", "true");
+            const search = readOption(options.search);
+            if (search)
+                params.set("search", search);
+            if (options.includeArchived)
+                params.set("include_archived", "true");
+            const limit = readOption(options.limit);
+            if (limit)
+                params.set("limit", limit);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/linkedin/inbox${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("get")
+        .description("Get one conversation with its full message thread. <conversation> accepts a conversation id or Unipile chat id.")
+        .argument("<conversation>", "Conversation id or Unipile chat id.")
+        .option("--message-limit <n>", "Maximum messages to return (1-500). Defaults to 100.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (conversation, options) => {
+        await handleAsyncAction("linkedin inbox get", options, () => {
+            const params = new URLSearchParams();
+            const messageLimit = readOption(options.messageLimit);
+            if (messageLimit)
+                params.set("message_limit", messageLimit);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/linkedin/inbox/${encodeURIComponent(conversation)}${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("send")
+        .description("Reply into a LinkedIn conversation. Sends a real LinkedIn message — requires --approved. Without it, returns a preview.")
+        .argument("<conversation>", "Conversation id or Unipile chat id.")
+        .requiredOption("--text <message>", "Reply text to send.")
+        .option("--approved", "Approve and send the message. Without this flag, returns a preview only.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (conversation, options) => {
+        await handleAsyncAction("linkedin inbox send", options, () => requestOxygen(`/api/cli/linkedin/inbox/${encodeURIComponent(conversation)}/send`, {
+            method: "POST",
+            body: {
+                text: readOption(options.text),
+                ...(options.approved ? { approved: true } : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("mark-read")
+        .description("Mark a conversation and all its messages as read.")
+        .argument("<conversation>", "Conversation id or Unipile chat id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (conversation, options) => {
+        await handleAsyncAction("linkedin inbox mark-read", options, () => requestOxygen(`/api/cli/linkedin/inbox/${encodeURIComponent(conversation)}/read`, {
+            method: "POST",
+        }));
+    }))
+        .addCommand(new Command("sync")
+        .description("Force a backstop inbox sync from Unipile for all active sender accounts (pulls recent chats + messages into the unibox).")
+        .option("--chat-limit <n>", "Maximum chats to sync per account. Defaults to 30.")
+        .option("--message-limit <n>", "Maximum messages to sync per chat. Defaults to 20.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin inbox sync", options, () => {
+            const body = {};
+            const chatLimit = readOption(options.chatLimit);
+            if (chatLimit)
+                body.chat_limit = Number(chatLimit);
+            const messageLimit = readOption(options.messageLimit);
+            if (messageLimit)
+                body.message_limit = Number(messageLimit);
+            return requestOxygen("/api/cli/linkedin/inbox/sync", { method: "POST", body });
+        });
+    })));
     program
         .command("workflows")
         .description("Durable workflow automation commands.")
@@ -3849,21 +4093,94 @@ function tableRunsListPath(options) {
 }
 async function requestColumnsRun(body, table, options) {
     const traceId = randomUUID();
+    let result;
     try {
-        return await requestOxygen("/api/cli/tables/columns/run", {
+        result = await requestOxygen("/api/cli/tables/columns/run", {
             method: "POST",
             body,
             traceId,
         });
     }
     catch (error) {
-        if (!options.background || !isNetworkTimeoutError(error))
+        // Paid runs are durable background runs server-side (even single-row since
+        // v1.144.0), so a network timeout is always recoverable by locating the
+        // created run via its trace id - not only when --background was passed.
+        // Inline (formula) runs have no run to recover; recovery returns null and
+        // the original error propagates.
+        if (!isNetworkTimeoutError(error))
             throw error;
         const recovered = await recoverBackgroundColumnRun(table, traceId);
         if (!recovered)
             throw error;
         return recovered;
     }
+    // "Run this cell" still resolves to the finished value in one command: when
+    // the server auto-backgrounds a single-row paid run (caller did not pass
+    // --background), wait for the created run and attach its item output.
+    // Inline (formula) results carry no action_run_id and pass through as-is.
+    if (!options.background && typeof body.row_id === "string" && isRecord(result)) {
+        const actionRunId = readRecordString(result, "action_run_id");
+        if (actionRunId)
+            return resolveSingleRowColumnRun(result, actionRunId);
+    }
+    return result;
+}
+/**
+ * Wait for an auto-backgrounded single-row column run to finish and return the
+ * terminal run merged with its item output (the cell value). On wait timeout
+ * the queued run envelope is returned unchanged, plus the follow-up command -
+ * the run keeps executing server-side either way.
+ */
+async function resolveSingleRowColumnRun(envelope, actionRunId) {
+    const timeoutSeconds = readEnvPositiveInt("OXYGEN_COLUMN_RUN_WAIT_TIMEOUT_SECONDS")
+        ?? SINGLE_ROW_COLUMN_RUN_WAIT_DEFAULT_TIMEOUT_SECONDS;
+    const intervalSeconds = readEnvPositiveInt("OXYGEN_COLUMN_RUN_WAIT_INTERVAL_SECONDS")
+        ?? SINGLE_ROW_COLUMN_RUN_WAIT_DEFAULT_INTERVAL_SECONDS;
+    let waited;
+    try {
+        waited = await waitForTableActionRun(actionRunId, {
+            timeoutSeconds: String(timeoutSeconds),
+            intervalSeconds: String(intervalSeconds),
+        });
+    }
+    catch (error) {
+        if (error instanceof OxygenError && error.code === "table_action_run_wait_timeout") {
+            return {
+                ...envelope,
+                auto_wait_timed_out: true,
+                next_step: `oxygen table-runs wait ${actionRunId}`,
+            };
+        }
+        throw error;
+    }
+    const finalRun = isRecord(waited.actionRun) ? waited.actionRun : envelope;
+    const items = await listColumnRunItems(actionRunId);
+    return {
+        ...finalRun,
+        ...(items ? { items } : {}),
+        auto_waited: {
+            polls: waited.polls,
+            elapsed_ms: waited.elapsedMs,
+        },
+    };
+}
+async function listColumnRunItems(actionRunId) {
+    try {
+        const response = await requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(actionRunId)}/items?limit=5`);
+        const items = Array.isArray(response.items) ? response.items.filter(isRecord) : [];
+        return items.length > 0 ? items : null;
+    }
+    catch {
+        // The terminal run state is the answer; item output is best-effort.
+        return null;
+    }
+}
+function readEnvPositiveInt(name) {
+    const value = process.env[name]?.trim();
+    if (!value)
+        return undefined;
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed >= 1 ? parsed : undefined;
 }
 async function recoverBackgroundColumnRun(table, traceId) {
     for (let attempt = 0; attempt < 3; attempt += 1) {
@@ -6306,6 +6623,62 @@ table, options) {
         ...(options.onlyMissing ? { only_missing: true } : {}),
     };
 }
+function readWorkingDaysOption(value) {
+    if (!readOption(value))
+        return undefined;
+    const days = readCsvOption(value).map((entry) => {
+        const parsed = Number(entry);
+        if (!Number.isInteger(parsed) || parsed < 1 || parsed > 7) {
+            throw new OxygenError("invalid_request", "--working-days must be comma-separated ISO weekdays 1-7 (1=Mon..7=Sun).", {
+                details: { value },
+                exitCode: 1,
+            });
+        }
+        return parsed;
+    });
+    return days;
+}
+function buildLinkedinLimitsBody(// skipcq: JS-R1005 -- CLI body builder maps per-account limit and working-hours flags.
+options) {
+    const limits = {};
+    const setLimit = (key, value) => {
+        const parsed = readNonNegativeInt(value);
+        if (parsed !== undefined)
+            limits[key] = parsed;
+    };
+    setLimit("invites_per_day", options.invitesPerDay);
+    setLimit("invites_per_week", options.invitesPerWeek);
+    setLimit("messages_per_day", options.messagesPerDay);
+    setLimit("inmails_per_day", options.inmailsPerDay);
+    setLimit("profile_views_per_day", options.profileViewsPerDay);
+    setLimit("follows_per_day", options.followsPerDay);
+    setLimit("likes_per_day", options.likesPerDay);
+    setLimit("total_actions_per_day", options.totalActionsPerDay);
+    setLimit("min_action_spacing_seconds", options.minSpacingSeconds);
+    setLimit("action_spacing_jitter_seconds", options.spacingJitterSeconds);
+    const workingHours = {};
+    const timezone = readOption(options.timezone);
+    if (timezone)
+        workingHours.timezone = timezone;
+    const days = readWorkingDaysOption(options.workingDays);
+    if (days !== undefined)
+        workingHours.days = days;
+    const start = readOption(options.workingStart);
+    if (start)
+        workingHours.start = start;
+    const end = readOption(options.workingEnd);
+    if (end)
+        workingHours.end = end;
+    const hasLimits = Object.keys(limits).length > 0;
+    const hasWorkingHours = Object.keys(workingHours).length > 0;
+    if (!hasLimits && !hasWorkingHours) {
+        throw new OxygenError("invalid_request", "Pass at least one limit flag (e.g. --invites-per-day) or working-hours flag (e.g. --timezone, --working-days).", { exitCode: 1 });
+    }
+    return {
+        ...(hasLimits ? { limits } : {}),
+        ...(hasWorkingHours ? { working_hours: workingHours } : {}),
+    };
+}
 function readPositiveInt(value) {
     const trimmed = value?.trim();
     if (!trimmed)

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

@@ -1,4 +1,5 @@
 export { OXYGEN_MINIMUM_CLI_VERSION, OXYGEN_VERSION } from "./version.js";
+export { WORKFLOW_TRIGGER_AUTO_PAUSE_METADATA_KEYS, clearWorkflowTriggerAutoPauseMetadata, } from "./workflow-trigger-metadata.js";
 export * from "./billing.js";
 export * from "./cell-format.js";
 export * from "./column-types.js";
@@ -46,3 +47,24 @@ export declare function failure(command: string, error: {
     details?: unknown;
 }, version?: string, minimumCliVersion?: string): CliFailure;
 export declare function toFailure(command: string, error: unknown, version?: string): CliFailure;
+export type SemanticVersion = {
+    major: number;
+    minor: number;
+    patch: number;
+};
+/**
+ * Parse a three-segment semantic version (e.g. `1.142.17`). Pre-release and
+ * build metadata suffixes (`-rc.1`, `+build`) are tolerated but ignored.
+ * Returns `null` when the input is not a parseable `major.minor.patch` string.
+ */
+export declare function parseSemver(version: string): SemanticVersion | null;
+/**
+ * Compare two semantic versions. Returns -1 when `a < b`, 1 when `a > b`, and
+ * 0 when they are equal. Unparseable inputs compare as equal (0) so callers
+ * fail open rather than misordering garbage.
+ */
+export declare function compareSemver(a: string, b: string): -1 | 0 | 1;
+/** True when `a` is a strictly greater semantic version than `b`. */
+export declare function isVersionGreater(a: string, b: string): boolean;
+/** True when `a` is a strictly lesser semantic version than `b`. */
+export declare function isVersionLess(a: string, b: string): boolean;

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

@@ -1,5 +1,6 @@
 import { OXYGEN_MINIMUM_CLI_VERSION, OXYGEN_VERSION } from "./version.js";
 export { OXYGEN_MINIMUM_CLI_VERSION, OXYGEN_VERSION } from "./version.js";
+export { WORKFLOW_TRIGGER_AUTO_PAUSE_METADATA_KEYS, clearWorkflowTriggerAutoPauseMetadata, } from "./workflow-trigger-metadata.js";
 export * from "./billing.js";
 export * from "./cell-format.js";
 export * from "./column-types.js";
@@ -51,3 +52,44 @@ export function toFailure(command, error, version = OXYGEN_VERSION) {
     }
     return failure(command, { code: "unexpected_error", message: "An unexpected error occurred." }, version);
 }
+/**
+ * Parse a three-segment semantic version (e.g. `1.142.17`). Pre-release and
+ * build metadata suffixes (`-rc.1`, `+build`) are tolerated but ignored.
+ * Returns `null` when the input is not a parseable `major.minor.patch` string.
+ */
+export function parseSemver(version) {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version);
+    if (!match)
+        return null;
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+    };
+}
+/**
+ * Compare two semantic versions. Returns -1 when `a < b`, 1 when `a > b`, and
+ * 0 when they are equal. Unparseable inputs compare as equal (0) so callers
+ * fail open rather than misordering garbage.
+ */
+export function compareSemver(a, b) {
+    const left = parseSemver(a);
+    const right = parseSemver(b);
+    if (!left || !right)
+        return 0;
+    for (const key of ["major", "minor", "patch"]) {
+        if (left[key] > right[key])
+            return 1;
+        if (left[key] < right[key])
+            return -1;
+    }
+    return 0;
+}
+/** True when `a` is a strictly greater semantic version than `b`. */
+export function isVersionGreater(a, b) {
+    return compareSemver(a, b) > 0;
+}
+/** True when `a` is a strictly lesser semantic version than `b`. */
+export function isVersionLess(a, b) {
+    return compareSemver(a, b) < 0;
+}

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

@@ -1,5 +1,8 @@
 export type TelemetryAttributes = Record<string, unknown>;
-export declare function withTelemetrySpan<T>(tracerName: string, name: string, attributes: TelemetryAttributes | undefined, fn: () => Promise<T>): Promise<T>;
+export type WithTelemetrySpanOptions = {
+    isTransient?: (error: unknown) => boolean;
+};
+export declare function withTelemetrySpan<T>(tracerName: string, name: string, attributes: TelemetryAttributes | undefined, fn: () => Promise<T>, options?: WithTelemetrySpanOptions): Promise<T>;
 export declare function setActiveTelemetryAttributes(attributes: TelemetryAttributes): void;
 export declare function markActiveTelemetryError(message: string, attributes?: TelemetryAttributes): void;
 export declare function addTelemetryEvent(name: string, attributes?: TelemetryAttributes): void;

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

@@ -4,7 +4,7 @@ import { normalizeTelemetryAttributes } from "./redaction.js";
 import { OXYGEN_VERSION } from "./version.js";
 const counterCache = new Map();
 const histogramCache = new Map();
-export async function withTelemetrySpan(tracerName, name, attributes, fn) {
+export async function withTelemetrySpan(tracerName, name, attributes, fn, options) {
     const tracer = trace.getTracer(tracerName, OXYGEN_VERSION);
     return tracer.startActiveSpan(name, { attributes: normalizeTelemetryAttributes(commonTelemetryAttributes(attributes)) }, async (span) => {
         try {
@@ -12,8 +12,16 @@ export async function withTelemetrySpan(tracerName, name, attributes, fn) {
         }
         catch (error) {
             span.recordException(error instanceof Error ? error : new Error(String(error)));
-            span.setStatus({ code: SpanStatusCode.ERROR });
-            span.setAttributes(normalizeTelemetryAttributes(errorTelemetryAttributes(error)));
+            if (options?.isTransient?.(error) === true) {
+                span.setAttributes(normalizeTelemetryAttributes({
+                    ...errorTelemetryAttributes(error),
+                    outcome: "transient_error",
+                }));
+            }
+            else {
+                span.setStatus({ code: SpanStatusCode.ERROR });
+                span.setAttributes(normalizeTelemetryAttributes(errorTelemetryAttributes(error)));
+            }
             throw error;
         }
         finally {
@@ -97,14 +105,18 @@ function getHistogram(name) {
 }
 function errorTelemetryAttributes(error) {
     if (error instanceof Error) {
+        // pg connect timeouts (and some driver errors) surface with an empty
+        // message; fall back to the error name so spans are never message-less.
+        const message = error.message.trim() ? error.message : error.name || "unknown_error";
         return {
             "error.id": errorId(error),
             "error.name": error.name,
-            "error.message": error.message,
+            "error.message": message,
         };
     }
+    const text = String(error).trim();
     return {
         "error.id": "non_error",
-        "error.message": String(error),
+        "error.message": text || "unknown_error",
     };
 }

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

@@ -1,2 +1,2 @@
-export declare const OXYGEN_VERSION = "1.142.4";
+export declare const OXYGEN_VERSION = "1.146.1";
 export declare const OXYGEN_MINIMUM_CLI_VERSION = "1.135.0";

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

@@ -1,3 +1,3 @@
-export const OXYGEN_VERSION = "1.142.4";
+export const OXYGEN_VERSION = "1.146.1";
 // Bump this only when deployed CLI/API contracts require a newer CLI.
 export const OXYGEN_MINIMUM_CLI_VERSION = "1.135.0";

package/node_modules/@oxygen/shared/dist/workflow-trigger-metadata.d.ts

@@ -0,0 +1,2 @@
+export declare const WORKFLOW_TRIGGER_AUTO_PAUSE_METADATA_KEYS: readonly ["consecutive_failure_count", "last_failure_code", "last_failure_at", "auto_paused_at", "auto_pause_reason"];
+export declare function clearWorkflowTriggerAutoPauseMetadata(metadata: Record<string, unknown>): Record<string, unknown>;

package/node_modules/@oxygen/shared/dist/workflow-trigger-metadata.js

@@ -0,0 +1,14 @@
+export const WORKFLOW_TRIGGER_AUTO_PAUSE_METADATA_KEYS = [
+    "consecutive_failure_count",
+    "last_failure_code",
+    "last_failure_at",
+    "auto_paused_at",
+    "auto_pause_reason",
+];
+export function clearWorkflowTriggerAutoPauseMetadata(metadata) {
+    const next = { ...metadata };
+    for (const key of WORKFLOW_TRIGGER_AUTO_PAUSE_METADATA_KEYS) {
+        delete next[key];
+    }
+    return next;
+}

package/package.json

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