@oxygen-agent/cli 1.1011.687 → 1.1011.767

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,39 @@ 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 };
     if (card.primitive === "publishing" && isUgcIntent(query))
         return { ...card, ...UGC_ROUTE_VIEW };
     const contactFind = card.id === "sourcing-and-provider-tools" ? oneShotContactFindingRecommendation(query) : null;
@@ -1540,6 +1565,8 @@ function oneShotContactFindingRecommendation(query) {
 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))
@@ -1850,6 +1877,8 @@ 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;

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/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-list.d.ts

@@ -0,0 +1,31 @@
+/** Bounded table discovery, shared by the HTTP query, CLI flags and MCP. */
+import { type Infer } from "./schema.js";
+export declare const TABLE_LIST_QUERY_CONTRACT: import("./schema.js").ContractObject<{
+    readonly project: import("./schema.js").StringProperty;
+    readonly tag: import("./schema.js").StringProperty;
+    readonly include_archived: import("./schema.js").BooleanProperty;
+    readonly limit: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly cursor: import("./schema.js").StringProperty;
+    readonly query: import("./schema.js").StringProperty;
+    readonly projection: {
+        type: "string";
+        enum: readonly ("full" | "summary")[];
+        description?: string;
+    };
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, never>;
+export type TableListQuery = Infer<typeof TABLE_LIST_QUERY_CONTRACT>;
+/** Unknown query keys are ignored for compatibility; only declared keys travel. */
+export declare function tableListQueryParams(query: TableListQuery): URLSearchParams;

package/node_modules/@oxygen/shared/dist/contracts/table-list.js

@@ -0,0 +1,22 @@
+/** Bounded table discovery, shared by the HTTP query, CLI flags and MCP. */
+import { bool, enumOf, int, obj, str } from "./schema.js";
+export const TABLE_LIST_QUERY_CONTRACT = obj({
+    project: str({ minLength: 1, maxLength: 200 }),
+    tag: str(),
+    include_archived: bool(),
+    limit: int({ minimum: 1, maximum: 1000, clamp: true }),
+    cursor: str({ maxLength: 2000 }),
+    query: str({ maxLength: 200, description: "Name/slug substring." }),
+    projection: enumOf(["full", "summary"]),
+    max_chars: int({ minimum: 2000, maximum: 40000 }),
+});
+/** Unknown query keys are ignored for compatibility; only declared keys travel. */
+export function tableListQueryParams(query) {
+    const params = new URLSearchParams();
+    for (const key of Object.keys(TABLE_LIST_QUERY_CONTRACT.properties)) {
+        const value = query[key];
+        if (value !== undefined)
+            params.set(key, String(value));
+    }
+    return params;
+}

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

@@ -0,0 +1,58 @@
+export declare const MAX_TABLE_RECOVERY_ITEMS = 1000;
+export declare const TABLE_FAVORITES_LIST_CONTRACT: import("./schema.js").ContractObject<{
+    readonly limit: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly cursor: import("./schema.js").StringProperty;
+    readonly max_chars: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, never>;
+export declare const TABLE_FAVORITE_CONTRACT: import("./schema.js").ContractObject<{
+    readonly table: import("./schema.js").StringProperty;
+    readonly folder: import("./schema.js").StringProperty;
+    readonly favorite: import("./schema.js").BooleanProperty;
+}, "favorite">;
+export declare const TABLE_LINK_SUGGEST_CONTRACT: import("./schema.js").ContractObject<{
+    readonly table: import("./schema.js").StringProperty;
+    readonly to: import("./schema.js").StringProperty;
+    readonly on: import("./schema.js").StringProperty;
+    readonly scan_limit: {
+        type: "number";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, "table" | "to">;
+export declare const TABLE_EFFECT_OUTCOMES: readonly ["applied", "not_applied"];
+export declare const TABLE_ITEM_RESOLVE_CONTRACT: import("./schema.js").ContractObject<{
+    readonly outcome: {
+        type: "string";
+        enum: readonly ("applied" | "not_applied")[];
+        description?: string;
+    };
+    readonly note: import("./schema.js").StringProperty;
+    readonly value: {
+        type?: never;
+        description?: string;
+    };
+}, "outcome">;
+export declare const TABLE_RECOVER_PENDING_CONTRACT: import("./schema.js").ContractObject<{
+    readonly table: import("./schema.js").StringProperty;
+    readonly max_items: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+}, "table">;

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

@@ -0,0 +1,30 @@
+/** Customer Table operations; the native routes retain identity and effect guards. */
+import { bool, enumOf, int, jsonValue, num, obj, str } from "./schema.js";
+const table = str({ minLength: 1, description: "Table id, slug, or Oxygen table URL." });
+export const MAX_TABLE_RECOVERY_ITEMS = 1000;
+export const TABLE_FAVORITES_LIST_CONTRACT = obj({
+    limit: int({ minimum: 1, maximum: 200, description: "Page size; MCP default 20." }),
+    cursor: str({ maxLength: 512, description: "Previous next_cursor; restart if stars changed." }),
+    max_chars: int({ minimum: 500, maximum: 10_000, description: "Complete response cap in characters." }),
+});
+export const TABLE_FAVORITE_CONTRACT = obj({
+    table: str({ minLength: 1, description: "Table id, slug, or Oxygen table URL. Pass exactly one of table or folder." }),
+    folder: str({ minLength: 1, description: "Folder id or slug. Pass exactly one of table or folder." }),
+    favorite: bool({ description: "true stars; false unstars." }),
+}, { required: ["favorite"] });
+export const TABLE_LINK_SUGGEST_CONTRACT = obj({
+    table,
+    to: table,
+    on: str({ description: "Optional join column key or id." }),
+    scan_limit: num({ description: "Native planner scan limit; bounded server-side." }),
+}, { required: ["table", "to"] });
+export const TABLE_EFFECT_OUTCOMES = ["applied", "not_applied"];
+export const TABLE_ITEM_RESOLVE_CONTRACT = obj({
+    outcome: enumOf(TABLE_EFFECT_OUTCOMES),
+    note: str(),
+    value: jsonValue({ description: "Verified cell result; any JSON, including null." }),
+}, { required: ["outcome"] });
+export const TABLE_RECOVER_PENDING_CONTRACT = obj({
+    table: str({ minLength: 1, description: "Table id or slug." }),
+    max_items: int({ minimum: 1, maximum: MAX_TABLE_RECOVERY_ITEMS, description: "Pending requests to poll; default 1000." }),
+}, { required: ["table"] });

package/node_modules/@oxygen/shared/dist/contracts/workflow-run-list.d.ts

@@ -0,0 +1,79 @@
+export declare const WORKFLOW_RUN_STATUS_VALUES: readonly ["queued", "running", "waiting", "awaiting_approval", "completed", "failed", "canceling", "canceled"];
+export declare const WORKFLOW_RUN_MODE_VALUES: readonly ["dry_run", "live", "smoke_test"];
+export declare const WORKFLOW_RUN_LIST_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 workflow: import("./schema.js").StringProperty;
+    readonly workflow_id: import("./schema.js").StringProperty;
+    readonly status: import("./schema.js").StringProperty;
+    readonly mode: import("./schema.js").StringProperty;
+    readonly cursor: import("./schema.js").StringProperty;
+    readonly limit: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly run_id: import("./schema.js").StringProperty;
+}, never>;
+export declare const WORKFLOW_RUN_LIST_MCP_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 workflow: import("./schema.js").StringProperty;
+    readonly workflow_id: import("./schema.js").StringProperty;
+    readonly cursor: import("./schema.js").StringProperty;
+    readonly limit: {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    };
+    readonly run_id: import("./schema.js").StringProperty;
+    readonly status: {
+        type: "string";
+        enum: readonly ("awaiting_approval" | "canceled" | "canceling" | "completed" | "failed" | "queued" | "running" | "waiting")[];
+        description?: string;
+    };
+    readonly mode: {
+        type: "string";
+        enum: readonly ("dry_run" | "live" | "smoke_test")[];
+        description?: string;
+    };
+}, never>;
+/** The native GET keeps raw strings, canonical alias precedence and absent
+ * values. CLI legacy trimming is an explicit adapter above this contract. */
+export declare function workflowRunListQueryParams(args: Record<string, unknown>): URLSearchParams;
+/** Exact native HTTP scalar selection, including blank canonical precedence. */
+export declare function readWorkflowRunListSelectors(params: URLSearchParams): {
+    workflowIdOrSlug: string | null;
+    status: string | null;
+    mode: string | null;
+    cursor: string | null;
+    runId: string | null;
+};

package/node_modules/@oxygen/shared/dist/contracts/workflow-run-list.js

@@ -0,0 +1,38 @@
+import { enumOf, int, obj, str } from "./schema.js";
+import { STORED_READ_WINDOW_FIELDS } from "./stored-read-window.js";
+export const WORKFLOW_RUN_STATUS_VALUES = ["queued", "running", "waiting", "awaiting_approval", "completed", "failed", "canceling", "canceled"];
+export const WORKFLOW_RUN_MODE_VALUES = ["dry_run", "live", "smoke_test"];
+export const WORKFLOW_RUN_LIST_CONTRACT = obj({
+    workflow: str({ minLength: 1, maxLength: 400, description: "Workflow id, slug, exact name, or copied URL." }),
+    workflow_id: str({ minLength: 1, maxLength: 400, description: "Canonical workflow ref; takes precedence over workflow on HTTP/MCP." }),
+    status: str({ description: "Stored status filter: queued, running, waiting, awaiting_approval, completed, failed, canceling, canceled. Native validation trims and ignores case." }),
+    mode: str({ description: "Stored execution mode filter: dry_run, live or smoke_test. Never runs a workflow." }),
+    cursor: str({ description: "Previous nextCursor, echoed unchanged with the same filters." }),
+    limit: int({ minimum: 1, maximum: 500, description: "Runs per page; native default 50." }),
+    run_id: str({ minLength: 1, maxLength: 80, description: "Exact stored run UUID within the same workflow/status/mode/cursor filters; opt-in windows only." }),
+    ...STORED_READ_WINDOW_FIELDS,
+});
+export const WORKFLOW_RUN_LIST_MCP_CONTRACT = obj({
+    ...WORKFLOW_RUN_LIST_CONTRACT.properties,
+    status: enumOf(WORKFLOW_RUN_STATUS_VALUES, { description: "Stored run status filter." }),
+    mode: enumOf(WORKFLOW_RUN_MODE_VALUES, { description: "Stored execution mode filter; executes nothing." }),
+});
+/** The native GET keeps raw strings, canonical alias precedence and absent
+ * values. CLI legacy trimming is an explicit adapter above this contract. */
+export function workflowRunListQueryParams(args) {
+    const pairs = [];
+    for (const key of Object.keys(WORKFLOW_RUN_LIST_CONTRACT.properties)) {
+        const value = args[key];
+        if (value !== undefined && value !== null)
+            pairs.push([key, String(value)]);
+    }
+    return new URLSearchParams(pairs);
+}
+/** Exact native HTTP scalar selection, including blank canonical precedence. */
+export function readWorkflowRunListSelectors(params) {
+    return {
+        workflowIdOrSlug: params.get("workflow_id") ?? params.get("workflow"),
+        status: params.get("status"), mode: params.get("mode"),
+        cursor: params.get("cursor"), runId: params.get("run_id"),
+    };
+}

package/node_modules/@oxygen/shared/dist/copilot-journeys.d.ts

@@ -12,8 +12,8 @@ export declare const COPILOT_JOURNEYS: readonly [{
     readonly slug: "inbound-led-outbound";
     readonly title: "Inbound-led outbound";
     readonly description: "Turn the people who engage with your LinkedIn posts into a capped, evidence-gated warm sequence with replies routed to your CRM.";
-    readonly recipeSlugs: readonly ["inbound-led-outbound", "linkedin-network-first-motion", "founder-posting-system", "reply-to-meeting"];
-    readonly seedMessage: "I chose the inbound-led-outbound recipe. Help me set up inbound-led outbound for my LinkedIn posts: watch who engages with them every day, assess each person against my ICP, hand me the strong fits, put the possible fits into a draft LinkedIn sequence on a schedule, move replies into my CRM, and write what we learn back into my knowledge wiki. Inspect the workspace first, follow the recipe, and resume from durable evidence instead of starting over. Do not connect an account, enroll anyone, send anything, or spend credits without asking me first.";
+    readonly recipeSlugs: readonly ["inbound-led-outbound", "founder-posting-system", "reply-to-meeting"];
+    readonly seedMessage: "I chose the inbound-led-outbound recipe. Help me turn the people paying attention to me on LinkedIn into conversations: capture a small sample, score each person against my ideal customer, show me the good fits and draft a LinkedIn message I approve. Inspect the workspace first and resume from what exists. Do not connect an account, enroll anyone, send anything, or spend credits without asking me first.";
 }, {
     readonly slug: "email-infra-setup";
     readonly title: "Outbound infrastructure";

package/node_modules/@oxygen/shared/dist/copilot-journeys.generated.d.ts

@@ -2,8 +2,8 @@ export declare const COPILOT_JOURNEYS_GENERATED: readonly [{
     readonly slug: "inbound-led-outbound";
     readonly title: "Inbound-led outbound";
     readonly description: "Turn the people who engage with your LinkedIn posts into a capped, evidence-gated warm sequence with replies routed to your CRM.";
-    readonly recipeSlugs: readonly ["inbound-led-outbound", "linkedin-network-first-motion", "founder-posting-system", "reply-to-meeting"];
-    readonly seedMessage: "I chose the inbound-led-outbound recipe. Help me set up inbound-led outbound for my LinkedIn posts: watch who engages with them every day, assess each person against my ICP, hand me the strong fits, put the possible fits into a draft LinkedIn sequence on a schedule, move replies into my CRM, and write what we learn back into my knowledge wiki. Inspect the workspace first, follow the recipe, and resume from durable evidence instead of starting over. Do not connect an account, enroll anyone, send anything, or spend credits without asking me first.";
+    readonly recipeSlugs: readonly ["inbound-led-outbound", "founder-posting-system", "reply-to-meeting"];
+    readonly seedMessage: "I chose the inbound-led-outbound recipe. Help me turn the people paying attention to me on LinkedIn into conversations: capture a small sample, score each person against my ideal customer, show me the good fits and draft a LinkedIn message I approve. Inspect the workspace first and resume from what exists. Do not connect an account, enroll anyone, send anything, or spend credits without asking me first.";
 }, {
     readonly slug: "email-infra-setup";
     readonly title: "Outbound infrastructure";

package/node_modules/@oxygen/shared/dist/copilot-journeys.generated.js

@@ -6,8 +6,8 @@ export const COPILOT_JOURNEYS_GENERATED = [
         slug: "inbound-led-outbound",
         title: "Inbound-led outbound",
         description: "Turn the people who engage with your LinkedIn posts into a capped, evidence-gated warm sequence with replies routed to your CRM.",
-        recipeSlugs: ["inbound-led-outbound", "linkedin-network-first-motion", "founder-posting-system", "reply-to-meeting"],
-        seedMessage: "I chose the inbound-led-outbound recipe. Help me set up inbound-led outbound for my LinkedIn posts: watch who engages with them every day, assess each person against my ICP, hand me the strong fits, put the possible fits into a draft LinkedIn sequence on a schedule, move replies into my CRM, and write what we learn back into my knowledge wiki. Inspect the workspace first, follow the recipe, and resume from durable evidence instead of starting over. Do not connect an account, enroll anyone, send anything, or spend credits without asking me first.",
+        recipeSlugs: ["inbound-led-outbound", "founder-posting-system", "reply-to-meeting"],
+        seedMessage: "I chose the inbound-led-outbound recipe. Help me turn the people paying attention to me on LinkedIn into conversations: capture a small sample, score each person against my ideal customer, show me the good fits and draft a LinkedIn message I approve. Inspect the workspace first and resume from what exists. Do not connect an account, enroll anyone, send anything, or spend credits without asking me first.",
     },
     {
         slug: "email-infra-setup",