@oxygen-agent/cli 1.853.1 → 1.861.0

package/README.md

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

package/dist/cli-values.d.ts

@@ -2,6 +2,22 @@
 export declare function readPositiveInt(value: string | undefined): number | undefined;
 /** Read a string field from an unknown record-shaped value, or null when it is missing/non-string. */
 export declare function readRecordString(value: unknown, key: string): string | null;
+/**
+ * Parse repeated `key=value` flags into an object. Call this INSIDE an action,
+ * never as a Commander `parseArg`.
+ *
+ * That placement is the whole point. A parser passed to Commander runs during
+ * `parseOptions`, OUTSIDE the action's try/catch, so throwing there escapes as
+ * an uncaught exception: a raw Node stack trace instead of the JSON envelope,
+ * and exit code 0 — a failure reporting success. Collect with the total
+ * `collectRepeatable`, then validate here where handleAsyncAction can shape the
+ * error. (Same shape as index.ts's readNamedCredentials, which predates this.)
+ *
+ * Later occurrences of the same key win, which is what a user retyping one
+ * binding expects. Only the first `=` splits, so a value containing `=`
+ * survives intact.
+ */
+export declare function parseKeyValuePairs(values: readonly string[], example?: string): Record<string, string>;
 /** Parse a JSON string that must decode to a plain object, throwing a typed invalid_json error otherwise. */
 export declare function parseJsonObject(value: string): Record<string, unknown>;
 /** Read a JSON-object CLI option (e.g. `--selection-json`, `--filter-tree-json`), or undefined when absent. */

package/dist/cli-values.js

@@ -27,6 +27,37 @@ export function readRecordString(value, key) {
     const entry = value[key];
     return typeof entry === "string" ? entry : null;
 }
+/**
+ * Parse repeated `key=value` flags into an object. Call this INSIDE an action,
+ * never as a Commander `parseArg`.
+ *
+ * That placement is the whole point. A parser passed to Commander runs during
+ * `parseOptions`, OUTSIDE the action's try/catch, so throwing there escapes as
+ * an uncaught exception: a raw Node stack trace instead of the JSON envelope,
+ * and exit code 0 — a failure reporting success. Collect with the total
+ * `collectRepeatable`, then validate here where handleAsyncAction can shape the
+ * error. (Same shape as index.ts's readNamedCredentials, which predates this.)
+ *
+ * Later occurrences of the same key win, which is what a user retyping one
+ * binding expects. Only the first `=` splits, so a value containing `=`
+ * survives intact.
+ */
+export function parseKeyValuePairs(values, example = "url=linkedin_url") {
+    const out = {};
+    for (const value of values) {
+        const separator = value.indexOf("=");
+        const key = separator > 0 ? value.slice(0, separator).trim() : "";
+        const entry = separator > 0 ? value.slice(separator + 1).trim() : "";
+        if (!key || !entry) {
+            throw new OxygenError("invalid_request", `Expected key=value, got "${value}".`, {
+                details: { value, example },
+                exitCode: 1,
+            });
+        }
+        out[key] = entry;
+    }
+    return out;
+}
 /** Parse a JSON string that must decode to a plain object, throwing a typed invalid_json error otherwise. */
 export function parseJsonObject(value) {
     let parsed;

package/dist/command-manifest.js

@@ -114,6 +114,7 @@ export function searchCommandManifest(manifest, query, requestedLimit = DEFAULT_
     const matches = tokens.length === 0
         ? []
         : manifest.commands
+            .filter((command) => !command.hidden)
             .map((command) => ({ command, score: scoreCommand(command, tokens, route) }))
             .filter((entry) => entry.score > 0)
             .sort((a, b) => b.score - a.score || a.command.name.localeCompare(b.command.name));
@@ -144,6 +145,7 @@ export function getCommandManifestEntry(manifest, exactName) {
 export function suggestCommandNames(manifest, query, limit = 3) {
     const tokens = tokenizeCommandQuery(query);
     return manifest.commands
+        .filter((command) => !command.hidden)
         .map((command) => ({ command, score: scoreCommand(command, tokens, null) }))
         .filter((entry) => entry.score > 0)
         .sort((a, b) => b.score - a.score || a.command.name.localeCompare(b.command.name))

package/dist/index.js

@@ -20,7 +20,7 @@ import { clearCredentials, defaultApiUrl, listCredentialProfiles, loadCredential
 import { ensureFreshCliForApiUrl, requestOxygen } from "./http-client.js";
 import { acquireMirrorLock, clearConflictFiles, deletePageFile, emptyMirrorState, findMirrorSlugByPageId, isFileDirty, listConflictFiles, listLocalMirrors, localPageSha256, markMirrorStale, mirrorExists, pageFilePath, planMirrorPush, purgeMirror, resetMirrorForFullResync, quarantineDirtyFile, readMirrorState, releaseMirrorLock, resolveDefaultConfigDir, resolveMirrorDir, writeGeneratedIndexFile, writeGeneratedLogFile, writeMirrorState, writePageFile, } from "./knowledge-mirror.js";
 import { waitForCliRun } from "./run-wait.js";
-import { assertModeFlagsExclusive, parseJsonObject, readJsonObjectOption, readPositiveInt, readRecordString, resolveLiveDryRunMode, } from "./cli-values.js";
+import { assertModeFlagsExclusive, parseKeyValuePairs, parseJsonObject, readJsonObjectOption, readPositiveInt, readRecordString, resolveLiveDryRunMode, } from "./cli-values.js";
 import { formatAiPromptPreviewNotice } from "./column-run-notices.js";
 import { runLocalCustomHttpColumn } from "./local-custom-http-column.js";
 import { captureCurrentTranscript, collectFeedbackEnvironment, TranscriptCaptureError, } from "./transcript.js";
@@ -452,6 +452,20 @@ function writeDryRunNotice(data) {
     if (typeof block.next_step === "string")
         process.stderr.write(`${block.next_step}\n`);
 }
+// An `oxy_live_` key can only ever answer for the one workspace it is bound to,
+// so `orgs list` returns a single row and `orgs use` refuses — both truthfully,
+// and both indistinguishable from "this account has one workspace" if you only
+// read stdout. The server says which credential answered and whether it can
+// switch; mirror that on stderr, the same split writeDryRunNotice uses, so the
+// machine-read envelope stays clean. This is the line that would have stopped a
+// user from minting a 21st key that also could not switch.
+function writeCredentialNotice(credential) {
+    if (!credential || credential.switchable !== false)
+        return;
+    if (typeof credential.message === "string" && credential.message.trim()) {
+        process.stderr.write(`${credential.message}\n`);
+    }
+}
 // A sender-profile write that could not durably host the photo still succeeds —
 // the profile is saved, just with a picture no inbox vendor will ever be able to
 // fetch. That is the one failure mode nobody notices until the mailboxes ship
@@ -2494,6 +2508,7 @@ export function createProgram() {
         .option("--token <token>", "CLI API token created in the Oxygen dashboard.")
         .option("--api-url <url>", "Oxygen API URL. Defaults to OXYGEN_API_URL or https://oxygen-agent.com.")
         .option("--profile <name>", "Store credentials under a named CLI profile and make it active.")
+        .option("--org <organization>", "Workspace to land in after logging in (id or slug). Needs a user key, which works across every workspace you belong to; a workspace-bound key can only land in its own.")
         .option("--force", "Repoint an existing profile at a different API host. Refused without this flag.")
         .option("--no-browser", "Skip the browser handoff and paste the token manually.")
         .option("--json", "Print a JSON envelope.")
@@ -2638,7 +2653,7 @@ export function createProgram() {
         .action(async (options) => {
         const outputOptions = { ...options, json: options.json || Boolean(activationCommand.opts().json) };
         await handleAsyncAction("activation state", outputOptions, () => requestOxygen("/api/cli/activation/state"));
-    }));
+    }), { hidden: true });
     const commandsCommand = program
         .command("commands")
         .description("Discover CLI commands. With no subcommand, print the backwards-compatible full manifest.")
@@ -2760,7 +2775,7 @@ export function createProgram() {
         .description("List organizations available to the current CLI identity.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("orgs list", options, () => requestOxygen("/api/cli/orgs"));
+        await handleOrgsListAction(options);
     }))
         .addCommand(new Command("use")
         .description("Select the active organization for this CLI profile.")
@@ -7093,6 +7108,8 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .addCommand(new Command("add")
         .description("Add a nullable column to a workspace table. Writes the definition only — this never runs the column and never spends credits; use `columns run` for that, with --dry-run first to see the cost.")
         .argument("<table>", "Table id or slug.")
+        .option("--preset <preset>", "Add a pre-built enrichment bundle instead of one column: `person_enrich` (one LinkedIn profile lookup, then headline, bio, location and followers for free) or `company_enrich` (domain, LinkedIn page, headcount, industry and full profile, cascading across providers until one answers). Oxygen finds the identity column itself — override with --input. Creating the columns is free; run them afterwards, --dry-run first.")
+        .option("--input <slot=column...>", "Bind a preset input to an exact column, e.g. --input url=linkedin_url, or --input company_name=account --input domain=website. Repeatable. Only needed when the automatic match is wrong or missing.", collectRepeatable, [])
         .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.")
@@ -7128,6 +7145,23 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         // skipcq: JS-R1005 — intentional per-option branching to assemble the columns-add request body
         .action(async (table, options) => {
         await handleAsyncAction("columns add", options, async () => {
+            // A preset names its own columns, so --label does not apply to it.
+            const preset = readOption(options.preset);
+            if (preset) {
+                if (options.label || options.promptKey || options.definitionJson) {
+                    throw new OxygenError("invalid_request", "--preset builds its own column set. Drop --label/--prompt-key/--definition-json, or add the column by hand without --preset.", { exitCode: 1 });
+                }
+                const presetBody = { table, preset };
+                const inputs = parseKeyValuePairs(options.input ?? []);
+                if (Object.keys(inputs).length > 0)
+                    presetBody.inputs = inputs;
+                if (options.key)
+                    presetBody.payload_column = options.key;
+                return requestOxygen("/api/cli/tables/columns", {
+                    method: "POST",
+                    body: presetBody,
+                });
+            }
             if (!options.promptKey && !options.label) {
                 throw new OxygenError("invalid_request", "--label is required.", { exitCode: 1 });
             }
@@ -12619,6 +12653,53 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             const suffix = params.toString();
             return requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/enrollments${suffix ? `?${suffix}` : ""}`);
         });
+    }))
+        .addCommand(new Command("contacts")
+        .description("List a launched campaign's table-backed contacts with full source variables and durable contacted/not-contacted status. Contacts removed from this campaign are hidden; source rows remain intact.")
+        .argument("<sequence>", "Sequence id or slug.")
+        .option("--contact-state <state>", "Filter: all, contacted, or not_contacted.", "all")
+        .option("--limit <n>", "Maximum contacts to return (1-500).", "100")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (sequence, options) => {
+        await handleAsyncAction("sequences contacts", options, () => {
+            const contactState = readOption(options.contactState) ?? "all";
+            if (!["all", "contacted", "not_contacted"].includes(contactState)) {
+                throw new Error("--contact-state must be all, contacted, or not_contacted.");
+            }
+            const limit = readPositiveInt(options.limit);
+            if (limit === undefined || limit > 500) {
+                throw new Error("--limit must be between 1 and 500.");
+            }
+            const params = new URLSearchParams({
+                contact_state: contactState,
+                limit: String(limit),
+            });
+            return requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/contacts?${params.toString()}`);
+        });
+    }))
+        .addCommand(new Command("contacts-remove")
+        .description("Remove selected source-table rows from this campaign only. Preview by default; --approved stops pending enrollment work and queues delegated-provider cleanup while preserving source rows and historical analytics.")
+        .argument("<sequence>", "Sequence id or slug.")
+        .requiredOption("--table-row-ids <ids>", "Comma-separated source table row UUIDs (maximum 500).")
+        .option("--approved", "Apply the previewed campaign-only removal.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (sequence, options) => {
+        await handleAsyncAction("sequences contacts-remove", options, () => {
+            const tableRowIds = options.tableRowIds
+                .split(",")
+                .map((value) => value.trim())
+                .filter(Boolean);
+            if (tableRowIds.length === 0 || tableRowIds.length > 500) {
+                throw new Error("--table-row-ids must contain between 1 and 500 row UUIDs.");
+            }
+            return requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/contacts`, {
+                method: "POST",
+                body: {
+                    table_row_ids: tableRowIds,
+                    approved: options.approved === true,
+                },
+            });
+        });
     }))
         .addCommand(new Command("reconcile")
         .description("Safely reconcile one ambiguous LinkedIn invite/message from provider reads. Preview-only unless --approved; never resends.")
@@ -13944,6 +14025,50 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 },
             });
         });
+    }))
+        .addCommand(new Command("auto-enroll")
+        .description("Standing permission to connect NEW eligible mailboxes to EmailGuard automatically, so monitoring keeps up with the fleet instead of needing a manual connect per inbox. Enrolment is a RECURRING monthly charge per inbox, so arming is approval-gated and always bounded by a per-cycle credit ceiling. Without --arm/--disarm/--run this reports the current state (0 credits).")
+        .option("--arm", "Arm the standing permission. Requires --max-credits; previews unless --approved.")
+        .option("--disarm", "Turn it off. Existing subscriptions are untouched. 0 credits, no approval needed.")
+        .option("--run", "Enrol one bounded batch now.")
+        .option("--dry-run", "With --run: report what would be enrolled without connecting or charging.")
+        .option("--max-credits <n>", "Per-billing-cycle credit ceiling this permission may spend (required with --arm).")
+        .option("--approved", "Actually arm (otherwise --arm returns a preview).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("mailboxes emailguard auto-enroll", options, () => {
+            const path = "/api/cli/mailboxes/emailguard/auto-enroll";
+            if (options.disarm) {
+                return requestOxygen(path, {
+                    method: "POST",
+                    body: { enabled: false },
+                });
+            }
+            if (options.arm) {
+                const ceiling = readOption(options.maxCredits);
+                if (!ceiling) {
+                    throw new Error("--max-credits <n> is required with --arm: a standing permission without a ceiling would be unlimited recurring spend authority.");
+                }
+                return requestOxygen(path, {
+                    method: "POST",
+                    body: {
+                        enabled: true,
+                        max_credits_per_cycle: Number(ceiling),
+                        ...(options.approved ? { approved: true } : {}),
+                    },
+                });
+            }
+            if (options.run) {
+                return requestOxygen(path, {
+                    method: "POST",
+                    body: {
+                        run: true,
+                        ...(options.dryRun ? { dry_run: true } : {}),
+                    },
+                });
+            }
+            return requestOxygen(path);
+        });
     })))
         .addCommand(new Command("delegation")
         .description("Google sending-domain delegation only — not Microsoft OAuth and not a credential-file handoff to OXYGEN Warm-up or EmailGuard. Reports covered domains plus the exact client id/scopes; --probe mints a real token per mailbox. Read-only, sends no mail, 0 Oxygen credits.")
@@ -19576,6 +19701,12 @@ async function runAuthDoctor() {
         }))
         : { ok: false, skipped: true, reason: "no_credentials" };
     const cachedIdentity = credentials?.identity ?? null;
+    const cachedOrganization = credentials?.activeOrganization ?? cachedIdentity?.organization ?? null;
+    // The live read wins over the stored `authKind`: a profile written by an older
+    // CLI can carry no kind at all, and the server always knows.
+    const liveAuthType = "ok" in identity && identity.ok && typeof identity.data.authType === "string"
+        ? identity.data.authType
+        : null;
     return {
         profile: context?.resolution.exists ? context.resolution.name : null,
         profile_source: context?.source ?? null,
@@ -19583,13 +19714,24 @@ async function runAuthDoctor() {
         api_url: apiUrl,
         auth_kind: credentials?.authKind ?? null,
         token_fingerprint: credentials ? formatFingerprint(createCredentialFingerprint(credentials.token)) : null,
-        cached_organization: credentials?.activeOrganization ?? cachedIdentity?.organization ?? null,
+        cached_organization: cachedOrganization,
         cached_user: cachedIdentity?.user ?? null,
         profile_error: profileError,
+        org_switching: {
+            switchable: resolveOrgSwitchability(liveAuthType ?? credentials?.authKind ?? null),
+            current_organization: cachedOrganization,
+        },
         health,
         identity,
     };
 }
+function resolveOrgSwitchability(authKind) {
+    if (authKind === "user_session" || authKind === "oauth")
+        return true;
+    if (authKind === "org_api_key")
+        return false;
+    return null;
+}
 async function runAuthDoctorCheck(fn) {
     try {
         return { ok: true, data: await fn() };
@@ -19606,31 +19748,79 @@ async function runAuthDoctorCheck(fn) {
         };
     }
 }
+async function handleOrgsListAction(options) {
+    try {
+        const data = await requestOxygen("/api/cli/orgs");
+        emitSuccess("orgs list", data, options);
+        writeCredentialNotice(data.credential);
+    }
+    catch (error) {
+        emitCliFailure("orgs list", error);
+    }
+}
+/**
+ * Write a completed org selection back onto the stored profile.
+ *
+ * Shared by `orgs use` and `oxygen login --org` so the two-step (log in, then
+ * switch) and the one-step collapse cannot drift apart.
+ *
+ * Gated on the credential being one that can actually carry a selection: an
+ * org-bound key's active workspace is a property of the key, not of the profile,
+ * so persisting a different one would only produce a profile that lies about
+ * where its commands land.
+ */
+async function persistOrganizationSelection(input) {
+    const { profile, credentials, organization } = input;
+    if (!profile || !credentials || !organization)
+        return false;
+    if (credentials.authKind !== "user_session" && !credentials.token.startsWith("oxy_user_")) {
+        return false;
+    }
+    await updateActiveOrganizationForProfile(profile, storedOrganizationFromOption(organization));
+    return true;
+}
+/** Select an organization server-side, then persist it. Used by `login --org`. */
+async function selectOrganizationForProfile(input) {
+    const data = await requestOxygen("/api/cli/orgs/select", {
+        method: "POST",
+        body: { organization: input.organization },
+        credentials: input.credentials,
+    });
+    const selectionPersisted = await persistOrganizationSelection({
+        profile: input.profile,
+        credentials: input.credentials,
+        organization: data.currentOrganization,
+    });
+    return { data, selectionPersisted };
+}
 async function handleOrgUseAction(organization, options, command) {
     try {
+        // Credentials stay ambient here: an OXYGEN_API_KEY in the environment
+        // outranks the stored profile inside requestOxygen, and passing the profile
+        // explicitly would silently select with the wrong one.
         const data = await requestOxygen("/api/cli/orgs/select", {
             method: "POST",
             body: { organization },
         });
         const context = await resolveActiveProfileWithSource();
-        const credentials = context.resolution.credentials;
-        const canPersistSelection = Boolean(context.resolution.exists &&
-            credentials &&
-            (credentials.authKind === "user_session" || credentials.token.startsWith("oxy_user_")) &&
-            data.currentOrganization);
-        if (canPersistSelection && data.currentOrganization) {
-            await updateActiveOrganizationForProfile(context.resolution.name, storedOrganizationFromOption(data.currentOrganization));
-        }
+        const profile = context.resolution.exists ? context.resolution.name : null;
+        const selectionPersisted = await persistOrganizationSelection({
+            profile,
+            credentials: context.resolution.credentials,
+            organization: data.currentOrganization,
+        });
         const result = {
             ...data,
-            profile: context.resolution.exists ? context.resolution.name : null,
-            selection_persisted: canPersistSelection,
+            profile,
+            selection_persisted: selectionPersisted,
         };
         if (options.json) {
             writeJson(success(command, result));
-            return;
         }
-        writeJson(result);
+        else {
+            writeJson(result);
+        }
+        writeCredentialNotice(data.credential);
     }
     catch (error) {
         emitCliFailure(command, error);
@@ -19906,14 +20096,39 @@ async function login(options) {
         profile: chosenProfile,
         allowHostChange: options.force === true,
     });
+    // `--org` collapses the two-step every agency user was doing by hand (`login`,
+    // then `orgs use`). It is skipped when the credential already landed in the
+    // requested workspace, so a workspace-bound key naming its own workspace
+    // succeeds instead of being refused for asking to stay where it is.
+    const requestedOrg = readOption(options.org) ?? process.env.OXYGEN_ORG?.trim() ?? null;
+    let activeOrganization = loginIdentity.activeOrganization;
+    let organizations = loginIdentity.organizations;
+    if (requestedOrg && !matchesStoredOrganization(activeOrganization, requestedOrg)) {
+        const selected = await selectOrganizationForProfile({
+            organization: requestedOrg,
+            profile,
+            credentials,
+        });
+        activeOrganization = storedOrganizationFromOption(selected.data.currentOrganization);
+        organizations = organizations.map((organization) => ({
+            ...organization,
+            selected: organization.id === selected.data.currentOrganization.id,
+        }));
+    }
     const skillsInstall = await runAutomaticSkillsInstall({ apiUrl: credentials.apiUrl, credentials });
     // Opt-in eager mirror of every reachable workspace, off by default so login
     // stays fast and non-surprising. Best-effort: a sync failure never fails login.
     if (process.env.OXYGEN_KNOWLEDGE_AUTOSYNC === "1") {
         await runKnowledgeMirrorSyncAll({ ifStale: true }).catch(() => undefined);
     }
+    const resolved = {
+        ...loginIdentity,
+        activeOrganization,
+        organizations,
+        ...(requestedOrg ? { selectionRequired: false } : {}),
+    };
     if (!options.json) {
-        process.stdout.write(formatLoginSuccessForResolved(loginIdentity, profile, { renamed, skillsInstall }));
+        process.stdout.write(formatLoginSuccessForResolved(resolved, profile, { renamed, skillsInstall }));
         const hint = await buildPostLoginHint(profile);
         if (hint)
             process.stdout.write(hint);
@@ -19922,13 +20137,24 @@ async function login(options) {
         logged_in: true,
         profile,
         api_url: credentials.apiUrl,
-        user: loginIdentity.user,
-        organization: loginIdentity.activeOrganization,
-        organizations: loginIdentity.organizations,
-        selection_required: loginIdentity.selectionRequired,
+        user: resolved.user,
+        organization: resolved.activeOrganization,
+        organizations: resolved.organizations,
+        selection_required: resolved.selectionRequired,
         skills_install: skillsInstall,
     };
 }
+// `--org` accepts whatever `orgs list` prints, so the match has to accept the
+// same handles the server does — minus clerkOrgId, which stored profiles do not
+// carry.
+function matchesStoredOrganization(organization, ref) {
+    if (!organization)
+        return false;
+    const normalized = ref.trim();
+    if (!normalized)
+        return false;
+    return organization.id === normalized || organization.slug === normalized;
+}
 async function applyAuthToken(options) {
     const token = readOption(options.token);
     if (!token) {
@@ -20416,6 +20642,7 @@ function formatAuthDoctor(data) {
         const org = data.cached_organization.slug ?? data.cached_organization.id;
         lines.push(`  ${styles.dim("Cached org")}    ${data.cached_organization.name} (${org})`);
     }
+    lines.push(`  ${styles.dim("Org switching")} ${formatOrgSwitching(data.org_switching)}`);
     if (data.profile_error) {
         lines.push(`  ${styles.dim("Profile error")} ${data.profile_error.code}: ${data.profile_error.message}`);
     }
@@ -20432,6 +20659,15 @@ function formatAuthDoctor(data) {
     lines.push("");
     return lines.join("\n");
 }
+function formatOrgSwitching(orgSwitching) {
+    if (orgSwitching.switchable === true)
+        return "available — `oxygen orgs use <organization>`";
+    if (orgSwitching.switchable === false) {
+        const name = orgSwitching.current_organization?.name;
+        return `locked to ${name ?? "this workspace"} — \`oxygen login\` for a switchable user key`;
+    }
+    return "unknown";
+}
 function formatProfileOrgCell(profile) {
     if (!profile.organization)
         return "(unknown org — run `oxygen whoami` to refresh)";

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

@@ -37,21 +37,19 @@ export const OXYGEN_CAPABILITY_ROUTES = [
         primitive: null,
         owns: "First-run setup and interactive Workspace Copilot sessions over the shared primitive contracts.",
         notFor: "Recurring deterministic automation or standing adaptive jobs; use Workflows or Agents.",
-        execution: "Start onboarding or a hosted Copilot session; every resulting action still uses its native primitive gate.",
+        execution: "Resolve factual onboarding state, then let the user choose a Recipe, Blueprint, or their own outcome before starting a hosted Copilot session.",
         posture: "mixed",
-        gatewayTools: ["oxygen_whoami", "oxygen_activation_state", "oxygen_context_resolve", "oxygen_copilot_start"],
-        gatewayCommands: ["whoami", "activation state", "context resolve", "copilot start"],
+        gatewayTools: ["oxygen_whoami", "oxygen_recipes_list", "oxygen_blueprints_list", "oxygen_context_resolve", "oxygen_copilot_start"],
+        gatewayCommands: ["whoami", "recipes list", "blueprints list", "context resolve", "copilot start"],
         skills: ["oxygen-quickstart", "oxygen-gtm"],
-        // `activation` carries the prescribed-play step state and the one next step. It
-        // belongs here rather than under a primitive because "where am I in setup" is a
-        // Control question — and without the section on this card, the Copilot's very
-        // first tool call routes past the only read that answers it.
+        // `activation` remains an exact legacy API family for saved clients, but it
+        // has no recommended gateway and is not an intent term or first-touch path.
         endpointSections: ["activation", "copilot", "home"],
         // "next step" alone is deliberately absent: it is a phrase every primitive's
         // users say ("next step of this workflow run"), and a 6-point multi-word hit
         // would drag those queries here. The terms kept are the ones only a founder
         // asking where they are in setup actually types.
-        intentTerms: ["onboard", "onboarding", "first run", "first day", "setup oxygen", "copilot", "assistant", "guided", "activation", "where am i", "next step in setup", "what do i do next"],
+        intentTerms: ["onboard", "onboarding", "first run", "first day", "setup oxygen", "copilot", "assistant", "guided", "where am i", "next step in setup", "what do i do next"],
     },
     {
         id: "billing-and-budgets",
@@ -171,7 +169,7 @@ export const OXYGEN_CAPABILITY_ROUTES = [
         gatewayCommands: ["recipes list", "recipes show", "recipes install"],
         skills: ["oxygen-recipes"],
         endpointSections: ["blueprints", "recipes", "templates"],
-        intentTerms: ["recipe", "playbook", "proven play", "journey", "day 1", "day 7", "day 30", "blueprint", "template", "what should i do"],
+        intentTerms: ["recipe", "playbook", "proven play", "activation play", "setup play", "journey", "day 1", "day 7", "day 30", "blueprint", "template", "what should i do"],
     },
     {
         id: "records",

package/node_modules/@oxygen/shared/dist/copilot-journeys.d.ts

@@ -7,14 +7,7 @@ export type CopilotJourney = {
     /** The first user message a journey card seeds into a new session. */
     seedMessage: string;
 };
-/**
- * The one journey a workspace with no play yet is pointed at. Exported as a named
- * constant because every consumer that needs "the prescribed play" must key on the
- * slug: the array is display-ordered, and `COPILOT_JOURNEYS[0]` would silently
- * re-designate a different journey the first time someone reorders the cards.
- * `home/suggestions.tsx` keys its glyphs the same way, for the same reason.
- */
-export declare const PRESCRIBED_COPILOT_JOURNEY_SLUG = "inbound-led-outbound";
+export declare const LINKEDIN_NETWORK_COPILOT_JOURNEY_SLUG = "inbound-led-outbound";
 export declare const COPILOT_JOURNEYS: readonly CopilotJourney[];
 export type CopilotJourneySlug = (typeof COPILOT_JOURNEYS)[number]["slug"];
 export declare function getCopilotJourney(slug: string): CopilotJourney | null;

package/node_modules/@oxygen/shared/dist/copilot-journeys.js

@@ -4,17 +4,12 @@
 // Each journey is a thin descriptor over EXISTING advisory catalog Recipes:
 // journeys add no runtime behavior, and every guardrail (never enroll/send/buy/
 // change DNS without approval) rides those recipes' own approval gates.
-/**
- * The one journey a workspace with no play yet is pointed at. Exported as a named
- * constant because every consumer that needs "the prescribed play" must key on the
- * slug: the array is display-ordered, and `COPILOT_JOURNEYS[0]` would silently
- * re-designate a different journey the first time someone reorders the cards.
- * `home/suggestions.tsx` keys its glyphs the same way, for the same reason.
- */
-export const PRESCRIBED_COPILOT_JOURNEY_SLUG = "inbound-led-outbound";
+// Stable slug for sessions deliberately launched from the matching Recipe.
+// It is never a default: first-touch surfaces stay outcome-neutral.
+export const LINKEDIN_NETWORK_COPILOT_JOURNEY_SLUG = "inbound-led-outbound";
 export const COPILOT_JOURNEYS = [
     {
-        slug: PRESCRIBED_COPILOT_JOURNEY_SLUG,
+        slug: LINKEDIN_NETWORK_COPILOT_JOURNEY_SLUG,
         title: "Inbound-led outbound",
         description: "Work the LinkedIn network you already have — connections and post engagers — as a capped warm motion.",
         // The network-first play leads: connections and post engagers are the two
@@ -29,10 +24,8 @@ export const COPILOT_JOURNEYS = [
         // Deliberately free of steps, commands, table names, and caps: encoding
         // mechanics here would fork a second, unversioned copy of the play that no
         // catalog gate can lint (ADR 0013 §11 — a journey is a thin pointer at
-        // advisory recipes, never a hardcoded kit). The activation-state instruction
-        // is the one piece of procedure that belongs here rather than in the recipe:
-        // it is about where THIS workspace already stands, which the catalog cannot know.
-        seedMessage: "I want to turn the LinkedIn network I already have — my connections and the people who engage with my posts — into a small, safe, approval-gated outreach motion. First read my workspace's current activation state and tell me where I already am, then resume from there instead of starting over. Follow the linkedin-network-first-motion recipe for the play itself. Do not connect an account, enroll anyone, send anything, or spend credits without asking me first.",
+        // advisory recipes, never a hardcoded kit).
+        seedMessage: "I chose the linkedin-network-first-motion recipe. Help me turn the LinkedIn network I already have — my connections and the people who engage with my posts — into a small, safe, approval-gated outreach motion. Inspect the relevant workspace primitives, follow the recipe, and resume from durable evidence instead of starting over. Do not connect an account, enroll anyone, send anything, or spend credits without asking me first.",
     },
     {
         slug: "tam-sourcing",

package/node_modules/@oxygen/shared/dist/sending-seats.d.ts

@@ -61,3 +61,31 @@ export declare function sendingSeatMonthlyPriceCents(key: SendingSeatKey): numbe
 export declare function sendingSeatSubtotalCents(key: SendingSeatKey, quantity: number): number;
 /** "$30.00" — seat prices are whole cents, so this never rounds. */
 export declare function formatSeatPrice(cents: number): string;
+/**
+ * Whether the connect-time seat requirement is armed.
+ *
+ * FAIL-CLOSED TO OFF, deliberately, and shipped that way. Arming this refuses a
+ * sender connection that succeeds today, so it is a customer-visible enforcement
+ * change and belongs to a human decision, not to whenever the code happens to
+ * deploy. Same posture as the free-tier entitlement flag.
+ *
+ * It is also the switch that decides whether grandfathered organizations are
+ * capped at their cutover count or effectively unlimited: with the gate off,
+ * everyone connects freely; with it on, an org may add senders beyond its legacy
+ * entitlement only by buying seats. Do not arm it until that call is made and
+ * the legacy backfill has run for every channel being enforced.
+ */
+export declare function sendingSeatGateEnabled(env?: NodeJS.ProcessEnv): boolean;
+export declare const SENDING_SEAT_GATE_ENABLED_ENV_VAR = "OXYGEN_SENDING_SEAT_GATE_ENABLED";
+/**
+ * Which seat kind a connect request consumes, by CLI path prefix.
+ *
+ * MAILBOXES ARE DELIBERATELY ABSENT. Email mailboxes live in the TENANT
+ * database, so the control-plane grandfathering backfill cannot see them and did
+ * not cover them. Enforcing a seat on mailbox connect today would refuse
+ * customers who already have mailboxes attached — the precise failure this whole
+ * grandfathering design exists to prevent. Add mailboxes here only once a
+ * tenant-aware backfill has granted their legacy entitlements.
+ */
+export declare const SEAT_KIND_BY_CONNECT_PREFIX: ReadonlyArray<readonly [prefix: string, seatKey: SendingSeatKey]>;
+export declare function seatKindForConnectPath(pathname: string): SendingSeatKey | null;

package/node_modules/@oxygen/shared/dist/sending-seats.js

@@ -99,3 +99,46 @@ export function sendingSeatSubtotalCents(key, quantity) {
 export function formatSeatPrice(cents) {
     return `$${(cents / 100).toFixed(2)}`;
 }
+/**
+ * Whether the connect-time seat requirement is armed.
+ *
+ * FAIL-CLOSED TO OFF, deliberately, and shipped that way. Arming this refuses a
+ * sender connection that succeeds today, so it is a customer-visible enforcement
+ * change and belongs to a human decision, not to whenever the code happens to
+ * deploy. Same posture as the free-tier entitlement flag.
+ *
+ * It is also the switch that decides whether grandfathered organizations are
+ * capped at their cutover count or effectively unlimited: with the gate off,
+ * everyone connects freely; with it on, an org may add senders beyond its legacy
+ * entitlement only by buying seats. Do not arm it until that call is made and
+ * the legacy backfill has run for every channel being enforced.
+ */
+export function sendingSeatGateEnabled(env = process.env) {
+    const raw = env[SENDING_SEAT_GATE_ENABLED_ENV_VAR];
+    if (!raw)
+        return false;
+    const normalized = raw.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+export const SENDING_SEAT_GATE_ENABLED_ENV_VAR = "OXYGEN_SENDING_SEAT_GATE_ENABLED";
+/**
+ * Which seat kind a connect request consumes, by CLI path prefix.
+ *
+ * MAILBOXES ARE DELIBERATELY ABSENT. Email mailboxes live in the TENANT
+ * database, so the control-plane grandfathering backfill cannot see them and did
+ * not cover them. Enforcing a seat on mailbox connect today would refuse
+ * customers who already have mailboxes attached — the precise failure this whole
+ * grandfathering design exists to prevent. Add mailboxes here only once a
+ * tenant-aware backfill has granted their legacy entitlements.
+ */
+export const SEAT_KIND_BY_CONNECT_PREFIX = [
+    ["/api/cli/senders/connect", "linkedin"],
+    ["/api/cli/whatsapp/connect", "whatsapp"],
+];
+export function seatKindForConnectPath(pathname) {
+    for (const [prefix, seatKey] of SEAT_KIND_BY_CONNECT_PREFIX) {
+        if (pathname === prefix || pathname.startsWith(`${prefix}/`))
+            return seatKey;
+    }
+    return null;
+}

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

@@ -1,4 +1,4 @@
-export declare const OXYGEN_VERSION = "1.853.1";
+export declare const OXYGEN_VERSION = "1.861.0";
 export declare const OXYGEN_MINIMUM_CLI_VERSION = "1.181.0";
 export declare const MANAGED_INBOX_MINIMUM_CLI_VERSION = "1.326.2";
 export declare const SUPPORT_AGENT_REPLY_MINIMUM_CLI_VERSION = "1.747.0";

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

@@ -1,4 +1,4 @@
-export const OXYGEN_VERSION = "1.853.1";
+export const OXYGEN_VERSION = "1.861.0";
 // The GLOBAL CLI compatibility floor: the oldest CLI allowed to call any
 // operational route. Raising it hard-rejects every older CLI from the entire
 // product, so it obeys one law, enforced by scripts/ci/cli-min-version-gate.mjs:

package/package.json

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