@oxygen-agent/cli 1.1011.687 → 1.1011.800

package/dist/workflow-run-list-flags.d.ts

@@ -0,0 +1,3 @@
+import { type ContractFlagOverlay } from "./contract-flags.js";
+export declare const WORKFLOW_RUN_LIST_FLAG_OVERLAY: ContractFlagOverlay;
+export declare function readWorkflowRunListFlags(options: Record<string, unknown>): Record<string, unknown>;

package/dist/workflow-run-list-flags.js

@@ -0,0 +1,21 @@
+import { WORKFLOW_RUN_LIST_CONTRACT } from "@oxygen/shared/contracts/workflow-run-list";
+import { readContractFlags } from "./contract-flags.js";
+import { readPositiveInt } from "./cli-values.js";
+import { readOption } from "./util.js";
+export const WORKFLOW_RUN_LIST_FLAG_OVERLAY = {
+    workflow: { valueName: "<workflow>", parse: readOption },
+    workflow_id: { valueName: "<workflow_id>", help: "Workflow id or slug; legacy CLI --workflow takes precedence.", parse: readOption },
+    status: { valueName: "<status>", parse: readOption },
+    mode: { valueName: "<mode>", parse: readOption },
+    cursor: { valueName: "<cursor>", parse: readOption },
+    // Preserve the shipped CLI parser: native HTTP owns the upper-500 refusal.
+    limit: { valueName: "<n>", parse: readPositiveInt },
+};
+export function readWorkflowRunListFlags(options) {
+    const args = readContractFlags(options, WORKFLOW_RUN_LIST_CONTRACT, WORKFLOW_RUN_LIST_FLAG_OVERLAY);
+    const workflow = args.workflow ?? args.workflow_id;
+    delete args.workflow_id;
+    if (workflow !== undefined)
+        args.workflow = workflow;
+    return args;
+}

package/node_modules/@oxygen/shared/dist/capability-discovery.js

@@ -574,26 +574,17 @@ export function inferCapabilityRoute(query) {
     // Its source nouns otherwise select a one-shot post search or follower order.
     if (isLinkedInAudienceCampaignIntent(query)) {
         const recipes = ROUTE_BY_ID.get("recipes");
-        const slug = query.trim().toLowerCase();
-        const namedPlay = AUDIENCE_PLAY_SLUGS.includes(slug) ? slug : null;
         if (recipes)
             return {
                 card: {
                     ...recipes,
-                    execution: "Pick the matching audience Recipe (own, competitor, creator or keyword post engagers, company-page followers or own followers), resolve current company/ICP context, then read that Recipe and the oxygen-signals file references/audience-campaigns.md. Preserve the exact source, attribution, qualification rule/version and object IDs. Prepare a bounded native audience campaign for email, LinkedIn DM/connection requests or WhatsApp. Keep capture, standing qualification, router and Sequence disabled until their own approval and credit scope; the shared guide owns execution.",
+                    execution: "Read the inbound-led-outbound Recipe and pick its source (your posts, a competitor's or creator's posts, a topic, your profile viewers, or your followers and connections), resolve current company/ICP context, then read the oxygen-signals file references/audience-campaigns.md. Preserve the exact source, attribution, qualification rule/version and object IDs. Prepare a bounded native audience campaign for email, LinkedIn DM/connection requests or WhatsApp. Keep capture, standing qualification, router and Sequence disabled until their own approval and credit scope; the shared guide owns execution.",
                     skills: ["oxygen-recipes", "oxygen-signals"],
                 },
                 recommendedTools: ["oxygen_recipes_list", "oxygen_recipes_get", "oxygen_context_resolve"],
                 recommendedCommands: ["recipes list", "recipes show", "context resolve"],
-                ...(namedPlay
-                    ? {
-                        exactCommand: `oxygen recipes show ${namedPlay} --json`,
-                        exactMcpCall: { tool: "oxygen_recipes_get", arguments: { slug: namedPlay } },
-                    }
-                    : {
-                        exactCommand: 'oxygen recipes list "linkedin audience" --view summary --json',
-                        exactMcpCall: { tool: "oxygen_recipes_list", arguments: { query: "linkedin audience", view: "summary" } },
-                    }),
+                exactCommand: `oxygen recipes show ${AUDIENCE_PLAY_SLUG} --json`,
+                exactMcpCall: { tool: "oxygen_recipes_get", arguments: { slug: AUDIENCE_PLAY_SLUG } },
             };
     }
     const explicit = explicitCapabilityIntent(normalized);
@@ -817,8 +808,11 @@ export function serializeCapabilityRoute(route, surfaceOrOptions = "cli", option
 function normalizeIntent(query) {
     return query.toLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
 }
-/** The six LinkedIn audience-campaign Recipes, by catalog slug. */
+/** The one LinkedIn audience-campaign Recipe since the 2026-10-04 consolidation. */
+const AUDIENCE_PLAY_SLUG = "inbound-led-outbound";
+/** The six audience Recipes it absorbed or replaced; a bare old slug still names the play. */
 const AUDIENCE_PLAY_SLUGS = [
+    AUDIENCE_PLAY_SLUG,
     "own-post-engagers",
     "competitor-post-engagers",
     "creator-post-engagers",
@@ -952,8 +946,42 @@ const UGC_ROUTE_VIEW = {
     posture: "mixed",
     skills: ["oxygen-ugc", "oxygen-publishing"],
 };
+/** Saved CRM preset configuration is a Records read, not an enrichment run. */
+function isCrmEnrichmentConfigurationRead(query) {
+    if (!/\bcrm\b/.test(query) || !/\benrich\w*\b/.test(query))
+        return false;
+    // Remove only local negated execution restrictions. A later positive verb
+    // ("read, do not change this, then enable...") still rejects this read view.
+    const intent = query.replace(/\bnot a provider run\b/g, "")
+        .replace(/\b(?:do not|don't|without)\s+(?:any\s+)?(?:chang(?:e|ing)|runn?ing|run|enabl(?:e|ing)|disabl(?:e|ing)|configur(?:e|ing)|send(?:ing)?|sync(?:ing)?)\b/g, "");
+    if (/\b(tables?|columns?|workflows?|agents?|functions?|callables?|providers?|hubspot|sync|deals?|custom|fields?|values?|history|failed|items?)\b/.test(intent))
+        return false;
+    if (/\b(enable|disable|set|configure|change|run|running|backfill|send|create|start|execute|apply)\b/.test(intent))
+        return false;
+    return /\b(configur(?:ation|ed)|settings?|presets?|auto(?:matic)?|armed|enabled|backlog)\b/.test(intent)
+        && /\b(read|inspect|list|show|view|what|which|how many|current|existing|already)\b/.test(intent);
+}
+function crmEnrichmentReadRecommendation(query) {
+    const omitCounts = /\b(?:skip|omit|leave)\b.{0,45}\bcounts?\b|\bwithout\b.{0,45}\b(?:counts?|scanning historical records)\b/.test(query);
+    return {
+        tools: ["oxygen_crm_enrichment"], commands: ["crm enrichment list"],
+        exactCommand: `oxygen crm enrichment list${omitCounts ? " --no-backfill" : ""} --projection summary --json`,
+        exactMcpCall: { tool: "oxygen_crm_enrichment", arguments: { action: "list", ...(omitCounts ? { backfill: false } : {}), projection: "summary" } },
+    };
+}
+const CRM_ENRICHMENT_READ_VIEW = {
+    owns: "Saved automatic-enrichment presets and batch caps for native CRM companies/people, backed by Tables auto-run.",
+    notFor: "Running enrichment, provider catalog/sourcing, linked working Tables, external CRM sync, or changing the standing grant.",
+    execution: "Read the saved configuration with action=list, free through oxygen_capabilities_call: this tool also writes, so its paid/write annotations and built-in approval policy remain. Omit object and use backfill=false to skip historical counts; object reads ignore it. summary is compact; preset_count counts catalog entries, trigger_default is the current plan-default cap, and backfill:null means no count was produced. set/enable/disable change standing auto-run; action=backfill previews for free, while paid live batches require native approval and a ceiling.",
+    posture: "mixed",
+};
 /** The card a route reports: Publishing's own, or its UGC view for a creator-program ask. */
 function routeCardFor(card, query) {
+    if (card.id === "records" && isCrmEnrichmentConfigurationRead(query))
+        return { ...card, ...CRM_ENRICHMENT_READ_VIEW };
+    const feed = card.primitive === "tables" ? tableFeedRecommendation(query) : null;
+    if (feed)
+        return { ...card, execution: feed.execution };
     if (card.primitive === "publishing" && isUgcIntent(query))
         return { ...card, ...UGC_ROUTE_VIEW };
     const contactFind = card.id === "sourcing-and-provider-tools" ? oneShotContactFindingRecommendation(query) : null;
@@ -1463,7 +1491,7 @@ function tableMaintenanceRecommendation(query) {
     if (table && /\bfeeds?\b/.test(query)) {
         return /\b(bind|attach|create|new)\b/.test(query)
             ? result(["oxygen_feeds_bind", "oxygen_feeds_list"], ["feeds bind", "feeds list"], "Bind the native Table feed: a declared-schema push source or scheduled provider pull. Inspect source, cadence and standing credit scope first; a pull feed is not an inbound webhook endpoint.")
-            : result(["oxygen_feeds_list", "oxygen_feeds_get"], ["feeds list", "feeds get"], "Inspect the native Table feed's source, cadence, caps and state. Pull feeds refill Tables on their own schedule. The current MCP catalog has no general cadence-update tool; do not substitute a Workflow or generic HTTP call.");
+            : result(["oxygen_feeds_list", "oxygen_feeds_get", "oxygen_feeds_update"], ["feeds list", "feeds get", "feeds update"], "Inspect the Table feed with feeds_get(include_route=true), then update it in place via oxygen_feeds_update (Signals pack/core write gateway) or feeds update. Preserve the full frozen request; source replacement resets its cursor. Scheduled replacements require one executable lane; fallbacks require no cadence. Native changed cadence or expanded paid source/cap authority can require renewed standing approval; configuration is free.");
     }
     const file = /\b(csv|jsonl?|xlsx|excel|spreadsheet|staged|uploaded|file)\b/.test(query)
         || /\b(?:pending|stuck|abandoned) imports?\b|\bimports?\b.{0,30}\b(pending|stuck|recover\w*)\b/.test(query);
@@ -1537,9 +1565,25 @@ function oneShotContactFindingRecommendation(query) {
         execution: "Hydrate the selected native one-shot lookup schema. mode=dry_run previews its waterfall; live requires the user's approved exact scope and positive max_credits. readOnlyHint=false and openWorldHint=true still apply to previews. External MCP uses oxygen_capabilities_call for an unlisted lookup; built-in agents call the native capability under their existing policy. Free catalog metadata uses the read gateway. Sending and bulk Table enrichment have separate owners.",
     };
 }
+/** Native row-supply feeds belong to Tables; Signals is their registered MCP pack. */
+function tableFeedRecommendation(rawQuery) {
+    // A pasted URL (e.g. linkedin.com/feed/update/...) names a resource, not a Table feed.
+    const query = rawQuery.replace(/\bhttps?:\/\/\S+/g, " ");
+    if (/\b(workflows?|agents?|rss|knowledge|mailbox\w*|crm|attachments?|webhooks?|inbound endpoints?|sequences?|publishing)\b/.test(query))
+        return null;
+    const explicit = /\bfeeds?\b/.test(query) && /\b(tables?|pull|cadence|refresh|saved search|source|filters?|credit|credits|caps?|update|bind)\b/.test(query);
+    const saved = /\btables?\b/.test(query) && /\bsaved search\b/.test(query) && /\b(refill\w*|refresh\w*|scheduled|cadence)\b/.test(query);
+    if (!explicit && !saved)
+        return null;
+    if (/\b(bind|attach|create|new)\b/.test(query))
+        return { tools: ["oxygen_feeds_bind", "oxygen_feeds_list"], commands: ["feeds bind", "feeds list"], execution: "Bind the native Table row-supply feed. Inspect source, cadence and standing credit scope first; pull feeds are distinct from inbound webhook endpoints. Feed tools are executable through the core gateways or Signals pack." };
+    return { tools: ["oxygen_feeds_list", "oxygen_feeds_get", "oxygen_feeds_update"], commands: ["feeds list", "feeds get", "feeds update"], execution: "Inspect the existing Table feed with feeds_get(include_route=true), then update it in place with oxygen_feeds_update (Signals pack or core write gateway). Preserve the complete frozen request; source replacement resets the cursor. Scheduled replacements require one executable lane; fallbacks require no cadence. Changed cadence, increased paid cap or replaced paid source can require renewed standing authorization. Configuration is free; future refreshes retain their approved cycle ceiling." };
+}
 function explicitCapabilityIntent(query) {
     if (sentLinkedInInvitationReadRecommendation(query))
         return ROUTE_BY_ID.get("connected-linkedin") ?? null;
+    if (isCrmEnrichmentConfigurationRead(query))
+        return ROUTE_BY_ID.get("records") ?? null;
     if (databaseRecommendation(query))
         return ROUTE_BY_ID.get("platform-operations") ?? null;
     if (oneShotContactFindingRecommendation(query))
@@ -1548,6 +1592,8 @@ function explicitCapabilityIntent(query) {
         return ROUTE_BY_ID.get("records") ?? null;
     if (storedReplyDraftReadRecommendation(query))
         return ROUTE_BY_PRIMITIVE.get("messages") ?? null;
+    if (tableFeedRecommendation(query))
+        return ROUTE_BY_PRIMITIVE.get("tables") ?? null;
     if (isConnectedAppsIntent(query) || isConnectedAppEventsIntent(query) || isConnectedAppSpendIntent(query)) {
         return ROUTE_BY_ID.get("workspace-access") ?? null;
     }
@@ -1850,9 +1896,14 @@ function recommendationsFor(card, query) {
     const sent = card.id === "connected-linkedin" ? sentLinkedInInvitationReadRecommendation(query) : null;
     if (sent)
         return sent;
+    if (card.id === "records" && isCrmEnrichmentConfigurationRead(query))
+        return crmEnrichmentReadRecommendation(query);
     const database = card.id === "platform-operations" ? databaseRecommendation(query) : null;
     if (database)
         return database;
+    const feed = card.primitive === "tables" ? tableFeedRecommendation(query) : null;
+    if (feed)
+        return { tools: feed.tools, commands: feed.commands };
     if (card.id === "billing-and-budgets" && /\b(credit prices|credit price catalog|customer credit)\b/.test(query)) {
         return { tools: ["oxygen_customer_credit_prices"], commands: ["pricing customer-credit-prices"] };
     }

package/node_modules/@oxygen/shared/dist/contracts/crm-enrichment-read.js

@@ -1,7 +1,7 @@
 import { bool, enumOf, int, obj, str } from "./schema.js";
 /** Read selectors only; action=backfill is a separate governed operation. */
 export const CRM_ENRICHMENT_READ_CONTRACT = obj({
-    object: str({ minLength: 1, maxLength: 120, description: "CRM object slug (companies, people, deals)." }),
+    object: str({ minLength: 1, maxLength: 120, description: "CRM object: companies or people." }),
     backfill: bool({ description: "list without object: include stored historical backlog counts (default true). false skips the scans; object reads ignore it. Never runs enrichment." }),
     projection: enumOf(["summary", "full", "value"], { description: "summary: standing configuration without long arrays. full: legacy data. value: lossless JSON of path, continued with next_cursor. Omit for legacy output." }),
     path: str({ maxLength: 1024, description: "value: JSON Pointer into the selected native result; empty selects everything. Examples /objects/0/auto_run or /presets." }),

package/node_modules/@oxygen/shared/dist/contracts/crm-support.d.ts

@@ -1,6 +1,7 @@
 export declare const CRM_NOTE_BODY_MAX_CHARS = 20000;
 export declare const CRM_NOTE_TITLE_MAX_CHARS = 300;
 export declare const CRM_FILE_LABEL_MAX_CHARS = 300;
+export declare const CRM_FILE_ATTACH_DESCRIPTION = "Attach inline base64 bytes to a CRM record; each call creates a new file and attachment, including identical retries. If a response is lost, inspect the record's files before deciding to retry. Entire request must fit 2 MB; larger originals use upload prepare/complete. No credits.";
 export declare const CRM_NOTE_EDIT_CONTRACT: import("./schema.js").ContractObject<{
     readonly body: import("./schema.js").StringProperty;
     readonly title: {

package/node_modules/@oxygen/shared/dist/contracts/crm-support.js

@@ -2,6 +2,7 @@ import { bool, enumOf, int, nullable, obj, str } from "./schema.js";
 export const CRM_NOTE_BODY_MAX_CHARS = 20_000;
 export const CRM_NOTE_TITLE_MAX_CHARS = 300;
 export const CRM_FILE_LABEL_MAX_CHARS = 300;
+export const CRM_FILE_ATTACH_DESCRIPTION = "Attach inline base64 bytes to a CRM record; each call creates a new file and attachment, including identical retries. If a response is lost, inspect the record's files before deciding to retry. Entire request must fit 2 MB; larger originals use upload prepare/complete. No credits.";
 export const CRM_NOTE_EDIT_CONTRACT = obj({
     body: str({ minLength: 1, maxLength: CRM_NOTE_BODY_MAX_CHARS, description: "Replacement Markdown text." }),
     title: nullable(str({ maxLength: CRM_NOTE_TITLE_MAX_CHARS, description: "Replacement title; null or empty clears." })),

package/node_modules/@oxygen/shared/dist/contracts/customer-operations.js

@@ -2,8 +2,10 @@
 import { arr, bool, enumOf, int, nullable, num, obj, str } from "./schema.js";
 import { DATABASE_ATTACH_CONTRACT, DATABASE_MIGRATE_CONTRACT, DATABASE_QUERY_CONTRACT } from "./database.js";
 import { WHATSAPP_DRAFTS_READ_CONTRACT } from "./whatsapp-reads.js";
+import { TABLE_FAVORITE_CONTRACT, TABLE_FAVORITES_LIST_CONTRACT, TABLE_ITEM_RESOLVE_CONTRACT, TABLE_LINK_SUGGEST_CONTRACT, TABLE_RECOVER_PENDING_CONTRACT } from "./table-operations.js";
 import { BILLING_OWNER_READ_CONTRACT } from "./billing-owner-read.js";
 import { COPILOT_SESSIONS_LIST_CONTRACT } from "./copilot-sessions.js";
+import { CRM_FILE_ATTACH_CONTRACT, CRM_FILE_ATTACH_DESCRIPTION } from "./crm-support.js";
 const text = (description) => str(description === undefined ? {} : { description });
 const list = () => arr(str());
 const json = { type: "object", additionalProperties: true };
@@ -42,7 +44,7 @@ export const CUSTOMER_OPERATIONS = [
     operation("context.canonical.get", "/api/cli/context/canonical/get", "POST", "context canonical get", "oxygen_context_canonical_get", "knowledge", "Read the pinned active context asset for a type; present=false means none is set.", { type: text() }, ["type"], { mutates: false }),
     operation("crm.notes.update", "/api/cli/crm/notes/{note_id}", "PATCH", "crm notes update", "oxygen_crm_note_update", "crm", "Edit a CRM note's body, title or pinned state; an empty title clears it.", { body: text(), title: nullable(text()), pinned: bool() }, [], mcpOnly),
     operation("crm.notes.delete", "/api/cli/crm/notes/{note_id}", "DELETE", "crm notes delete", "oxygen_crm_note_delete", "crm", "Delete one CRM note in this workspace.", {}, [], mcpOnly),
-    operation("crm.files.attach_inline", "/api/cli/crm/objects/{object}/records/{row_id}/files", "POST", "crm files attach-inline", "oxygen_crm_file_attach", "crm", "Attach base64 file bytes to one CRM record. For larger files use prepare-upload and complete-upload.", { name: text(), content_base64: text(), label: text() }, ["name", "content_base64"]),
+    operation("crm.files.attach_inline", "/api/cli/crm/objects/{object}/records/{row_id}/files", "POST", "crm files attach-inline", "oxygen_crm_file_attach", "crm", CRM_FILE_ATTACH_DESCRIPTION, CRM_FILE_ATTACH_CONTRACT.properties, [...(CRM_FILE_ATTACH_CONTRACT.required ?? [])]),
     operation("crm.files.prepare", "/api/cli/crm/objects/{object}/records/{row_id}/files/upload-url", "POST", "crm files prepare-upload", "oxygen_crm_file_prepare_upload", "crm", "Reserve a CRM file upload by exact name, length and SHA-256; returns a scoped upload URL.", { name: text(), byte_length: int({ minimum: 0 }), sha256: text() }, ["name", "byte_length", "sha256"]),
     operation("crm.files.complete", "/api/cli/crm/objects/{object}/records/{row_id}/files/{file_id}/uploaded", "POST", "crm files complete-upload", "oxygen_crm_file_complete_upload", "crm", "Verify a reserved CRM upload and attach it to its record; mismatched bytes remain pending.", { label: text() }),
     operation("crm.files.delete", "/api/cli/crm/files/{attachment_id}", "DELETE", "crm files detach", "oxygen_crm_file_delete", "crm", "Detach a CRM attachment by attachment_id, preserving the stored file.", {}, [], mcpOnly),
@@ -76,17 +78,17 @@ export const CUSTOMER_OPERATIONS = [
     operation("settings.beta.get", "/api/cli/settings/beta-features", "GET", "settings beta-features get", "oxygen_settings_beta_features_get", "workspace", "Read this workspace's beta-navigation opt-in."),
     operation("settings.beta.set", "/api/cli/settings/beta-features", "POST", "settings beta-features set", "oxygen_settings_beta_features_set", "workspace", "Enable or disable beta navigation for this workspace; admin or owner only.", { enabled: bool() }, ["enabled"]),
     operation("spintax.generate", "/api/cli/spintax", "POST", "spintax generate", "oxygen_spintax_generate", "sequences", "Generate spintax for outreach text. Costs exactly 3 credits; failed generation refunds the reservation.", { text: str({ minLength: 1, maxLength: 4000 }), section: str({ maxLength: 80 }) }, ["text"], { spends: true }),
-    operation("table_action_items.resolve", "/api/cli/table-action-items/{item_id}/resolve", "POST", "table-actions resolve", "oxygen_table_action_item_resolve", "tables", "Record a verified uncertain Table action outcome; never repeats the external action.", { outcome: enumOf(["applied", "not_applied"]), note: text(), value: { oneOf: [text(), num(), bool(), json, rows(), { type: "null" }] } }, ["outcome"]),
+    operation("table_action_items.resolve", "/api/cli/table-action-items/{item_id}/resolve", "POST", "table-actions resolve", "oxygen_table_action_item_resolve", "tables", "Record a human-verified uncertain Table action outcome without repeating it. Use cells resolve for row/column coordinates.", TABLE_ITEM_RESOLVE_CONTRACT.properties, ["outcome"]),
     operation("table_ingestions.append", "/api/cli/table-ingestion-runs/{ingestion_run_id}/items", "POST", "table-ingestions append", "oxygen_table_ingestions_append_items", "runs", "Append bounded ingestion items to an existing run; preserves the run's approved scope.", { items: rows(), max_attempts: int({ minimum: 1 }) }, ["items"], cliOnly),
-    operation("tables.favorites.get", "/api/cli/tables/favorite", "GET", "tables favorites", "oxygen_tables_favorites", "tables", "Read this member's table and folder favorites in the active workspace. A per-member preference; free (0 credits)."),
-    operation("tables.favorite.set", "/api/cli/tables/favorite", "POST", "tables favorite", "oxygen_tables_favorite", "tables", "Star or unstar exactly one table or folder in the active workspace. Free (0 credits); reads back the saved per-member preference.", { table: text("Table id or slug. Pass exactly one of table or folder."), folder: text("Folder id or slug. Pass exactly one of table or folder."), favorite: bool({ description: "true stars; false unstars. Free (0 credits); changes only this member's preference." }) }, ["favorite"]),
+    operation("tables.favorites.get", "/api/cli/tables/favorite", "GET", "tables favorites", "oxygen_tables_favorites", "tables", "Page Table/folder stars (per-member preference; free (0 credits)); use next_cursor. Tool-catalog favorites are separate.", TABLE_FAVORITES_LIST_CONTRACT.properties, [], { generated: { cli: true, mcp: false } }),
+    operation("tables.favorite.set", "/api/cli/tables/favorite", "POST", "tables favorite", "oxygen_tables_favorite", "tables", "Star/unstar exactly one table or folder; read back saved per-member preference. Free (0 credits). Tool-catalog favorites are separate.", TABLE_FAVORITE_CONTRACT.properties, ["favorite"]),
     operation("tables.import.csv", "/api/cli/tables/import-csv", "POST", "tables import-csv", "oxygen_tables_import_csv", "tables", "Import inline CSV into a hosted Table through its durable ingestion run. Use staged upload for large files.", { csv_text: text(), csv_base64: text(), table: text(), table_name: text(), project: text(), filename: text(), upsert_key: text(), batch_size: int({ minimum: 1, maximum: 5000 }) }, [], cliOnly),
     operation("tables.import.prepare", "/api/cli/tables/import-url", "POST", "tables import-upload", "oxygen_tables_import_upload", "tables", "Prepare a scoped storage upload for a hosted Table import; uploads and imports are separate, inspectable steps.", { file_name: text(), content_type: text(), byte_length: int({ minimum: 1 }), trace_id: text(), format: enumOf(["csv", "json", "xlsx"]) }, ["file_name", "byte_length"]),
     operation("tables.import.preview", "/api/cli/tables/import-preview", "POST", "tables import-preview", "oxygen_tables_import_preview", "tables", "Preview a staged file's headers, rows and existing-table mapping; writes no imported rows.", { storage_key: text(), file_name: text(), format: enumOf(["csv", "json", "xlsx"]), byte_length: int({ minimum: 1 }), table: text(), upsert_key: text() }, ["storage_key", "byte_length"], { mutates: false }),
     operation("tables.import.staged", "/api/cli/tables/import-staged", "POST", "tables import-staged", "oxygen_tables_import_staged", "tables", "Start a durable hosted import from this workspace's staged file; choose an existing table or create_name.", { table: text(), create_name: text(), project: text(), storage_key: text(), storage_bucket: text(), storage_provider: enumOf(["s3"]), file_name: text(), format: enumOf(["csv", "json", "xlsx"]), sha256: text(), upsert_key: text(), source_key_map: json, byte_length: int({ minimum: 1 }), row_count: int({ minimum: 1 }), max_concurrency: int({ minimum: 1, maximum: 1000 }), source: enumOf(["cli", "mcp", "web"]), batch_size: int({ minimum: 1, maximum: 5000 }) }, ["storage_key", "byte_length"]),
     operation("tables.import.file", "/api/cli/tables/import-file", "POST", "tables import-file", "oxygen_tables_import_file", "tables", "Import small base64 file bytes through the shared multipart import API; use staged upload for large files.", { content_base64: text(), file_name: text(), content_type: text(), table: text(), table_name: text(), project: text(), format: enumOf(["csv", "json", "xlsx"]), sheet: text(), upsert_key: text(), source_key_map: json, source_hash: text(), batch_size: int({ minimum: 1, maximum: 5000 }), max_concurrency: int({ minimum: 1 }) }, ["content_base64", "file_name"], { multipart: { contentField: "content_base64", nameField: "file_name", typeField: "content_type", fileField: "file" } }),
-    operation("tables.link.suggest", "/api/cli/tables/link/suggest", "POST", "tables link-suggest", "oxygen_tables_link_suggest", "tables", "Preview which columns can link two Tables and how many rows match; creates no relation.", { table: text(), to: text(), on: text(), scan_limit: int({ minimum: 1 }) }, ["table", "to"], { mutates: false }),
-    operation("tables.recover_pending", "/api/cli/tables/recover-pending", "POST", "tables recover-pending", "oxygen_tables_recover_pending", "tables", "Recover bounded pending cells in one Table through the platform's native recovery path.", { table: text(), max_items: int({ minimum: 1 }) }, ["table"], mcpOnly),
+    operation("tables.link.suggest", "/api/cli/tables/link/suggest", "POST", "tables link-suggest", "oxygen_tables_link_suggest", "tables", "Plan column links and matching row counts between Tables; creates no relation. Apply with tables link bulk.", TABLE_LINK_SUGGEST_CONTRACT.properties, ["table", "to"], { mutates: false }),
+    operation("tables.recover_pending", "/api/cli/tables/recover-pending", "POST", "tables recover-pending", "oxygen_tables_recover_pending", "tables", "Poll pending BetterContact requests and save recovered phones; no new orders. Does not resume imports.", TABLE_RECOVER_PENDING_CONTRACT.properties, ["table"], { ...mcpOnly, annotations: { openWorldHint: true } }),
     operation("tables.webhooks.create", "/api/cli/tables/webhooks", "POST", "tables webhook create", "oxygen_table_webhook_create", "tables", "Create an inbound Table webhook or platform LinkedIn feed. Optional auto_run is standing permission with explicit or plan-default delivery ceilings.", { table: text(), name: text(), mode: enumOf(["insert", "upsert"]), upsert_key: text(), items_path: text(), event_id_path: text(), event_type_path: text(), occurred_at_path: text(), auth_mode: enumOf(["none", "secret"]), feed_kind: enumOf(["generic", "unipile"]), unipile_account_id: text(), event_types: list(), mapping: text(), auto_run: json }, ["table"], mcpOnly),
     operation("tables.webhooks.update", "/api/cli/tables/webhooks", "PATCH", "tables webhook update", "oxygen_table_webhook_update", "tables", "Edit a Table webhook's name, state or standing auto_run; auth_mode=secret rotates its secret and returns it once.", { endpoint_id: text(), name: text(), status: enumOf(["active", "disabled"]), auth_mode: enumOf(["none", "secret"]), auto_run: json, clear_auto_run: bool() }, ["endpoint_id"], mcpOnly),
     operation("whatsapp.draft", "/api/cli/whatsapp/draft", "POST", "whatsapp draft", "oxygen_whatsapp_draft", "inbox", "Generate a WhatsApp reply draft in the workspace voice, or approve a reviewed draft for an existing chat. Draft generation uses managed AI credits.", { conversation_id: text(), goal: text(), row_id: text(), object: text(), approved: bool(), draft_id: text(), text: text() }, ["conversation_id"], { ...cliOnly, spends: true }),

package/node_modules/@oxygen/shared/dist/contracts/operations.js

@@ -9,6 +9,7 @@ import { str } from "./schema.js";
 import { SENDER_LIMITS_SET_OPERATION } from "./sender-limits.js";
 import { WORKSPACE_PAGES_GET_OPERATION, WORKSPACE_PAGES_UPDATE_OPERATION } from "./workspace-pages.js";
 import { BROWSER_OPERATIONS } from "./browser-operations.js";
+import { TABLE_FEED_UPDATE_OPERATION } from "./table-feed-update.js";
 import { CUSTOMER_OPERATIONS } from "./customer-operations.js";
 /** The route with its `{param}` segments filled in, each URL-encoded. */
 export function operationPath(spec, params) {
@@ -79,6 +80,6 @@ export function operationFormData(spec, body) {
     }
     return form;
 }
-export const OPERATION_SPECS = [SENDER_LIMITS_SET_OPERATION, CONNECTOR_UPDATE_OPERATION, CONNECTOR_EVENTS_REVOKE_OPERATION, WORKSPACE_PAGES_GET_OPERATION, WORKSPACE_PAGES_UPDATE_OPERATION, ...CUSTOMER_OPERATIONS, ...BROWSER_OPERATIONS];
+export const OPERATION_SPECS = [SENDER_LIMITS_SET_OPERATION, CONNECTOR_UPDATE_OPERATION, CONNECTOR_EVENTS_REVOKE_OPERATION, WORKSPACE_PAGES_GET_OPERATION, WORKSPACE_PAGES_UPDATE_OPERATION, TABLE_FEED_UPDATE_OPERATION, ...CUSTOMER_OPERATIONS, ...BROWSER_OPERATIONS];
 export const CLI_OPERATIONS = [...CUSTOMER_OPERATIONS, ...BROWSER_OPERATIONS].filter((spec) => spec.generated?.cli !== false);
 export const MCP_OPERATIONS = [...CUSTOMER_OPERATIONS, ...BROWSER_OPERATIONS].filter((spec) => spec.generated?.mcp !== false);

package/node_modules/@oxygen/shared/dist/contracts/schema.d.ts

@@ -55,6 +55,9 @@ export interface OneOfProperty {
     description?: string;
 }
 export type JsonProperty = {
+    type?: never;
+    description?: string;
+} | {
     $ref: string;
 } | StringProperty | NumberProperty | BooleanProperty | NullProperty | ObjectProperty | ArrayProperty | OneOfProperty;
 /** The top level of a contract: a closed object. */
@@ -88,6 +91,11 @@ export declare function num(options?: NumberOptions): {
     "x-clamp"?: true;
 };
 export declare function bool(options?: Described): BooleanProperty;
+/** Any JSON value, including null; used for native cell-result values. */
+export declare function jsonValue(options?: Described): {
+    type?: never;
+    description?: string;
+};
 export declare function str(options?: Described & {
     minLength?: number;
     maxLength?: number;

package/node_modules/@oxygen/shared/dist/contracts/schema.js

@@ -31,6 +31,10 @@ export function num(options) {
 export function bool(options = {}) {
     return described({ type: "boolean" }, options.description);
 }
+/** Any JSON value, including null; used for native cell-result values. */
+export function jsonValue(options = {}) {
+    return { ...options };
+}
 export function str(options = {}) {
     const { description, ...rest } = options;
     return described({ type: "string", ...rest }, description);
@@ -172,6 +176,8 @@ function walkValue(schema, value, path, walk) {
         walk.issues.push({ path, message: `${path} does not match any accepted shape.` });
         return value;
     }
+    if (schema.type === undefined)
+        return value;
     if (schema.type === "null") {
         if (value !== null)
             walk.issues.push({ path, message: `${path} must be null.` });

package/node_modules/@oxygen/shared/dist/contracts/sequence-analytics-read.d.ts

@@ -0,0 +1,38 @@
+export declare const SEQUENCE_ANALYTICS_READ_CONTRACT: import("./schema.js").ContractObject<{
+    readonly projection: {
+        type: "string";
+        enum: readonly ("full" | "summary" | "value")[];
+        description?: string;
+    };
+    readonly path: import("./schema.js").StringProperty;
+    readonly value_cursor: import("./schema.js").StringProperty;
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly range: {
+        type: "string";
+        enum: readonly ("14d" | "180d" | "28d" | "30d" | "365d" | "7d" | "90d" | "all")[];
+        description?: string;
+    };
+    readonly from: import("./schema.js").StringProperty;
+    readonly to: import("./schema.js").StringProperty;
+    readonly sequence: import("./schema.js").StringProperty;
+    readonly campaigns: import("./schema.js").StringProperty;
+    readonly senders: import("./schema.js").StringProperty;
+}, never>;
+/** Preserve shipped query precedence, repeated/CSV senders, and native range
+ * coercion. Only opt-in representation controls are separately validated. */
+export declare function sequenceAnalyticsSelection(params: URLSearchParams): {
+    range: {
+        preset: string | null;
+        from: string | null;
+        to: string | null;
+    };
+    sequenceId: string | null;
+    sequenceIds: string[];
+    senders: string[];
+};

package/node_modules/@oxygen/shared/dist/contracts/sequence-analytics-read.js

@@ -0,0 +1,22 @@
+import { enumOf, obj, str } from "./schema.js";
+import { STORED_READ_WINDOW_FIELDS } from "./stored-read-window.js";
+export const SEQUENCE_ANALYTICS_READ_CONTRACT = obj({
+    range: enumOf(["7d", "14d", "28d", "30d", "90d", "180d", "365d", "all"], { description: "Default 14d. all starts at oldest selected campaign, at most 1830 days; daily<=92 days, weekly<=550, else monthly." }),
+    from: str({ description: "Custom start date (YYYY-MM-DD)." }),
+    to: str({ description: "Custom end date (YYYY-MM-DD)." }),
+    sequence: str({ description: "Exact campaign id/slug, including outside latest 500. Single scope ignores campaigns; includes sender/message performance." }),
+    campaigns: str({ description: "CSV ids/slugs: org totals, series, email attribution and operational summary only. Roster/fleet/per-campaign stats retain latest 500; ignored with sequence." }),
+    senders: str({ description: "CSV analytics.senders keys or sender/profile ids (oxygen_senders_profiles_list). Narrows counts/funnels/series/attribution/drilldowns, not roster or operational health/work." }),
+    ...STORED_READ_WINDOW_FIELDS,
+});
+/** Preserve shipped query precedence, repeated/CSV senders, and native range
+ * coercion. Only opt-in representation controls are separately validated. */
+export function sequenceAnalyticsSelection(params) {
+    const csv = (values) => values.flatMap(value => value.split(",")).map(value => value.trim()).filter(value => value.length > 0);
+    return {
+        range: { preset: params.get("range"), from: params.get("from"), to: params.get("to") },
+        sequenceId: params.get("sequence") ?? params.get("sequence_id") ?? null,
+        sequenceIds: csv([params.get("campaigns") ?? params.get("sequences") ?? ""]),
+        senders: csv(params.getAll("senders")),
+    };
+}

package/node_modules/@oxygen/shared/dist/contracts/table-feed-update.d.ts

@@ -0,0 +1,222 @@
+/** Native Table feed PATCH grammar. Scheduling and credit authority remain server-owned. */
+import { type ContractObject } from "./schema.js";
+import type { OperationSpec } from "./operations.js";
+export declare const TABLE_FEED_LANE_CONTRACT: ContractObject<{
+    readonly tool_id: import("./schema.js").StringProperty;
+    readonly request: {
+        type: "object";
+        additionalProperties: boolean;
+    };
+    readonly rows_path: {
+        oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+        description?: string;
+    };
+    readonly row_mapping: {
+        oneOf: [{
+            type: "object";
+            additionalProperties: boolean;
+        }, import("./schema.js").NullProperty];
+        description?: string;
+    };
+    readonly cursor_path: {
+        oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+        description?: string;
+    };
+    readonly cursor_request_key: {
+        oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+        description?: string;
+    };
+}, "request" | "tool_id">;
+export declare const TABLE_FEED_ROUTE_CONTRACT: ContractObject<{
+    readonly tool_id: import("./schema.js").StringProperty;
+    readonly request: {
+        type: "object";
+        additionalProperties: boolean;
+    };
+    readonly rows_path: {
+        oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+        description?: string;
+    };
+    readonly row_mapping: {
+        oneOf: [{
+            type: "object";
+            additionalProperties: boolean;
+        }, import("./schema.js").NullProperty];
+        description?: string;
+    };
+    readonly cursor_path: {
+        oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+        description?: string;
+    };
+    readonly cursor_request_key: {
+        oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+        description?: string;
+    };
+    readonly tool_ids: import("./schema.js").ArrayProperty<import("./schema.js").StringProperty>;
+    readonly lanes: import("./schema.js").ArrayProperty<ContractObject<{
+        readonly tool_id: import("./schema.js").StringProperty;
+        readonly request: {
+            type: "object";
+            additionalProperties: boolean;
+        };
+        readonly rows_path: {
+            oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+            description?: string;
+        };
+        readonly row_mapping: {
+            oneOf: [{
+                type: "object";
+                additionalProperties: boolean;
+            }, import("./schema.js").NullProperty];
+            description?: string;
+        };
+        readonly cursor_path: {
+            oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+            description?: string;
+        };
+        readonly cursor_request_key: {
+            oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+            description?: string;
+        };
+    }, "request" | "tool_id">>;
+    readonly max_pages: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly upsert_key: {
+        oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+        description?: string;
+    };
+}, "request" | "tool_id">;
+export declare const TABLE_FEED_GET_OPTIONS_CONTRACT: ContractObject<{
+    readonly include_route: import("./schema.js").BooleanProperty;
+}, never>;
+export declare const TABLE_FEED_UPDATE_CONTRACT: ContractObject<{
+    readonly feed: import("./schema.js").StringProperty;
+    readonly name: import("./schema.js").StringProperty;
+    readonly status: {
+        type: "string";
+        enum: readonly ("active" | "disabled")[];
+        description?: string;
+    };
+    readonly run_state: {
+        type: "string";
+        enum: readonly ("error" | "exhausted" | "idle" | "running")[];
+        description?: string;
+    };
+    readonly sync: ContractObject<{
+        readonly every: {
+            oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+            description?: string;
+        };
+        readonly max_credits_per_cycle: {
+            readonly type: "number";
+            readonly exclusiveMinimum: 0;
+            readonly description: "Future-cycle ceiling; configuration spends nothing.";
+        };
+        readonly max_rows_per_cycle: {
+            type: "integer";
+            description?: string;
+            minimum?: number;
+            maximum?: number;
+            "x-clamp"?: true;
+        };
+    }, "every" | "max_credits_per_cycle" | "max_rows_per_cycle">;
+    readonly route: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly tool_id: import("./schema.js").StringProperty;
+            readonly request: {
+                type: "object";
+                additionalProperties: boolean;
+            };
+            readonly rows_path: {
+                oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+                description?: string;
+            };
+            readonly row_mapping: {
+                oneOf: [{
+                    type: "object";
+                    additionalProperties: boolean;
+                }, import("./schema.js").NullProperty];
+                description?: string;
+            };
+            readonly cursor_path: {
+                oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+                description?: string;
+            };
+            readonly cursor_request_key: {
+                oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+                description?: string;
+            };
+            readonly tool_ids: import("./schema.js").ArrayProperty<import("./schema.js").StringProperty>;
+            readonly lanes: import("./schema.js").ArrayProperty<ContractObject<{
+                readonly tool_id: import("./schema.js").StringProperty;
+                readonly request: {
+                    type: "object";
+                    additionalProperties: boolean;
+                };
+                readonly rows_path: {
+                    oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+                    description?: string;
+                };
+                readonly row_mapping: {
+                    oneOf: [{
+                        type: "object";
+                        additionalProperties: boolean;
+                    }, import("./schema.js").NullProperty];
+                    description?: string;
+                };
+                readonly cursor_path: {
+                    oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+                    description?: string;
+                };
+                readonly cursor_request_key: {
+                    oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+                    description?: string;
+                };
+            }, "request" | "tool_id">>;
+            readonly max_pages: {
+                type: "integer";
+                description?: string;
+                minimum?: number;
+                maximum?: number;
+                "x-clamp"?: true;
+            };
+            readonly upsert_key: {
+                oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+                description?: string;
+            };
+        };
+        readonly required?: readonly ("request" | "tool_id")[];
+        readonly description: "Full frozen route from feeds_get(include_route=true). Replacement resets cursor/error. Scheduled replacements require one executable lane; distinct fallbacks require no cadence.";
+    };
+    readonly filters: {
+        type: "object";
+        additionalProperties: boolean;
+    };
+    readonly intent_id: import("./schema.js").StringProperty;
+    readonly input_shape: import("./schema.js").StringProperty;
+    readonly route_id: import("./schema.js").StringProperty;
+    readonly registry_version: import("./schema.js").StringProperty;
+    readonly source_prompt: import("./schema.js").StringProperty;
+    readonly approved: import("./schema.js").BooleanProperty;
+}, "feed">;
+/** New surfaces refuse provenance edits the native PATCH would otherwise ignore. */
+export declare function tableFeedUpdateIssues(args: Record<string, unknown>): string[];
+export declare const TABLE_FEED_UPDATE_OPERATION: OperationSpec<ContractObject>;
+/** The existing native PATCH scope comparison, separate from configuration cost. */
+export declare function tableFeedUpdateScopeChange(args: Record<string, unknown>, current: {
+    every: string | null;
+    maxCredits: number | null;
+}): {
+    every: string | null;
+    raisesCap: boolean;
+    replacesSource: boolean;
+    changesCadence: boolean;
+    needsReapproval: boolean;
+};