@oxygen-agent/cli 1.50.37 → 1.64.5

package/dist/index.js

@@ -14,13 +14,16 @@ import { inferRowsFileFormat, normalizeRowsForNewTable, normalizeRowsFormat, par
 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 ]",
@@ -161,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")
@@ -209,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")
@@ -263,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")
@@ -527,6 +546,25 @@ export function createProgram() {
         .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.")
@@ -629,6 +667,23 @@ export function createProgram() {
             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.")
@@ -661,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")
@@ -872,15 +943,25 @@ export function createProgram() {
         .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)
@@ -891,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")
@@ -911,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.")
@@ -918,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),
@@ -967,6 +1052,7 @@ export function createProgram() {
                     ...(readOption(options.connectionId) ? { connection_id: readOption(options.connectionId) } : {}),
                     ...(options.background ? { background: true } : {}),
                     ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
+                    ...(maxConcurrency ? { max_concurrency: maxConcurrency } : {}),
                 },
             });
         });
@@ -1129,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: {
@@ -1142,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) } : {}),
             },
         }));
@@ -1427,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) => {
@@ -1533,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 () => {
@@ -1540,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}`);
         });
@@ -1621,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.")
@@ -1719,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.")
@@ -1831,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 } : {}),
             },
         }));
@@ -2281,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.")
@@ -2721,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);
@@ -2922,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,
@@ -2940,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;
@@ -2961,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,
@@ -2978,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;
@@ -3079,6 +3170,246 @@ async function exportRows(table, options) {
         ...(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 } : {});
 }
@@ -3117,11 +3448,12 @@ function formatRows(rows, format, columns) {
         ...rows.flatMap((row) => Object.keys(row)),
     ].filter((key, index, all) => all.indexOf(key) === index && rows.some((row) => key in row));
     if (format === "csv") {
+        const csvBody = [
+            keys.map(escapeCsvField).join(","),
+            ...rows.map((row) => keys.map((key) => escapeCsvField(row[key])).join(",")),
+        ].join("\n");
         return {
-            content: [
-                keys.map(escapeCsvField).join(","),
-                ...rows.map((row) => keys.map((key) => escapeCsvField(row[key])).join(",")),
-            ].join("\n") + "\n",
+            content: `${csvBody}\n`,
             rescuedCount: 0,
         };
     }
@@ -3152,21 +3484,27 @@ function formatRows(rows, format, columns) {
         }
         return Math.min(max, 60);
     });
-    const renderRow = (cells) => "| " + cells.map((cell, i) => clipCell(cell, widths[i]).padEnd(widths[i])).join(" | ") + " |";
-    const separator = "|" + widths.map((w) => "-".repeat(w + 2)).join("|") + "|";
+    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 };
+    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) + "…";
+    return `${value.slice(0, width - 1)}…`;
 }
 function escapeCsvField(value) {
     const text = value === null || value === undefined
@@ -3252,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);
@@ -3275,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);
@@ -3311,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),
@@ -3319,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);
@@ -3327,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 = {};
@@ -3413,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,
@@ -3431,6 +3902,7 @@ async function login(options) {
         api_url: credentials.apiUrl,
         user: identity.user,
         organization: identity.organization,
+        skills_install: skillsInstall,
     };
 }
 async function useAuthToken(options) {
@@ -3445,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) {
@@ -3593,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";
@@ -3603,11 +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)],
@@ -3626,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) {
@@ -3637,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) {
@@ -3653,34 +4176,116 @@ 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 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) {
+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);
     const removed = result.removedProfile
@@ -3705,8 +4310,34 @@ 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);
     const border = `+${"-".repeat(width + 2)}+`;
@@ -3725,6 +4356,7 @@ function ansi(enabled) {
         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) {
@@ -3752,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);