@oxygen-agent/cli 1.982.3 → 1.1003.12

package/node_modules/@oxygen/shared/dist/capability-discovery.d.ts

@@ -1,3 +1,4 @@
+import { type EnrichmentIntentTaxonomyEntry } from "./enrichment-intents.js";
 import { type RecipePrimitive } from "./recipes.js";
 export type CapabilityLayer = "Control" | "Knowledge" | "Data" | "Action" | "External";
 export type CapabilityPosture = "read_only" | "workspace_write" | "paid_read" | "external_write" | "mixed";
@@ -29,6 +30,22 @@ export type CapabilityRouteMatch = {
      * intent is that narrow; `recommendedCommands[0]` is the same command.
      */
     exactCommand?: string;
+    /**
+     * The opinionated enrichment catalogue row a data-type ask resolves to
+     * ("get the funding round" -> enrich_company:funding). Present only when
+     * the ask names a data type; the catalogue command is then the first
+     * recommendation, ahead of any raw provider tool.
+     */
+    catalogIntent?: {
+        id: string;
+        label: string;
+        status: EnrichmentIntentTaxonomyEntry["status"];
+        group: EnrichmentIntentTaxonomyEntry["group"];
+        /** The catalogue-first path: read the row, then add/preview; `exactCommand` names the row. */
+        tools: string[];
+        commands: string[];
+        exactCommand: string;
+    };
 };
 export type PrimitiveRouteMatch = CapabilityRouteMatch & {
     card: PrimitiveRouteCard;

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

@@ -1,3 +1,4 @@
+import { findEnrichmentIntentByAlias } from "./enrichment-intents.js";
 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
@@ -210,10 +211,10 @@ export const OXYGEN_CAPABILITY_ROUTES = [
         primitive: "tables",
         owns: "Typed working datasets, rows, formulas, AI/tool/waterfall columns, reusable Functions with isolated drafts and published versions, 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. For standard person or company enrichment, `columns add <table> --preset person_enrich|company_enrich` (MCP oxygen_columns_add with preset) adds the maintained bundle in one call before any hand-built tool column.",
+        execution: "Create and run work in hosted OXYGEN Tables; validate a small sample before bounded paid runs. To see what a table's own columns can be enriched with and what each costs per row before adding anything, run `tools search --for-table <table>` (MCP oxygen_tools_search with for_table): free, it returns priced suggestions with the exact add command. For standard person or company enrichment, `columns add <table> --preset person_enrich|company_enrich` (MCP oxygen_columns_add with preset) adds the maintained bundle in one call before any hand-built tool column. Person questions over that bundle's profile payload (skill set, grad school, location, job fit, current company) and person appearance research (events, keynotes, podcasts, GitHub profile) are `columns catalog --category people` templates, added with `columns add <table> --prompt-key <key> --input <name>=<column>`. For a company fact OXYGEN already knows how to research (founders, parent company, funding, cloud provider, offers demos, industry, NAICS, HQ, LinkedIn/Crunchbase page lookups) or a page extraction, `columns catalog` lists the ready-made template and `columns add <table> --prompt-key <key> --input <name>=<column>` (MCP oxygen_columns_add with prompt_key) adds it with no prompt to write.",
         posture: "mixed",
-        gatewayTools: ["oxygen_tables_create", "oxygen_columns_add", "oxygen_enrich_column_preview", "oxygen_tables_link_bulk", "oxygen_callables_manage"],
-        gatewayCommands: ["tables create", "columns add", "enrich-column preview", "tables link", "functions list", "functions draft"],
+        gatewayTools: ["oxygen_tables_create", "oxygen_tools_search", "oxygen_columns_add", "oxygen_columns_catalog", "oxygen_enrich_column_preview", "oxygen_tables_link_bulk", "oxygen_callables_manage"],
+        gatewayCommands: ["tables create", "tools search", "columns add", "columns catalog", "enrich-column preview", "tables link", "functions list", "functions draft"],
         skills: ["oxygen-gtm", "oxygen-table-tidy", "oxygen-diagnostics", "oxygen-clay-migration", "oxygen-linkedin-marketing"],
         endpointSections: ["action-columns", "callables", "functions", "columns", "company-enrichment", "enrich-column", "enrichment", "projects", "supabase", "table-action-items", "table-action-runs", "table-ingestion-runs", "tables"],
         // "link"/"join"/"connect"/"relate" route here for `tables link`. Added after a
@@ -221,7 +222,12 @@ export const OXYGEN_CAPABILITY_ROUTES = [
         // `tables create` / `columns add` / `enrich-column preview` — none of which
         // do it. The agent only found the right command by grepping the raw 25k-line
         // command manifest, which is not a discovery path a customer has.
-        intentTerms: ["table", "spreadsheet", "rows", "column", "columns", "dataset", "csv", "import", "enrich", "enrichment", "waterfall", "score", "formula", "ai column", "lookup", "link", "link tables", "join", "connect", "relate", "relationship", "function", "functions", "reusable function", "function draft", "function version", "callable"],
+        // "founders" / "parent company" / "cloud provider" / "company research" route
+        // here for `columns catalog`. Added after the 2026-09-16 blind baseline asked
+        // `capabilities search "founders of a company"` and got `route: null` with a
+        // generic sourcing pointer, then hand-wrote four research prompts for
+        // questions the template catalog now answers by key.
+        intentTerms: ["table", "spreadsheet", "rows", "column", "columns", "dataset", "csv", "import", "enrich", "enrichment", "waterfall", "score", "formula", "ai column", "lookup", "link", "link tables", "join", "connect", "relate", "relationship", "function", "functions", "reusable function", "function draft", "function version", "callable", "column template", "skill set", "grad school", "podcast appearance", "keynote", "github profile", "job fit", "founders", "parent company", "subsidiaries", "cloud provider", "company research", "research question", "research column", "web research", "template catalog", "ready-made", "offers demos", "naics", "cost per row", "price per row", "what can i enrich", "enrichment cost", "credits per row"],
     },
     {
         id: "messages",
@@ -269,15 +275,26 @@ export const OXYGEN_CAPABILITY_ROUTES = [
         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"],
+        owns: "The curated funnel, channel, spend and needs-action reporting, PLUS the workspace's own saved dashboards: named pages of chart / view / iframe / rich-text / code / live-source widgets over tables and CRM objects.",
+        notFor: "Arbitrary BI modeling or a separate analytics store. Outreach volume and replies are not chartable yet — group a table or a CRM object, or read the curated funnel with `dashboards summary`.",
+        execution: "Compute hosted curated views over Records, Messages, Signals, Sequences and runs; store and serve user-defined dashboards from ox_dashboards.",
+        // Was `read_only` until v1.1002.0, which is when a workspace could first SAVE a
+        // dashboard. A blind user eval (2026-09-21) caught the drift the expensive way:
+        // the agent asked this router for "dashboard", was told read_only and
+        // "not for BI modeling", and only found the eight mutating commands by
+        // separately searching the command index. This record is step 4 of the CLI's
+        // own quickstart, so a stale posture here routes users away from what shipped.
+        // `mixed`, not workspace_write: this capability now spans a read (summary,
+        // widget data), a workspace write (dashboards, tabs, widgets) AND one
+        // external-reach spending call (a live_source refresh calls its bound
+        // provider). "read_write" is not a member of CapabilityPosture -- inventing
+        // it is what broke the shared build on the first attempt.
+        posture: "mixed",
+        gatewayTools: ["oxygen_dashboard_summary", "oxygen_dashboards_list", "oxygen_dashboards_create", "oxygen_dashboards_widget_kinds", "oxygen_dashboards_widget_add", "oxygen_dashboards_widget_data"],
+        gatewayCommands: ["dashboards summary", "dashboards list", "dashboards create", "dashboards widgets kinds", "dashboards widgets add", "dashboards widgets data"],
         skills: ["oxygen-gtm"],
         endpointSections: ["dashboards"],
-        intentTerms: ["dashboard", "report", "reporting", "funnel", "metrics", "kpi", "performance", "pipeline summary"],
+        intentTerms: ["dashboard", "report", "reporting", "funnel", "metrics", "kpi", "performance", "pipeline summary", "save", "saved dashboard", "custom dashboard", "widget", "chart", "weekly report", "monday", "come back to"],
     },
     {
         id: "ads",
@@ -313,10 +330,15 @@ export const OXYGEN_CAPABILITY_ROUTES = [
         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.",
+        // The external-campaign sentence exists because a 2026-09-16 blind user asked
+        // to "push table rows to smartlead campaign", landed here, read the native
+        // email track's "Only 'instantly' is supported" and concluded Smartlead was
+        // unreachable. The governed path for a campaign the customer already runs
+        // elsewhere is `sequences push-external`; it is not a Sequence.
+        execution: "Use the one-step gateway for new LinkedIn initiation or create/enroll/start a hosted campaign with bounded send authority. To push table rows into an existing Smartlead, Instantly, lemlist or HeyReach campaign you already run, use `sequences push-external` (dry_run preview, then --approved); the native email track of a Sequence stays Instantly-bound.",
         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"],
+        gatewayTools: ["oxygen_sequences_send", "oxygen_sequences_create", "oxygen_sequences_enroll", "oxygen_sequences_start", "oxygen_sequences_list", "oxygen_sequences_push_external"],
+        gatewayCommands: ["sequences send", "sequences create", "sequences enroll", "sequences start", "sequences list", "sequences push-external"],
         skills: ["oxygen-sequencer"],
         endpointSections: ["senders", "sequencer", "sequences", "spintax", "suppressions", "voice"],
         // "sender identity", "sender profile" and "phone number" are here because a
@@ -324,7 +346,7 @@ export const OXYGEN_CAPABILITY_ROUTES = [
         // to workspace-access — "identity" matched the AUTH sense. The nouns a user
         // reaches for when naming a sending identity or the dialing pool have to land
         // on the group that actually owns `senders profiles` and `voice numbers`.
-        intentTerms: ["sequence", "campaign", "cadence", "enroll", "outreach", "linkedin message", "linkedin dm", "nurture", "follow up", "sender rotation", "stop on reply", "sender identity", "sending identity", "sender profile", "phone number", "dialing", "dialer", "call", "cold call"],
+        intentTerms: ["sequence", "campaign", "cadence", "enroll", "outreach", "linkedin message", "linkedin dm", "nurture", "follow up", "sender rotation", "stop on reply", "sender identity", "sending identity", "sender profile", "phone number", "dialing", "dialer", "call", "cold call", "smartlead", "instantly", "lemlist", "heyreach", "external sequencer", "push to campaign", "push rows to campaign", "add leads to campaign"],
     },
     {
         id: "publishing",
@@ -493,6 +515,8 @@ export const OXYGEN_CAPABILITY_ROUTES = [
 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]));
+/** Cards a catalogue row may decorate: the data surfaces, never sequences/posts/billing. */
+const CATALOGUE_CARD_IDS = new Set(["tables", "sourcing-and-provider-tools", "signals"]);
 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();
@@ -518,15 +542,62 @@ export function inferCapabilityRoute(query) {
     if (!normalized)
         return null;
     const explicit = explicitCapabilityIntent(normalized);
-    const card = explicit ?? highestScoringRoute(normalized);
+    const catalogRow = findEnrichmentIntentByAlias(normalized);
+    // Card scoring stays the owner of routing; the catalogue only breaks a
+    // no-match tie ("get the funding round for these accounts" names no card
+    // term) and decorates the data cards it belongs to.
+    const card = explicit ?? highestScoringRoute(normalized) ?? (catalogRow ? cardForCatalogueIntent(catalogRow) : null);
     if (!card)
         return null;
     const recommendations = recommendationsFor(card, normalized);
+    // The card's own recommendations are a pinned contract (tool order, no
+    // exact command on plain enrichment asks); the catalogue path travels
+    // beside them in `catalogIntent`, never inside them.
+    const catalogue = catalogRow && CATALOGUE_CARD_IDS.has(card.id) ? catalogueRecommendations(catalogRow, card) : null;
     return {
         card,
         recommendedTools: recommendations.tools,
         recommendedCommands: recommendations.commands,
         ...(recommendations.exactCommand ? { exactCommand: recommendations.exactCommand } : {}),
+        ...(catalogue && catalogRow
+            ? { catalogIntent: { id: catalogRow.id, label: catalogRow.label, status: catalogRow.status, group: catalogRow.group, tools: catalogue.tools, commands: catalogue.commands, exactCommand: catalogue.exactCommand } }
+            : {}),
+    };
+}
+/**
+ * A data-type ask ("tech stack", "decision makers at each account", "funding
+ * events") owns its card by taxonomy group: person/contact/company rows are
+ * Tables columns, decision-maker rows are the sourcing tools, signal rows are
+ * the signals card when one exists.
+ */
+function cardForCatalogueIntent(row) {
+    if (row.group === "decision_maker")
+        return ROUTE_BY_ID.get("sourcing-and-provider-tools") ?? null;
+    if (row.group === "signal")
+        return ROUTE_BY_ID.get("signals") ?? ROUTE_BY_PRIMITIVE.get("signals") ?? null;
+    return ROUTE_BY_PRIMITIVE.get("tables") ?? null;
+}
+function catalogueRecommendations(row, card) {
+    const exactCommand = `oxygen enrichment catalog --intent ${row.id}`;
+    if (row.group === "decision_maker" || card.id === "sourcing-and-provider-tools") {
+        return {
+            tools: ["oxygen_enrichment_catalog", "oxygen_people_search_plan", "oxygen_people_search_run"],
+            commands: ["enrichment catalog", "people search plan", "people search run"],
+            exactCommand,
+        };
+    }
+    if (row.group === "signal") {
+        return {
+            tools: ["oxygen_enrichment_catalog", "oxygen_signals_search_plan", "oxygen_signals_search_run"],
+            commands: ["enrichment catalog", "signals search plan", "signals search run"],
+            exactCommand,
+        };
+    }
+    const find = row.surfaces.find ? [`oxygen_${row.surfaces.find.replace(/[\s-]+/g, "_")}`] : [];
+    return {
+        tools: ["oxygen_enrichment_catalog", "oxygen_columns_add", "oxygen_enrich_column_preview", ...find],
+        commands: ["enrichment catalog", "columns add", "enrich-column preview", ...(row.surfaces.find ? [row.surfaces.find] : [])],
+        exactCommand,
     };
 }
 export function inferPrimitiveRoute(query) {
@@ -551,6 +622,9 @@ export function serializeCapabilityRoute(route) {
         recommended_commands: route.recommendedCommands,
         recommended_tools: route.recommendedTools,
         ...(route.exactCommand ? { exact_command: route.exactCommand } : {}),
+        ...(route.catalogIntent
+            ? { catalog_intent: { id: route.catalogIntent.id, label: route.catalogIntent.label, status: route.catalogIntent.status, group: route.catalogIntent.group, tools: route.catalogIntent.tools, commands: route.catalogIntent.commands, exact_command: route.catalogIntent.exactCommand } }
+            : {}),
         hydrate: {
             cli: "oxygen commands get <exact-command> --json",
             mcp: "oxygen_capabilities_schema",
@@ -642,6 +716,10 @@ function explicitCapabilityIntent(query) {
     // Monday verify new signups" still lands on Workflows.
     if (isEmailVerificationIntent(query))
         return ROUTE_BY_PRIMITIVE.get("tables") ?? null;
+    // "verify these phone numbers" is a verification column on a table, not a
+    // dialer action; without this the sequences card's call terms win.
+    if (/\b(verify|validate|check)\b[^.]{0,40}\b(phone|mobile)\b/.test(query))
+        return ROUTE_BY_PRIMITIVE.get("tables") ?? null;
     if (/\b(recipe|playbook|proven play|what should i do)\b/.test(query)) {
         return ROUTE_BY_PRIMITIVE.get("recipes") ?? null;
     }
@@ -838,6 +916,16 @@ function recommendationsFor(card, query) {
                 commands: ["tables watcher preview", "tables watcher create", "tables watcher get", "tables watcher update", "tables watcher pause", "tables watcher resume"],
             };
         }
+        if (isCompanyResearchQuestionIntent(query)) {
+            // A fact the template catalog already answers by key: list the keys first
+            // (free), add the column by key (free), then price and run it. Ahead of
+            // the bare "run" noun below, because "which cloud provider does it run
+            // on" is a question about the company, not about a run.
+            return {
+                tools: ["oxygen_columns_catalog", "oxygen_columns_add", "oxygen_columns_run", "oxygen_tables_describe"],
+                commands: ["columns catalog", "columns add", "columns run", "tables describe"],
+            };
+        }
         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"],
@@ -1012,6 +1100,16 @@ function isEmailVerificationIntent(query) {
 // ask ("find companies with a website in Germany") keeps its owner. LinkedIn
 // page recovery is deliberately left to the LinkedIn rules above it, which
 // already resolve company pages through the public-research catalog.
+/**
+ * A company fact the template catalog answers by key — founders, parent company,
+ * subsidiaries, cloud provider, NAICS, demos — and the "ready-made / template
+ * catalog / research question" phrasing itself. Kept to nouns no other card
+ * owns: "funding" alone belongs to Signals and "industry" alone to company
+ * search, so both stay off this list.
+ */
+function isCompanyResearchQuestionIntent(query) {
+    return /\b(founders?|founded by|parent compan(?:y|ies)|subsidiar(?:y|ies)|cloud provider|naics|column templates?|template catalog|ready[- ]made|research question|company research|offers? demos?|gives? demos?)\b/.test(query);
+}
 function isCompanyUrlRecoveryIntent(query) {
     const urlNoun = /\b(websites?|web ?sites?|website urls?|domains?|urls?|homepages?)\b/;
     const companyNoun = /\b(compan(?:y|ies)|accounts?|organi[sz]ations?|brands?|vendors?)\b/;

package/node_modules/@oxygen/shared/dist/column-autofill.d.ts

@@ -0,0 +1,52 @@
+/**
+ * "Did I type this, or did Oxygen?" — the single rule behind the bolt.
+ *
+ * A CRM record mixes two kinds of field in one list: the handful a founder
+ * types (name, stage, owner, a phone they were given) and the majority Oxygen
+ * fills from one paid LinkedIn scrape and the free extractors over its payload.
+ * Reading a record without that distinction, every cell looks equally
+ * authoritative — which is exactly backwards, because a scraped headline and a
+ * hand-corrected job title deserve different trust.
+ *
+ * The grid already marks derived columns in its header (`ColumnDefinitionBadge`)
+ * and the record page did not, so the same field read as enriched in one place
+ * and hand-entered in the other. This is the shared answer both surfaces call.
+ *
+ * The rule is TOTAL over column kinds and deliberately coarse: a bolt means
+ * "you did not type this", and the label says what did. Splitting hairs between
+ * an AI column and a formula over an AI column's payload is an implementation
+ * detail a customer has no reason to hold.
+ */
+/** What produced the value in this column's cells. */
+export type ColumnAutoFillKind = 
+/** A provider call — the paid lanes and everything extracted from their payloads. */
+"enrichment"
+/** A model wrote it (`ai`, `research`). */
+ | "ai"
+/** Computed from other cells on the same row. */
+ | "derived"
+/** Read across a link from another row or record. */
+ | "linked"
+/** Oxygen's own bookkeeping — rollups, sync markers, engagement projections. */
+ | "system";
+export type ColumnAutoFill = {
+    kind: ColumnAutoFillKind;
+    /** One short phrase, shown as the bolt's tooltip. Sentence case, no period. */
+    label: string;
+};
+/** The shape this rule needs. Structural so tenant-db, the web and the CLI all fit. */
+export type AutoFillColumnInput = {
+    kind?: string | null;
+    definition?: Record<string, unknown> | null;
+};
+/**
+ * What filled this column, or `null` when the answer is "a person did".
+ *
+ * `manual` and `source` columns are typed or imported by the workspace.
+ * `relation` and `bind` columns hold links a person or an identity match made,
+ * and the chip already says what it points at — a bolt there would mark the
+ * whole CRM as machine-written.
+ */
+export declare function columnAutoFill(column: AutoFillColumnInput): ColumnAutoFill | null;
+/** True when the column's value comes from outside the workspace's own typing. */
+export declare function isAutoFilledColumn(column: AutoFillColumnInput): boolean;

package/node_modules/@oxygen/shared/dist/column-autofill.js

@@ -0,0 +1,80 @@
+/**
+ * "Did I type this, or did Oxygen?" — the single rule behind the bolt.
+ *
+ * A CRM record mixes two kinds of field in one list: the handful a founder
+ * types (name, stage, owner, a phone they were given) and the majority Oxygen
+ * fills from one paid LinkedIn scrape and the free extractors over its payload.
+ * Reading a record without that distinction, every cell looks equally
+ * authoritative — which is exactly backwards, because a scraped headline and a
+ * hand-corrected job title deserve different trust.
+ *
+ * The grid already marks derived columns in its header (`ColumnDefinitionBadge`)
+ * and the record page did not, so the same field read as enriched in one place
+ * and hand-entered in the other. This is the shared answer both surfaces call.
+ *
+ * The rule is TOTAL over column kinds and deliberately coarse: a bolt means
+ * "you did not type this", and the label says what did. Splitting hairs between
+ * an AI column and a formula over an AI column's payload is an implementation
+ * detail a customer has no reason to hold.
+ */
+function readString(definition, key) {
+    const value = definition?.[key];
+    return typeof value === "string" && value.trim() !== "" ? value : null;
+}
+/**
+ * A `fill: "empty"` formula is not an ordinary calculation. It is the codebase's
+ * "an extracted fact is a FIELD, not a formula" shape: the expression runs once
+ * over an enrichment payload the row already paid for, stores a real typed
+ * value, and leaves a human's correction alone on the next run. To the person
+ * reading the record that is enrichment, not arithmetic.
+ */
+function isExtractedFromPayload(column) {
+    return readString(column.definition, "fill") === "empty";
+}
+/** Name the provider lane when the column declares one, so the tooltip is specific. */
+function enrichmentLabel(column) {
+    const toolId = readString(column.definition, "toolId") ?? readString(column.definition, "tool_id");
+    // Vendor names never reach a customer surface — the managed scraper is a
+    // deliberately vendor-neutral rail (`packages/providers/src/descriptors/scraper.ts`),
+    // and tests fail if the vendor behind it leaks. Speak in terms of the SOURCE.
+    if (toolId?.startsWith("scraper.linkedin"))
+        return "Enriched from LinkedIn";
+    if (toolId)
+        return "Enriched by a data provider";
+    return "Enriched automatically";
+}
+/**
+ * What filled this column, or `null` when the answer is "a person did".
+ *
+ * `manual` and `source` columns are typed or imported by the workspace.
+ * `relation` and `bind` columns hold links a person or an identity match made,
+ * and the chip already says what it points at — a bolt there would mark the
+ * whole CRM as machine-written.
+ */
+export function columnAutoFill(column) {
+    switch (column.kind) {
+        case "tool":
+        case "enrichment":
+            return { kind: "enrichment", label: enrichmentLabel(column) };
+        case "ai":
+            return { kind: "ai", label: "Written by an AI column" };
+        case "research":
+            return { kind: "ai", label: "Researched on the web by AI" };
+        case "formula":
+            return isExtractedFromPayload(column)
+                ? { kind: "enrichment", label: "Extracted from enrichment data" }
+                : { kind: "derived", label: "Calculated from other fields" };
+        case "lookup":
+            return { kind: "linked", label: "Read from a linked record" };
+        case "workflow":
+            return { kind: "system", label: "Written by a workflow" };
+        case "system":
+            return { kind: "system", label: "Maintained by Oxygen" };
+        default:
+            return null;
+    }
+}
+/** True when the column's value comes from outside the workspace's own typing. */
+export function isAutoFilledColumn(column) {
+    return columnAutoFill(column) !== null;
+}

package/node_modules/@oxygen/shared/dist/column-output-fields.js

@@ -26,8 +26,10 @@
  * may contain a dot or a space. Such a field carries `referenceable: false` and
  * is display-only.
  */
-import { buildResearchCellSchema, deriveResearchOutputContract, usesServerManagedResearchSchema, } from "./research-output-contract.js";
+import { buildResearchCellSchema, isResearchEnvelopeSchema, researchEvidenceRequired, deriveResearchOutputContract, usesServerManagedResearchSchema, } from "./research-output-contract.js";
 import { isTemplateSafePath, parseJsonPath, readJsonPath } from "./json-path.js";
+import { isRecord } from "./type-guards.js";
+import { readString } from "./value-readers.js";
 const MAX_FIELDS = 40;
 const MAX_SCHEMA_DEPTH = 5;
 const EMPTY_CONTRACT = {
@@ -36,12 +38,6 @@ const EMPTY_CONTRACT = {
     primaryField: null,
     serverManaged: false,
 };
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readString(value) {
-    return typeof value === "string" && value.trim() ? value.trim() : null;
-}
 export function humanizeFieldSegment(segment) {
     const titled = segment
         .split(/[_\s-]+/)
@@ -263,13 +259,21 @@ function researchContract(definition) {
     const prompt = readString(definition.prompt) ?? "";
     const webSearch = isRecord(definition.webSearch) ? definition.webSearch : null;
     const contract = deriveResearchOutputContract(prompt, {
-        evidenceRequired: webSearch?.evidenceMode === "strict",
+        evidenceRequired: researchEvidenceRequired(webSearch),
     });
     // The STORED shape, not the model-facing one: a research cell carries
-    // `sources`, never the `citations` the model answered with.
+    // `sources`, never the `citations` the model answered with. A column whose
+    // own schema is still the research envelope (a catalog template's typed
+    // answer) gets the same rewrite, so `answer.plan_count` is offered and
+    // `citations` is not; a hand-authored schema that replaced the envelope is
+    // used verbatim, because the cell then holds exactly what it declares.
     const schema = serverManaged
         ? buildResearchCellSchema(contract)
-        : (isRecord(definition.outputSchema) ? definition.outputSchema : null);
+        : isRecord(definition.outputSchema)
+            ? (isResearchEnvelopeSchema(definition.outputSchema)
+                ? buildResearchCellSchema(null, definition.outputSchema)
+                : definition.outputSchema)
+            : null;
     if (!schema)
         return EMPTY_CONTRACT;
     return {

package/node_modules/@oxygen/shared/dist/company-enrichment-fields.d.ts

@@ -0,0 +1,108 @@
+export declare const COMPANY_ENRICHMENT_FIELD_CATEGORIES: readonly ["identity", "firmographics", "funding", "relationships", "signals", "technology", "web_presence"];
+export type CompanyEnrichmentFieldCategory = (typeof COMPANY_ENRICHMENT_FIELD_CATEGORIES)[number];
+export declare const COMPANY_ENRICHMENT_FIELD_CATEGORY_LABELS: Record<CompanyEnrichmentFieldCategory, string>;
+export type CompanyEnrichmentFieldDataType = "text" | "numeric" | "jsonb";
+/**
+ * Where a DERIVED field reads its value from: another field's already-resolved
+ * payload. `autoRun: true` means requesting the derived field on its own fetches
+ * that source first (the source's own lanes run as a pre-step, billed and
+ * disclosed in the plan). `autoRun: false` means the source is consulted only
+ * when the same run resolved it anyway or the row already holds it — never
+ * fetched just for this field, because it would cost more than the field is
+ * worth (a 490-credit funding lookup for a 5-credit Facebook URL).
+ */
+export type CompanyEnrichmentDerivedSource = {
+    field: CompanyEnrichmentFieldKey;
+    autoRun: boolean;
+};
+export type CompanyEnrichmentFieldDefinition = {
+    field: CompanyEnrichmentFieldKey;
+    label: string;
+    category: CompanyEnrichmentFieldCategory;
+    /** ONE founder-voice line, rendered next to the field in every picker. */
+    description: string;
+    /** Default target column key when a table has no matching column. */
+    columnKey: string;
+    dataType: CompanyEnrichmentFieldDataType;
+    /** Semantic type stamped on the created target column, when one applies. */
+    semanticType: string | null;
+    /** Ordered sources a derived field reads; empty for a lane-resolved field. */
+    derivedFrom: readonly CompanyEnrichmentDerivedSource[];
+    /** Extra caller input the field needs before it can answer. */
+    requires?: "check_technologies";
+    /**
+     * `coming_soon` (D51, 2026-09-19): the field keeps its vocabulary entry and
+     * column key so existing columns still render, but it has no provider lane,
+     * no picker group and no `--fields` acceptance until its lane is re-measured.
+     */
+    availability?: "coming_soon";
+};
+export type CompanyEnrichmentFieldKey = "domain" | "linkedin_url" | "headcount" | "industry" | "funding" | "revenue" | "technologies" | "hiring_signals" | "company_profile" | "description" | "founded_year" | "hq_address" | "hq_country" | "logo_url" | "specialties" | "company_type" | "funding_stage" | "latest_funding_round" | "total_funding" | "funding_rounds_count" | "investors" | "competitors" | "corporate_structure" | "parent_company" | "subsidiaries" | "acquisitions" | "news" | "job_openings" | "technology_check" | "crunchbase_url" | "github_url" | "facebook_url" | "instagram_url" | "youtube_url";
+export declare const COMPANY_ENRICHMENT_FIELD_DEFINITIONS: readonly CompanyEnrichmentFieldDefinition[];
+export declare const COMPANY_ENRICHMENT_FIELD_KEYS: readonly CompanyEnrichmentFieldKey[];
+export declare function isCompanyEnrichmentFieldKey(value: string): value is CompanyEnrichmentFieldKey;
+export declare function companyEnrichmentFieldDefinition(field: CompanyEnrichmentFieldKey): CompanyEnrichmentFieldDefinition;
+/** D51: a field parked `coming_soon` has no lane, no picker group and is refused by `--fields`. */
+export declare function isComingSoonCompanyEnrichmentField(field: CompanyEnrichmentFieldKey): boolean;
+/** A field whose value is read out of another field's payload, never a provider call of its own. */
+export declare function isDerivedCompanyEnrichmentField(field: CompanyEnrichmentFieldKey): boolean;
+/**
+ * What `find company` resolves when the caller names no fields. Identity plus
+ * the firmographics that cost nothing beyond the one profile lookup the
+ * headcount/industry lanes already make; funding, relationship and web-presence
+ * fields stay opt-in because each adds a priced lane.
+ */
+export declare const DEFAULT_COMPANY_FIND_FIELDS: readonly CompanyEnrichmentFieldKey[];
+/**
+ * What `columns add --preset company_enrich` creates when the caller names no
+ * fields: the identity/firmographic set plus the full profile and the funding
+ * facts LinkedIn publishes for free off that same profile. Every lane-priced
+ * relationship, signal, technology and web-presence field is opt-in through
+ * `--fields`, so the default bundle's per-row ceiling stays the profile chain's.
+ */
+export declare const DEFAULT_COMPANY_PRESET_FIELDS: readonly CompanyEnrichmentFieldKey[];
+export type CompanyEnrichmentFieldGroupId = "profile_details" | "funding_details" | "job_openings" | "tech_stack" | "technology_check";
+export type CompanyEnrichmentFieldGroup = {
+    id: CompanyEnrichmentFieldGroupId;
+    /** Picker row and catalog label, in customer words. */
+    label: string;
+    /** ONE founder-voice line. No provider names. */
+    description: string;
+    /** The catalog fields this group adds to the company bundle, in column order. */
+    fields: readonly CompanyEnrichmentFieldKey[];
+    /**
+     * What the group does to the per-row bill.
+     *
+     * `included` — every field is read out of the company profile the default
+     * bundle already fetches, so ticking it adds columns and no credits.
+     * `extra` — at least one field has its own provider lookup, so the run can
+     * bill more per row. The exact number depends on which lane answers, which
+     * only a dry run over the real rows can say; no surface quotes one here.
+     */
+    cost: "included" | "extra";
+    /** Set when the group cannot be added without extra caller input. */
+    requires?: "check_technologies";
+};
+/**
+ * The opt-in company fields, grouped the way a customer asks for them ("add
+ * competitors", "add their tech stack"). Every surface that offers a company
+ * field beyond the default bundle reads THIS list: the enrichment column catalog
+ * (`oxygen enrichment catalog`, `oxygen_enrichment_catalog`), the web add-column
+ * picker, and the catalog pricing. Adding a group adds its fields to the SAME
+ * company enrichment column — re-applying the bundle widens the existing
+ * column's field list instead of creating a second paid column.
+ */
+export declare const COMPANY_ENRICHMENT_FIELD_GROUPS: readonly CompanyEnrichmentFieldGroup[];
+export declare function companyEnrichmentFieldGroup(id: string): CompanyEnrichmentFieldGroup | null;
+/**
+ * Parse a comma-separated or array field list against the catalog. Returns the
+ * unique, lowercased keys in request order, or throws naming every unknown
+ * entry with the supported list — never a silent fallback to a default set,
+ * which is how `--fields tech,hiring,profile` once ran the four default fields
+ * and billed for an answer nobody asked for (OXP-7.2.9).
+ */
+export declare function parseCompanyEnrichmentFieldList(value: unknown): {
+    fields: CompanyEnrichmentFieldKey[];
+    unknown: string[];
+    coming_soon: CompanyEnrichmentFieldKey[];
+};