@oxygen-agent/cli 1.987.20 → 1.1010.1

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,62 @@
+import { PROFESSIONAL_NETWORK_DATA_LABEL } from "./data-suppliers.js";
+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");
+    // Name the source and its supplier (Philipp, 2026-09-25: suppliers are named;
+    // data-extraction labels say "Professional Network"). The label comes from
+    // one owner so it cannot drift from the picker and the Connections card.
+    if (toolId?.startsWith("scraper.linkedin"))
+        return `Enriched from ${PROFESSIONAL_NETWORK_DATA_LABEL}`;
+    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-decision.d.ts

@@ -0,0 +1,50 @@
+export declare const COLUMN_DECISION_ENGINE = "system_one";
+export declare const COLUMN_DECISION_MODES: readonly ["labels", "yes_no", "score"];
+export type ColumnDecisionMode = (typeof COLUMN_DECISION_MODES)[number];
+export declare const COLUMN_DECISION_GROUNDINGS: readonly ["workspace", "none"];
+export type ColumnDecisionGrounding = (typeof COLUMN_DECISION_GROUNDINGS)[number];
+export declare const COLUMN_DECISION_MIN_LABELS = 2;
+export declare const COLUMN_DECISION_MAX_LABELS = 20;
+export declare const COLUMN_DECISION_MIN_LEVELS = 2;
+export declare const COLUMN_DECISION_MAX_LEVELS = 10;
+export declare const COLUMN_DECISION_MAX_OPTION_CHARS = 80;
+/** Floors the ADR shipped with: 0.85 for a choice or score, a 70/30 band for yes/no. */
+export declare const COLUMN_DECISION_DEFAULT_MIN_CONFIDENCE: Readonly<Record<ColumnDecisionMode, number>>;
+export declare const COLUMN_DECISION_DEFAULT_FIELD: Readonly<Record<ColumnDecisionMode, string>>;
+/** Keys the cell writes next to the answer field; a field may not reuse one. */
+export declare const COLUMN_DECISION_RESERVED_FIELDS: ReadonlySet<string>;
+export type ColumnDecisionDefinition = {
+    engine: typeof COLUMN_DECISION_ENGINE;
+    mode: ColumnDecisionMode;
+    /** The cell key the answer lands under. */
+    field: string;
+    /** `labels` mode: the options, in the customer's own words. */
+    labels?: string[];
+    /** `score` mode: ordered levels, lowest first. */
+    levels?: string[];
+    /** Below this the answer is kept as a best guess marked uncertain. */
+    minConfidence: number;
+    /** `workspace` sends the column's workspace knowledge slice in the state; `none` (the default) judges the row alone. */
+    grounding: ColumnDecisionGrounding;
+};
+/** A validation failure naming the field, for the normalizer to wrap in its own error type. */
+export declare class ColumnDecisionError extends Error {
+    readonly field: string;
+    readonly value: unknown;
+    constructor(message: string, field: string, value?: unknown);
+}
+/** True for any definition that carries a `decision` object, valid or not. */
+export declare function hasColumnDecision(definition: unknown): boolean;
+/** The stored decision, or null. Assumes the normalizer already validated it. */
+export declare function readColumnDecision(definition: unknown): ColumnDecisionDefinition | null;
+/**
+ * Validate and fill a caller-supplied decision. Throws {@link ColumnDecisionError}
+ * naming the bad field; the caller maps it to its own error envelope.
+ */
+export declare function normalizeColumnDecision(value: unknown): ColumnDecisionDefinition;
+/**
+ * The cell's JSON Schema, derived from the decision so filters, sorts, sub-columns
+ * and `{{column.field}}` references see a typed answer: an enum for labels, a
+ * boolean for yes/no, a number for a score.
+ */
+export declare function columnDecisionOutputSchema(decision: ColumnDecisionDefinition): Record<string, unknown>;

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

@@ -0,0 +1,228 @@
+/**
+ * The classification column contract: an AI column whose `definition.decision`
+ * asks System One (TypeSafe Jev, ADR 0027) a closed question per row instead of
+ * asking a generative model for prose.
+ *
+ * Three modes, one per System One question type:
+ *
+ * - `labels` — pick one of 2–20 customer labels (a `choice`).
+ * - `yes_no` — a yes/no probability (a `noul`). Its confidence is how far the
+ *   probability sits from 50%, so a 0.7 floor means "yes at 70% or more, no at
+ *   30% or less".
+ * - `score`  — rate against 2–10 ordered levels, lowest first (a `score`). The
+ *   value is the vendor's 0-based position, so it sorts and filters as a number.
+ *
+ * The column's own `prompt` is the question. Row values never enter it: the
+ * runner rewrites `{{tokens}}` to bracketed names and sends the values in the
+ * state (ADR 0027 §5). Below the floor the cell keeps the best guess, marked
+ * `uncertain` with its confidence; there is no generative fallback on this
+ * surface (ADR 0027 amendment 2026-09-25).
+ *
+ * Pure and client-safe: the tenant-db normalizer, the runner, the web editor,
+ * the CLI and the MCP server all read the same shape from here.
+ */
+import { isRecord } from "./type-guards.js";
+export const COLUMN_DECISION_ENGINE = "system_one";
+export const COLUMN_DECISION_MODES = ["labels", "yes_no", "score"];
+export const COLUMN_DECISION_GROUNDINGS = ["workspace", "none"];
+export const COLUMN_DECISION_MIN_LABELS = 2;
+export const COLUMN_DECISION_MAX_LABELS = 20;
+export const COLUMN_DECISION_MIN_LEVELS = 2;
+export const COLUMN_DECISION_MAX_LEVELS = 10;
+export const COLUMN_DECISION_MAX_OPTION_CHARS = 80;
+/** Floors the ADR shipped with: 0.85 for a choice or score, a 70/30 band for yes/no. */
+export const COLUMN_DECISION_DEFAULT_MIN_CONFIDENCE = {
+    labels: 0.85,
+    yes_no: 0.7,
+    score: 0.85,
+};
+export const COLUMN_DECISION_DEFAULT_FIELD = {
+    labels: "label",
+    yes_no: "answer",
+    score: "score",
+};
+/** Keys the cell writes next to the answer field; a field may not reuse one. */
+export const COLUMN_DECISION_RESERVED_FIELDS = new Set([
+    "confidence",
+    "uncertain",
+    "reason",
+    "probabilities",
+    "level",
+]);
+const FIELD_SHAPE = /^[a-z][a-z0-9_]{0,39}$/;
+/** A validation failure naming the field, for the normalizer to wrap in its own error type. */
+export class ColumnDecisionError extends Error {
+    field;
+    value;
+    constructor(message, field, value) {
+        super(message);
+        this.name = "ColumnDecisionError";
+        this.field = field;
+        this.value = value;
+    }
+}
+/** True for any definition that carries a `decision` object, valid or not. */
+export function hasColumnDecision(definition) {
+    return isRecord(definition) && isRecord(definition.decision);
+}
+/** The stored decision, or null. Assumes the normalizer already validated it. */
+export function readColumnDecision(definition) {
+    if (!isRecord(definition) || !isRecord(definition.decision))
+        return null;
+    const decision = definition.decision;
+    if (decision.engine !== COLUMN_DECISION_ENGINE)
+        return null;
+    if (!COLUMN_DECISION_MODES.includes(decision.mode))
+        return null;
+    const mode = decision.mode;
+    const field = typeof decision.field === "string" && FIELD_SHAPE.test(decision.field)
+        ? decision.field
+        : COLUMN_DECISION_DEFAULT_FIELD[mode];
+    const minConfidence = typeof decision.minConfidence === "number" && Number.isFinite(decision.minConfidence)
+        ? decision.minConfidence
+        : COLUMN_DECISION_DEFAULT_MIN_CONFIDENCE[mode];
+    const grounding = decision.grounding === "workspace" ? "workspace" : "none";
+    const strings = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+    return {
+        engine: COLUMN_DECISION_ENGINE,
+        mode,
+        field,
+        ...(mode === "labels" ? { labels: strings(decision.labels) } : {}),
+        ...(mode === "score" ? { levels: strings(decision.levels) } : {}),
+        minConfidence,
+        grounding,
+    };
+}
+function readOptionList(value, field, bounds) {
+    const raw = typeof value === "string" ? value.split(",") : value;
+    if (!Array.isArray(raw)) {
+        throw new ColumnDecisionError(`decision.${field} must be a list of strings.`, `decision.${field}`, value);
+    }
+    const options = [];
+    const seen = new Set();
+    for (const entry of raw) {
+        if (typeof entry !== "string") {
+            throw new ColumnDecisionError(`decision.${field} must contain only strings.`, `decision.${field}`, entry);
+        }
+        const option = entry.trim();
+        if (!option)
+            continue;
+        if (option.length > COLUMN_DECISION_MAX_OPTION_CHARS) {
+            throw new ColumnDecisionError(`Each of decision.${field} must be at most ${COLUMN_DECISION_MAX_OPTION_CHARS} characters.`, `decision.${field}`, option);
+        }
+        const folded = option.toLowerCase();
+        if (seen.has(folded)) {
+            throw new ColumnDecisionError(`decision.${field} lists "${option}" twice.`, `decision.${field}`, option);
+        }
+        seen.add(folded);
+        options.push(option);
+    }
+    if (options.length < bounds.min || options.length > bounds.max) {
+        throw new ColumnDecisionError(`decision.${field} needs ${bounds.min}–${bounds.max} entries (got ${options.length}).`, `decision.${field}`, options);
+    }
+    return options;
+}
+/**
+ * Validate and fill a caller-supplied decision. Throws {@link ColumnDecisionError}
+ * naming the bad field; the caller maps it to its own error envelope.
+ */
+export function normalizeColumnDecision(value) {
+    if (!isRecord(value)) {
+        throw new ColumnDecisionError("decision must be an object.", "decision", value);
+    }
+    const engine = value.engine ?? COLUMN_DECISION_ENGINE;
+    if (engine !== COLUMN_DECISION_ENGINE) {
+        throw new ColumnDecisionError(`decision.engine must be "${COLUMN_DECISION_ENGINE}".`, "decision.engine", engine);
+    }
+    const mode = value.mode;
+    if (!COLUMN_DECISION_MODES.includes(mode)) {
+        throw new ColumnDecisionError(`decision.mode must be one of ${COLUMN_DECISION_MODES.join(", ")}.`, "decision.mode", mode);
+    }
+    const decisionMode = mode;
+    const rawField = value.field;
+    let field = COLUMN_DECISION_DEFAULT_FIELD[decisionMode];
+    if (rawField !== undefined && rawField !== null) {
+        if (typeof rawField !== "string" || !FIELD_SHAPE.test(rawField.trim())) {
+            throw new ColumnDecisionError("decision.field must be a lowercase key (letters, digits, underscores; starts with a letter; at most 40 characters).", "decision.field", rawField);
+        }
+        field = rawField.trim();
+    }
+    if (COLUMN_DECISION_RESERVED_FIELDS.has(field)) {
+        throw new ColumnDecisionError(`decision.field cannot be "${field}": the cell already writes that key.`, "decision.field", field);
+    }
+    const floorMin = decisionMode === "yes_no" ? 0.5 : 0.05;
+    let minConfidence = COLUMN_DECISION_DEFAULT_MIN_CONFIDENCE[decisionMode];
+    if (value.minConfidence !== undefined && value.minConfidence !== null) {
+        const raw = value.minConfidence;
+        if (typeof raw !== "number" || !Number.isFinite(raw) || raw < floorMin || raw > 1) {
+            throw new ColumnDecisionError(`decision.minConfidence must be a number from ${floorMin} to 1${decisionMode === "yes_no" ? " for yes/no (0.7 means yes at 70% or more, no at 30% or less)" : ""}.`, "decision.minConfidence", raw);
+        }
+        minConfidence = raw;
+    }
+    // Default `none` (2026-09-25): a classification judges the row against the
+    // column's own question. Workspace knowledge is opt-in, because the ICP slice
+    // turned "is this SaaS?" into "is this our ICP?" in the blind acceptance run
+    // (Stripe came back "other: not a B2B SaaS targeting seed founders").
+    const grounding = value.grounding ?? "none";
+    if (!COLUMN_DECISION_GROUNDINGS.includes(grounding)) {
+        throw new ColumnDecisionError(`decision.grounding must be one of ${COLUMN_DECISION_GROUNDINGS.join(", ")}.`, "decision.grounding", grounding);
+    }
+    if (decisionMode === "labels") {
+        if (value.levels !== undefined) {
+            throw new ColumnDecisionError("decision.levels belongs to score mode; labels mode takes decision.labels.", "decision.levels");
+        }
+        const labels = readOptionList(value.labels, "labels", {
+            min: COLUMN_DECISION_MIN_LABELS,
+            max: COLUMN_DECISION_MAX_LABELS,
+        });
+        return { engine: COLUMN_DECISION_ENGINE, mode: decisionMode, field, labels, minConfidence, grounding: grounding };
+    }
+    if (decisionMode === "score") {
+        if (value.labels !== undefined) {
+            throw new ColumnDecisionError("decision.labels belongs to labels mode; score mode takes decision.levels, lowest first.", "decision.labels");
+        }
+        const levels = readOptionList(value.levels, "levels", {
+            min: COLUMN_DECISION_MIN_LEVELS,
+            max: COLUMN_DECISION_MAX_LEVELS,
+        });
+        return { engine: COLUMN_DECISION_ENGINE, mode: decisionMode, field, levels, minConfidence, grounding: grounding };
+    }
+    if (value.labels !== undefined || value.levels !== undefined) {
+        throw new ColumnDecisionError("yes_no mode takes no labels or levels.", value.labels !== undefined ? "decision.labels" : "decision.levels");
+    }
+    return { engine: COLUMN_DECISION_ENGINE, mode: decisionMode, field, minConfidence, grounding: grounding };
+}
+/**
+ * The cell's JSON Schema, derived from the decision so filters, sorts, sub-columns
+ * and `{{column.field}}` references see a typed answer: an enum for labels, a
+ * boolean for yes/no, a number for a score.
+ */
+export function columnDecisionOutputSchema(decision) {
+    const answer = decision.mode === "labels"
+        ? {
+            type: ["string", "null"],
+            enum: [...(decision.labels ?? []), null],
+            description: "The chosen label (the best guess when uncertain).",
+        }
+        : decision.mode === "yes_no"
+            ? { type: ["boolean", "null"], description: "Yes or no (the best guess when uncertain)." }
+            : {
+                type: ["number", "null"],
+                description: `Position on the scale, 0 (${decision.levels?.[0] ?? "lowest"}) to ${Math.max(0, (decision.levels?.length ?? 1) - 1)} (${decision.levels?.at(-1) ?? "highest"}).`,
+            };
+    const properties = {
+        [decision.field]: answer,
+        ...(decision.mode === "score"
+            ? { level: { type: ["string", "null"], enum: [...(decision.levels ?? []), null], description: "The nearest level." } }
+            : {}),
+        confidence: { type: "number", description: "How sure the classifier is, 0 to 1." },
+        uncertain: { type: "boolean", description: "True when confidence is below the column's floor." },
+        reason: { type: "string", description: "The answer and its confidence in words." },
+    };
+    return {
+        type: "object",
+        additionalProperties: true,
+        properties,
+        required: [decision.field, "confidence", "uncertain", "reason"],
+    };
+}

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

@@ -28,6 +28,8 @@
  */
 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-]+/)

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

@@ -0,0 +1,113 @@
+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 what it says
+ * about the company. Every lane-priced relationship, funding, signal,
+ * technology and web-presence field is opt-in through `--fields`, so the
+ * default bundle's per-row ceiling stays the profile chain's.
+ *
+ * Funding stage and latest round left the default on 2026-09-24 (founder, D55):
+ * the profile lane is Blitz first now, and Blitz's company profile carries no
+ * funding, so on the rows Blitz answers those two columns would sit empty. They
+ * live in the Funding details group instead.
+ */
+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[];
+};