@oxygen-agent/cli 1.1013.61 → 1.1013.93

package/README.md

@@ -34,4 +34,4 @@ oxygen update
 
 For product documentation, visit https://oxygen-agent.com/docs. For support, visit https://oxygen-agent.com.
 
-Version: 1.1013.61
+Version: 1.1013.93

package/dist/index.js

@@ -76,6 +76,7 @@ import { PUBLIC_WEBHOOK_INGRESS_PER_TARGET_PER_MINUTE } from "@oxygen/shared/pla
 import { AI_COLUMN_CREDITS, AI_COLUMN_WEB_SEARCH_TYPICAL_CREDITS } from "@oxygen/shared/pricing-sheet";
 import { TAG_COLORS } from "@oxygen/shared/select-options";
 import { SEQUENCE_LIFECYCLES, sequenceDisplayStatus } from "@oxygen/shared/sequence-lifecycle";
+import { lookupColumnDataType } from "@oxygen/shared/table-field-types";
 import { FILTER_TREE_OPERATORS } from "@oxygen/shared/table-filter-operators";
 import { assertRecipeBundleSafe, assertPortableWorkflowDefinition, assertWorkflowGraphManifest, assertWorkflowManifest, buildRecipeManifest, compileWorkflowDefinition, isAnyWorkflowManifest, isRecipeManifest, isWorkflowDefinition, isWorkflowGraphManifest, isWorkflowManifest, hashPortableWorkflowGraphManifest, WORKFLOW_GRAPH_COMPILER_VERSION, WORKFLOW_GRAPH_MANIFEST_VERSION, } from "@oxygen/workflows";
 import { Command, CommanderError, Option } from "commander";
@@ -7016,7 +7017,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .addCommand(new Command("create")
         .description("Create a table private to the active workspace. Free — 0 Oxygen credits. To create a table and import a file in one step, use `tables import --create <name>`.")
         .argument("<name>", "Display name for the table.")
-        .requiredOption("--columns-json <json>", 'Required nonempty JSON array of column definitions, e.g. [{"key":"name","label":"Name","dataType":"text"},{"key":"domain","label":"Domain","dataType":"text"}]. Inspect an existing shape with `oxygen tables describe <table>`.')
+        .requiredOption("--columns-json <json>", 'Required nonempty JSON array of column definitions, e.g. [{"key":"name","label":"Name","dataType":"text"},{"key":"domain","label":"Domain","dataType":"text"}]. A column may name a field type instead, as `columns add --type` does: {"label":"Stage","type":"select","options":["Lead","Won"]} (text, number, checkbox, date, json, markdown, image, select, multi_select, status). Inspect an existing shape with `oxygen tables describe <table>`.')
         .option("--project <project>", "Project id or slug. Defaults to General.")
         .option("--json", "Print a JSON envelope.")
         .action(async (name, options) => {
@@ -7593,33 +7594,44 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         });
     });
     tablesCommand.addCommand(new Command("relate")
-        .description("Relate two tables: define empty Tables-owned relation columns on the source and target. Then use `oxygen tables link` to populate row-to-row edges. Works on any workspace table; plain tables stay plain and are never registered as CRM objects. Defaults to dry-run.")
+        .description("Link two tables (the web's \"Link to another table\"): creates an empty linked-record column on BOTH tables, so links show and can be removed from either side; matching values are not required. `oxygen tables relate contacts --to accounts --live` names them from the tables (account on contacts, contacts on accounts) and re-running it finds the same link. Then use `oxygen tables link` to populate row-to-row edges. Works on any workspace table; plain tables stay plain and are never registered as CRM objects. Defaults to dry-run.")
         .argument("<table>", "Source table id or slug.")
-        .argument("<slug>", "Relation slug — also the relation column key on the source, such as client.")
-        .requiredOption("--target-table <table>", "Target table id or slug. May also be a CRM object table (companies, people, deals).")
-        .option("--display-name <name>", "Display name for the relation column. Defaults to the slug in Title Case.")
+        .argument("[slug]", "Relation slug — also the relation column key on the source, such as client. Omit it to name the relation from the target table (or reuse the one relation that already links them).")
+        .option("--to <table>", "Table to link to: id or slug. May also be a CRM object table (companies, people, deals).")
+        .option("--target-table <table>", "Same as --to.")
+        .option("--display-name <name>", "Display name for the relation column. Defaults to the target table's name, or the slug in Title Case when you name the slug.")
         .option("--cardinality <cardinality>", "one_to_one, one_to_many, many_to_one, or many_to_many (source:target). Default many_to_many. one_to_many means each source row links many target rows and each target row links back to one source.")
-        .option("--inverse-slug <slug>", "Inverse relation slug on the target; also creates the inverse relation column there.")
+        .option("--inverse-slug <slug>", "Key of the linked-record column on the target table. Defaults to a name from the source table; a standard CRM object target (companies, people, deals) gets no column there.")
         .option("--inverse-display-name <name>", "Display name for the inverse side.")
         .option("--dry-run", "Preview the relation plan without writing.")
         .option("--live", "Apply the relation. Default is dry-run.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, slug, options) => {
-        await handleAsyncAction("tables relate", options, () => requestOxygen("/api/cli/tables/relations", {
-            method: "POST",
-            body: {
-                table,
-                relationship: {
-                    slug,
-                    target_table: options.targetTable,
-                    ...(options.displayName ? { display_name: options.displayName } : {}),
-                    ...(options.cardinality ? { cardinality: options.cardinality } : {}),
-                    ...(options.inverseSlug ? { inverse_slug: options.inverseSlug } : {}),
-                    ...(options.inverseDisplayName ? { inverse_display_name: options.inverseDisplayName } : {}),
+        await handleAsyncAction("tables relate", options, () => {
+            const to = readOption(options.to);
+            const targetTable = readOption(options.targetTable);
+            if (to && targetTable && to !== targetTable) {
+                throw new OxygenError("invalid_request", "--to and --target-table name different tables; pass one.", { exitCode: 1 });
+            }
+            if (!to && !targetTable) {
+                throw new OxygenError("invalid_request", "Name the table to link to with --to <table>.", { exitCode: 1 });
+            }
+            return requestOxygen("/api/cli/tables/relations", {
+                method: "POST",
+                body: {
+                    table,
+                    relationship: {
+                        ...(readOption(slug) ? { slug: readOption(slug) } : {}),
+                        target_table: to ?? targetTable,
+                        ...(options.displayName ? { display_name: options.displayName } : {}),
+                        ...(options.cardinality ? { cardinality: options.cardinality } : {}),
+                        ...(options.inverseSlug ? { inverse_slug: options.inverseSlug } : {}),
+                        ...(options.inverseDisplayName ? { inverse_display_name: options.inverseDisplayName } : {}),
+                    },
+                    mode: options.live ? "live" : "dry_run",
                 },
-                mode: options.live ? "live" : "dry_run",
-            },
-        }));
+            });
+        });
     }))
         .addCommand(new Command("relations")
         .description("Inspect and manage native Tables-owned relation definitions.")
@@ -9803,7 +9815,7 @@ Examples:
         .command("columns")
         .description("Workspace table column commands. Price first: `tools search --for-table <table>` lists every enrichment this table's columns support with its credit cost per row (0 credits). Ready-made templates (pricing pages, job posts, event pages, 10-Ks, website facts, market questions, text extraction, plus free 0-credit cleanups — company names, job titles, email type, text to list; person questions over an enriched LinkedIn profile and person appearances; company research questions — founders, parent company, funding, cloud provider, offers demos, industry, NAICS, HQ and footprint, LinkedIn/Crunchbase/careers page lookups): `columns catalog`, then `columns add <table> --prompt-key <key> --input <name>=<column>`. Column choice guide: the oxygen-tables skill (`oxygen skills get oxygen-tables --json`); enrichment presets and waterfalls: the oxygen-enrichment skill. With --json parse stdout only: the envelope is stdout, and the spend and cost notes (`estimated N credits for a live run`) are stderr, so merging the streams breaks the JSON.")
         .addCommand(new Command("add")
-        .description("Add a nullable column, a catalog template (--prompt-key) or a multi-column enrichment bundle (--preset) to a workspace table. Writes the definition only — this never runs the column and never spends credits; use `columns run` for that, with --dry-run first to see the cost. For a page, posting or filing the row already links to, or a company fact Oxygen already knows how to research (founders, parent company, funding, cloud provider, offers demos, industry, NAICS, HQ, a LinkedIn or Crunchbase page), pick a template from `columns catalog` (--prompt-key) instead of writing a prompt; or read a URL column with --kind research --research-url. The guide is the oxygen-tables skill (`oxygen skills get oxygen-tables --json`). For ICP fit, use Classify Score: `columns add <table> --label 'ICP fit' --score 'low,medium,high' --prompt 'Assess {{company_name}}: {{description}}, {{employees}} employees' --grounding workspace` (0.075 credits/row). A formula column needs no run at all: it evaluates on read from its current inputs, so `tables query` shows its values immediately.")
+        .description("Add a nullable column, a catalog template (--prompt-key) or a multi-column enrichment bundle (--preset) to a workspace table. Writes the definition only — this never runs the column and never spends credits; use `columns run` for that, with --dry-run first to see the cost. For a page, posting or filing the row already links to, or a company fact Oxygen already knows how to research (founders, parent company, funding, cloud provider, offers demos, industry, NAICS, HQ, a LinkedIn or Crunchbase page), pick a template from `columns catalog` (--prompt-key) instead of writing a prompt; or read a URL column with --kind research --research-url. The guide is the oxygen-tables skill (`oxygen skills get oxygen-tables --json`). For ICP fit, use Classify Score: `columns add <table> --label 'ICP fit' --score 'low,medium,high' --prompt 'Assess {{company_name}}: {{description}}, {{employees}} employees' --grounding workspace` (0.075 credits/row). A formula column needs no run at all: it evaluates on read from its current inputs, so `tables query` shows its values immediately. A plain field is --type: text, number, checkbox, date, json, markdown, image, or a choice column — select, multi_select or status, with --options \"Lead,Contacted,Won\". To link another table row to row, use `oxygen tables relate <table> --to <other-table> --live`; to read a value out of one, --lookup-table.")
         .argument("<table>", "Table id or slug.")
         .option("--preset <preset>", "Add a pre-built column bundle instead of one column, which is what --prompt-key adds: a preset writes SEVERAL columns at once and needs no --input on a table whose identity column it can find, while --prompt-key adds one template column and binds each input you name. Presets: `person_enrich` (one LinkedIn profile lookup — Blitz first, the LinkedIn Scraper only when Blitz has no match — then first/last/full name, current company and its LinkedIn URL, job title, start date, education, school, headline, bio, location and followers as free stored fields that fill when the lookup runs, followers only on rows the LinkedIn Scraper answers because Blitz publishes none; the person templates in `columns catalog --category people` all read its payload column), `company_enrich` (one company lookup from a domain or LinkedIn URL — Blitz first, the LinkedIn Scraper only when Blitz has no match, about 1 credit a company — keeping the whole profile in its JSON column plus name, domain, LinkedIn URL, headcount, industry, description, founded year and HQ country as free stored fields; no field choices; binds to the person preset's current_company_linkedin_url automatically), `company_tech_stack` (the technologies a company runs, from its website and hiring), `company_funding` (total raised, latest round, number of rounds and investors), `company_revenue` (an annual revenue estimate), `company_hiring` (the roles a company is hiring for, with a count) — each of these four is one paid lookup column that fills its own columns, priced per row in `tools search --for-table` — or `domain_check` (1 credit/row for a live/redirect/parked/not_found/dead verdict on every domain, cached 30 days, plus a free label column to filter on). For a single cleaned or classified column, use a template from `columns catalog` instead — that is one column, not a bundle. Name the input column with --input: `url` for person_enrich, `domain` and/or `linkedin_url` for the company presets. Any column works whatever it is called; without --input Oxygen guesses from column names. Creating the columns is free; run them afterwards, --dry-run first.")
         .option("--input <slot=column...>", "Bind a preset or template input to an exact column, e.g. --input url=pricing_url with --prompt-key, or --input domain=website --input linkedin_url=company_li with --preset. Repeatable. For a preset it is only needed when the automatic match is wrong or missing; for a template it names the column each declared input reads.", collectRepeatable, [])
@@ -9829,7 +9841,11 @@ Examples:
         .option("--research-mode <mode>", "Research columns: how tightly the answer is bound to the sources. Default: summarize and combine what they say. strict: answer only from what a source states verbatim (for figures and identifiers). estimate: reason to a figure from the evidence (for revenue or headcount).")
         .option("--research-results <n>", "Research columns: how many search results to ground each row on (1-25, default 5). More evidence costs no extra search, but a larger prompt.")
         .option("--research-engine <engine>", "Research columns: pin the search provider (serper or exa), or with --research-url the page-fetch provider (firecrawl or exa). Defaults to serper for search and firecrawl for fetch, falling back automatically. Most users should not set this.")
-        .option("--semantic-type <type>", "Optional semantic type such as company_domain.")
+        .option("--type <type>", "Field type, the web picker's names: text, number, checkbox, date, json, markdown, image, select, multi_select or status. Sets kind manual with the matching data and semantic type (multi_select stores jsonb); text/number/checkbox/date/json also work as a data type beside --kind.")
+        .option("--options <choices>", "Choices for a select, multi_select or status column, comma-separated, in display order, e.g. \"Lead,Contacted,Replied,Won\". Each value is what a cell stores; colors are assigned. Use --options-json for labels or colors.")
+        .option("--options-json <json>", "Choices as a JSON array of strings or {value,label?,color?} objects (colors: gray, red, orange, amber, yellow, green, teal, blue, indigo, purple, pink). value is what a cell stores; label is what the grid shows.")
+        .option("--description <text>", "A note on the column, shown in its header and the column editor.")
+        .option("--semantic-type <type>", "Optional semantic type: a display hint such as company.domain or person.email, or a choice type (select, multi_select, status) — --type sets those for you.")
         .option("--definition-json <json>", "Optional JSON object with column definition metadata. Required for --kind formula as a flat object: {\"expression\":\"trim(company_name)\"}. Check the expression with `formulas validate` first.")
         .option("--prompt <text-or-file>", "AI or research column prompt, or a path to a prompt file — a value that resolves to a readable file is read as one, matching --prompt everywhere else in this CLI. On its own it sets kind=ai; pair it with --kind research to make it a Web Research Agent that searches the web per row. If the prompt names its output sections — a line reading 'Return the following sections:' followed by 'Score: ...', 'Reasoning: ...' — the column answers in exactly that shape and each section becomes a referenceable sub-column; otherwise it answers in plain text. Use --no-structured-output to keep it plain text either way. Reference other columns inline as {{column_key}} — no --input-mapping needed; unknown keys are rejected here instead of failing per row. Merges into --definition-json (the escape hatch for everything else); a `prompt` in both is an error.")
         .option("--prompt-key <key>", "Add a column template from `oxygen columns catalog` (e.g. pricing_plan_summary_v1 reads a pricing-page URL column and returns plan count, price range and enterprise plan; company_founders_v1 reads a domain column and returns the founders with sources; person_skill_set_v1 reads the person_enrich payload column with --input profile=person_enrich). Materializes the template's prompt, output schema and grounding and sets its kind (ai, research, formula, or search — a managed web search whose cell is a page URL). Bind each declared input with --input <name>=<column_key>.")
@@ -9894,8 +9910,8 @@ Examples:
             // A preset names its own columns, so --label does not apply to it.
             const preset = readOption(options.preset);
             if (preset) {
-                if (options.label || options.promptKey || options.definitionJson) {
-                    throw new OxygenError("invalid_request", "--preset builds its own column set. Drop --label/--prompt-key/--definition-json, or add the column by hand without --preset.", { exitCode: 1 });
+                if (options.label || options.promptKey || options.definitionJson || options.type || options.options || options.optionsJson) {
+                    throw new OxygenError("invalid_request", "--preset builds its own column set. Drop --label/--prompt-key/--definition-json/--type/--options, or add the column by hand without --preset.", { exitCode: 1 });
                 }
                 // Named only when passed: the classification flags are hidden from help.
                 const classificationFlag = options.classify ? "--classify" : options.yesNo ? "--yes-no" : options.score ? "--score" : null;
@@ -9966,8 +9982,22 @@ Examples:
                 column.kind = options.kind;
             if (options.semanticType)
                 column.semantic_type = options.semanticType;
-            if (options.definitionJson)
-                column.definition = parseJsonObject(options.definitionJson);
+            // --description joins --definition-json in one assignment: a second
+            // self-spread of column.definition multiplies the parity scanner's work.
+            const description = readOption(options.description);
+            if (options.definitionJson || description) {
+                column.definition = {
+                    ...(options.definitionJson ? parseJsonObject(options.definitionJson) : {}),
+                    ...(description ? { description } : {}),
+                };
+            }
+            // A field type and its choices travel as themselves; the server
+            // resolves them exactly as the web picker's rows do.
+            if (readOption(options.type))
+                column.type = readOption(options.type);
+            const choices = readColumnOptionsFlags(options);
+            if (choices)
+                column.options = choices;
             const requestedKind = readOption(options.kind)?.toLowerCase() ?? null;
             const isResearch = requestedKind === "research";
             if (capability)
@@ -10058,15 +10088,11 @@ Examples:
                 const lookupDefinition = applyLookupColumnConfig(definition, options);
                 column.definition = lookupDefinition;
                 // Derive the output data type from the mode so callers don't have to know
-                // it (the bind lesson): count/aggregate -> numeric, exists -> boolean,
-                // first_match -> jsonb (holds a scalar OR the multi-return object).
+                // it (the bind lesson), with the web editor's rule: count/aggregate ->
+                // numeric, exists -> boolean, first_match -> text for one return column,
+                // jsonb for several. Sent explicitly so an older server agrees too.
                 if (!options.dataType) {
-                    const mode = typeof lookupDefinition.mode === "string" ? lookupDefinition.mode : "first_match";
-                    column.data_type = mode === "count" || mode === "aggregate"
-                        ? "numeric"
-                        : mode === "exists"
-                            ? "boolean"
-                            : "jsonb";
+                    column.data_type = lookupColumnDataType(lookupDefinition.mode ?? "first_match", lookupDefinition.returnColumns);
                 }
             }
             const body = { table, column };
@@ -10268,12 +10294,26 @@ Examples:
         });
     }))
         .addCommand(new Command("update")
-        .description("Update a workspace column: label and visibility, and for AI/research columns the prompt, named inputs, model, reasoning level, run condition, output schema, and web-research settings.")
+        .description("Update a workspace column: label, note, position and visibility; a choice column's options; a lookup or bind column's source, join and mode; and for AI/research columns the prompt, named inputs, model, reasoning level, run condition, output schema, and web-research settings.")
         .argument("<table>", "Table id or slug.")
         .argument("<column>", "Column id or key.")
         .option("--label <label>", "New display label.")
-        .option("--semantic-type <type>", "New semantic type.")
+        .option("--semantic-type <type>", "New semantic type: a display hint such as company.domain, or a choice type (select, multi_select, status) to give a column options.")
         .option("--clear-semantic-type", "Clear the column's semantic type.")
+        .option("--options <choices>", "Replace a select, multi_select or status column's choices, comma-separated in display order. Cells keep the values they hold; keep a value in the list to keep it selectable.")
+        .option("--options-json <json>", "Replacement choices as a JSON array of strings or {value,label?,color?}. Rename a choice by giving the same value a new label.")
+        .option("--description <text>", "Replace the column's note.")
+        .option("--lookup-table <table>", "Lookup columns: read from this source table instead; pass --lookup-match with it, since the join column belongs to the source.")
+        .option("--lookup-match <pair>", "Lookup columns: new join as localColumn=sourceColumn.")
+        .option("--lookup-normalize <mode>", "Lookup columns: key normalization exact, lower-trim, email, domain, or linkedin.")
+        .option("--lookup-mode <mode>", "Lookup columns: first-match, count, exists, or aggregate. The column's data type follows the mode.")
+        .option("--lookup-return <csv>", "Lookup columns: the source columns first-match returns.")
+        .option("--lookup-order <column:dir>", "Lookup columns: first-match tie-break, e.g. created_at:desc.")
+        .option("--lookup-aggregate <fn:column>", "Lookup columns: aggregate reducer as fn:column (sum, avg, min or max).")
+        .option("--bind-object <slug>", "Bind columns: resolve rows to this CRM object instead (companies, people, deals, ...).")
+        .option("--bind-map <pairs>", "Bind columns: identity=column pairs to add or change, e.g. domain=website.")
+        .option("--bind-create", "Bind columns: create a CRM record for unmatched rows (a truth write; runs need --approved).")
+        .option("--no-bind-create", "Bind columns: leave unmatched rows unbound.")
         .option("--position <n>", "Move the column to this zero-based position.")
         .option("--definition-json <json>", "Definition metadata to shallow-merge into the column; arrays are replaced wholesale and missing keys leave existing fields unchanged.")
         .option("--definition-unset <keys>", "Comma-separated definition keys to REMOVE after the merge (e.g. outputSchema,model) — a merge can only add or overwrite. Lifecycle and provenance keys are rejected.")
@@ -10341,10 +10381,33 @@ Examples:
             // the server SHALLOW-merges `definition`, so a nested inputMapping
             // sent through --definition-json adds keys and can never remove one.
             // This replaces the object wholesale.
+            // Every flag below adds whole keys, merged into `definition` ONCE. The
+            // surface-parity scanner re-reads each assignment that spreads a
+            // variable into itself, so stacking `definition = { ...definition }`
+            // assignments multiplied its work 13x and timed the gate out (#5086).
+            const additions = {};
             const inputMapping = readOption(options.inputMapping);
-            if (inputMapping) {
-                definition = { ...(definition ?? {}), inputMapping: parseJsonObject(inputMapping) };
+            if (inputMapping)
+                additions.inputMapping = parseJsonObject(inputMapping);
+            const description = readOption(options.description);
+            if (description)
+                additions.description = description;
+            // Lookup and bind flags edit the STORED configuration: the server merges
+            // `definition` one level deep, so a partial `match` would replace the
+            // whole join. Read the column, apply the flags over it, send the result.
+            const editsLookup = hasLookupColumnFlags(options);
+            const editsBind = Boolean(readOption(options.bindObject) || readOption(options.bindMap))
+                || typeof options.bindCreate === "boolean";
+            if (editsLookup || editsBind) {
+                const stored = await readStoredColumnForUpdate(table, column);
+                if (editsLookup)
+                    Object.assign(additions, lookupDefinitionEdit(stored, options));
+                if (editsBind)
+                    Object.assign(additions, bindDefinitionEdit(stored, options));
             }
+            if (Object.keys(additions).length > 0)
+                definition = { ...(definition ?? {}), ...additions };
+            const choices = readColumnOptionsFlags(options);
             await assertColumnDefinitionReferences(table, definition);
             // Sent beside `definition`, never inside it: the server merges the
             // depth into the column's STORED search block, so it cannot drop a
@@ -10355,6 +10418,7 @@ Examples:
                 body: {
                     table,
                     column,
+                    ...(choices ? { options: choices } : {}),
                     ...(researchDepth ? { research_depth: researchDepth } : {}),
                     ...(readOption(options.label) ? { label: readOption(options.label) } : {}),
                     ...(options.clearSemanticType ? { semantic_type: null } : readOption(options.semanticType) ? { semantic_type: readOption(options.semanticType) } : {}),
@@ -10379,7 +10443,7 @@ Examples:
         .argument("<table>", "Table id or slug.")
         .argument("<column>", "Column id or key.")
         .requiredOption("--to <target>", "agent (Web Research Agent), ai (AI column, no web access) or keyword (Keyword search).")
-        .option("--prompt <text>", "Keyword search to agent only: the question the agent answers for each row.")
+        .option("--prompt <text>", "Keyword search to agent only: the question the agent answers for each row. Defaults to the column's saved search, as the web's mode switch does.")
         .option("--yes", "Convert, clearing the column's current results.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, column, options) => {
@@ -10409,7 +10473,7 @@ Examples:
         .description("Convert a manual text column to a stronger data type, migrating stored values.")
         .argument("<table>", "Table id or slug.")
         .argument("<column>", "Column id or key.")
-        .requiredOption("--data-type <type>", "Target data type: text, numeric, boolean, or timestamptz.")
+        .requiredOption("--data-type <type>", "Target data type: text, numeric, boolean, jsonb, or timestamptz (the web's Data type choices).")
         .option("--dry-run", "Preview the conversion (row counts and samples) without writing.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, column, options) => {
@@ -21092,10 +21156,20 @@ async function uploadCopilotAttachment(sessionId, filePath) {
     }
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), 300_000);
+    // Content-Type is bound into the storage signature. Older tickets omit the
+    // SDK's binary default; newer tickets supply every required upload header.
+    const uploadHeaders = { "content-type": "application/octet-stream" };
+    if (isRecord(upload.headers)) {
+        for (const [name, value] of Object.entries(upload.headers)) {
+            if (typeof value === "string")
+                uploadHeaders[name] = value;
+        }
+    }
     let putResponse;
     try {
         putResponse = await fetch(uploadUrl, {
             method: "PUT",
+            headers: uploadHeaders,
             body: new Uint8Array(fileBuffer),
             signal: controller.signal,
         });
@@ -22110,6 +22184,70 @@ function applyLookupColumnConfig(definition, options) {
         definition.aggregate = aggregate;
     return definition;
 }
+// `--options a,b,c` or `--options-json '[...]'`: a choice column's option list in
+// the shape the server's `options` field takes (strings or {value,label,color}).
+function readColumnOptionsFlags(options) {
+    const csv = readOption(options.options);
+    const json = readOption(options.optionsJson);
+    if (csv && json) {
+        throw new OxygenError("invalid_request", "Pass --options or --options-json, not both.", { exitCode: 1 });
+    }
+    if (json)
+        return parseJsonArray(json);
+    if (!csv)
+        return null;
+    return csv.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function hasLookupColumnFlags(options) {
+    return Boolean(readOption(options.lookupTable)
+        || readOption(options.lookupMatch)
+        || readOption(options.lookupNormalize)
+        || readOption(options.lookupMode)
+        || readOption(options.lookupReturn)
+        || readOption(options.lookupOrder)
+        || readOption(options.lookupAggregate));
+}
+async function readStoredColumnForUpdate(table, column) {
+    const describe = await requestOxygen("/api/cli/tables/describe", { method: "POST", body: { table, include_archived: true } });
+    const stored = (describe.columns ?? []).find((entry) => entry.key === column || entry.id === column);
+    if (!stored) {
+        throw new OxygenError("column_not_found", `Column ${column} was not found on ${table}.`, {
+            details: { table, column },
+            exitCode: 1,
+        });
+    }
+    return stored;
+}
+function storedDefinitionCopy(stored) {
+    return isRecord(stored.definition) ? structuredClone(stored.definition) : {};
+}
+function pickDefinitionKeys(definition, keys) {
+    return Object.fromEntries(keys.filter((key) => definition[key] !== undefined).map((key) => [key, definition[key]]));
+}
+// `columns update --lookup-*`: the same flags as `columns add`, applied over the
+// stored lookup so a partial edit (only the normalization, only the mode) keeps
+// the rest of the join. A new source table needs its own join column.
+function lookupDefinitionEdit(stored, options) {
+    if (stored.kind !== "lookup") {
+        throw new OxygenError("invalid_request", `--lookup-* flags edit a lookup column, and ${stored.key} is a ${stored.kind ?? "plain"} column.`, { details: { column: stored.key, kind: stored.kind ?? null }, exitCode: 1 });
+    }
+    if (readOption(options.lookupTable) && !readOption(options.lookupMatch)) {
+        throw new OxygenError("invalid_request", "--lookup-table changes the source table, so pass --lookup-match localColumn=sourceColumn with it: the join column belongs to the source table.", { exitCode: 1 });
+    }
+    const next = applyLookupColumnConfig(storedDefinitionCopy(stored), options);
+    return pickDefinitionKeys(next, ["version", "sourceTable", "match", "inputMapping", "mode", "returnColumns", "orderBy", "aggregate"]);
+}
+// `columns update --bind-*`: applied over the stored binding; --bind-map adds or
+// changes identities and keeps the others (`--input-mapping` replaces them all).
+function bindDefinitionEdit(stored, options) {
+    if (stored.kind !== "bind") {
+        throw new OxygenError("invalid_request", `--bind-* flags edit a bind column, and ${stored.key} is a ${stored.kind ?? "plain"} column.`, { details: { column: stored.key, kind: stored.kind ?? null }, exitCode: 1 });
+    }
+    const next = applyBindColumnConfig(storedDefinitionCopy(stored), options);
+    if (options.bindCreate === false)
+        next.onNoMatch = "none";
+    return pickDefinitionKeys(next, ["version", "object", "inputMapping", "onNoMatch"]);
+}
 // Parse a `tables promote --map` value into the wire mappings [{column, attribute}].
 // Accepts the CSV pair form `column=attribute,column2=attribute2` (LHS is the working
 // column, RHS the CRM attribute — the reverse of --bind-map's identity=column), a

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

@@ -1082,6 +1082,9 @@ function routeCardFor(card, query) {
     const maintenance = card.primitive === "tables" ? tableMaintenanceRecommendation(query) : null;
     if (maintenance)
         card = { ...card, execution: maintenance.execution };
+    const structure = card.primitive === "tables" && !maintenance ? tableStructureRecommendation(query) : null;
+    if (structure)
+        card = { ...card, posture: "workspace_write", execution: structure.execution };
     const read = card.primitive === "tables" ? tableReadRecommendation(query) : null;
     if (read)
         card = { ...card, execution: read.execution };
@@ -1639,6 +1642,49 @@ function tableMaintenanceRecommendation(query) {
     }
     return null;
 }
+/**
+ * Column structure the web's column editor and "Link to another table" own:
+ * linking two tables, plain and choice field types with their options, and a
+ * lookup or bind column's configuration. All of it was reachable from the CLI
+ * and MCP, but generic table discovery ranked `tables create` first (2026-10-10:
+ * "link two tables" put `tables relate` tenth, and the Copilot, asked for a
+ * select column, decided the API had none). Sort, rank and order wording stays
+ * with the value-order read above.
+ */
+function tableStructureRecommendation(query) {
+    if (isFunctionIntent(query) || isSecondPartyDecisionIntent(query)
+        || /\b(workflows?|agents?|campaigns?|sequences?|crm|views?|kanban|sort\w*|order\w*|rank\w*|runs?|credits?)\b/.test(query))
+        return null;
+    const edits = /\b(change|edit|update|rename|recolou?r|replace|remove|delete|existing)\b/.test(query);
+    const pair = (add, update) => {
+        const [first, second] = edits ? [update, add] : [add, update];
+        return { tools: [first[0], second[0]], commands: [first[1], second[1]] };
+    };
+    if (/\b(link\w*|connect\w*|relat\w*|join\w*)\b/.test(query)
+        && /\btables\b|\btable\b.{0,40}\btable\b|\blinked.records?\b|\blinked.record.columns?\b/.test(query))
+        return {
+            tools: ["oxygen_tables_relate", "oxygen_tables_link", "oxygen_tables_link_bulk", "oxygen_tables_relations"],
+            commands: ["tables relate", "tables link", "tables relations list"],
+            execution: "Link two Tables like the web's Link to another table: tables relate <table> --to <other> (oxygen_tables_relate) creates an empty linked-record column on BOTH tables; no matching values are needed and plain tables never become CRM objects. Then link rows one pair at a time with tables link <table> <row_id> --relation <slug> --target-row-id <id> (oxygen_tables_link), or by matching values with tables link <table> --to <other> (oxygen_tables_link_bulk: free preview, then approved). tables relations list|update|archive manages it. 0 credits.",
+        };
+    if (/\b(lookups?|look up|vlookup)\b/.test(query) && /\b(columns?|tables?)\b/.test(query))
+        return {
+            ...pair(["oxygen_columns_add", "columns add"], ["oxygen_columns_update", "columns update"]),
+            execution: "A lookup column reads another Table by a key: columns add <table> --lookup-table <source> --lookup-match <local>=<source_column> with --lookup-mode first-match|count|exists|aggregate, --lookup-return, --lookup-normalize, --lookup-order or --lookup-aggregate (MCP oxygen_columns_add kind lookup). Edit one with the same flags on columns update; they apply over the stored join, and the data type follows the mode. Free; reads resolve live. To link rows instead, tables relate.",
+        };
+    if (/\b(bind|binding)\b/.test(query) && /\bcolumns?\b/.test(query))
+        return {
+            ...pair(["oxygen_columns_add", "columns add"], ["oxygen_columns_update", "columns update"]),
+            execution: "A bind column resolves each row to a CRM record: columns add <table> --bind-object companies --bind-map domain=<column> (MCP kind bind, definition.object and inputMapping). columns update --bind-object/--bind-map/--bind-create edits it over the stored binding. Creating records on no match is a truth write that needs an approved run.",
+        };
+    if (/\b(columns?|fields?)\b/.test(query)
+        && /\b(select|single.select|multi.?select|dropdown|picklist|status|choices?|options?|checkbox|date|number|markdown)\b/.test(query))
+        return {
+            ...pair(["oxygen_columns_add", "columns add"], ["oxygen_columns_update", "columns update"]),
+            execution: "Add a plain field by its type, the web picker's names: columns add <table> --label <label> --type select|multi_select|status|text|number|checkbox|date|json|markdown|image, with --options \"A,B,C\" for a choice type (MCP oxygen_columns_add column.type, choices in definition.options). Replace a choice column's options with columns update --options (MCP options); cells store each value, so a rename is a new label on the same value. Setting a cell is a row write. 0 credits.",
+        };
+    return null;
+}
 /** Stored conversation drafts are Messages data, rather than worker queue health. */
 function storedReplyDraftReadRecommendation(query) {
     if (!/\bdrafts?\b/.test(query)
@@ -2447,6 +2493,9 @@ function recommendationsFor(card, query) {
         const maintenance = tableMaintenanceRecommendation(query);
         if (maintenance)
             return maintenance;
+        const structure = tableStructureRecommendation(query);
+        if (structure)
+            return structure;
         if (isTableCapacityReadIntent(query))
             return {
                 tools: ["oxygen_limits_show", "oxygen_tables_query", "oxygen_tables_describe"],

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

@@ -1,5 +1,6 @@
 /** Browser resource operations, using the same scoped handlers on every surface. */
-import { arr, bool, enumOf, int, nullable, num, obj, str } from "./schema.js";
+import { TABLE_FIELD_TYPES } from "../table-field-types.js";
+import { arr, bool, enumOf, int, jsonValue, nullable, num, obj, str } from "./schema.js";
 import { TABLE_ROW_READ_WINDOW_FIELDS } from "./table-row-read.js";
 import { TABLE_ROW_REMOVAL_FIELDS } from "./table-row-removal.js";
 const text = (description) => str(description ? { description } : {});
@@ -68,7 +69,7 @@ export const BROWSER_OPERATIONS = [
     operation("tables.resource.column_stats", `${table}/column-stats`, "GET", "tables column-stats", "oxygen_table_column_stats", "tables", "Read per-column completion and provider statistics; large Tables use labeled samples."),
     operation("tables.resource.fill_progress", `${table}/fill-progress`, "GET", "tables fill-progress", "oxygen_table_fill_progress", "tables", "Read hosted Table fill progress and any actionable ingestion failure."),
     operation("tables.resource.kind_estimates", "/api/cli/tables/column-kind-estimates", "GET", "columns kind-estimates", "oxygen_column_kind_estimates", "tables", "Read managed credit estimates for available Table column kinds."),
-    operation("tables.resource.columns.create", `${table}/columns`, "POST", "columns create", "oxygen_table_column_create", "tables", "Create a Table column at an optional zero-based position.", { column: obj({ label: text(), key: text(), kind: text(), data_type: dataType(), semantic_type: text(), definition: json }, { required: ["label"] }), position: int({ minimum: 0 }) }, ["column"]),
+    operation("tables.resource.columns.create", `${table}/columns`, "POST", "columns create", "oxygen_table_column_create", "tables", "Create a Table column at an optional zero-based position; type is a field type, and a choice type takes options (cells store each value).", { column: obj({ label: text(), key: text(), kind: text(), type: enumOf(TABLE_FIELD_TYPES), options: arr(jsonValue()), data_type: dataType(), semantic_type: text(), definition: json }, { required: ["label"] }), position: int({ minimum: 0 }) }, ["column"]),
     operation("tables.resource.columns.edit", column, "PATCH", "columns edit", "oxygen_table_column_edit", "tables", "Save a column's label, type, order or definition. Returns downstream reference warnings rather than silently discarding them.", { label: text(), semantic_type: nullable(text()), definition: json, definition_unset: strings(), data_type: dataType(), position: int({ minimum: 0 }) }),
     operation("tables.resource.columns.archive", `${column}/archive`, "POST", "columns archive", "oxygen_columns_archive", "tables", "Archive a Table column indefinitely while preserving its stored values.", {}, [], nativeCli),
     operation("tables.resource.columns.duplicate", `${column}/duplicate`, "POST", "columns duplicate", "oxygen_table_column_duplicate", "tables", "Duplicate a Table column and its definition with an optional new label.", { label: text() }),
@@ -84,8 +85,8 @@ export const BROWSER_OPERATIONS = [
     operation("tables.resource.rows.delete", `${table}/rows/{row}`, "DELETE", "tables rows remove", "oxygen_table_row_remove", "tables", "Remove one row from a workspace Table."),
     operation("tables.resource.rows.bulk_delete", `${table}/rows/delete`, "POST", "tables rows remove-selection", "oxygen_table_rows_remove_selection", "tables", "Permanently delete Table rows by a readable filter tree, exact ids or a matching selection. Unsupported scope fields are refused.", TABLE_ROW_REMOVAL_FIELDS, [], {}, { destructiveHint: true }),
     operation("tables.resource.rows.ids", `${table}/rows/ids`, "GET", "tables rows range-ids", "oxygen_table_rows_range_ids", "tables", "Resolve a bounded row range into exact ids, preserving the current filter, search, sort and CRM scope.", { offset: int({ minimum: 0 }), limit: int({ minimum: 1 }), filter: text(), search: text(), sort: text(), crm_object: text() }, ["offset", "limit"]),
-    operation("tables.resource.relationships.get", `${table}/records/{row}/relationships`, "GET", "tables rows relationships", "oxygen_table_row_relationships", "crm", "Read a CRM-backed Table row's relationship links and available targets."),
-    operation("tables.resource.relationships.set", `${table}/records/{row}/relationships`, "POST", "tables rows relationship-set", "oxygen_table_row_relationship_set", "crm", "Set one CRM-backed Table row's relationship and return the saved links.", { relationship: text(), target_row_id: text() }, ["relationship", "target_row_id"]),
+    operation("tables.resource.relationships.get", `${table}/records/{row}/relationships`, "GET", "tables rows relationships", "oxygen_table_row_relationships", "crm", "Read one Table row's linked records, across Table relations and CRM relationships, and the relations it can link through."),
+    operation("tables.resource.relationships.set", `${table}/records/{row}/relationships`, "POST", "tables rows relationship-set", "oxygen_table_row_relationship_set", "crm", "Link one Table row to a target row through a relation (Table or CRM) and return the link.", { relationship: text("Relation slug: the linked-record column key."), target_row_id: text("Row id in the related table.") }, ["relationship", "target_row_id"]),
     operation("tables.resource.views.list", `${table}/views`, "GET", "tables views list", "oxygen_tables_views_list", "tables", "List saved Table views and their complete display configuration.", {}, [], nativeCli),
     operation("tables.resource.views.create", `${table}/views`, "POST", "tables views create", "oxygen_tables_views_create", "tables", "Create a saved Table view; group_by configures the same kanban grouping as the browser.", viewFields, ["name"], nativeCli),
     operation("tables.resource.views.edit", `${table}/views/{view}`, "PATCH", "tables views update", "oxygen_tables_views_update", "tables", "Edit a saved view's name, type, configuration, grouping, order or default status.", viewFields, [], nativeCli),

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

@@ -90,7 +90,7 @@ export const CUSTOMER_OPERATIONS = [
     operation("tables.import.preview", "/api/cli/tables/import-preview", "POST", "tables import-preview", "oxygen_tables_import_preview", "tables", "Preview a staged file's headers, rows and existing-table mapping; writes no imported rows.", { storage_key: text(), file_name: text(), format: enumOf(["csv", "json", "xlsx"]), byte_length: int({ minimum: 1 }), table: text(), upsert_key: text() }, ["storage_key", "byte_length"], { mutates: false }),
     operation("tables.import.staged", "/api/cli/tables/import-staged", "POST", "tables import-staged", "oxygen_tables_import_staged", "tables", "Start a durable hosted import from this workspace's staged file; choose an existing table or create_name.", { table: text(), create_name: text(), project: text(), storage_key: text(), storage_bucket: text(), storage_provider: enumOf(["s3"]), file_name: text(), format: enumOf(["csv", "json", "xlsx"]), sha256: text(), upsert_key: text(), source_key_map: json, byte_length: int({ minimum: 1 }), row_count: int({ minimum: 1 }), max_concurrency: int({ minimum: 1, maximum: 1000 }), source: enumOf(["cli", "mcp", "web"]), batch_size: int({ minimum: 1, maximum: 5000 }) }, ["storage_key", "byte_length"]),
     operation("tables.import.file", "/api/cli/tables/import-file", "POST", "tables import-file", "oxygen_tables_import_file", "tables", "Import small base64 file bytes through the shared multipart import API; use staged upload for large files.", { content_base64: text(), file_name: text(), content_type: text(), table: text(), table_name: text(), project: text(), format: enumOf(["csv", "json", "xlsx"]), sheet: text(), upsert_key: text(), source_key_map: json, source_hash: text(), batch_size: int({ minimum: 1, maximum: 5000 }), max_concurrency: int({ minimum: 1 }) }, ["content_base64", "file_name"], { multipart: { contentField: "content_base64", nameField: "file_name", typeField: "content_type", fileField: "file" } }),
-    operation("tables.link.suggest", "/api/cli/tables/link/suggest", "POST", "tables link-suggest", "oxygen_tables_link_suggest", "tables", "Plan column links and matching row counts between Tables; creates no relation. Apply with tables link bulk.", TABLE_LINK_SUGGEST_CONTRACT.properties, ["table", "to"], { mutates: false }),
+    operation("tables.link.suggest", "/api/cli/tables/link/suggest", "POST", "tables link-suggest", "oxygen_tables_link_suggest", "tables", "Plan column links and matching row counts between Tables; creates no relation. Apply with tables link --to (MCP oxygen_tables_link_bulk).", TABLE_LINK_SUGGEST_CONTRACT.properties, ["table", "to"], { mutates: false }),
     operation("tables.recover_pending", "/api/cli/tables/recover-pending", "POST", "tables recover-pending", "oxygen_tables_recover_pending", "tables", "Recover BetterContact email/phone requests and read verification blockers; no new orders or imports.", TABLE_RECOVER_PENDING_CONTRACT.properties, ["table"], { ...mcpOnly, annotations: { openWorldHint: true } }),
     operation("tables.webhooks.create", "/api/cli/tables/webhooks", "POST", "tables webhook create", "oxygen_table_webhook_create", "tables", "Create an inbound Table webhook or platform LinkedIn feed. Optional auto_run is standing permission with explicit or plan-default delivery ceilings.", { table: text(), name: text(), mode: enumOf(["insert", "upsert"]), upsert_key: text(), items_path: text(), event_id_path: text(), event_type_path: text(), occurred_at_path: text(), auth_mode: enumOf(["none", "secret"]), feed_kind: enumOf(["generic", "unipile"]), unipile_account_id: text(), event_types: list(), mapping: text(), auto_run: json }, ["table"], mcpOnly),
     operation("tables.webhooks.update", "/api/cli/tables/webhooks", "PATCH", "tables webhook update", "oxygen_table_webhook_update", "tables", "Edit a Table webhook's name, state or standing auto_run; auth_mode=secret rotates its secret and returns it once.", { endpoint_id: text(), name: text(), status: enumOf(["active", "disabled"]), auth_mode: enumOf(["none", "secret"]), auto_run: json, clear_auto_run: bool() }, ["endpoint_id"], mcpOnly),

package/node_modules/@oxygen/shared/dist/hosted-ai.d.ts

@@ -46,9 +46,7 @@ export type HostedAiModelSpec = {
     /** Ordered fallback model ids tried when `model` is unavailable. */
     fallbackModels: readonly string[];
     /**
-     * OpenRouter reasoning effort to request; omit entirely for models that only
-     * support their max mode (Kimi K3) — the request builder sends no reasoning
-     * param for those.
+     * OpenRouter reasoning effort to request; omit to use the provider default.
      */
     reasoningEffort?: "low" | "medium" | "high";
     /**
@@ -224,8 +222,10 @@ export declare function redactManagedModelIds<T>(value: T, options?: {
  */
 export declare function hostedAiDefaultModels(useCase: HostedAiUseCase): Record<HostedAiLevel, string>;
 /**
- * Whether the hosted copilot is enabled for this environment. FAIL CLOSED: only
- * the exact strings "1" or "true" (case-insensitive, trimmed) enable it;
- * anything else — unset, "", "0", "false" — leaves it off.
+ * Staff dev experiment: only the authoritative selfhost-dev deployment and an
+ * explicit enable flag can run Copilot. NODE_ENV and request hosts cannot open
+ * it; production and shadow remain closed even with an enabled flag.
  */
 export declare function isCopilotEnabled(env?: Record<string, string | undefined>): boolean;
+/** Historical cost reconciliation may settle receipts without running Copilot. */
+export declare function isCopilotAccountingEnabled(env?: Record<string, string | undefined>): boolean;

package/node_modules/@oxygen/shared/dist/hosted-ai.js

@@ -22,7 +22,8 @@
  */
 export const HOSTED_AI_MODEL_REGISTRY = {
     /**
-     * Managed AI-column tiers, re-picked 2026-09-26 on measured evidence
+     * Historical calibration of the September AI-column tiers, re-picked
+     * 2026-09-26 on measured evidence (Balanced and Max refreshed below)
      * (Philipp, 2026-09-26: Clay-level quality, faster, 30-50% cheaper than Clay,
      * and at least 5x markup on AI and research columns -- with one explicit
      * founder exception for Max, below).
@@ -46,7 +47,7 @@ export const HOSTED_AI_MODEL_REGISTRY = {
      *   Balanced  deepseek-v4.1-flash, no reasoning  4.23      0.0079 (0.60x v4-pro @ $0.0132)     4    ~5.1x
      *   Max       gpt-6-sol                    4.13 (5th; fastest, 1-3 s)  0.098            25   ~2.5x
      *
-     * Balanced runs with reasoning OFF (`disableReasoning`): on the prod-shaped
+     * September Balanced ran with reasoning OFF (`disableReasoning`): on the prod-shaped
      * set it cost $0.00141/row against reasoning-on v4-pro's $0.00235 with
      * classify, extract and research accuracy unchanged (100%; research citations
      * 90%). With reasoning on it would not clear 5x at 4 credits.
@@ -74,8 +75,11 @@ export const HOSTED_AI_MODEL_REGISTRY = {
      * models answered $49, including Luna, V4.1 Flash and Sol; Gemini 3.8 Flash
      * (Max's fallback) was one of the four that did not.
      *
-     * `reasoningEffort` is deliberately unset on every tier; the only reasoning
-     * control measured for columns is Balanced's off switch above.
+     * Refresh approved 2026-10-10: Balanced now uses Haiku 5.5 medium and Max
+     * uses Sol 6.1 medium; Fast and all customer credit prices stay unchanged.
+     * The measurements above describe the September models, not a bakeoff of
+     * these replacements. Selection/pricing evidence: oxygen-knowledge/wiki/ops/
+     * Background AI Model Selection 2026-10.md. No new inference spend was used.
      * Retired ids live in LEGACY_MANAGED_AI_COLUMN_MODELS.
      */
     ai_column: {
@@ -88,18 +92,19 @@ export const HOSTED_AI_MODEL_REGISTRY = {
             maxOutputTokens: 4096,
         },
         medium: {
-            model: "deepseek/deepseek-v4.1-flash",
+            model: "anthropic/claude-haiku-5.5",
             displayName: "Oxygen Balanced",
-            fallbackModels: ["openai/gpt-6-luna"],
-            estPromptUsdPerM: 0.3,
-            estCompletionUsdPerM: 1.2,
+            fallbackModels: ["deepseek/deepseek-v4.1-flash"],
+            reasoningEffort: "medium",
+            estPromptUsdPerM: 0.1,
+            estCompletionUsdPerM: 0.5,
             maxOutputTokens: 4096,
-            disableReasoning: true,
         },
         high: {
-            model: "openai/gpt-6-sol",
+            model: "openai/gpt-6.1-sol",
             displayName: "Oxygen Max",
             fallbackModels: ["google/gemini-3.8-flash"],
+            reasoningEffort: "medium",
             estPromptUsdPerM: 2,
             estCompletionUsdPerM: 10,
             maxOutputTokens: 4096,
@@ -114,8 +119,9 @@ export const HOSTED_AI_MODEL_REGISTRY = {
          * cache WRITE on a fresh model, ten times a turn. Models only change below
          * this thread, where the context is fresh -- see COPILOT_ERRAND_LEVEL.
          *
-         * `reasoningEffort: "medium"` is the change that made this tier worth
-         * shipping. Until 2026-09-21 this model was sent with NO `reasoning` field at
+         * Before the 2026-10-10 Sol refresh, Auto ran Kimi K3. Its
+         * `reasoningEffort: "medium"` made that tier worth shipping.
+         * Until 2026-09-21 Kimi was sent with NO `reasoning` field at
          * all, on a registry comment asserting K3 was max-reasoning-only. Measured
          * against the live API on the same prompt and tool schema, that claim was
          * false and the omission was the expensive case:
@@ -129,16 +135,14 @@ export const HOSTED_AI_MODEL_REGISTRY = {
          * surface where output is ~61% of the bill.
          */
         auto: {
-            model: "moonshotai/kimi-k3",
+            model: "openai/gpt-6.1-sol",
             displayName: "Oxygen Auto",
-            // z-ai/glm-5.3 rather than the old moonshotai/kimi-k2.6: k2.6 advertises
-            // `reasoning` but NOT `reasoning_effort`, and caps at 262k context, so
-            // falling back to it silently dropped both the dial above and three
-            // quarters of the window. GLM-5.3 keeps both and caches automatically.
-            fallbackModels: ["z-ai/glm-5.3"],
+            // Approved 2026-10-10 for NEW sessions. Existing sessions retain their
+            // persisted resolved_model; Kimi's priced spec survives under high.
+            fallbackModels: ["anthropic/claude-sonnet-5.5"],
             reasoningEffort: "medium",
-            estPromptUsdPerM: 1.7,
-            estCompletionUsdPerM: 8.5,
+            estPromptUsdPerM: 2,
+            estCompletionUsdPerM: 10,
             maxOutputTokens: 8192,
         },
         low: {
@@ -183,10 +187,10 @@ export const HOSTED_AI_MODEL_REGISTRY = {
         },
         /**
          * Retained only for sessions created before "Oxygen Auto" shipped, whose
-         * `reasoning_level` is already 'high' on the row. Same model as `auto`, and
-         * it now carries the same effort dial -- the old "K3 is max-only" comment
-         * here was measured false (see `auto`), and an existing session should not
-         * keep paying for the omission just because it started earlier.
+         * `reasoning_level` is already 'high' on the row, and for Auto sessions
+         * pinned to Kimi before the 2026-10-10 refresh. Keep its pricing, effort
+         * and GLM fallback so changing the new-session default never switches an
+         * existing conversation's model or loses its prompt cache.
          */
         high: {
             model: "moonshotai/kimi-k3",
@@ -239,6 +243,8 @@ export const LEGACY_MANAGED_AI_COLUMN_MODELS = {
     "deepseek/deepseek-v4-flash": "low",
     "deepseek/deepseek-v4-pro": "medium",
     "moonshotai/kimi-k2.6": "high",
+    "deepseek/deepseek-v4.1-flash": "medium",
+    "openai/gpt-6-sol": "high",
 };
 /**
  * Managed model ids OXYGEN ran that never sat in the registry above, mapped to
@@ -445,6 +451,11 @@ function managedModelLabels(preferredUseCase, env = typeof process === "undefine
             labels.set(model, level === "AUTO" ? COPILOT_TIER_LABELS.auto : MANAGED_AI_TIER_LABELS[level.toLowerCase()]);
         }
     }
+    // Historical Copilot events carry a model id without their session's level.
+    // Keep Kimi's former Auto label when reading those events after the refresh;
+    // session payloads use their persisted reasoning_level instead.
+    if (!labels.has("moonshotai/kimi-k3"))
+        labels.set("moonshotai/kimi-k3", COPILOT_TIER_LABELS.auto);
     const useCases = Object.keys(HOSTED_AI_MODEL_REGISTRY);
     const ordered = preferredUseCase
         ? [preferredUseCase, ...useCases.filter((useCase) => useCase !== preferredUseCase)]
@@ -579,11 +590,17 @@ export function hostedAiDefaultModels(useCase) {
     };
 }
 /**
- * Whether the hosted copilot is enabled for this environment. FAIL CLOSED: only
- * the exact strings "1" or "true" (case-insensitive, trimmed) enable it;
- * anything else — unset, "", "0", "false" — leaves it off.
+ * Staff dev experiment: only the authoritative selfhost-dev deployment and an
+ * explicit enable flag can run Copilot. NODE_ENV and request hosts cannot open
+ * it; production and shadow remain closed even with an enabled flag.
  */
 export function isCopilotEnabled(env = process.env) {
+    if (env.OXYGEN_DEPLOY_ENV?.trim().toLowerCase() !== "selfhost-dev")
+        return false;
+    return isCopilotAccountingEnabled(env);
+}
+/** Historical cost reconciliation may settle receipts without running Copilot. */
+export function isCopilotAccountingEnabled(env = process.env) {
     const raw = env.OXYGEN_COPILOT_ENABLED;
     if (typeof raw !== "string")
         return false;

package/node_modules/@oxygen/shared/dist/staff.d.ts

@@ -0,0 +1,2 @@
+/** Staff authorization uses configured email domains, never a workspace role. */
+export declare function isStaffEmail(email: string | null | undefined, env?: Record<string, string | undefined>): boolean;

package/node_modules/@oxygen/shared/dist/staff.js

@@ -0,0 +1,12 @@
+/** Staff authorization uses configured email domains, never a workspace role. */
+export function isStaffEmail(email, env = process.env) {
+    if (!email)
+        return false;
+    const at = email.lastIndexOf("@");
+    if (at <= 0)
+        return false;
+    const domain = email.slice(at + 1).toLowerCase();
+    return (env.OXYGEN_STAFF_EMAIL_DOMAINS ?? "")
+        .split(",")
+        .some((entry) => entry.trim().toLowerCase() === domain && domain.length > 0);
+}

package/node_modules/@oxygen/shared/dist/table-field-types.d.ts

@@ -0,0 +1,46 @@
+import { type SelectOption } from "./select-options.js";
+export declare const TABLE_FIELD_TYPES: readonly ["text", "number", "checkbox", "date", "json", "markdown", "image", "select", "multi_select", "status"];
+export type TableFieldType = (typeof TABLE_FIELD_TYPES)[number];
+export type TableFieldDataType = "text" | "numeric" | "boolean" | "timestamptz" | "jsonb";
+/** The canonical field type for a spelling, or null when it is not one. */
+export declare function resolveTableFieldType(raw: unknown): TableFieldType | null;
+/**
+ * Whether a field type only describes how the value is STORED. Those compose
+ * with every column kind (`type: "text"` beside `kind: "ai"` keeps meaning the
+ * data type, as it always did on `tables create`); a type with a semantic is a
+ * manual field of its own.
+ */
+export declare function isDataOnlyTableFieldType(type: TableFieldType): boolean;
+export declare function tableFieldTypeTakesOptions(type: TableFieldType): boolean;
+export declare function tableFieldTypeDataType(type: TableFieldType): TableFieldDataType;
+export declare function tableFieldTypeSemantic(type: TableFieldType): string | null;
+export type TableFieldTypeColumn = {
+    kind: "manual";
+    dataType: TableFieldDataType;
+    semanticType: string | null;
+    definition: {
+        options?: SelectOption[];
+    };
+};
+/**
+ * The stored column a field type creates. A choice type always carries an
+ * `options` array (empty when none were given), exactly as the picker seeds
+ * it, so the editor opens on an option list rather than a missing one.
+ */
+export declare function tableFieldTypeColumn(type: TableFieldType, options?: unknown): TableFieldTypeColumn;
+export type LookupResultDataType = "text" | "numeric" | "boolean" | "jsonb";
+/**
+ * The data type a lookup column gets for its mode when nobody chose one: the
+ * web editor's rule, shared so `columns add` and `columns update` on the CLI
+ * and MCP derive the same type instead of leaving text in place and failing at
+ * run time. count/aggregate are numbers, exists is a boolean, a first_match
+ * returning one column is that value as text, and several (or none chosen yet)
+ * are an object.
+ */
+export declare function lookupColumnDataType(mode: unknown, returnColumns: unknown): LookupResultDataType;
+/**
+ * Whether a stored data type can hold a lookup's result: the run validator's
+ * rule (`validateTableActionLookupColumn` in @oxygen/tenant-db). A single-return
+ * first_match fits any type, so editing one never forces a retype.
+ */
+export declare function lookupDataTypeFits(mode: unknown, returnColumns: unknown, dataType: string): boolean;

package/node_modules/@oxygen/shared/dist/table-field-types.js

@@ -0,0 +1,126 @@
+// One vocabulary for a Table column's FIELD TYPE: the plain data and choice
+// columns the web "+ Add column" picker offers (Text, Number, Checkbox, Date,
+// JSON, Markdown, Select, Multi-select, Status) plus the editor's "Display as
+// image". Every authoring surface resolves a `type` through here, so a Select
+// column made by the CLI, MCP, the Copilot or the picker is the same stored
+// column: kind manual, data type text, semantic type select, options in its
+// definition.
+//
+// Why it exists (2026-10-10): the Workspace Copilot, asked for a relationship-
+// stage select column, concluded "plain select isn't supported by the API" and
+// made a text column. The API could always store one, but only as a
+// kind + data_type + semantic_type + definition.options combination that no
+// schema named, and multi-select additionally needs jsonb. A type name is the
+// thing a person or an agent actually asks for.
+//
+// CLIENT-SAFE LEAF: the web picker imports it; keep runtime imports to
+// ./select-options.
+import { normalizeSelectOptions } from "./select-options.js";
+export const TABLE_FIELD_TYPES = [
+    "text",
+    "number",
+    "checkbox",
+    "date",
+    "json",
+    "markdown",
+    "image",
+    "select",
+    "multi_select",
+    "status",
+];
+const SHAPES = {
+    text: { dataType: "text", semanticType: null, takesOptions: false },
+    number: { dataType: "numeric", semanticType: null, takesOptions: false },
+    checkbox: { dataType: "boolean", semanticType: null, takesOptions: false },
+    date: { dataType: "timestamptz", semanticType: null, takesOptions: false },
+    json: { dataType: "jsonb", semanticType: null, takesOptions: false },
+    markdown: { dataType: "text", semanticType: "markdown", takesOptions: false },
+    image: { dataType: "text", semanticType: "image", takesOptions: false },
+    select: { dataType: "text", semanticType: "select", takesOptions: true },
+    // A multi-select cell is a list, so it is stored as jsonb; the picker has
+    // always seeded it that way, and a text multi-select cannot hold its values.
+    multi_select: { dataType: "jsonb", semanticType: "multi_select", takesOptions: true },
+    status: { dataType: "text", semanticType: "status", takesOptions: true },
+};
+// Accepted spellings. A column `type` on `tables create` has always meant its
+// data type, so every data type and data-type alias the tenant normalizer
+// accepts resolves to the field type that stores it (`url`/`email` are text
+// there too). The rest are the picker's ids and the obvious variants.
+const ALIASES = {
+    numeric: "number",
+    boolean: "checkbox",
+    timestamptz: "date",
+    jsonb: "json",
+    url: "text",
+    email: "text",
+    single_select: "select",
+    multiselect: "multi_select",
+};
+/** The canonical field type for a spelling, or null when it is not one. */
+export function resolveTableFieldType(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const normalized = raw.trim().toLowerCase().replace(/[\s-]+/g, "_");
+    if (TABLE_FIELD_TYPES.includes(normalized))
+        return normalized;
+    return ALIASES[normalized] ?? null;
+}
+/**
+ * Whether a field type only describes how the value is STORED. Those compose
+ * with every column kind (`type: "text"` beside `kind: "ai"` keeps meaning the
+ * data type, as it always did on `tables create`); a type with a semantic is a
+ * manual field of its own.
+ */
+export function isDataOnlyTableFieldType(type) {
+    return SHAPES[type].semanticType === null;
+}
+export function tableFieldTypeTakesOptions(type) {
+    return SHAPES[type].takesOptions;
+}
+export function tableFieldTypeDataType(type) {
+    return SHAPES[type].dataType;
+}
+export function tableFieldTypeSemantic(type) {
+    return SHAPES[type].semanticType;
+}
+/**
+ * The stored column a field type creates. A choice type always carries an
+ * `options` array (empty when none were given), exactly as the picker seeds
+ * it, so the editor opens on an option list rather than a missing one.
+ */
+export function tableFieldTypeColumn(type, options) {
+    const shape = SHAPES[type];
+    return {
+        kind: "manual",
+        dataType: shape.dataType,
+        semanticType: shape.semanticType,
+        definition: shape.takesOptions ? { options: normalizeSelectOptions(options ?? []) } : {},
+    };
+}
+/**
+ * The data type a lookup column gets for its mode when nobody chose one: the
+ * web editor's rule, shared so `columns add` and `columns update` on the CLI
+ * and MCP derive the same type instead of leaving text in place and failing at
+ * run time. count/aggregate are numbers, exists is a boolean, a first_match
+ * returning one column is that value as text, and several (or none chosen yet)
+ * are an object.
+ */
+export function lookupColumnDataType(mode, returnColumns) {
+    if (mode === "exists")
+        return "boolean";
+    if (mode === "count" || mode === "aggregate")
+        return "numeric";
+    return Array.isArray(returnColumns) && returnColumns.length === 1 ? "text" : "jsonb";
+}
+/**
+ * Whether a stored data type can hold a lookup's result: the run validator's
+ * rule (`validateTableActionLookupColumn` in @oxygen/tenant-db). A single-return
+ * first_match fits any type, so editing one never forces a retype.
+ */
+export function lookupDataTypeFits(mode, returnColumns, dataType) {
+    if (mode === "count" || mode === "aggregate")
+        return dataType === "numeric";
+    if (mode === "exists")
+        return dataType === "boolean";
+    return !(Array.isArray(returnColumns) && returnColumns.length > 1) || dataType === "jsonb";
+}

package/node_modules/@oxygen/shared/dist/version.generated.d.ts

@@ -1 +1 @@
-export declare const OXYGEN_BUILD_VERSION = "1.1013.61";
+export declare const OXYGEN_BUILD_VERSION = "1.1013.93";

package/node_modules/@oxygen/shared/dist/version.generated.js

@@ -1,2 +1,2 @@
 // GENERATED by scripts/ci/version-stamp.mjs from VERSION + git history. Do not edit; do not commit.
-export const OXYGEN_BUILD_VERSION = "1.1013.61";
+export const OXYGEN_BUILD_VERSION = "1.1013.93";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.1013.61",
+  "version": "1.1013.93",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",