@oxygen-agent/cli 1.591.1 → 1.610.7

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

@@ -0,0 +1,766 @@
+import { RECIPE_PRIMITIVES } from "./recipes.js";
+// One compact semantic index covers every top-level /api/cli endpoint section.
+// It is navigation, never execution: live schemas, prices, readiness, and
+// approval enforcement remain on the exact command/tool selected from here.
+export const OXYGEN_CAPABILITY_ROUTES = [
+    {
+        id: "workspace-access",
+        layer: "Control",
+        primitive: null,
+        owns: "Authentication, CLI identities, API keys, sessions, organizations, and active-workspace selection.",
+        notFor: "Workspace GTM data, provider credentials, or execution inside a primitive.",
+        execution: "Resolve identity and select the hosted workspace before operating its primitives.",
+        posture: "mixed",
+        gatewayTools: ["oxygen_whoami", "oxygen_orgs_list", "oxygen_orgs_select"],
+        gatewayCommands: ["whoami", "orgs list", "orgs select"],
+        skills: ["oxygen-quickstart"],
+        endpointSections: ["api-keys", "auth", "login-requests", "orgs", "sessions", "settings", "whoami"],
+        intentTerms: ["login", "authenticate", "identity", "who am i", "workspace", "organization", "org", "api key", "session", "switch workspace"],
+    },
+    {
+        id: "discovery-and-skills",
+        layer: "Control",
+        primitive: null,
+        owns: "Bounded capability, command, provider-operation, Recipe, and product-skill discovery with exact hydration on demand.",
+        notFor: "Executing GTM work or loading full manifests and schemas before a capability is selected.",
+        execution: "Search by outcome, choose the owner, then hydrate one exact command, MCP schema, provider descriptor, or skill.",
+        posture: "read_only",
+        gatewayTools: ["oxygen_capabilities_search", "oxygen_tools_search", "oxygen_recipes_list"],
+        gatewayCommands: ["capabilities search", "commands search", "skills search", "tools search", "recipes list"],
+        skills: ["oxygen-quickstart", "oxygen-gtm"],
+        endpointSections: ["skills"],
+        intentTerms: ["discover", "discovery", "capability", "capabilities", "command", "commands", "skill", "skills", "which tool", "how do i"],
+    },
+    {
+        id: "onboarding-and-copilot",
+        layer: "Control",
+        primitive: null,
+        owns: "First-run setup and interactive Workspace Copilot sessions over the shared primitive contracts.",
+        notFor: "Recurring deterministic automation or standing adaptive jobs; use Workflows or Agents.",
+        execution: "Start onboarding or a hosted Copilot session; every resulting action still uses its native primitive gate.",
+        posture: "mixed",
+        gatewayTools: ["oxygen_whoami", "oxygen_context_resolve", "oxygen_copilot_start"],
+        gatewayCommands: ["whoami", "context resolve", "copilot start"],
+        skills: ["oxygen-quickstart", "oxygen-gtm"],
+        endpointSections: ["copilot", "home"],
+        intentTerms: ["onboard", "onboarding", "first run", "first day", "setup oxygen", "copilot", "assistant", "guided"],
+    },
+    {
+        id: "billing-and-budgets",
+        layer: "Control",
+        primitive: null,
+        owns: "Credits, plan state, usage receipts, subscriptions, and standing budget policies.",
+        notFor: "Authorizing a specific provider call or external write; that action still needs its own preview and approval.",
+        execution: "Read billing state or set a hosted budget policy; exact action ceilings remain primitive-owned.",
+        posture: "mixed",
+        gatewayTools: ["oxygen_billing_balance", "oxygen_billing_usage", "oxygen_budget_list"],
+        gatewayCommands: ["billing balance", "billing usage", "budget list"],
+        skills: ["oxygen-gtm", "oxygen-diagnostics"],
+        endpointSections: ["billing", "budget", "limits"],
+        intentTerms: ["billing", "credits", "credit balance", "usage", "spend", "cost", "budget", "subscription", "invoice", "cancel plan"],
+    },
+    {
+        id: "support-and-feedback",
+        layer: "Control",
+        primitive: null,
+        owns: "Customer support tickets, product feedback, transcript-backed reports, and ticket follow-up.",
+        notFor: "Primitive run diagnosis when no support report is needed; inspect Observability first.",
+        execution: "File or inspect a hosted support record and return its deep link; never send a customer reply automatically.",
+        posture: "workspace_write",
+        gatewayTools: ["oxygen_feedback", "oxygen_support_ticket_create", "oxygen_support_tickets_list"],
+        gatewayCommands: ["feedback", "support file", "support list"],
+        skills: ["oxygen-feedback"],
+        endpointSections: ["feedback", "support"],
+        intentTerms: ["support", "feedback", "bug report", "feature request", "report issue", "ticket", "complaint"],
+    },
+    {
+        id: "platform-operations",
+        layer: "Control",
+        primitive: null,
+        owns: "Staff/admin diagnostics, worker queue health, tenant repair, and database operating surfaces.",
+        notFor: "Ordinary customer GTM work or product Observability over customer-visible runs.",
+        execution: "Use the authenticated hosted operational endpoints; production mutations and migrations keep their human gates.",
+        posture: "mixed",
+        gatewayTools: ["oxygen_worker_queue_stats", "oxygen_worker_failures", "oxygen_observability_runs"],
+        gatewayCommands: ["worker queue-stats", "worker failures", "db status"],
+        skills: ["oxygen-diagnostics"],
+        endpointSections: ["admin", "db", "worker"],
+        intentTerms: ["admin", "worker", "queue", "tenant repair", "database", "db status", "stuck jobs", "operations"],
+    },
+    {
+        id: "agency-directory",
+        layer: "Control",
+        primitive: null,
+        owns: "The current organization profile and publication state in the public OXYGEN agency directory.",
+        notFor: "CRM company records, workspace membership, or outbound campaigns.",
+        execution: "Read, update, publish, or unpublish the hosted directory listing.",
+        posture: "workspace_write",
+        gatewayTools: ["oxygen_directory_get", "oxygen_directory_update", "oxygen_directory_publish"],
+        gatewayCommands: ["directory get", "directory update", "directory publish"],
+        skills: ["oxygen-agency-directory"],
+        endpointSections: ["directory"],
+        intentTerms: ["agency directory", "agency listing", "directory profile", "publish agency", "partner listing"],
+    },
+    {
+        id: "knowledge-graph",
+        layer: "Knowledge",
+        primitive: "knowledge-graph",
+        owns: "Durable workspace context: company, ICP, positioning, offers, rubrics, prompts, and linked wiki pages.",
+        notFor: "Working row sets, campaign execution, or local chat memory.",
+        execution: "Read and write the hosted workspace Knowledge Graph; canonical changes remain proposal-gated.",
+        posture: "workspace_write",
+        gatewayTools: ["oxygen_knowledge_search", "oxygen_knowledge_index", "oxygen_knowledge_page_get"],
+        gatewayCommands: ["knowledge search", "knowledge index", "knowledge page get"],
+        skills: ["oxygen-knowledge"],
+        endpointSections: ["context", "knowledge"],
+        intentTerms: ["knowledge", "wiki", "context", "icp", "positioning", "offer", "rubric", "brand", "voice", "company profile"],
+    },
+    {
+        id: "recipes",
+        layer: "Knowledge",
+        primitive: "recipes",
+        owns: "Versioned advisory playbooks that teach when and why to run proven GTM motions through native primitives.",
+        notFor: "A hidden runtime, mandatory bundle, or replacement for hosted Workflows.",
+        execution: "Browse or install the Recipe; optional Blueprints scaffold infrastructure while native primitives execute.",
+        posture: "workspace_write",
+        gatewayTools: ["oxygen_recipes_list", "oxygen_recipes_get"],
+        gatewayCommands: ["recipes list", "recipes show", "recipes install"],
+        skills: ["oxygen-recipes"],
+        endpointSections: ["blueprints", "recipes", "templates"],
+        intentTerms: ["recipe", "playbook", "proven play", "journey", "day 1", "day 7", "day 30", "blueprint", "template", "what should i do"],
+    },
+    {
+        id: "records",
+        layer: "Data",
+        primitive: "records",
+        owns: "Canonical companies, people, deals, identities, relationships, activities, merges, and CRM sync state.",
+        notFor: "Disposable sourcing, enrichment, or scoring work; use Tables before promotion.",
+        execution: "Operate the hosted native CRM and preserve field/relationship provenance.",
+        posture: "workspace_write",
+        gatewayTools: ["oxygen_crm_record_search", "oxygen_crm_record_get"],
+        gatewayCommands: ["crm search", "crm get", "crm describe"],
+        skills: ["oxygen-gtm"],
+        endpointSections: ["crm"],
+        intentTerms: ["record", "records", "crm", "company record", "contact", "person record", "deal", "timeline", "merge", "relationship"],
+    },
+    {
+        id: "tables",
+        layer: "Data",
+        primitive: "tables",
+        owns: "Typed working datasets, rows, formulas, AI/tool/waterfall columns, cell state, projects, and run provenance.",
+        notFor: "Canonical CRM truth, message cadence, or an off-platform spreadsheet runtime.",
+        execution: "Create and run work in hosted OXYGEN Tables; validate a small sample before bounded paid runs.",
+        posture: "mixed",
+        gatewayTools: ["oxygen_tables_create", "oxygen_columns_add", "oxygen_enrich_column_preview"],
+        gatewayCommands: ["tables create", "columns add", "enrich-column preview"],
+        skills: ["oxygen-gtm", "oxygen-table-tidy", "oxygen-diagnostics", "oxygen-clay-migration"],
+        endpointSections: ["action-columns", "callables", "columns", "company-enrichment", "enrich-column", "enrichment", "projects", "table-action-runs", "table-ingestion-runs", "tables"],
+        intentTerms: ["table", "rows", "column", "columns", "dataset", "csv", "import", "enrich", "enrichment", "waterfall", "score", "formula", "ai column", "lookup"],
+    },
+    {
+        id: "messages",
+        layer: "Data",
+        primitive: "messages",
+        owns: "One-to-one message facts, conversations, direct email, inbox drafts, and replies in existing channel threads.",
+        notFor: "Net-new LinkedIn initiation, cadence, enrollment, sender rotation, or reply-stop programs; those belong to Sequences.",
+        execution: "Preview and approve a direct email or existing-thread reply; every sent fact stays in the hosted Messages ledger.",
+        posture: "external_write",
+        gatewayTools: ["oxygen_inbox_send", "oxygen_email_send", "oxygen_messages_query"],
+        gatewayCommands: ["inbox send", "email send", "messages query"],
+        skills: ["oxygen-unibox"],
+        endpointSections: ["email", "inbox", "message-reviews", "messages"],
+        intentTerms: ["message", "messages", "reply", "email", "inbox", "conversation", "thread", "direct email", "draft reply", "one off"],
+    },
+    {
+        id: "posts",
+        layer: "Data",
+        primitive: "posts",
+        owns: "Broadcast post artifacts, author/channel identity, provider IDs, comments, reactions, and performance history.",
+        notFor: "One-to-one conversations, delivery scheduling, or generic public LinkedIn provider search.",
+        execution: "Read or create the hosted Post artifact; Publishing owns scheduled delivery.",
+        posture: "workspace_write",
+        gatewayTools: ["oxygen_posts_get", "oxygen_posts_comments_list", "oxygen_posts_reactions_list", "oxygen_posts_create"],
+        gatewayCommands: ["posts get", "posts comments", "posts reactions", "posts create"],
+        skills: ["oxygen-linkedin-marketing"],
+        endpointSections: [],
+        intentTerms: ["post artifact", "social post", "post comments", "post reactions", "post performance", "broadcast content"],
+    },
+    {
+        id: "signals",
+        layer: "Data",
+        primitive: "signals",
+        owns: "Durable typed pulse, engagement, and product events resolved onto records.",
+        notFor: "Message bodies, post artifacts, or ad-hoc provider webhooks as private automation state.",
+        execution: "Read the hosted signal stream and feed subscriptions, Sequences, or Workflows.",
+        posture: "workspace_write",
+        gatewayTools: ["oxygen_signals_list", "oxygen_signals_leads_today"],
+        gatewayCommands: ["signals list", "signals leads-today", "signals registry"],
+        skills: ["oxygen-gtm", "oxygen-linkedin-marketing"],
+        endpointSections: ["signals", "signup-leads"],
+        intentTerms: ["signal", "signals", "intent", "website visit", "job change", "fundraising", "warm leads", "engager", "follower", "viewer"],
+    },
+    {
+        id: "dashboards",
+        layer: "Data",
+        primitive: "dashboards",
+        owns: "Curated funnel, channel, spend, and needs-action reporting over native state.",
+        notFor: "Arbitrary BI modeling or a separate analytics store.",
+        execution: "Compute hosted curated views over Records, Messages, Signals, Sequences, and runs.",
+        posture: "read_only",
+        gatewayTools: ["oxygen_dashboard_summary"],
+        gatewayCommands: ["dashboards summary"],
+        skills: ["oxygen-gtm"],
+        endpointSections: ["dashboards"],
+        intentTerms: ["dashboard", "report", "reporting", "funnel", "metrics", "kpi", "performance", "pipeline summary"],
+    },
+    {
+        id: "ads",
+        layer: "Data",
+        primitive: "ads",
+        owns: "Competitor ad intelligence today; owned-audience activation is a roadmap boundary.",
+        notFor: "Organic Posts, Publishing, or claiming unshipped audience activation.",
+        execution: "Discover and run the hosted ad-intelligence provider operation with the normal paid-read gate.",
+        posture: "paid_read",
+        gatewayTools: ["oxygen_adyntel_ads_search", "oxygen_tools_search"],
+        gatewayCommands: ["tools search"],
+        skills: ["oxygen-gtm"],
+        endpointSections: [],
+        intentTerms: ["ad", "ads", "advertising", "ad creative", "competitor ads", "ad intelligence", "meta ads", "linkedin ads"],
+    },
+    {
+        id: "tags",
+        layer: "Data",
+        primitive: "tags",
+        owns: "The normalized cross-primitive label vocabulary and campaign handle.",
+        notFor: "A campaign entity, private per-surface labels, or arbitrary execution state.",
+        execution: "Read or mutate tags through the hosted union surface; rename is preview-first.",
+        posture: "workspace_write",
+        gatewayTools: ["oxygen_tags_list", "oxygen_tags_get", "oxygen_tags_rename"],
+        gatewayCommands: ["tags list", "tags get", "tags rename"],
+        skills: ["oxygen-gtm"],
+        endpointSections: ["tags"],
+        intentTerms: ["tag", "tags", "label", "labels", "campaign handle", "grouping", "organize campaign"],
+    },
+    {
+        id: "sequences",
+        layer: "Action",
+        primitive: "sequences",
+        owns: "Net-new LinkedIn outreach plus versioned multichannel programs, cadence, enrollment, sender limits, suppression, reply-stop, and dispatch.",
+        notFor: "A reply in an existing conversation or a direct one-off email; use Messages. Not for general deterministic automation.",
+        execution: "Use the one-step gateway for new LinkedIn initiation or create/enroll/start a hosted campaign with bounded send authority.",
+        posture: "external_write",
+        gatewayTools: ["oxygen_sequences_send", "oxygen_sequences_create", "oxygen_sequences_enroll", "oxygen_sequences_start", "oxygen_sequences_list"],
+        gatewayCommands: ["sequences send", "sequences create", "sequences enroll", "sequences start", "sequences list"],
+        skills: ["oxygen-sequencer"],
+        endpointSections: ["senders", "sequencer", "sequences", "spintax", "suppressions", "voice"],
+        intentTerms: ["sequence", "campaign", "cadence", "enroll", "outreach", "linkedin message", "linkedin dm", "nurture", "follow up", "sender rotation", "stop on reply"],
+    },
+    {
+        id: "publishing",
+        layer: "Action",
+        primitive: "publishing",
+        owns: "Approval-gated scheduling, dispatch, retries, review, and attempt provenance for broadcast Posts.",
+        notFor: "One-to-one messaging, outreach campaigns, or general automation.",
+        execution: "Create and schedule on OXYGEN; explicit approval releases the hosted publisher.",
+        posture: "external_write",
+        gatewayTools: ["oxygen_publishing_posts_create", "oxygen_publishing_posts_list", "oxygen_publishing_posts_approve"],
+        gatewayCommands: ["publishing posts create", "publishing posts list", "publishing posts approve"],
+        skills: ["oxygen-linkedin-marketing"],
+        endpointSections: ["publishing"],
+        intentTerms: ["publish", "publishing", "schedule post", "content calendar", "posting calendar", "approve post", "social publishing"],
+    },
+    {
+        id: "workflows",
+        layer: "Action",
+        primitive: "workflows",
+        owns: "Deterministic hosted automation definitions, versions, triggers, branching, retries, approvals, modes, and durable runs.",
+        notFor: "Local cron, client-side execution, adaptive Agent goals, or outreach cadence already owned by Sequences.",
+        execution: "Author locally if useful, then schema/lint/apply and call the Workflow on OXYGEN workers; outbound uses internal oxygen.sequence_enroll against an already active bounded Sequence.",
+        posture: "mixed",
+        gatewayTools: ["oxygen_workflows_schema", "oxygen_workflows_lint", "oxygen_workflows_apply", "oxygen_workflows_call", "oxygen_workflows_tail"],
+        gatewayCommands: ["workflows schema", "workflows lint", "workflows apply", "workflows call", "workflows tail"],
+        skills: ["oxygen-workflow-authoring"],
+        endpointSections: ["workflows"],
+        intentTerms: ["workflow", "automation", "automate", "webhook", "cron", "trigger", "branch", "retry", "orchestrate", "scheduled job", "deterministic graph"],
+    },
+    {
+        id: "agents",
+        layer: "Action",
+        primitive: "agents",
+        owns: "Adaptive governed worker definitions, versions, authorization, context, triggers, threads, checkpoints, inference, and first-class runs.",
+        notFor: "A known deterministic graph that belongs in Workflows or an opaque uploaded runtime.",
+        execution: "Publish and run a hosted governed Agent with explicit tool authority and a separate bounded spend ceiling.",
+        posture: "mixed",
+        gatewayTools: ["oxygen_agent_list", "oxygen_agent_create", "oxygen_agent_run"],
+        gatewayCommands: ["agent list", "agent create", "agent run"],
+        skills: ["oxygen-gtm"],
+        endpointSections: ["agent", "notetaker"],
+        intentTerms: ["agent", "adaptive", "goal directed", "autonomous", "persistent thread", "checkpoint", "standing job", "notetaker"],
+    },
+    {
+        id: "observability",
+        layer: "Action",
+        primitive: "observability",
+        owns: "The cross-primitive read lens for runs, timelines, approvals, costs, failures, retries, and outputs.",
+        notFor: "Operational infrastructure logs or a second execution engine.",
+        execution: "Inspect hosted run state and decide pending approvals through native read/control surfaces.",
+        posture: "read_only",
+        gatewayTools: ["oxygen_observability_runs", "oxygen_observability_approvals", "oxygen_observability_events"],
+        gatewayCommands: ["observability runs", "observability approvals", "observability events"],
+        skills: ["oxygen-diagnostics"],
+        endpointSections: ["observability", "runs"],
+        intentTerms: ["observability", "run", "runs", "failure", "failed", "retry", "provenance", "cost", "approval", "what is running"],
+    },
+    {
+        id: "sourcing-and-provider-tools",
+        layer: "External",
+        primitive: null,
+        owns: "Company/people sourcing, one-shot contact finding, provider-operation discovery, and durable search plans feeding Tables.",
+        notFor: "Enriching rows that already exist; use native table columns and waterfalls. Not for raw provider selection when a native gateway exists.",
+        execution: "Plan or preview the hosted search, then run with an explicit scope and credit ceiling; hydrate one provider descriptor only when needed.",
+        posture: "paid_read",
+        gatewayTools: ["oxygen_search_plan", "oxygen_sourcing_plan", "oxygen_find_company", "oxygen_tools_search"],
+        gatewayCommands: ["search plan", "sourcing plan", "find company", "tools search"],
+        skills: ["oxygen-gtm"],
+        endpointSections: ["companies", "find", "lead-sourcing", "people", "search", "sourcing", "tools", "verify"],
+        intentTerms: ["find companies", "find people", "source leads", "build a list", "tam", "prospect", "provider", "tool catalog", "find email", "find phone"],
+    },
+    {
+        id: "linkedin-public-research",
+        layer: "External",
+        primitive: null,
+        owns: "Cookieless public or third-party LinkedIn profiles, companies, posts, search, reactions, comments, and engagers through native scraper operations.",
+        notFor: "The workspace account network/inbox or any LinkedIn write; those require the connected LinkedIn surface.",
+        execution: "For a known post's engagers, preview the durable engagement harvest; for other reads, search `scraper.*`, hydrate one descriptor, and run without a connected-account quota.",
+        posture: "paid_read",
+        gatewayTools: ["oxygen_tools_search", "oxygen_tools_get"],
+        gatewayCommands: ["tools search", "tools get"],
+        skills: ["oxygen-gtm", "oxygen-linkedin-marketing"],
+        endpointSections: [],
+        intentTerms: ["public linkedin", "third party linkedin", "linkedin profile", "linkedin company", "linkedin post", "linkedin comments", "linkedin reactions", "linkedin engagers", "harvest", "cookieless"],
+        negativeTerms: ["my linkedin", "our linkedin", "own linkedin", "connected account", "inbox", "send", "invite", "publish"],
+    },
+    {
+        id: "connected-integrations",
+        layer: "External",
+        primitive: null,
+        owns: "Connected SaaS accounts, OAuth/BYOK readiness, custom integration manifests, and provider actions that lack a native primitive gateway.",
+        notFor: "Recreating native Tables, Messages, Sequences, Publishing, or Workflows through a generic provider action.",
+        execution: "Inspect readiness, then connect or call the hosted integration under its exact write/spend gate.",
+        posture: "mixed",
+        gatewayTools: ["oxygen_integrations_list", "oxygen_integrations_connect", "oxygen_integrations_list_actions"],
+        gatewayCommands: ["integrations list", "integrations connect", "custom-integrations list"],
+        skills: ["oxygen-gtm"],
+        endpointSections: ["custom-integrations", "integrations"],
+        intentTerms: ["integration", "integrations", "connect provider", "oauth", "byok", "custom http", "custom integration", "connection readiness"],
+    },
+    {
+        id: "sending-infrastructure",
+        layer: "External",
+        primitive: null,
+        owns: "Sending domains, managed/BYOK mailboxes, warmup, deliverability, egress IPs, and infrastructure health beneath Sequences.",
+        notFor: "Writing campaign copy or sending outside a Sequence/Message owner.",
+        execution: "Inspect or provision hosted sending infrastructure with explicit recurring-cost and external-write approval.",
+        posture: "mixed",
+        gatewayTools: ["oxygen_mailboxes_list", "oxygen_domains_list", "oxygen_mailboxes_health"],
+        gatewayCommands: ["mailboxes list", "domains list", "mailboxes health"],
+        skills: ["oxygen-email-infra", "oxygen-deliverability", "oxygen-sequencer"],
+        endpointSections: ["deliverability", "domains", "egress", "mailboxes", "managed-inboxes"],
+        intentTerms: ["mailbox", "mailboxes", "sending domain", "dns", "warmup", "deliverability", "placement", "egress ip", "email infrastructure", "managed inbox"],
+    },
+    {
+        id: "connected-linkedin",
+        layer: "External",
+        primitive: null,
+        owns: "The workspace LinkedIn account network/private data and connected-account writes used by Signals, Messages, Sequences, and Publishing.",
+        notFor: "Ordinary public or third-party LinkedIn research; use the cookieless native scraper.",
+        execution: "Use the owning primitive gateway; the connected account provides identity and transport, not a competing product runtime.",
+        posture: "mixed",
+        gatewayTools: ["oxygen_senders_list", "oxygen_linkedin_connections_import", "oxygen_inbox_list"],
+        gatewayCommands: ["senders list", "connections import", "inbox list"],
+        skills: ["oxygen-linkedin-marketing", "oxygen-sequencer", "oxygen-unibox"],
+        endpointSections: ["linkedin"],
+        intentTerms: ["my linkedin", "our linkedin", "own linkedin", "connected linkedin", "connections", "followers", "profile viewers", "sales navigator", "recruiter", "linkedin inbox"],
+    },
+    {
+        id: "connected-whatsapp",
+        layer: "External",
+        primitive: null,
+        owns: "Connected WhatsApp accounts, account limits, warm existing-thread sends, and transport beneath Messages/Sequences.",
+        notFor: "A generic chat executor: replies belong to Messages and cold/multistep outreach belongs to Sequences.",
+        execution: "Inspect the connected account, then route reply or initiation intent to the owning native primitive.",
+        posture: "external_write",
+        gatewayTools: ["oxygen_whatsapp_accounts_list", "oxygen_inbox_send", "oxygen_sequences_create"],
+        gatewayCommands: ["whatsapp accounts", "inbox send", "sequences create"],
+        skills: ["oxygen-unibox", "oxygen-sequencer"],
+        endpointSections: ["whatsapp"],
+        intentTerms: ["whatsapp", "whatsapp account", "whatsapp reply", "whatsapp outreach", "warm send"],
+    },
+];
+export const OXYGEN_PRIMITIVE_ROUTES = OXYGEN_CAPABILITY_ROUTES
+    .filter((card) => card.primitive !== null);
+const ROUTE_BY_ID = new Map(OXYGEN_CAPABILITY_ROUTES.map((card) => [card.id, card]));
+const ROUTE_BY_PRIMITIVE = new Map(OXYGEN_PRIMITIVE_ROUTES.map((card) => [card.primitive, card]));
+const NORMALIZED_PRIMITIVES = [...RECIPE_PRIMITIVES].sort();
+const NORMALIZED_ROUTE_PRIMITIVES = OXYGEN_PRIMITIVE_ROUTES.map((card) => card.primitive).sort();
+if (NORMALIZED_PRIMITIVES.join("|") !== NORMALIZED_ROUTE_PRIMITIVES.join("|")) {
+    throw new Error("OXYGEN capability routes must cover the shared fifteen-primitive catalog exactly.");
+}
+export function getCapabilityRoute(id) {
+    return ROUTE_BY_ID.get(id.trim().toLowerCase()) ?? null;
+}
+export function getCapabilityRouteMatch(id) {
+    const card = getCapabilityRoute(id);
+    if (!card)
+        return null;
+    const recommendations = recommendationsFor(card, normalizeIntent(id));
+    return {
+        card,
+        recommendedTools: recommendations.tools,
+        recommendedCommands: recommendations.commands,
+    };
+}
+export function inferCapabilityRoute(query) {
+    const normalized = normalizeIntent(query);
+    if (!normalized)
+        return null;
+    const explicit = explicitCapabilityIntent(normalized);
+    const card = explicit ?? highestScoringRoute(normalized);
+    if (!card)
+        return null;
+    const recommendations = recommendationsFor(card, normalized);
+    return {
+        card,
+        recommendedTools: recommendations.tools,
+        recommendedCommands: recommendations.commands,
+    };
+}
+export function inferPrimitiveRoute(query) {
+    const route = inferCapabilityRoute(query);
+    if (!route || route.card.primitive === null)
+        return null;
+    return route;
+}
+export function serializeCapabilityRoute(route) {
+    if (!route)
+        return null;
+    return {
+        capability_id: route.card.id,
+        layer: route.card.layer,
+        primitive: route.card.primitive,
+        owns: route.card.owns,
+        not_for: route.card.notFor,
+        execution: route.card.execution,
+        posture: route.card.posture,
+        skills: route.card.skills,
+        endpoint_sections: route.card.endpointSections,
+        recommended_commands: route.recommendedCommands,
+        recommended_tools: route.recommendedTools,
+        hydrate: {
+            cli: "oxygen commands get <exact-command> --json",
+            mcp: "oxygen_capabilities_schema",
+        },
+    };
+}
+function normalizeIntent(query) {
+    return query.toLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function explicitCapabilityIntent(query) {
+    if (isHostedWorkflowIntent(query))
+        return ROUTE_BY_PRIMITIVE.get("workflows") ?? null;
+    // A deferred acquisition motion starts with the public-data owner. This keeps
+    // "find/qualify now, contact later" from skipping straight to the final write
+    // step; the recommendation still hands the eventual initiation to Sequences.
+    if (isPublicLinkedInRead(query) && isDeferredLinkedInOutreach(query)) {
+        return ROUTE_BY_ID.get("linkedin-public-research") ?? null;
+    }
+    // When one ask combines public LinkedIn research with initiating a new
+    // conversation now, the external write owner wins. The Sequences
+    // recommendation still exposes the native scraper discovery step for the
+    // research input.
+    if (isNetNewLinkedInInitiation(query))
+        return ROUTE_BY_PRIMITIVE.get("sequences") ?? null;
+    if (isPublicLinkedInRead(query))
+        return ROUTE_BY_ID.get("linkedin-public-research") ?? null;
+    if (/\b(my|our|own)\b.{0,40}\blinkedin\b.{0,40}\b(post )?engagers?\b/.test(query)) {
+        return ROUTE_BY_PRIMITIVE.get("signals") ?? null;
+    }
+    if (/\b(recipe|playbook|proven play|what should i do)\b/.test(query)) {
+        return ROUTE_BY_PRIMITIVE.get("recipes") ?? null;
+    }
+    if (/\btable\b.{0,24}\b(action |ingestion )?runs?\b/.test(query)) {
+        return ROUTE_BY_PRIMITIVE.get("tables") ?? null;
+    }
+    if (/\b(message )?reviews?\b/.test(query))
+        return ROUTE_BY_PRIMITIVE.get("messages") ?? null;
+    if (/\b(tag|tags|label|labels)\b/.test(query))
+        return ROUTE_BY_PRIMITIVE.get("tags") ?? null;
+    if (/\b(disposable|working)\b.{0,30}\b(list|dataset|table)\b|\b(prospect|sourcing) table\b/.test(query)) {
+        return ROUTE_BY_PRIMITIVE.get("tables") ?? null;
+    }
+    if (/\bwhatsapp\b.{0,30}\b(account|connect|limits?|sync)\b/.test(query)) {
+        return ROUTE_BY_ID.get("connected-whatsapp") ?? null;
+    }
+    if (!isNetNewLinkedInInitiation(query)
+        && (/\b(one[ -]off|ad[ -]hoc|just once|reply once|single message|direct message|direct email|no cadence)\b/.test(query)
+            || /\b(reply|respond|follow up)\b.{0,30}\b(conversation|thread|email|linkedin|whatsapp|dm)\b/.test(query))) {
+        return ROUTE_BY_PRIMITIVE.get("messages") ?? null;
+    }
+    if (/\b(my|our|own|connected)\b.{0,40}\blinkedin\b|\b(sales navigator|salesnav|recruiter|profile viewers?|linkedin inbox)\b/.test(query)) {
+        return ROUTE_BY_ID.get("connected-linkedin") ?? null;
+    }
+    if (/\b(publish|schedule|approve)\b.{0,24}\b(post|content)\b|\bcontent calendar\b/.test(query)) {
+        return ROUTE_BY_PRIMITIVE.get("publishing") ?? null;
+    }
+    if (/\b(sequence|campaign|cadence|enroll|nurture)\b/.test(query)
+        || /\b(day\s*\d+|days?\s+\d|multi[ -]step|rotate senders?|sender rotation|stop on reply|until (?:they )?reply)\b/.test(query)) {
+        return ROUTE_BY_PRIMITIVE.get("sequences") ?? null;
+    }
+    if (/\b(reply|respond)\b.{0,30}\b(conversation|thread|email|linkedin|whatsapp|dm)\b/.test(query)) {
+        return ROUTE_BY_PRIMITIVE.get("messages") ?? null;
+    }
+    if (/\b(find emails?|find phones?|find companies|find people|source (?:leads?|a list|companies|people)|build (?:me )?a list|tam|prospect)\b/.test(query)) {
+        return ROUTE_BY_ID.get("sourcing-and-provider-tools") ?? null;
+    }
+    if (/\b(agent|adaptive|goal[ -]directed|persistent thread|checkpoint|standing job)\b/.test(query)) {
+        return ROUTE_BY_PRIMITIVE.get("agents") ?? null;
+    }
+    return null;
+}
+function highestScoringRoute(query) {
+    let best = null;
+    for (const card of OXYGEN_CAPABILITY_ROUTES) {
+        let score = 0;
+        for (const term of card.intentTerms) {
+            if (query.includes(term))
+                score += term.includes(" ") ? 6 : 2;
+        }
+        for (const term of card.negativeTerms ?? []) {
+            if (query.includes(term))
+                score -= term.includes(" ") ? 8 : 3;
+        }
+        if (score > (best?.score ?? 0))
+            best = { card, score };
+    }
+    return best?.card ?? null;
+}
+function recommendationsFor(card, query) {
+    if (card.id === "linkedin-public-research" && isPublicLinkedInEngagerHarvest(query)) {
+        const motion = isLinkedInEngagerMotion(query);
+        return {
+            tools: [
+                ...(motion ? ["oxygen_recipes_list"] : []),
+                "oxygen_engagement_harvest",
+                "oxygen_engagement_harvest_status",
+                "oxygen_tools_search",
+                "oxygen_tools_get",
+                ...(isDeferredLinkedInOutreach(query)
+                    ? ["oxygen_sequences_send", "oxygen_sequences_list"]
+                    : []),
+            ],
+            commands: [
+                ...(motion ? ["recipes list"] : []),
+                "engagement harvest",
+                "engagement status",
+                "tools search",
+                "tools get",
+                ...(isDeferredLinkedInOutreach(query)
+                    ? ["sequences send", "sequences list"]
+                    : []),
+            ],
+        };
+    }
+    if (card.primitive === "tables") {
+        if (/\b(table )?(action )?runs?\b/.test(query)) {
+            return {
+                tools: ["oxygen_table_runs_get", "oxygen_table_runs_items", "oxygen_table_runs_wait", "oxygen_table_runs_retry_failed"],
+                commands: ["table-runs get", "table-runs items", "table-runs wait", "table-runs retry-failed"],
+            };
+        }
+        if (/\b(waterfall|enrich|enrichment|work email|mobile phone)\b/.test(query)) {
+            return {
+                tools: ["oxygen_enrich_column_preview", "oxygen_columns_add", "oxygen_enrich_column_run", "oxygen_table_runs_get"],
+                commands: ["enrich-column preview", "columns add", "enrich-column run", "table-runs get"],
+            };
+        }
+        if (/\b(ai column|classif(?:y|ication)|extract(?:ion)?|scor(?:e|ing)|summari[sz](?:e|ation)|draft(?:ing)?|research)\b/.test(query)) {
+            return {
+                tools: ["oxygen_columns_add", "oxygen_columns_run", "oxygen_tables_describe", "oxygen_context_resolve"],
+                commands: ["columns add", "columns run", "tables describe", "context resolve"],
+            };
+        }
+        if (/\bformula|deterministic transform\b/.test(query)) {
+            return {
+                tools: ["oxygen_formulas_list", "oxygen_formulas_validate", "oxygen_columns_add"],
+                commands: ["formulas list", "formulas validate", "columns add"],
+            };
+        }
+    }
+    if (card.primitive === "messages") {
+        if (/\b(message )?reviews?\b/.test(query)) {
+            return {
+                tools: ["oxygen_reviews_list", "oxygen_reviews_next", "oxygen_reviews_decide"],
+                commands: ["reviews list", "reviews next", "reviews decide"],
+            };
+        }
+        const existingThread = /\b(reply|respond|conversation|thread|inbox|existing)\b/.test(query);
+        if (/\bemail\b/.test(query) && !existingThread) {
+            return {
+                tools: ["oxygen_email_send", "oxygen_inbox_send", "oxygen_messages_query"],
+                commands: ["email send", "inbox send", "messages query"],
+            };
+        }
+    }
+    if (card.primitive === "sequences") {
+        if (isNetNewLinkedInInitiation(query)) {
+            const publicResearch = isPublicLinkedInRead(query);
+            const harvestEngagers = publicResearch && isPublicLinkedInEngagerHarvest(query);
+            return {
+                tools: [
+                    "oxygen_sequences_send",
+                    ...(harvestEngagers
+                        ? ["oxygen_engagement_harvest", "oxygen_engagement_harvest_status"]
+                        : publicResearch
+                            ? ["oxygen_tools_search", "oxygen_tools_get"]
+                            : []),
+                    "oxygen_senders_list",
+                    "oxygen_sequences_list",
+                ],
+                commands: [
+                    "sequences send",
+                    ...(harvestEngagers
+                        ? ["engagement harvest", "engagement status"]
+                        : publicResearch
+                            ? ["tools search", "tools get"]
+                            : []),
+                    "senders list",
+                    "sequences list",
+                ],
+            };
+        }
+        if (/\benroll/.test(query)) {
+            return {
+                tools: ["oxygen_sequences_enroll", "oxygen_sequences_create", "oxygen_sequences_start", "oxygen_sequences_list"],
+                commands: ["sequences enroll", "sequences create", "sequences start", "sequences list"],
+            };
+        }
+        if (/\b(start|launch|run|activate)\b/.test(query)) {
+            return {
+                tools: ["oxygen_sequences_start", "oxygen_sequences_list", "oxygen_sequences_create", "oxygen_sequences_enroll"],
+                commands: ["sequences start", "sequences list", "sequences create", "sequences enroll"],
+            };
+        }
+        return {
+            tools: ["oxygen_sequences_create", "oxygen_sequences_enroll", "oxygen_sequences_start", "oxygen_sequences_list", "oxygen_sequences_send"],
+            commands: ["sequences create", "sequences enroll", "sequences start", "sequences list", "sequences send"],
+        };
+    }
+    if (card.primitive === "workflows") {
+        if (isLinkedInEngagerMotion(query)) {
+            return {
+                tools: [
+                    "oxygen_recipes_list",
+                    "oxygen_blueprints_describe",
+                    "oxygen_blueprints_preflight",
+                    "oxygen_tools_get",
+                    "oxygen_sequences_list",
+                ],
+                commands: [
+                    "recipes list",
+                    "blueprints describe",
+                    "blueprints preflight",
+                    "tools get",
+                    "sequences list",
+                ],
+            };
+        }
+        if (/\b(workflow )?templates?\b/.test(query)) {
+            return {
+                tools: ["oxygen_workflow_templates_search", "oxygen_workflow_templates_describe", "oxygen_workflow_templates_preflight", "oxygen_workflow_templates_apply"],
+                commands: ["workflows templates search", "workflows templates describe", "workflows templates preflight", "workflows templates apply"],
+            };
+        }
+        if (isNetNewLinkedInInitiation(query) || /\b(outreach|sequence|enroll|message)\b/.test(query)) {
+            return {
+                tools: ["oxygen_workflows_schema", "oxygen_workflows_lint", "oxygen_workflows_apply", "oxygen_tools_get", "oxygen_sequences_list", "oxygen_sequences_start"],
+                commands: ["workflows schema", "workflows lint", "workflows apply", "tools get", "sequences list", "sequences start"],
+            };
+        }
+        if (/\b(tail|inspect|status|events?|failures?)\b/.test(query)) {
+            return {
+                tools: ["oxygen_workflows_tail", "oxygen_workflows_list", "oxygen_workflows_call"],
+                commands: ["workflows tail", "workflows list", "workflows call"],
+            };
+        }
+        if (/\b(run|call|execute)\b/.test(query) && !/\b(build|create|author|design|apply)\b/.test(query)) {
+            return {
+                tools: ["oxygen_workflows_call", "oxygen_workflows_tail", "oxygen_workflows_schema"],
+                commands: ["workflows call", "workflows tail", "workflows schema"],
+            };
+        }
+    }
+    if (card.primitive === "signals" && /\blinkedin\b.{0,40}\bengagers?\b/.test(query)) {
+        return {
+            tools: ["oxygen_engagement_list_engagers", "oxygen_signals_list", "oxygen_signals_leads_today"],
+            commands: ["engagement list", "signals list", "signals leads-today"],
+        };
+    }
+    if (card.id === "connected-whatsapp" && /\b(account|connect|limits?|sync)\b/.test(query)) {
+        return {
+            tools: ["oxygen_whatsapp_accounts_list", "oxygen_whatsapp_get", "oxygen_whatsapp_limits_get", "oxygen_whatsapp_connect"],
+            commands: ["whatsapp accounts list", "whatsapp get", "whatsapp limits get", "whatsapp connect"],
+        };
+    }
+    return { tools: [...card.gatewayTools], commands: [...card.gatewayCommands] };
+}
+function isNetNewLinkedInInitiation(query) {
+    const mentionsLinkedIn = /\blinkedin\b|\bdm\b/.test(query);
+    const startsConversation = /\b(send|message|dm|contact|reach out|initiate|start)\b/.test(query)
+        || /\bnew\b.{0,40}\bconversation\b/.test(query);
+    if (!mentionsLinkedIn || !startsConversation)
+        return false;
+    // "Conversation" can describe either side of the boundary. New/start is an
+    // initiation; reply/existing/thread/inbox is continuation state in Messages.
+    if (/\b(reply|respond|existing|thread|inbox)\b/.test(query))
+        return false;
+    return !/\b(sequence|campaign|cadence|enroll|nurture|multi[ -]step|multi[ -]recipient|leads|contacts|recipients|audience|rotate senders?|stop on reply|day\s*\d+)\b/.test(query);
+}
+function isHostedWorkflowIntent(query) {
+    const strongWorkflowLanguage = /\b(workflow|automation|automate|automatically|webhook|cron|event trigger|branching?|retr(?:y|ies)|orchestrat(?:e|ion)|scheduled job|deterministic graph)\b/.test(query);
+    const cadenceLanguage = /\b(sequence|campaign|cadence|day\s*\d+|multi[ -]step|rotate senders?|sender rotation|stop on reply|until (?:they )?reply)\b/.test(query);
+    const workflowMechanics = /\b(webhook|cron|event trigger|triggered by|branching?|retr(?:y|ies)|orchestrat(?:e|ion)|scheduled job|deterministic graph|automatically)\b/.test(query)
+        || /\bwhen\b.{0,50}\b(signs? up|created|updated|changes?|happens?|received)\b/.test(query);
+    if (cadenceLanguage && !workflowMechanics)
+        return false;
+    if (strongWorkflowLanguage)
+        return true;
+    if (cadenceLanguage)
+        return false;
+    return /\b(nightly|hourly|daily|weekly|every (?:monday|tuesday|wednesday|thursday|friday|saturday|sunday|day|night|week|month))\b/.test(query)
+        || (/\bschedule(?:d)?\b/.test(query) && !/\bpost|content\b/.test(query));
+}
+function isPublicLinkedInRead(query) {
+    if (!query.includes("linkedin"))
+        return false;
+    const disclaimsConnectedAccount = /\b(without|no|not using|does not require)\b.{0,24}\bconnected(?: linkedin)? account\b/.test(query);
+    const connectedOwnership = !disclaimsConnectedAccount
+        && /\b(my|our|own|connected|connections|followers|inbox|messages|recruiter|sales\s*navigator|salesnav|unipile|viewers)\b/.test(query);
+    if (connectedOwnership)
+        return false;
+    return /\b(comments?|companies|company|competitor|cookieless|engagers?|harvest|posts?|profiles?|public|reactions?|reactors?|scrape|scraper|search|third[ -]party)\b/.test(query);
+}
+function isPublicLinkedInEngagerHarvest(query) {
+    return /\bpost\b/.test(query)
+        && /\b(engagers?|engaged|react(?:ors?|ing|ed|ions?)|commenters?|harvest)\b/.test(query);
+}
+function isDeferredLinkedInOutreach(query) {
+    if (!isNetNewLinkedInInitiation(query))
+        return false;
+    return /\b(later|eventually|after (?:they|we|i)? ?(?:are )?qualif(?:y|ied)|once (?:they|we|i)? ?(?:are )?qualif(?:y|ied)|prepare|ready)\b/.test(query)
+        || /\bwithout\b.{0,30}\b(?:running|sending|contacting|messaging)\b.{0,20}\b(?:now|today)\b/.test(query)
+        || /\b(?:do not|don t|not)\b.{0,20}\b(?:run|send|contact|message)\b.{0,20}\b(?:now|today)\b/.test(query);
+}
+function isLinkedInEngagerMotion(query) {
+    return isPublicLinkedInEngagerHarvest(query)
+        && /\b(competitor|daily|repeatable|monitor|motion|qualif(?:y|ied)|workflow|later|eventually)\b/.test(query);
+}