@oxygen-agent/cli 1.46.0 → 1.64.5

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { execFileSync, spawnSync } from "node:child_process";
+// skipcq: JS-0271 — bin entry source; build chmod+x on dist/index.js
+import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -8,17 +9,21 @@ import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { Command } from "commander";
-import { OXYGEN_VERSION, OxygenError, success, toFailure } from "@oxygen/shared";
+import { formatCellForDisplay, OXYGEN_VERSION, OxygenError, success, toFailure } from "@oxygen/shared";
 import { inferRowsFileFormat, normalizeRowsForNewTable, normalizeRowsFormat, parseRowsFileBuffer, } from "@oxygen/shared/file-import";
 import { assertRecipeBundleSafe, assertWorkflowManifest, buildRecipeManifest, compileWorkflowDefinition, isAnyWorkflowManifest, isRecipeManifest, isWorkflowDefinition, isWorkflowManifest, } from "@oxygen/workflows";
 import { isRecipeDefinition } from "@oxygen/recipe-sdk";
 import { createBrowserLoginSession, openBrowser } from "./browser-login.js";
-import { clearCredentials, defaultApiUrl, listCredentialProfiles, normalizeApiUrl, saveCredentials, switchCredentialProfile, } from "./credentials.js";
+import { clearCredentials, defaultApiUrl, listCredentialProfiles, normalizeApiUrl, pickProfileNameForIdentity, resolveActiveProfile, saveCredentials, switchCredentialProfile, } from "./credentials.js";
 import { requestOxygen } from "./http-client.js";
 import { runLocalCustomHttpColumn } from "./local-custom-http-column.js";
 import { addSessionOutput, addSessionStatus, getSessionUsage, startSession, updateSessionStep, } from "./session.js";
+import { doctorAgentSkills, installAgentSkills, listAgentSkills, runAutomaticSkillsInstall, } from "./skills.js";
+import { updateCli } from "./update.js";
 const BROWSER_LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
 const OXYGEN_SPINNER_INTERVAL_MS = 90;
+const INITIAL_OXYGEN_PROFILE_ENV = process.env.OXYGEN_PROFILE?.trim() || null;
+let globalProfileFlag = null;
 const OXYGEN_SPINNER_FRAMES = [
     "[Oxygen  ]",
     "[ Oxygen ]",
@@ -43,7 +48,6 @@ const TABLE_INGESTION_WAIT_DEFAULT_TIMEOUT_SECONDS = 600;
 const TABLE_INGESTION_WAIT_DEFAULT_INTERVAL_SECONDS = 5;
 const WORKFLOW_TAIL_DEFAULT_TIMEOUT_SECONDS = 600;
 const WORKFLOW_TAIL_DEFAULT_INTERVAL_SECONDS = 2;
-const DEFAULT_CLI_PACKAGE_SPEC = "@oxygen-agent/cli@latest";
 const CLI_MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 const RECIPE_ESBUILD_NODE_PATHS = [
     resolve("node_modules"),
@@ -160,8 +164,10 @@ export function createProgram() {
         .option("--profile <name>", "Use a stored CLI profile for this command.");
     program.hook("preAction", () => {
         const options = program.opts();
-        if (options.profile)
+        if (options.profile) {
+            globalProfileFlag = options.profile;
             process.env.OXYGEN_PROFILE = options.profile;
+        }
     });
     program
         .command("login")
@@ -208,6 +214,20 @@ export function createProgram() {
         .option("--json", "Print a JSON envelope.")
         .action(async (profile, options) => {
         await handleLogoutAction({ ...options, profile });
+    }))
+        .addCommand(new Command("env")
+        .description("Print shell `export` lines that pin this terminal to a stored CLI profile.")
+        .argument("<profile>", "Stored profile name.")
+        .option("--unset", "Print `unset` lines instead of `export` lines.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (profile, options) => {
+        await handleProfilesEnvAction(profile, options);
+    }))
+        .addCommand(new Command("current")
+        .description("Show the profile the next command will use, and where it came from.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleProfilesCurrentAction(options);
     }));
     program
         .command("logout")
@@ -262,7 +282,7 @@ export function createProgram() {
         .description("Show the current Oxygen CLI identity.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("whoami", options, async () => requestOxygen("/api/cli/whoami"));
+        await handleWhoamiAction(options);
     });
     program
         .command("status")
@@ -518,14 +538,33 @@ export function createProgram() {
         await handleAsyncAction("tables import", options, async () => importRows(table, options));
     }))
         .addCommand(new Command("export")
-        .description("Export workspace table rows as JSON, JSONL, or CSV.")
+        .description("Export workspace table rows as JSON, JSONL, CSV, or a human-readable table.")
         .argument("<table>", "Table id or slug.")
-        .option("--format <format>", "json, jsonl, or csv. Defaults to json.")
+        .option("--format <format>", "json, jsonl, csv, or table. Defaults to json. Use table for a typed, human-readable rendering with thousands grouping.")
         .option("--output <path>", "Write export content to a file.")
         .option("--limit <n>", "Maximum rows to export. Defaults to 100; hard cap is 1000.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
         await handleAsyncAction("tables export", options, async () => exportRows(table, options));
+    }))
+        .addCommand(new Command("export-bundle")
+        .description("Export a workspace table as a portable bundle (schema + every row) for cross-environment / cross-org copies.")
+        .argument("<table>", "Table id or slug to export.")
+        .option("--output <path>", "Write the bundle JSON to a file. Defaults to stdout.")
+        .option("--page-size <n>", "Rows per cursor-paginated request. Defaults to 500; hard cap is 1000.")
+        .option("--json", "Print a JSON envelope (omit row payload — use --output to keep the rows).")
+        .action(async (table, options) => {
+        await handleAsyncAction("tables export-bundle", options, async () => exportTableBundle(table, options));
+    }))
+        .addCommand(new Command("import-bundle")
+        .description("Recreate a workspace table from an export-bundle file in this org. Restores columns (incl. enrichment/tool definitions) and inserts every row.")
+        .requiredOption("--file <path>", "Bundle JSON file produced by `tables export-bundle`.")
+        .option("--name <name>", "Override the table display name. Defaults to the bundle's table name.")
+        .option("--project <project>", "Project id or slug for the new table. Defaults to General.")
+        .option("--batch-size <n>", "Rows per insert request. Defaults to 500; paid orgs may use up to 5000.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("tables import-bundle", options, async () => importTableBundle(options));
     }))
         .addCommand(new Command("list")
         .description("List workspace tables in the current tenant database.")
@@ -617,6 +656,34 @@ export function createProgram() {
             method: "POST",
             body: { table },
         }));
+    }))
+        .addCommand(new Command("move")
+        .description("Move a workspace table to a different project.")
+        .argument("<table>", "Table id or slug.")
+        .requiredOption("--project <project>", "Destination project id or slug.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("tables move", options, async () => requestOxygen("/api/cli/tables/move", {
+            method: "POST",
+            body: { table, project: options.project },
+        }));
+    }))
+        .addCommand(new Command("recover-pending")
+        .description("Re-poll BetterContact async enrichments that timed out mid-poll and write any newly-found phones back to the table.")
+        .argument("<table>", "Table id or slug.")
+        .option("--max-items <n>", "Max pending cache rows to poll in this run. Defaults to 1000.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("tables recover-pending", options, async () => {
+            const maxItems = options.maxItems ? Number.parseInt(options.maxItems, 10) : undefined;
+            return requestOxygen("/api/cli/tables/recover-pending", {
+                method: "POST",
+                body: {
+                    table,
+                    ...(Number.isFinite(maxItems) ? { max_items: maxItems } : {}),
+                },
+            });
+        });
     }));
     tablesCommand.addCommand(new Command("webhook")
         .description("Create and manage direct table webhooks.")
@@ -649,6 +716,22 @@ export function createProgram() {
     program
         .command("context")
         .description("Workspace-level GTM context commands.")
+        .addCommand(new Command("resolve")
+        .description("Resolve task-scoped workspace GTM context with readiness and revision provenance.")
+        .option("--purpose <purpose>", "general, lead_sourcing, qualification, outbound_copy, or workflow_design.")
+        .option("--asset-type <csv>", "Comma-separated context asset types to include.")
+        .option("--asset-status <status>", "draft, active, archived, or all. Defaults to active.")
+        .option("--tags <csv>", "Comma-separated asset tags that must be present.")
+        .option("--include-archived", "Include archived assets when no asset status is set.")
+        .option("--max-assets <n>", "Maximum assets to include. Defaults to 10, max 50.")
+        .option("--require-ready", "Exit with a conflict error when required context sections are missing.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("context resolve", options, async () => requestOxygen("/api/cli/context/resolve", {
+            method: "POST",
+            body: buildContextResolveBody(options),
+        }));
+    }))
         .addCommand(new Command("profile")
         .description("Company profile and ICP memory.")
         .addCommand(new Command("get")
@@ -721,21 +804,164 @@ export function createProgram() {
             body: { id: assetId },
         }));
     })));
+    program
+        .command("templates")
+        .description("Reusable prompt templates layered into AI columns at run time.")
+        .addCommand(new Command("list")
+        .description("List prompt templates in the workspace.")
+        .option("--kind <kind>", "Filter by ai_column_system, scoring_rubric, or other.")
+        .option("--include-archived", "Include archived templates.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("templates list", options, async () => {
+            const params = new URLSearchParams();
+            if (readOption(options.kind))
+                params.set("kind", readOption(options.kind));
+            if (options.includeArchived)
+                params.set("include_archived", "true");
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/templates${qs}`);
+        });
+    }))
+        .addCommand(new Command("get")
+        .description("Read one prompt template by id or slug.")
+        .argument("<id_or_slug>", "Template UUID or slug.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (idOrSlug, options) => {
+        await handleAsyncAction("templates get", options, async () => requestOxygen("/api/cli/templates/get", {
+            method: "POST",
+            body: idOrSlug.includes("-") && idOrSlug.length >= 32
+                ? { id: idOrSlug }
+                : { slug: idOrSlug },
+        }));
+    }))
+        .addCommand(new Command("upsert")
+        .description("Create or update a prompt template.")
+        .option("--id <id>", "Existing template UUID to update. Omit to create.")
+        .option("--slug <slug>", "Stable slug (kebab-case).")
+        .option("--name <name>", "Human-readable name.")
+        .option("--description <text>", "Short description.")
+        .option("--kind <kind>", "Template kind: ai_column_system, scoring_rubric, or other.")
+        .option("--body <text>", "Prompt body.")
+        .option("--body-file <path>", "Path to a file containing the prompt body.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("templates upsert", options, async () => {
+            const body = {};
+            if (readOption(options.id))
+                body.id = readOption(options.id);
+            if (readOption(options.slug))
+                body.slug = readOption(options.slug);
+            if (readOption(options.name))
+                body.name = readOption(options.name);
+            if (readOption(options.description) !== undefined)
+                body.description = readOption(options.description);
+            if (readOption(options.kind))
+                body.kind = readOption(options.kind);
+            if (readOption(options.body))
+                body.body = readOption(options.body);
+            else if (readOption(options.bodyFile)) {
+                const path = readOption(options.bodyFile);
+                const fs = await import("node:fs/promises");
+                body.body = await fs.readFile(path, "utf8");
+            }
+            return requestOxygen("/api/cli/templates/upsert", { method: "POST", body });
+        });
+    }))
+        .addCommand(new Command("archive")
+        .description("Archive a prompt template. Seeded templates cannot be archived.")
+        .argument("<id>", "Template UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("templates archive", options, async () => requestOxygen("/api/cli/templates/archive", { method: "POST", body: { id } }));
+    }));
+    program
+        .command("reviews")
+        .description("Human-in-the-loop reviews for AI-generated outreach messages.")
+        .addCommand(new Command("list")
+        .description("List message reviews.")
+        .option("--status <status>", "Filter by pending, accepted, rejected, or superseded.")
+        .option("--table <table_id>", "Filter by table id.")
+        .option("--limit <n>", "Max rows to return (default 50, max 200).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("reviews list", options, async () => {
+            const params = new URLSearchParams();
+            if (readOption(options.status))
+                params.set("status", readOption(options.status));
+            if (readOption(options.table))
+                params.set("table_id", readOption(options.table));
+            if (readOption(options.limit))
+                params.set("limit", readOption(options.limit));
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/message-reviews${qs}`);
+        });
+    }))
+        .addCommand(new Command("next")
+        .description("Read the oldest pending review.")
+        .option("--table <table_id>", "Filter by table id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("reviews next", options, async () => {
+            const params = new URLSearchParams();
+            if (readOption(options.table))
+                params.set("table_id", readOption(options.table));
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/message-reviews/next${qs}`);
+        });
+    }))
+        .addCommand(new Command("accept")
+        .description("Accept a pending message review.")
+        .argument("<review_id>", "Message review UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (reviewId, options) => {
+        await handleAsyncAction("reviews accept", options, async () => requestOxygen("/api/cli/message-reviews/decide", {
+            method: "POST",
+            body: { id: reviewId, decision: "accept" },
+        }));
+    }))
+        .addCommand(new Command("reject")
+        .description("Reject a pending message review with optional highlights and auto-rerun.")
+        .argument("<review_id>", "Message review UUID.")
+        .option("--highlights-json <json>", "JSON array of {start,end,comment} highlight objects.")
+        .option("--auto-rerun", "Trigger a single-row rerun of the column after rejecting.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (reviewId, options) => {
+        await handleAsyncAction("reviews reject", options, async () => {
+            const body = { id: reviewId, decision: "reject" };
+            if (readOption(options.highlightsJson)) {
+                body.highlights = JSON.parse(readOption(options.highlightsJson));
+            }
+            if (options.autoRerun)
+                body.auto_rerun = true;
+            return requestOxygen("/api/cli/message-reviews/decide", { method: "POST", body });
+        });
+    }));
     program
         .command("columns")
         .description("Workspace table column commands.")
         .addCommand(new Command("add")
         .description("Add a nullable column to a workspace table.")
         .argument("<table>", "Table id or slug.")
-        .requiredOption("--label <label>", "Display label for the new column.")
+        .option("--label <label>", "Display label for the new column. Required unless --prompt-key supplies a default title.")
         .option("--key <key>", "Optional stable column key. Defaults to a normalized label.")
         .option("--data-type <type>", "Column data type: text, numeric, boolean, jsonb, or timestamptz.")
         .option("--kind <kind>", "Column kind. Defaults to manual.")
         .option("--semantic-type <type>", "Optional semantic type such as company_domain.")
         .option("--definition-json <json>", "Optional JSON object with column definition metadata.")
+        .option("--prompt-key <key>", "OXYGEN prompt-library key (e.g. email_draft_v1). Materializes prompt + output_schema and forces kind=ai.")
+        .option("--input-mapping <json>", "Required with --prompt-key. JSON object mapping prompt input names to column or literal refs.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        const column = { label: options.label };
+        if (!options.promptKey && !options.label) {
+            throw new OxygenError("invalid_request", "--label is required.", { exitCode: 1 });
+        }
+        if (options.promptKey && !options.inputMapping) {
+            throw new OxygenError("missing_input_mapping", "--input-mapping is required when --prompt-key is provided.", { exitCode: 1 });
+        }
+        const column = {};
+        if (options.label)
+            column.label = options.label;
         if (options.key)
             column.key = options.key;
         if (options.dataType)
@@ -746,12 +972,14 @@ export function createProgram() {
             column.semantic_type = options.semanticType;
         if (options.definitionJson)
             column.definition = parseJsonObject(options.definitionJson);
+        const body = { table, column };
+        if (options.promptKey)
+            body.prompt_key = options.promptKey;
+        if (options.inputMapping)
+            body.input_mapping = parseJsonObject(options.inputMapping);
         await handleAsyncAction("columns add", options, async () => requestOxygen("/api/cli/tables/columns", {
             method: "POST",
-            body: {
-                table,
-                column,
-            },
+            body,
         }));
     }))
         .addCommand(new Command("run")
@@ -766,6 +994,7 @@ export function createProgram() {
         .option("--connection-id <connection_id>", "Optional provider integration connection id.")
         .option("--background", "Create a durable background table action run instead of executing synchronously.")
         .option("--max-credits <n>", "Maximum managed/provider credits to reserve for a background run.")
+        .option("--max-concurrency <n>", "Maximum concurrent row items for a background run. Defaults to 50.")
         .option("--local", "Run a custom HTTP column in this CLI process so env-var secrets stay local.")
         .option("--local-concurrency <n>", "Maximum concurrent custom HTTP requests for --local. Defaults to 3.")
         .option("--json", "Print a JSON envelope.")
@@ -773,6 +1002,7 @@ export function createProgram() {
         const limit = readPositiveInt(options.limit);
         const localConcurrency = readPositiveInt(options.localConcurrency);
         const maxCredits = readPositiveNumber(options.maxCredits);
+        const maxConcurrency = readPositiveInt(options.maxConcurrency);
         const filterSelection = readFilterSelectionOption(options.filterJson);
         const selectedModes = [
             Boolean(options.all),
@@ -822,9 +1052,28 @@ export function createProgram() {
                     ...(readOption(options.connectionId) ? { connection_id: readOption(options.connectionId) } : {}),
                     ...(options.background ? { background: true } : {}),
                     ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
+                    ...(maxConcurrency ? { max_concurrency: maxConcurrency } : {}),
                 },
             });
         });
+    }))
+        .addCommand(new Command("rerun")
+        .description("Re-run a single AI column cell, optionally threading a prior message review's feedback into the prompt.")
+        .requiredOption("--table <table>", "Table id or slug.")
+        .requiredOption("--column <column>", "Column id or key.")
+        .requiredOption("--row <row_id>", "Row UUID.")
+        .option("--from-review-id <review_id>", "Prior message review whose feedback to thread into the regeneration prompt.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("columns rerun", options, async () => requestOxygen("/api/cli/columns/rerun", {
+            method: "POST",
+            body: {
+                table: options.table,
+                column: options.column,
+                row_id: options.row,
+                ...(readOption(options.fromReviewId) ? { from_review_id: readOption(options.fromReviewId) } : {}),
+            },
+        }));
     }))
         .addCommand(new Command("materialize")
         .description("Materialize useful fields from a JSONB result column into target columns.")
@@ -966,10 +1215,12 @@ export function createProgram() {
         .option("--force", "Run even when the target cell already has a value.")
         .option("--connection-id <connection_id>", "Optional provider integration connection id.")
         .option("--max-credits <n>", "Maximum managed/provider credits to reserve for this run.")
+        .option("--max-concurrency <n>", "Maximum concurrent row items for this run.")
         .option("--metadata-json <json>", "Optional metadata object to attach to the run.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
         const maxCredits = readPositiveNumber(options.maxCredits);
+        const maxConcurrency = readPositiveInt(options.maxConcurrency);
         await handleAsyncAction("table-runs create", options, async () => requestOxygen("/api/cli/table-action-runs", {
             method: "POST",
             body: {
@@ -979,6 +1230,7 @@ export function createProgram() {
                 ...(options.force ? { force: true } : {}),
                 ...(readOption(options.connectionId) ? { connection_id: readOption(options.connectionId) } : {}),
                 ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
+                ...(maxConcurrency ? { max_concurrency: maxConcurrency } : {}),
                 ...(options.metadataJson ? { metadata: parseJsonObject(options.metadataJson) } : {}),
             },
         }));
@@ -1211,6 +1463,48 @@ export function createProgram() {
             },
         }));
     }));
+    program
+        .command("companies")
+        .description("Company prospecting and account enrichment workflows.")
+        .addCommand(new Command("enrich")
+        .description("Preview or run a company enrichment waterfall over an existing table.")
+        .addCommand(new Command("preview")
+        .description("Inspect missing company fields, provider routing, and credit estimates without provider calls.")
+        .argument("<table>", "Table id or slug.")
+        .option("--missing-fields <fields>", "Comma-separated fields to fill: domain,linkedin_url,headcount,industry,funding,technologies,hiring_signals,company_profile.")
+        .option("--providers <providers>", "Comma-separated provider order pool. Defaults to blitzapi,crustdata,ai_ark,prospeo,leadmagic.")
+        .option("--all", "Preview all rows.")
+        .option("--limit <n>", "Preview a limited row scope.")
+        .option("--row-ids <ids>", "Comma-separated row ids.")
+        .option("--filter-json <json>", "Filter object or array for row selection.")
+        .option("--selection-json <json>", "Raw table action selection JSON.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("companies enrich preview", options, async () => requestOxygen("/api/cli/company-enrichment/preview", {
+            method: "POST",
+            body: readCompaniesEnrichBody(table, options),
+        }));
+    }))
+        .addCommand(new Command("run")
+        .description("Queue a live company enrichment waterfall, or return a dry-run plan.")
+        .argument("<table>", "Table id or slug.")
+        .option("--missing-fields <fields>", "Comma-separated fields to fill.")
+        .option("--providers <providers>", "Comma-separated provider pool.")
+        .option("--mode <mode>", "dry_run or live. Defaults to live.")
+        .option("--max-credits <n>", "Required credit ceiling for live runs.")
+        .option("--all", "Run on all rows.")
+        .option("--limit <n>", "Run on a limited row scope.")
+        .option("--row-ids <ids>", "Comma-separated row ids.")
+        .option("--filter-json <json>", "Filter object or array for row selection.")
+        .option("--selection-json <json>", "Raw table action selection JSON.")
+        .option("--force", "Re-run the waterfall audit column even when it already has a value.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("companies enrich run", options, async () => requestOxygen("/api/cli/company-enrichment/run", {
+            method: "POST",
+            body: readCompaniesEnrichBody(table, options),
+        }));
+    })));
     program
         .command("worker")
         .description("Background worker commands.")
@@ -1222,7 +1516,7 @@ export function createProgram() {
     }))
         .addCommand(new Command("failures")
         .description("List failed background action and ingestion items.")
-        .option("--queue <queue>", "all, actions, or ingestions. Defaults to all.")
+        .option("--queue <queue>", "all, actions, ingestions, or bullmq. Defaults to all.")
         .option("--limit <n>", "Maximum failed items per queue. Defaults to 25; server cap is 100.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
@@ -1328,6 +1622,7 @@ export function createProgram() {
         .addCommand(new Command("costs")
         .description("Show provider costs (COGS) per workspace. Staff only.")
         .option("--top <n>", "Limit number of workspace columns. Defaults to all.")
+        .option("--credential-mode <mode>", "managed (default; real COGS), byok (customer-supplied credentials), or all.", "managed")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("admin costs", options, async () => {
@@ -1335,6 +1630,10 @@ export function createProgram() {
             const top = readPositiveInt(options.top);
             if (top)
                 params.set("top", String(top));
+            const credentialMode = readOption(options.credentialMode);
+            if (credentialMode && credentialMode !== "managed") {
+                params.set("credential_mode", credentialMode);
+            }
             const suffix = params.toString() ? `?${params.toString()}` : "";
             return requestOxygen(`/api/cli/admin/costs${suffix}`);
         });
@@ -1416,6 +1715,27 @@ export function createProgram() {
     program
         .command("cells")
         .description("Workspace cell provenance commands.")
+        .addCommand(new Command("inspect")
+        .description("Inspect one cell's value, row context, and recent history.")
+        .argument("<table>", "Table id or slug.")
+        .argument("<row_id>", "Workspace row UUID.")
+        .argument("<column>", "Column id or key.")
+        .option("--history-limit <n>", "Maximum recent cell changes to include. Defaults to 10; cap 50.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, rowId, column, options) => {
+        await handleAsyncAction("cells inspect", options, async () => {
+            const historyLimit = readPositiveInt(options.historyLimit);
+            return requestOxygen("/api/cli/tables/cells/inspect", {
+                method: "POST",
+                body: {
+                    table,
+                    row_id: rowId,
+                    column,
+                    ...(historyLimit ? { history_limit: historyLimit } : {}),
+                },
+            });
+        });
+    }))
         .addCommand(new Command("history")
         .description("Show cell change history.")
         .argument("<table>", "Table id or slug.")
@@ -1514,7 +1834,7 @@ export function createProgram() {
         .addCommand(new Command("search")
         .description("Search the tool catalog.")
         .argument("[query]", "Search text.")
-        .option("--verbosity <verbosity>", "summary or full. Defaults to summary.")
+        .option("--verbosity <verbosity>", "minimal, summary, or full. Defaults to summary. Use minimal for high-fanout discovery sweeps that need to stay under the MCP token budget.")
         .option("--only-runnable", "Only return tools runnable by the active organization.")
         .option("--capability <tag>", "Filter by capability tag, such as mobile_phone.")
         .option("--json", "Print a JSON envelope.")
@@ -1626,13 +1946,16 @@ export function createProgram() {
         .option("--selection-json <json>", "Full row selection object for server-side row selection.")
         .option("--only-missing", "Queue rows missing the capability's normalized output when no explicit selection is passed.")
         .option("--force", "Re-run rows with an existing target enrichment value.")
+        .option("--max-concurrency <n>", "Maximum concurrent row items for this enrichment run. Defaults to 20.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
+        const maxConcurrency = readPositiveInt(options.maxConcurrency);
         await handleAsyncAction("enrich-column run", options, async () => requestOxygen("/api/cli/enrich-column/run", {
             method: "POST",
             body: {
                 ...buildEnrichColumnBody(table, options),
                 max_credits: readPositiveNumber(options.maxCredits),
+                ...(maxConcurrency ? { max_concurrency: maxConcurrency } : {}),
                 ...(options.force ? { force: true } : {}),
             },
         }));
@@ -1644,8 +1967,9 @@ export function createProgram() {
         .description("Configure provider events that can trigger workflows.")
         .addCommand(new Command("list")
         .description("List supported provider events and this org's enabled subscriptions.")
-        .option("--source <source>", "Filter by event source, such as hubspot.")
+        .option("--source <source>", "Filter by event source, such as hubspot or composio.gmail.")
         .option("--event <event>", "Filter by event type, such as contact.created.")
+        .option("--toolkit <id>", "Filter by toolkit / integration id, such as gmail.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("integrations events list", options, async () => {
@@ -1654,25 +1978,47 @@ export function createProgram() {
                 query.set("source", readOption(options.source) ?? "");
             if (readOption(options.event))
                 query.set("event", readOption(options.event) ?? "");
+            if (readOption(options.toolkit))
+                query.set("toolkit", readOption(options.toolkit) ?? "");
             const suffix = query.toString() ? `?${query.toString()}` : "";
             return requestOxygen(`/api/cli/integrations/events${suffix}`);
         });
     }))
         .addCommand(new Command("enable")
         .description("Enable a provider event for a connected integration account.")
-        .requiredOption("--source <source>", "Event source, such as hubspot.")
+        .requiredOption("--source <source>", "Event source, such as hubspot or composio.gmail.")
         .requiredOption("--event <event>", "Event type, such as contact.created.")
         .option("--connection-id <connection_id>", "Specific integration connection id. Defaults to the active default connection.")
+        .option("--trigger-config <json>", "JSON object passed to the provider when registering the trigger (Composio triggers only).")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("integrations events enable", options, async () => requestOxygen("/api/cli/integrations/events/enable", {
-            method: "POST",
-            body: {
-                source: readOption(options.source),
-                event: readOption(options.event),
-                ...(readOption(options.connectionId) ? { connection_id: readOption(options.connectionId) } : {}),
-            },
-        }));
+        await handleAsyncAction("integrations events enable", options, async () => {
+            const triggerConfigRaw = readOption(options.triggerConfig);
+            let triggerConfig;
+            if (triggerConfigRaw) {
+                try {
+                    const parsed = JSON.parse(triggerConfigRaw);
+                    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                        throw new Error("--trigger-config must be a JSON object.");
+                    }
+                    triggerConfig = parsed;
+                }
+                catch (error) {
+                    throw new Error(error instanceof Error
+                        ? `Invalid --trigger-config: ${error.message}`
+                        : "Invalid --trigger-config");
+                }
+            }
+            return requestOxygen("/api/cli/integrations/events/enable", {
+                method: "POST",
+                body: {
+                    source: readOption(options.source),
+                    event: readOption(options.event),
+                    ...(readOption(options.connectionId) ? { connection_id: readOption(options.connectionId) } : {}),
+                    ...(triggerConfig ? { trigger_config: triggerConfig } : {}),
+                },
+            });
+        });
     }))
         .addCommand(new Command("disable")
         .description("Disable a provider event for a connected integration account.")
@@ -2053,11 +2399,25 @@ export function createProgram() {
     }));
     program
         .command("skills")
-        .description("Agent skill installation commands.")
+        .description("Agent skill discovery and installation commands.")
+        .addCommand(new Command("list")
+        .description("List Oxygen agent skills available from the public skill index.")
+        .option("--api-url <url>", "Oxygen app URL. Defaults to OXYGEN_API_URL or https://oxygen-agent.com.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("skills list", options, async () => listAgentSkills(options));
+    }))
+        .addCommand(new Command("doctor")
+        .description("Check Oxygen skill index reachability and local installer prerequisites.")
+        .option("--api-url <url>", "Oxygen app URL. Defaults to OXYGEN_API_URL or https://oxygen-agent.com.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("skills doctor", options, async () => doctorAgentSkills(options));
+    }))
         .addCommand(new Command("install")
         .description("Install Oxygen agent skills into local agent skill directories.")
         .option("--api-url <url>", "Oxygen app URL. Defaults to OXYGEN_API_URL or https://oxygen-agent.com.")
-        .option("--agents <agents>", "Space or comma separated agents. Defaults to codex, claude-code, and cursor.")
+        .option("--agents <agents...>", "Space or comma separated agents. Defaults to codex, claude-code, and cursor.")
         .option("--skill <skill>", "Skill name or '*'. Defaults to '*'.")
         .option("--project", "Install into the current project instead of global agent scope.")
         .option("--copy", "Copy skill files instead of symlinking when supported by npx skills.")
@@ -2183,6 +2543,7 @@ function referencesRecipeSdk(source) {
 // Escape Next static analysis (the CLI is bundled by tsc, but mirror the
 // worker's escape so both load identically).
 const dynamicRecipeImport = new Function("specifier", "return import(specifier);");
+// skipcq: JS-R1003
 async function importRecipeModule(specifier) {
     try {
         return await dynamicRecipeImport(specifier);
@@ -2384,6 +2745,55 @@ function readTableRunSelection(options) {
         exitCode: 1,
     });
 }
+function readCompaniesEnrichBody(table, options) {
+    const body = { table };
+    const fields = readCsvOption(options.missingFields);
+    const providers = readCsvOption(options.providers);
+    const selection = readCompaniesEnrichSelection(options);
+    const mode = readOption(options.mode);
+    const maxCredits = readPositiveNumber(options.maxCredits);
+    if (fields.length > 0)
+        body.missing_fields = fields;
+    if (providers.length > 0)
+        body.providers = providers;
+    if (selection)
+        body.selection = selection;
+    if (mode)
+        body.mode = mode;
+    if (maxCredits !== undefined)
+        body.max_credits = maxCredits;
+    if (options.force !== undefined)
+        body.force = Boolean(options.force);
+    return body;
+}
+function readCompaniesEnrichSelection(options) {
+    const explicitSelection = readSelectionJsonOption(options.selectionJson);
+    const hasAll = Boolean(options.all);
+    const limit = readPositiveInt(options.limit);
+    const rowIds = readCsvOption(options.rowIds);
+    const filterSelection = readFilterSelectionOption(options.filterJson);
+    const selectedModes = [
+        Boolean(explicitSelection),
+        hasAll,
+        Boolean(limit),
+        rowIds.length > 0,
+        Boolean(filterSelection),
+    ].filter(Boolean).length;
+    if (selectedModes > 1) {
+        throw new OxygenError("invalid_company_enrichment", "Pass only one row scope option.", { exitCode: 1 });
+    }
+    if (explicitSelection)
+        return explicitSelection;
+    if (hasAll)
+        return { mode: "all" };
+    if (limit)
+        return { mode: "limit", limit };
+    if (rowIds.length > 0)
+        return { mode: "row_ids", row_ids: rowIds };
+    if (filterSelection)
+        return filterSelection;
+    return undefined;
+}
 function readFilterSelectionOption(value) {
     const filters = readFilterJsonOption(value);
     return filters ? { mode: "filter", filters } : undefined;
@@ -2443,58 +2853,6 @@ function normalizeSessionStepStatus(value) {
         exitCode: 1,
     });
 }
-function installAgentSkills(options) {
-    const apiUrl = normalizeApiUrl(readOption(options.apiUrl) ?? defaultApiUrl());
-    const indexUrl = `${apiUrl}/.well-known/skills/index.json`;
-    const agents = readWords(options.agents ?? "codex claude-code cursor");
-    const skill = readOption(options.skill) ?? "*";
-    const args = [
-        "skills",
-        "add",
-        indexUrl,
-        "--agents",
-        ...agents,
-        "--yes",
-        "--skill",
-        skill,
-        "--full-depth",
-    ];
-    if (!options.project)
-        args.push("--global");
-    if (options.copy)
-        args.push("--copy");
-    let output = "";
-    try {
-        output = execFileSync("npx", args, {
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-    }
-    catch (error) {
-        const failure = error;
-        throw new OxygenError("skills_install_failed", "Unable to install Oxygen agent skills.", {
-            details: {
-                index_url: indexUrl,
-                stdout: failure.stdout?.slice(0, 2000) ?? "",
-                stderr: failure.stderr?.slice(0, 2000) ?? failure.message ?? "unknown",
-            },
-            exitCode: 1,
-        });
-    }
-    return {
-        indexUrl,
-        agents,
-        skill,
-        scope: options.project ? "project" : "global",
-        output,
-    };
-}
-function readWords(value) {
-    return value
-        .split(/[,\s]+/)
-        .map((entry) => entry.trim())
-        .filter(Boolean);
-}
 async function importRows(table, options) {
     const format = normalizeRowsFormat(options.format, inferRowsFileFormat(options.file));
     const parsedRows = await readRowsFile(options.file, format, options.sheet);
@@ -2599,11 +2957,13 @@ async function prepareImportTarget(table, options, parsedRows) {
             exitCode: 1,
         });
     }
+    const createdWebUrl = readRecordString(created, "web_url")
+        ?? readRecordString(created, "deepLink");
     return {
         tableRef: createdSlug,
         rows: normalized.rows,
         createdTable: created,
-        tableWebUrl: tableWebUrl(createdSlug),
+        tableWebUrl: createdWebUrl ?? tableWebUrl(createdSlug),
         upsertKey: normalizeCreatedTableUpsertKey(options.upsertKey, normalized.keyBySource),
     };
 }
@@ -2642,6 +3002,7 @@ async function enqueueImportRows(table, options, rows, format, batchSize, contex
         },
     });
     const ingestionRunId = readRequiredResponseString(created, "id");
+    const queueWait = readRecord(created, "queue_wait");
     if (isTerminalTableIngestionStatus(readRecordString(created, "status"))) {
         return {
             ingestionRun: created,
@@ -2660,6 +3021,7 @@ async function enqueueImportRows(table, options, rows, format, batchSize, contex
             mode: upsertKey ? "upsert" : "insert",
             upsertKey: upsertKey ?? null,
             idempotencyKey,
+            ...(queueWait ? { queue_wait: queueWait } : {}),
         };
     }
     let insertedItems = 0;
@@ -2681,6 +3043,7 @@ async function enqueueImportRows(table, options, rows, format, batchSize, contex
         duplicatePositions += readCount(appended.duplicatePositions);
         latestRun = appended.run ?? latestRun;
     }
+    emitQueueWaitStderrNote(queueWait);
     return {
         ingestionRun: latestRun,
         ingestionRunId,
@@ -2698,8 +3061,16 @@ async function enqueueImportRows(table, options, rows, format, batchSize, contex
         mode: upsertKey ? "upsert" : "insert",
         upsertKey: upsertKey ?? null,
         idempotencyKey,
+        ...(queueWait ? { queue_wait: queueWait } : {}),
     };
 }
+function emitQueueWaitStderrNote(queueWait) {
+    if (!queueWait)
+        return;
+    const note = readRecordString(queueWait, "note");
+    if (note)
+        process.stderr.write(`note: ${note}\n`);
+}
 async function waitForTableIngestionRun(runId, options) {
     const timeoutSeconds = readPositiveInt(options.timeoutSeconds)
         ?? TABLE_INGESTION_WAIT_DEFAULT_TIMEOUT_SECONDS;
@@ -2786,18 +3157,259 @@ async function exportRows(table, options) {
             ...(limit ? { limit } : {}),
         },
     });
-    const content = formatRows(result.rows, format, result.columns);
+    const formatted = formatRows(result.rows, format, result.columns);
     if (options.output) {
-        writeFileSync(options.output, content);
+        writeFileSync(options.output, formatted.content);
     }
     return {
         table: result.table ?? null,
         format,
         rowCount: result.rows.length,
         output: options.output ?? null,
-        ...(options.output ? {} : { content }),
+        ...(options.output ? {} : { content: formatted.content }),
+        ...(formatted.rescuedCount > 0 ? { rescuedNumericCells: formatted.rescuedCount } : {}),
+    };
+}
+const TABLE_BUNDLE_SCHEMA_VERSION = 1;
+const TABLE_BUNDLE_MAX_PAGE_SIZE = 1000;
+const TABLE_BUNDLE_DEFAULT_PAGE_SIZE = 500;
+async function exportTableBundle(table, options) {
+    const pageSize = Math.min(readPositiveInt(options.pageSize) ?? TABLE_BUNDLE_DEFAULT_PAGE_SIZE, TABLE_BUNDLE_MAX_PAGE_SIZE);
+    // Pull the canonical schema (incl. enrichment/tool definitions and
+    // semantic types) from `describe`; the paginated query response only
+    // surfaces the user-visible projection.
+    const describe = await requestOxygen("/api/cli/tables/describe", { method: "POST", body: { table } });
+    const tableMeta = describe.table ?? null;
+    const columns = (describe.columns ?? []).map(toBundleColumn);
+    const rows = [];
+    let cursor = null;
+    let expectedTotal = null;
+    let pageCount = 0;
+    let hasMoreFlag = false;
+    do {
+        const requestBody = { table, limit: pageSize };
+        if (cursor)
+            requestBody.cursor = cursor;
+        const page = await requestOxygen("/api/cli/tables/query", { method: "POST", body: requestBody });
+        pageCount += 1;
+        if (expectedTotal === null) {
+            expectedTotal = readBundleNumber(page.totalCount) ?? readBundleNumber(page.total_count) ?? null;
+        }
+        for (const row of page.rows ?? [])
+            rows.push(row);
+        cursor = typeof page.nextCursor === "string" && page.nextCursor.length > 0 ? page.nextCursor : null;
+        hasMoreFlag = Boolean(page.hasMore);
+        // Defensive: hasMore=false should always mean cursor=null. If a future
+        // server change ever sets one without the other, stop iterating on
+        // hasMore=false so we don't loop forever.
+        if (!hasMoreFlag)
+            cursor = null;
+    } while (cursor);
+    if (expectedTotal !== null && rows.length !== expectedTotal) {
+        throw new OxygenError("bundle_export_incomplete", "Cursor pagination ended before every row was written. The bundle would be a silent under-export.", {
+            details: {
+                table,
+                totalCount: expectedTotal,
+                exportedCount: rows.length,
+                missing: expectedTotal - rows.length,
+                pages: pageCount,
+            },
+            exitCode: 1,
+        });
+    }
+    const tableId = readRecordString(tableMeta, "id");
+    const tableSlug = readRecordString(tableMeta, "slug");
+    const projectSlug = readRecordString(tableMeta, "projectSlug");
+    const bundle = {
+        schemaVersion: TABLE_BUNDLE_SCHEMA_VERSION,
+        exportedAt: new Date().toISOString(),
+        table: {
+            id: tableId ?? null,
+            slug: tableSlug ?? null,
+            name: readRecordString(tableMeta, "displayName") ?? readRecordString(tableMeta, "name") ?? null,
+            projectSlug: projectSlug ?? null,
+        },
+        columns,
+        rows,
+        totals: {
+            rowCount: rows.length,
+            ...(expectedTotal !== null ? { sourceTotalCount: expectedTotal } : {}),
+            pages: pageCount,
+            pageSize,
+        },
+    };
+    if (options.output) {
+        writeFileSync(options.output, `${JSON.stringify(bundle, null, 2)}\n`);
+    }
+    const summary = {
+        table_id: tableId ?? null,
+        table_slug: tableSlug ?? null,
+        schema_version: TABLE_BUNDLE_SCHEMA_VERSION,
+        column_count: columns.length,
+        row_count: rows.length,
+        pages: pageCount,
+        page_size: pageSize,
+        output: options.output ?? null,
+        ...(tableId ? { web_url: tableWebUrl(tableId) } : tableSlug ? { web_url: tableWebUrl(tableSlug) } : {}),
+    };
+    // When piping to stdout, also emit the full bundle so it can be redirected
+    // into a file. With --output, the file is the source of truth; keep the
+    // stdout response a small summary so it's readable.
+    return options.output ? summary : { ...summary, bundle };
+}
+async function importTableBundle(options) {
+    const path = options.file;
+    if (!path || !path.trim()) {
+        throw new OxygenError("invalid_input", "--file is required.", { exitCode: 1 });
+    }
+    const batchSize = normalizeImportBatchSize(options.batchSize);
+    const raw = readFileSync(resolve(path), "utf8");
+    const bundle = parseBundleFile(raw);
+    const columns = bundle.columns.map(bundleColumnToCreateInput);
+    if (columns.length === 0) {
+        throw new OxygenError("invalid_bundle", "Bundle has no columns; nothing to import.", { exitCode: 1 });
+    }
+    const tableName = readOption(options.name) ?? bundle.tableName;
+    if (!tableName) {
+        throw new OxygenError("invalid_bundle", "Bundle has no table.name and no --name override was provided.", { exitCode: 1 });
+    }
+    const createResponse = await requestOxygen("/api/cli/tables", {
+        method: "POST",
+        body: {
+            name: tableName,
+            columns,
+            ...(readOption(options.project) ? { project: readOption(options.project) } : {}),
+        },
+    });
+    const createdTable = readRecord(createResponse, "table");
+    const newTableId = readRecordString(createResponse, "table_id")
+        ?? (createdTable ? readRecordString(createdTable, "id") : null);
+    const newTableSlug = readRecordString(createResponse, "table_slug")
+        ?? (createdTable ? readRecordString(createdTable, "slug") : null);
+    if (!newTableId) {
+        throw new OxygenError("invalid_response", "Table create response did not include an id; bundle import cannot proceed.", { exitCode: 1 });
+    }
+    const validColumnKeys = new Set(columns.map((column) => column.key).filter((key) => Boolean(key)));
+    const stagedRows = bundle.rows.map((row) => stripRowForImport(row, validColumnKeys));
+    let inserted = 0;
+    for (let offset = 0; offset < stagedRows.length; offset += batchSize) {
+        const batch = stagedRows.slice(offset, offset + batchSize);
+        if (batch.length === 0)
+            continue;
+        await requestOxygen("/api/cli/tables/rows", {
+            method: "POST",
+            body: { table: newTableId, rows: batch },
+        });
+        inserted += batch.length;
+    }
+    return {
+        table_id: newTableId,
+        table_slug: newTableSlug ?? null,
+        column_count: columns.length,
+        row_count: inserted,
+        source_table: bundle.tableSummary,
+        schema_version: bundle.schemaVersion,
+        web_url: tableWebUrl(newTableSlug ?? newTableId),
+    };
+}
+function toBundleColumn(column) {
+    // Persist only the fields `tables create` knows how to ingest. Drop ids,
+    // physical column names, archivedAt — those are tenant-local and would
+    // collide on import.
+    return {
+        key: column.key,
+        ...(column.label !== undefined ? { label: column.label } : {}),
+        ...(column.dataType !== undefined ? { dataType: column.dataType } : {}),
+        ...(column.kind !== undefined ? { kind: column.kind } : {}),
+        ...(column.semanticType !== undefined ? { semanticType: column.semanticType } : {}),
+        ...(column.definition !== undefined ? { definition: column.definition } : {}),
+        ...(column.position !== undefined ? { position: column.position } : {}),
+    };
+}
+function bundleColumnToCreateInput(column) {
+    const label = typeof column.label === "string" && column.label.trim()
+        ? column.label.trim()
+        : typeof column.key === "string"
+            ? column.key
+            : null;
+    if (!label) {
+        throw new OxygenError("invalid_bundle", "Bundle column is missing label/key.", {
+            details: { column },
+            exitCode: 1,
+        });
+    }
+    return {
+        label,
+        ...(typeof column.key === "string" ? { key: column.key } : {}),
+        ...(typeof column.dataType === "string" ? { dataType: column.dataType } : {}),
+        ...(typeof column.kind === "string" ? { kind: column.kind } : {}),
+        ...(typeof column.semanticType === "string" ? { semanticType: column.semanticType } : {}),
+        ...(column.definition && typeof column.definition === "object" && !Array.isArray(column.definition)
+            ? { definition: column.definition }
+            : {}),
     };
 }
+function parseBundleFile(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        throw new OxygenError("invalid_bundle", "Bundle file is not valid JSON.", {
+            details: { reason: error instanceof Error ? error.message : "unknown" },
+            exitCode: 1,
+        });
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new OxygenError("invalid_bundle", "Bundle file must be a JSON object.", { exitCode: 1 });
+    }
+    const record = parsed;
+    const schemaVersion = typeof record.schemaVersion === "number" ? record.schemaVersion : 1;
+    if (schemaVersion !== TABLE_BUNDLE_SCHEMA_VERSION) {
+        throw new OxygenError("unsupported_bundle_version", `Bundle schema version ${schemaVersion} is not supported by this CLI.`, {
+            details: { supported: TABLE_BUNDLE_SCHEMA_VERSION, got: schemaVersion },
+            exitCode: 1,
+        });
+    }
+    const rawColumns = record.columns;
+    if (!Array.isArray(rawColumns)) {
+        throw new OxygenError("invalid_bundle", "Bundle is missing a columns array.", { exitCode: 1 });
+    }
+    const rawRows = record.rows;
+    if (!Array.isArray(rawRows)) {
+        throw new OxygenError("invalid_bundle", "Bundle is missing a rows array.", { exitCode: 1 });
+    }
+    const tableSummary = record.table && typeof record.table === "object" && !Array.isArray(record.table)
+        ? record.table
+        : null;
+    return {
+        schemaVersion,
+        tableName: tableSummary
+            ? (readRecordString(tableSummary, "name") ?? readRecordString(tableSummary, "displayName"))
+            : null,
+        tableSummary,
+        columns: rawColumns.filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry)),
+        rows: rawRows.filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry)),
+    };
+}
+function stripRowForImport(row, validColumnKeys) {
+    const out = {};
+    for (const [key, value] of Object.entries(row)) {
+        if (key === "_row_id" || key === "_created_at" || key === "_updated_at")
+            continue;
+        if (validColumnKeys.size > 0 && !validColumnKeys.has(key))
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+function readBundleNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim() && Number.isFinite(Number(value)))
+        return Number(value);
+    return null;
+}
 async function readRowsFile(path, format, sheet) {
     return await parseRowsFileBuffer(readFileSync(path), format, sheet ? { sheet } : {});
 }
@@ -2808,18 +3420,26 @@ function normalizeCreatedTableUpsertKey(value, keyBySource) {
 }
 function normalizeExportRowsFormat(value) {
     const normalized = value?.trim().toLowerCase() || "json";
-    if (normalized === "json" || normalized === "jsonl" || normalized === "csv")
+    if (normalized === "json"
+        || normalized === "jsonl"
+        || normalized === "csv"
+        || normalized === "table")
         return normalized;
-    throw new OxygenError("invalid_format", "Export format must be json, jsonl, or csv.", {
+    throw new OxygenError("invalid_format", "Export format must be json, jsonl, csv, or table.", {
         details: { format: value },
         exitCode: 1,
     });
 }
 function formatRows(rows, format, columns) {
-    if (format === "json")
-        return `${JSON.stringify(rows, null, 2)}\n`;
-    if (format === "jsonl")
-        return `${rows.map((row) => JSON.stringify(row)).join("\n")}\n`;
+    if (format === "json") {
+        return { content: `${JSON.stringify(rows, null, 2)}\n`, rescuedCount: 0 };
+    }
+    if (format === "jsonl") {
+        return {
+            content: `${rows.map((row) => JSON.stringify(row)).join("\n")}\n`,
+            rescuedCount: 0,
+        };
+    } // skipcq: JS-0246
     const keys = [
         "_row_id",
         "_created_at",
@@ -2827,10 +3447,64 @@ function formatRows(rows, format, columns) {
         ...(columns?.map((column) => column.key) ?? []),
         ...rows.flatMap((row) => Object.keys(row)),
     ].filter((key, index, all) => all.indexOf(key) === index && rows.some((row) => key in row));
-    return [
-        keys.map(escapeCsvField).join(","),
-        ...rows.map((row) => keys.map((key) => escapeCsvField(row[key])).join(",")),
-    ].join("\n") + "\n";
+    if (format === "csv") {
+        const csvBody = [
+            keys.map(escapeCsvField).join(","),
+            ...rows.map((row) => keys.map((key) => escapeCsvField(row[key])).join(",")),
+        ].join("\n");
+        return {
+            content: `${csvBody}\n`,
+            rescuedCount: 0,
+        };
+    }
+    // "table": render with type-aware formatting and a Markdown-style frame.
+    const columnByKey = new Map(columns?.map((c) => [c.key, c]) ?? []);
+    let rescuedCount = 0;
+    const headers = keys.map((key) => columnByKey.get(key)?.label ?? key);
+    const formattedRows = rows.map((row) => keys.map((key) => {
+        const column = columnByKey.get(key) ?? null;
+        const formatted = formatCellForDisplay(row[key], column, {
+            surface: "cli",
+            onRescued: () => {
+                rescuedCount += 1;
+            },
+        });
+        // Pipe and any line-break char are the row/cell delimiters of the
+        // Markdown frame — raw values containing them would corrupt the layout.
+        // Match on the line-break class (not just `\r?\n`) so a standalone `\r`
+        // doesn't slip through and split the row visually.
+        return formatted.replace(/[\r\n]+/g, " ↵ ").replace(/\|/g, "\\|");
+    }));
+    const widths = headers.map((header, columnIndex) => {
+        let max = header.length;
+        for (const row of formattedRows) {
+            const cell = row[columnIndex] ?? "";
+            if (cell.length > max)
+                max = cell.length;
+        }
+        return Math.min(max, 60);
+    });
+    const renderRow = (cells) => {
+        const padded = cells.map((cell, i) => {
+            const w = widths[i] ?? 0;
+            return clipCell(cell, w).padEnd(w);
+        });
+        return `| ${padded.join(" | ")} |`;
+    };
+    const separator = `|${widths.map((w) => "-".repeat(w + 2)).join("|")}|`;
+    const lines = [renderRow(headers), separator, ...formattedRows.map(renderRow)];
+    if (rescuedCount > 0) {
+        lines.push("");
+        lines.push(`# Note: reformatted ${rescuedCount} cell${rescuedCount === 1 ? "" : "s"} that look numeric in text columns. Run \`oxygen columns retype --to numeric\` to make this permanent.`);
+    }
+    return { content: `${lines.join("\n")}\n`, rescuedCount };
+}
+function clipCell(value, width) {
+    if (value.length <= width)
+        return value;
+    if (width <= 1)
+        return value.slice(0, width);
+    return `${value.slice(0, width - 1)}…`;
 }
 function escapeCsvField(value) {
     const text = value === null || value === undefined
@@ -2916,6 +3590,54 @@ function isTerminalTableActionRunStatus(status) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+async function resolveActiveProfileWithSource() {
+    const resolution = await resolveActiveProfile();
+    let source;
+    if (globalProfileFlag)
+        source = "flag";
+    else if (INITIAL_OXYGEN_PROFILE_ENV)
+        source = "env";
+    else
+        source = resolution.source === "env" ? "env" : resolution.source;
+    return { resolution, source };
+}
+async function handleWhoamiAction(options) {
+    try {
+        const identity = await requestOxygen("/api/cli/whoami");
+        const context = await resolveActiveProfileWithSource();
+        if (context.resolution.exists) {
+            const cached = context.resolution.credentials?.identity;
+            const orgChanged = !cached || cached.organization.id !== identity.organization.id;
+            const userChanged = !cached || cached.user.id !== identity.user.id;
+            if (orgChanged || userChanged) {
+                const refreshed = {
+                    token: context.resolution.credentials.token,
+                    apiUrl: context.resolution.credentials.apiUrl,
+                    identity: identityFromWhoami(identity),
+                };
+                await saveCredentials(refreshed, process.env, {
+                    profile: context.resolution.name,
+                    activate: false,
+                }).catch(() => undefined);
+            }
+        }
+        const data = {
+            ...identity,
+            profile: context.resolution.exists ? context.resolution.name : null,
+            profile_source: context.source,
+        };
+        if (options.json) {
+            writeJson(success("whoami", data));
+            return;
+        }
+        process.stdout.write(formatWhoami(identity, context));
+    }
+    catch (error) {
+        const failure = toFailure("whoami", error);
+        writeJson(failure);
+        process.exitCode = error instanceof OxygenError ? error.exitCode : 1;
+    }
+}
 async function handleLoginAction(options) {
     try {
         const data = await login(options);
@@ -2939,10 +3661,14 @@ async function handleAuthUseTokenAction(options) {
                 api_url: data.credentials.apiUrl,
                 user: data.identity.user,
                 organization: data.identity.organization,
+                renamed: data.renamed,
             }));
             return;
         }
-        process.stdout.write(formatLoginSuccess(data.identity, data.credentials, data.profile));
+        process.stdout.write(formatLoginSuccess(data.identity, data.credentials, data.profile, { renamed: data.renamed }));
+        const hint = await buildPostLoginHint(data.profile);
+        if (hint)
+            process.stdout.write(hint);
     }
     catch (error) {
         const failure = toFailure("auth use-token", error);
@@ -2975,6 +3701,8 @@ async function handleProfilesListAction(options) {
 async function handleProfilesUseAction(profile, options) {
     try {
         const activeProfile = await switchCredentialProfile(profile);
+        const state = await listCredentialProfiles().catch(() => null);
+        const totalProfiles = state?.profiles.length ?? 1;
         const data = {
             active_profile: activeProfile.name,
             profile: summarizeCredentialProfile(activeProfile, true),
@@ -2983,7 +3711,7 @@ async function handleProfilesUseAction(profile, options) {
             writeJson(success("profiles use", data));
             return;
         }
-        process.stdout.write(formatProfileUseSuccess(data.profile));
+        process.stdout.write(formatProfileUseSuccess(data.profile, { totalProfiles }));
     }
     catch (error) {
         const failure = toFailure("profiles use", error);
@@ -2991,6 +3719,74 @@ async function handleProfilesUseAction(profile, options) {
         process.exitCode = error instanceof OxygenError ? error.exitCode : 1;
     }
 }
+async function handleProfilesEnvAction(profile, options) {
+    try {
+        if (options.unset) {
+            const data = {
+                profile,
+                unset: ["OXYGEN_PROFILE", "OXYGEN_API_URL"],
+            };
+            if (options.json) {
+                writeJson(success("profiles env", data));
+                return;
+            }
+            process.stdout.write("unset OXYGEN_PROFILE OXYGEN_API_URL\n");
+            return;
+        }
+        const state = await listCredentialProfiles();
+        const match = state.profiles.find((entry) => entry.name === profile);
+        if (!match) {
+            throw new OxygenError("profile_not_found", `Oxygen CLI profile "${profile}" is not stored.`, {
+                details: { profile },
+                exitCode: 1,
+            });
+        }
+        const env = {
+            OXYGEN_PROFILE: match.name,
+            OXYGEN_API_URL: match.apiUrl,
+        };
+        if (options.json) {
+            writeJson(success("profiles env", { profile: match.name, env }));
+            return;
+        }
+        process.stdout.write(`export OXYGEN_PROFILE=${shellQuote(match.name)}\n`);
+        process.stdout.write(`export OXYGEN_API_URL=${shellQuote(match.apiUrl)}\n`);
+    }
+    catch (error) {
+        const failure = toFailure("profiles env", error);
+        writeJson(failure);
+        process.exitCode = error instanceof OxygenError ? error.exitCode : 1;
+    }
+}
+async function handleProfilesCurrentAction(options) {
+    try {
+        const context = await resolveActiveProfileWithSource();
+        const credentials = context.resolution.credentials;
+        const data = {
+            profile: context.resolution.exists ? context.resolution.name : null,
+            profile_source: context.source,
+            api_url: credentials?.apiUrl ?? null,
+            organization: credentials?.identity?.organization ?? null,
+            user: credentials?.identity?.user ?? null,
+            stored: context.resolution.exists,
+        };
+        if (options.json) {
+            writeJson(success("profiles current", data));
+            return;
+        }
+        process.stdout.write(formatProfilesCurrent(context));
+    }
+    catch (error) {
+        const failure = toFailure("profiles current", error);
+        writeJson(failure);
+        process.exitCode = error instanceof OxygenError ? error.exitCode : 1;
+    }
+}
+function shellQuote(value) {
+    if (/^[A-Za-z0-9_.\-:\/@%+=]+$/.test(value))
+        return value;
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
 async function handleLogoutAction(options) {
     try {
         const clearOptions = {};
@@ -3030,64 +3826,6 @@ async function handleUpdateAction(options) {
         process.exitCode = error instanceof OxygenError ? error.exitCode : 1;
     }
 }
-function detectCliInstallPrefix() {
-    try {
-        const path = fileURLToPath(import.meta.url);
-        const suffixes = [
-            "/lib/node_modules/@oxygen-agent/cli/dist/index.js",
-            "/lib/node_modules/@oxygen/cli/dist/index.js",
-        ];
-        for (const suffix of suffixes) {
-            if (path.endsWith(suffix)) {
-                return path.slice(0, -suffix.length);
-            }
-        }
-    }
-    catch {
-        // Non-file URL (e.g. running from a bundler) — fall through.
-    }
-    return null;
-}
-function updateCli(options) {
-    const packageSpec = readOption(options.package) ?? DEFAULT_CLI_PACKAGE_SPEC;
-    const prefix = detectCliInstallPrefix();
-    const args = prefix
-        ? ["install", "-g", "--prefix", prefix, packageSpec]
-        : ["install", "-g", packageSpec];
-    const command = ["npm", ...args].join(" ");
-    if (options.dryRun) {
-        return {
-            current_version: OXYGEN_VERSION,
-            package: packageSpec,
-            command,
-            dry_run: true,
-            updated: false,
-        };
-    }
-    const result = spawnSync("npm", args, {
-        encoding: "utf8",
-        stdio: options.json ? ["ignore", "pipe", "pipe"] : "inherit",
-    });
-    if (result.error || result.status !== 0) {
-        throw new OxygenError("cli_update_failed", "Unable to update the Oxygen CLI.", {
-            details: {
-                command,
-                package: packageSpec,
-                exit_code: result.status,
-                reason: result.error instanceof Error ? result.error.message : null,
-                stderr: typeof result.stderr === "string" && result.stderr.trim() ? result.stderr.trim().slice(0, 4000) : null,
-            },
-            exitCode: 1,
-        });
-    }
-    return {
-        current_version: OXYGEN_VERSION,
-        package: packageSpec,
-        command,
-        dry_run: false,
-        updated: true,
-    };
-}
 function buildApiKeyCreateBody(options) {
     const body = {};
     const name = readOption(options.name);
@@ -3135,17 +3873,28 @@ async function login(options) {
         browser: options.browser !== false,
         json: Boolean(options.json),
     });
-    const credentials = {
-        token,
-        apiUrl,
-    };
+    const credentials = { token, apiUrl };
     const identity = await requestOxygen("/api/cli/whoami", { credentials });
-    const saveOptions = {};
-    if (options.profile !== undefined)
-        saveOptions.profile = options.profile;
-    const profile = await saveCredentials(credentials, process.env, saveOptions);
+    credentials.identity = identityFromWhoami(identity);
+    const explicitProfile = readOption(options.profile) ?? readEnvProfileName();
+    let chosenProfile;
+    let renamed = false;
+    if (explicitProfile) {
+        chosenProfile = explicitProfile;
+    }
+    else {
+        const seed = identity.organization.slug?.trim() || identity.organization.id;
+        const picked = await pickProfileNameForIdentity(identity.organization.id, seed);
+        chosenProfile = picked.name;
+        renamed = picked.renamed;
+    }
+    const profile = await saveCredentials(credentials, process.env, { profile: chosenProfile });
+    const skillsInstall = runAutomaticSkillsInstall({ apiUrl: credentials.apiUrl });
     if (!options.json) {
-        process.stdout.write(formatLoginSuccess(identity, credentials, profile));
+        process.stdout.write(formatLoginSuccess(identity, credentials, profile, { renamed, skillsInstall }));
+        const hint = await buildPostLoginHint(profile);
+        if (hint)
+            process.stdout.write(hint);
     }
     return {
         logged_in: true,
@@ -3153,6 +3902,7 @@ async function login(options) {
         api_url: credentials.apiUrl,
         user: identity.user,
         organization: identity.organization,
+        skills_install: skillsInstall,
     };
 }
 async function useAuthToken(options) {
@@ -3167,17 +3917,59 @@ async function useAuthToken(options) {
         apiUrl: normalizeApiUrl(readOption(options.apiUrl) ?? defaultApiUrl()),
     };
     const identity = await requestOxygen("/api/cli/whoami", { credentials });
-    const saveOptions = {};
-    if (options.profile !== undefined)
-        saveOptions.profile = options.profile;
-    const profile = await saveCredentials(credentials, process.env, saveOptions);
+    credentials.identity = identityFromWhoami(identity);
+    const explicitProfile = readOption(options.profile) ?? readEnvProfileName();
+    let chosenProfile;
+    let renamed = false;
+    if (explicitProfile) {
+        chosenProfile = explicitProfile;
+    }
+    else {
+        const seed = identity.organization.slug?.trim() || identity.organization.id;
+        const picked = await pickProfileNameForIdentity(identity.organization.id, seed);
+        chosenProfile = picked.name;
+        renamed = picked.renamed;
+    }
+    const profile = await saveCredentials(credentials, process.env, { profile: chosenProfile });
     return {
         identity,
         credentials,
         api_url: credentials.apiUrl,
         profile,
+        renamed,
     };
 }
+function readEnvProfileName() {
+    const value = process.env.OXYGEN_PROFILE?.trim();
+    return value ? value : null;
+}
+function identityFromWhoami(response) {
+    return {
+        organization: {
+            id: response.organization.id,
+            slug: response.organization.slug ?? null,
+            name: response.organization.name,
+        },
+        user: {
+            id: response.user.id,
+            email: response.user.email ?? null,
+        },
+        capturedAt: new Date().toISOString(),
+    };
+}
+async function buildPostLoginHint(activeProfile) {
+    if (output.isTTY !== true || process.env.NO_COLOR) {
+        const state = await listCredentialProfiles().catch(() => null);
+        if (!state || state.profiles.length < 2)
+            return "";
+        return `\n  Pin this terminal:  eval "$(oxygen profiles env ${activeProfile})"\n\n`;
+    }
+    const state = await listCredentialProfiles().catch(() => null);
+    if (!state || state.profiles.length < 2)
+        return "";
+    const c = ansi(true);
+    return `\n  ${c.dim("Pin this terminal:")}  ${c.bold(`eval "$(oxygen profiles env ${activeProfile})"`)}\n\n`;
+}
 async function promptForToken(options) {
     const fallbackLoginUrl = createCliLoginUrl(options.apiUrl);
     if (options.json) {
@@ -3315,9 +4107,11 @@ function startOxygenSpinner(message) {
         },
     };
 }
-function formatLoginSuccess(identity, credentials, profile) {
+function formatLoginSuccess(identity, credentials, profile, options = {}) {
     const email = identity.user.email ?? identity.user.id;
-    const org = identity.organization.name || identity.organization.slug || identity.organization.id;
+    const orgName = identity.organization.name || identity.organization.slug || identity.organization.id;
+    const orgSlug = identity.organization.slug ?? null;
+    const org = orgSlug && orgSlug !== orgName ? `${orgName} (${orgSlug})` : orgName;
     const key = identity.apiKey
         ? `${identity.apiKey.tokenPrefix}...${identity.apiKey.tokenSuffix}`
         : "stored";
@@ -3325,10 +4119,14 @@ function formatLoginSuccess(identity, credentials, profile) {
         .update(`oxygen-cli:${credentials.token}`)
         .digest("hex");
     const c = ansi(output.isTTY === true && !process.env.NO_COLOR);
+    const profileLabel = options.renamed
+        ? `${profile} ${c.dim("(auto-renamed to avoid collision)")}`
+        : profile;
+    // skipcq: JS-0820 — not a React component; rule misfire on array of tuples
     const rows = [
         ["Account", email],
         ["Organization", org],
-        ["Profile", profile],
+        ["Profile", profileLabel],
         ["API", credentials.apiUrl],
         ["Token", key],
         ["Fingerprint", formatFingerprint(fingerprint)],
@@ -3347,6 +4145,7 @@ function formatLoginSuccess(identity, credentials, profile) {
         "",
         ...rows.map(([label, value]) => `  ${c.dim(label.padEnd(labelWidth))}   ${value}`),
         "",
+        ...formatAutomaticSkillsInstallStatusLines(options.skillsInstall),
     ].join("\n");
 }
 function formatFingerprint(hex) {
@@ -3358,6 +4157,9 @@ function summarizeCredentialProfile(profile, active) {
         active,
         api_url: profile.apiUrl,
         token_fingerprint: formatFingerprint(createCredentialFingerprint(profile.token)),
+        organization: profile.identity?.organization ?? null,
+        user: profile.identity?.user ?? null,
+        identity_captured_at: profile.identity?.capturedAt ?? null,
     };
 }
 function createCredentialFingerprint(token) {
@@ -3374,33 +4176,115 @@ function formatProfilesList(data) {
             "",
         ].join("\n");
     }
-    const labelWidth = Math.max(...data.profiles.map((profile) => profile.name.length));
-    return [
+    const nameWidth = Math.max(...data.profiles.map((profile) => profile.name.length));
+    const orgWidth = Math.max(...data.profiles.map((profile) => formatProfileOrgCell(profile).length));
+    const lines = [
         "",
         `${c.bold("Oxygen CLI Profiles")}`,
         "",
         ...data.profiles.map((profile) => {
             const marker = profile.active ? "*" : " ";
+            const orgCell = formatProfileOrgCell(profile);
             return [
-                `${marker} ${profile.name.padEnd(labelWidth)}`,
+                `${marker} ${profile.name.padEnd(nameWidth)}`,
+                orgCell.padEnd(orgWidth),
                 c.dim(profile.api_url),
                 c.dim(profile.token_fingerprint),
             ].join("  ");
         }),
         "",
-    ].join("\n");
+    ];
+    if (data.profiles.length >= 2) {
+        lines.push(`  ${c.dim("Pin a terminal:")}  ${c.bold(`eval "$(oxygen profiles env <profile>)"`)}`);
+        lines.push("");
+    }
+    return lines.join("\n");
 }
-function formatProfileUseSuccess(profile) {
+function formatProfileOrgCell(profile) {
+    if (!profile.organization)
+        return "(unknown org — run `oxygen whoami` to refresh)";
+    const { slug, name } = profile.organization;
+    if (slug && slug !== name)
+        return `${name} (${slug})`;
+    return name || slug || profile.organization.id;
+}
+function formatProfileUseSuccess(profile, options) {
     const c = ansi(output.isTTY === true && !process.env.NO_COLOR);
-    return [
+    const lines = [
         "",
         `${c.green("[OK]")} ${c.bold("CLI profile selected")}`,
         "",
-        `  ${c.dim("Profile")}       ${profile.name}`,
-        `  ${c.dim("API")}           ${profile.api_url}`,
-        `  ${c.dim("Fingerprint")}   ${profile.token_fingerprint}`,
+        `  ${c.dim("Profile")}        ${profile.name}`,
+        `  ${c.dim("Organization")}   ${formatProfileOrgCell(profile)}`,
+        `  ${c.dim("API")}            ${profile.api_url}`,
+        `  ${c.dim("Fingerprint")}    ${profile.token_fingerprint}`,
+        "",
+    ];
+    if (options.totalProfiles >= 2) {
+        lines.push(`  ${c.dim("Note: this changes the active profile for every shell.")}`);
+        lines.push(`  ${c.dim("To pin this terminal only, run:")} ${c.bold(`eval "$(oxygen profiles env ${profile.name})"`)}`);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function formatWhoami(identity, context) {
+    const c = ansi(output.isTTY === true && !process.env.NO_COLOR);
+    const email = identity.user.email ?? identity.user.id;
+    const orgName = identity.organization.name || identity.organization.slug || identity.organization.id;
+    const orgSlug = identity.organization.slug ?? null;
+    const org = orgSlug && orgSlug !== orgName ? `${orgName} (${orgSlug})` : orgName;
+    const sourceLabel = describeProfileSource(context.source);
+    const profileName = context.resolution.exists ? context.resolution.name : "(no stored profile)";
+    const apiUrl = context.resolution.credentials?.apiUrl ?? defaultApiUrl();
+    const rows = [
+        ["Account", email],
+        ["Organization", org],
+        ["Profile", `${profileName} ${c.dim(`(${sourceLabel})`)}`],
+        ["API", apiUrl],
+    ];
+    const labelWidth = Math.max(...rows.map(([label]) => label.length));
+    return [
+        "",
+        ...rows.map(([label, value]) => `  ${c.dim(label.padEnd(labelWidth))}   ${value}`),
         "",
     ].join("\n");
+} // skipcq: JS-C1002
+function formatProfilesCurrent(context) {
+    const c = ansi(output.isTTY === true && !process.env.NO_COLOR);
+    const sourceLabel = describeProfileSource(context.source);
+    if (!context.resolution.exists) {
+        return [
+            "",
+            `${c.dim("No stored profile resolves for this shell.")}`,
+            `  ${c.dim("Source:")}  ${sourceLabel}`,
+            `  ${c.dim("Run")} ${c.bold("oxygen login")} ${c.dim("to create one.")}`,
+            "",
+        ].join("\n");
+    }
+    const credentials = context.resolution.credentials;
+    const orgCell = credentials.identity
+        ? (credentials.identity.organization.slug && credentials.identity.organization.slug !== credentials.identity.organization.name
+            ? `${credentials.identity.organization.name} (${credentials.identity.organization.slug})`
+            : credentials.identity.organization.name)
+        : "(unknown — run `oxygen whoami` to refresh)";
+    return [
+        "",
+        `${c.bold("Active Oxygen CLI Profile")}`,
+        "",
+        `  ${c.dim("Profile")}        ${context.resolution.name}`,
+        `  ${c.dim("Source")}         ${sourceLabel}`,
+        `  ${c.dim("Organization")}   ${orgCell}`,
+        `  ${c.dim("API")}            ${credentials.apiUrl}`,
+        "",
+    ].join("\n");
+}
+function describeProfileSource(source) {
+    switch (source) {
+        case "flag": return "from --profile flag";
+        case "env": return "from OXYGEN_PROFILE";
+        case "file": return "from stored active profile";
+        case "default": return "default fallback";
+    }
 }
 function formatLogoutSuccess(result) {
     const c = ansi(output.isTTY === true && !process.env.NO_COLOR);
@@ -3412,7 +4296,7 @@ function formatLogoutSuccess(result) {
         `${c.green("[OK]")} ${c.bold("CLI logged out")}`,
         "",
         `  ${c.dim("Credentials")}   ${removed}`,
-        `  ${c.dim("Profiles left")}  ${String(result.remainingProfiles)}`,
+        `  ${c.dim("Profiles left")}  ${String(result.remainingProfiles)}`, // skipcq: JS-C1002
         "",
     ].join("\n");
 }
@@ -3426,7 +4310,33 @@ function formatUpdateSuccess(result) {
         `  ${c.dim("Package")}     ${result.package}`,
         `  ${c.dim("Command")}     ${result.command}`,
         "",
+        ...formatAutomaticSkillsInstallStatusLines(result.skills_install),
     ].join("\n");
+} // skipcq: JS-C1002
+function formatAutomaticSkillsInstallStatusLines(result) {
+    if (!result)
+        return [];
+    const c = ansi(output.isTTY === true && !process.env.NO_COLOR);
+    if (!result.attempted) {
+        if (result.reason === "dry_run")
+            return [];
+        return [
+            `${c.dim("Skills")}      skipped (${result.reason ?? "not attempted"})`,
+            "",
+        ];
+    }
+    if (result.ok) {
+        return [
+            `${c.green("[OK]")} ${c.bold("Oxygen skills installed")}`,
+            "",
+        ];
+    }
+    return [
+        `${c.yellow("[WARN]")} Oxygen skills could not be installed; the CLI command still completed.`,
+        `  ${c.dim("Check")} ${"oxygen skills doctor --json"}`,
+        `  ${c.dim("Retry")} ${result.command}`,
+        "",
+    ];
 }
 function renderBox(lines) {
     const width = Math.max(...lines.map(visibleLength), 0);
@@ -3435,6 +4345,7 @@ function renderBox(lines) {
     return [border, ...body, border].join("\n");
 }
 function visibleLength(value) {
+    // skipcq: JS-0004 — ESC (\x1b) is the ANSI CSI introducer; required to strip color codes
     return value.replace(/\x1b\[[0-9;]*m/g, "").length;
 }
 function ansi(enabled) {
@@ -3442,9 +4353,10 @@ function ansi(enabled) {
         ? (text) => `\x1b[${open}m${text}\x1b[${close}m`
         : (text) => text;
     return {
-        bold: wrap(1, 22),
+        bold: wrap(1, 22), // skipcq: JS-0117  // skipcq: JS-W1035
         dim: wrap(2, 22),
         green: wrap(32, 39),
+        yellow: wrap(33, 39),
     };
 }
 function readOption(value) {
@@ -3472,6 +4384,20 @@ function contextAssetsQuery(options) {
     const value = query.toString();
     return value ? `?${value}` : "";
 }
+function buildContextResolveBody(options) {
+    const assetTypes = readCsvOption(options.assetType);
+    const tags = readCsvOption(options.tags);
+    const maxAssets = readNonNegativeInt(options.maxAssets);
+    return {
+        ...(readOption(options.purpose) ? { purpose: readOption(options.purpose) } : {}),
+        ...(assetTypes.length > 0 ? { asset_types: assetTypes } : {}),
+        ...(readOption(options.assetStatus) ? { asset_status: readOption(options.assetStatus) } : {}),
+        ...(tags.length > 0 ? { tags } : {}),
+        ...(options.includeArchived ? { include_archived: true } : {}),
+        ...(maxAssets !== undefined ? { max_assets: maxAssets } : {}),
+        ...(options.requireReady ? { require_ready: true } : {}),
+    };
+}
 function buildContextAssetUpsertBody(options) {
     const asset = options.assetJson ? parseJsonObject(options.assetJson) : {};
     const tags = readCsvOption(options.tags);