@oxygen-agent/cli 1.184.3 → 1.209.23

package/dist/index.js

@@ -1,5 +1,3 @@
-#!/usr/bin/env node
-// skipcq: JS-0271 — bin entry source; build chmod+x on dist/index.js
 import { execFileSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
@@ -374,6 +372,43 @@ function resolveCrmSetupMode(options) {
     }
     return options.live === true ? "live" : "dry_run";
 }
+function buildCrmObjectCreateBody(options) {
+    const slug = readOption(options.slug);
+    if (!slug) {
+        throw new OxygenError("missing_slug", "--slug is required.", { exitCode: 1 });
+    }
+    const displayName = readOption(options.displayName);
+    if (!displayName) {
+        throw new OxygenError("missing_display_name", "--display-name is required.", { exitCode: 1 });
+    }
+    const columns = options.columnsJson ? parseJsonArray(options.columnsJson) : [];
+    const identities = options.identitiesJson ? parseJsonArray(options.identitiesJson) : [];
+    return {
+        slug,
+        display_name: displayName,
+        columns,
+        identities,
+        mode: resolveCrmSetupMode(options),
+        ...(readOption(options.singularName) ? { singular_name: readOption(options.singularName) } : {}),
+        ...(readOption(options.pluralName) ? { plural_name: readOption(options.pluralName) } : {}),
+        ...(readOption(options.labelColumn) ? { label_column: readOption(options.labelColumn) } : {}),
+        ...(options.relationshipsJson ? { relationships: parseJsonArray(options.relationshipsJson) } : {}),
+        ...(readOption(options.project) ? { project: readOption(options.project) } : {}),
+    };
+}
+function buildCrmObjectAddAttrBody(options) {
+    const column = readOption(options.columnJson)
+        ? parseJsonObject(options.columnJson)
+        : null;
+    if (!column) {
+        throw new OxygenError("missing_column", "--column-json is required.", { exitCode: 1 });
+    }
+    return {
+        column,
+        mode: resolveCrmSetupMode(options),
+        ...(options.asIdentityJson ? { identity: parseJsonObject(options.asIdentityJson) } : {}),
+    };
+}
 function buildCrmAssertBody(object, options) {
     return {
         object,
@@ -382,6 +417,28 @@ function buildCrmAssertBody(object, options) {
         mode: resolveCrmSetupMode(options),
     };
 }
+function buildCrmSyncImportBody(provider, options) {
+    return {
+        provider,
+        object: options.object,
+        mode: resolveCrmSetupMode(options),
+        ...(options.into ? { into: options.into } : {}),
+        ...(readPositiveInt(options.limit) !== undefined ? { limit: readPositiveInt(options.limit) } : {}),
+        ...(readPositiveNumber(options.maxCredits) !== undefined ? { max_credits: readPositiveNumber(options.maxCredits) } : {}),
+        ...(options.approved ? { approved: true } : {}),
+    };
+}
+function buildCrmSyncStatusPath(runId) {
+    const params = new URLSearchParams();
+    params.set("run_id", runId);
+    return `/api/cli/crm/sync/status?${params.toString()}`;
+}
+function buildCrmSyncLinksPath(object, rowId) {
+    const params = new URLSearchParams();
+    params.set("object", object);
+    params.set("row_id", rowId);
+    return `/api/cli/crm/sync/links?${params.toString()}`;
+}
 function buildCrmSearchBody(query, options) {
     const objects = readCsvOption(options.objects);
     const limit = readPositiveInt(options.limit);
@@ -391,6 +448,50 @@ function buildCrmSearchBody(query, options) {
         ...(limit !== undefined ? { limit } : {}),
     };
 }
+function buildCrmMergeBody(object, survivorRowId, loserRowId, options) {
+    const mode = resolveCrmSetupMode(options);
+    if (mode === "live" && options.confirm !== true) {
+        throw new OxygenError("confirm_required", "crm merge --live requires --confirm after inspecting the dry-run field diff.", { exitCode: 1 });
+    }
+    return {
+        object,
+        survivor_row_id: survivorRowId,
+        loser_row_id: loserRowId,
+        mode,
+        ...(options.confirm === true ? { confirm: true } : {}),
+        ...(options.fieldOverridesJson ? { field_overrides: parseJsonObject(options.fieldOverridesJson) } : {}),
+    };
+}
+function buildNotetakerSetupBody(options) {
+    return {
+        mode: resolveNotetakerMode(options),
+        enabled: options.disabled === true ? false : true,
+        capture_mode: "invited_bot",
+        auto_record_scope: "manual",
+        ...(readOption(options.botName) ? { bot_name: readOption(options.botName) } : {}),
+        ...(readPositiveInt(options.defaultMaxMinutes) ? { default_max_minutes: readPositiveInt(options.defaultMaxMinutes) } : {}),
+        ...(readPositiveNumber(options.defaultMaxCredits) ? { default_max_credits: readPositiveNumber(options.defaultMaxCredits) } : {}),
+        ...(readPositiveInt(options.retentionDays) ? { retention_days: readPositiveInt(options.retentionDays) } : {}),
+    };
+}
+function buildNotetakerScheduleBody(meetingUrl, options) {
+    return {
+        mode: resolveNotetakerMode(options),
+        meeting_url: meetingUrl,
+        approved: options.approved === true,
+        ...(readOption(options.title) ? { title: readOption(options.title) } : {}),
+        ...(readOption(options.joinAt) ? { join_at: readOption(options.joinAt) } : {}),
+        ...(readPositiveInt(options.maxMinutes) ? { max_minutes: readPositiveInt(options.maxMinutes) } : {}),
+        ...(readPositiveNumber(options.maxCredits) ? { max_credits: readPositiveNumber(options.maxCredits) } : {}),
+        ...(readOption(options.crmLinksJson) ? { crm_links: parseJsonArray(readOption(options.crmLinksJson) ?? "") } : {}),
+    };
+}
+function resolveNotetakerMode(options) {
+    if (options.live === true && options.dryRun === true) {
+        throw new OxygenError("conflicting_flags", "Pass either --live or --dry-run, not both.", { exitCode: 1 });
+    }
+    return options.live === true ? "live" : "dry_run";
+}
 function buildCrmRelationshipUpsertBody(object, rowId, options) {
     return {
         object,
@@ -403,6 +504,122 @@ function buildCrmRelationshipUpsertBody(object, rowId, options) {
         mode: resolveCrmSetupMode(options),
     };
 }
+function buildCrmActivityBody(object, rowId, options) {
+    const body = {
+        mode: resolveCrmSetupMode(options),
+        activity_type: options.type,
+        links: [{ object, row_id: rowId, role: options.role ?? "actor" }],
+    };
+    if (options.summary)
+        body.summary = options.summary;
+    if (options.body)
+        body.body = options.body;
+    if (options.channel)
+        body.channel = options.channel;
+    if (options.direction)
+        body.direction = options.direction;
+    if (options.occurredAt)
+        body.occurred_at = options.occurredAt;
+    if (options.sourceProvider)
+        body.source_provider = options.sourceProvider;
+    if (options.providerEventId)
+        body.provider_event_id = options.providerEventId;
+    if (options.metadataJson)
+        body.metadata = parseJsonObject(options.metadataJson);
+    return body;
+}
+function buildCrmActivityNoteBody(object, rowId, text, options) {
+    return {
+        mode: resolveCrmSetupMode(options),
+        activity_type: "note",
+        summary: text,
+        links: [{ object, row_id: rowId, role: "actor" }],
+    };
+}
+function buildCrmTimelinePath(object, rowId, options) {
+    const params = new URLSearchParams();
+    if (options.limit)
+        params.set("limit", options.limit);
+    if (options.cursor)
+        params.set("cursor", options.cursor);
+    const query = params.toString();
+    const base = `/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/timeline`;
+    return query ? `${base}?${query}` : base;
+}
+function buildCrmPipelinePath(options) {
+    const params = new URLSearchParams();
+    if (readOption(options.pipeline))
+        params.set("pipeline", readOption(options.pipeline));
+    if (options.limit)
+        params.set("limit", options.limit);
+    const query = params.toString();
+    return query ? `/api/cli/crm/pipeline?${query}` : "/api/cli/crm/pipeline";
+}
+function buildCrmDuplicatesPath(object, options) {
+    const params = new URLSearchParams();
+    if (options.limit)
+        params.set("limit", options.limit);
+    const query = params.toString();
+    const base = `/api/cli/crm/objects/${encodeURIComponent(object)}/duplicates`;
+    return query ? `${base}?${query}` : base;
+}
+function buildCrmAutomationSetBody(templateId, options) {
+    if (options.armed === true && options.disarmed === true) {
+        throw new OxygenError("conflicting_flags", "Pass either --armed or --disarmed, not both.", { exitCode: 1 });
+    }
+    if (options.armed !== true && options.disarmed !== true) {
+        throw new OxygenError("missing_flag", "Pass --armed or --disarmed.", { exitCode: 1 });
+    }
+    const body = {
+        template_id: templateId,
+        armed: options.armed === true,
+        mode: resolveCrmSetupMode(options),
+    };
+    if (options.configJson)
+        body.config = parseJsonObject(options.configJson);
+    return body;
+}
+function buildCrmAutomationAuditPath(options) {
+    const params = new URLSearchParams();
+    if (readOption(options.templateId))
+        params.set("template_id", readOption(options.templateId));
+    if (options.limit)
+        params.set("limit", options.limit);
+    const query = params.toString();
+    return query ? `/api/cli/crm/automation/audit?${query}` : "/api/cli/crm/automation/audit";
+}
+function buildCrmListCreateBody(slug, options) {
+    const body = {
+        slug,
+        base_object: options.base,
+        kind: options.kind,
+        mode: resolveCrmSetupMode(options),
+    };
+    if (options.displayName)
+        body.display_name = options.displayName;
+    if (options.project)
+        body.project = options.project;
+    if (options.filterJson)
+        body.filter = parseJsonObject(options.filterJson);
+    return body;
+}
+function buildCrmListEntryBody(object, rowId, options) {
+    return {
+        object,
+        row_id: rowId,
+        mode: resolveCrmSetupMode(options),
+    };
+}
+function buildCrmListMembersPath(list, options) {
+    const params = new URLSearchParams();
+    if (options.limit)
+        params.set("limit", options.limit);
+    if (options.cursor)
+        params.set("cursor", options.cursor);
+    const query = params.toString();
+    const base = `/api/cli/crm/lists/${encodeURIComponent(list)}/members`;
+    return query ? `${base}?${query}` : base;
+}
 function parseCrmIdentityOption(value) {
     const separator = value.indexOf("=");
     if (separator <= 0 || separator === value.length - 1) {
@@ -425,6 +642,10 @@ function readSpecFileBody(path) {
         throw error;
     }
 }
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUuid(value) {
+    return UUID_PATTERN.test(value);
+}
 // Builds the `prompts` command tree (list/get/upsert/archive). The
 // deprecated `templates` alias is the identical tree — same subcommands,
 // options, request bodies, and routes — differing only in the parent command
@@ -459,7 +680,7 @@ function buildPromptTemplatesCommand(surface, description) {
         .action(async (idOrSlug, options) => {
         await handleAsyncAction(`${surface} get`, options, () => requestOxygen("/api/cli/templates/get", {
             method: "POST",
-            body: idOrSlug.includes("-") && idOrSlug.length >= 32
+            body: isUuid(idOrSlug)
                 ? { id: idOrSlug }
                 : { slug: idOrSlug },
         }));
@@ -818,6 +1039,24 @@ export function createProgram() {
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("support admin list", options, () => requestOxygen(withSupportListQuery("/api/cli/admin/support/tickets", options)));
+    }))
+        .addCommand(new Command("get")
+        .description("Show one support ticket with its message thread (staff only).")
+        .argument("<ticketId>", "Ticket UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (ticketId, options) => {
+        await handleAsyncAction("support admin get", options, () => requestOxygen(`/api/cli/admin/support/tickets/${encodeURIComponent(ticketId)}`));
+    }))
+        .addCommand(new Command("reply")
+        .description("Add a staff message to a support ticket without resolving it.")
+        .argument("<ticketId>", "Ticket UUID.")
+        .requiredOption("--body <body>", "Reply body.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (ticketId, options) => {
+        await handleAsyncAction("support admin reply", options, () => requestOxygen(`/api/cli/admin/support/tickets/${encodeURIComponent(ticketId)}/messages`, {
+            method: "POST",
+            body: { body: readOption(options.body) },
+        }));
     }))
         .addCommand(new Command("resolve")
         .description("Resolve a support ticket and notify the opener (staff only).")
@@ -1013,6 +1252,50 @@ export function createProgram() {
             body: { name },
         }));
     }));
+    program
+        .command("notetaker")
+        .description("AI meeting notetaker setup, scheduling, and session inspection.")
+        .addCommand(new Command("setup")
+        .description("Configure the Recall-backed Oxygen Notetaker. Defaults to dry-run.")
+        .option("--bot-name <name>", "Meeting bot display name. Defaults to Oxygen Notetaker.")
+        .option("--disabled", "Save the notetaker as disabled when used with --live.")
+        .option("--default-max-minutes <n>", "Default maximum meeting minutes to reserve. Defaults to 60.")
+        .option("--default-max-credits <n>", "Default spend cap for live schedules.")
+        .option("--retention-days <n>", "Transcript/artifact retention window. Defaults to 30.")
+        .option("--dry-run", "Preview setup without writing settings.")
+        .option("--live", "Apply notetaker settings.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("notetaker setup", options, () => requestOxygen("/api/cli/notetaker/setup", {
+            method: "POST",
+            body: buildNotetakerSetupBody(options),
+        }));
+    }))
+        .addCommand(new Command("schedule")
+        .description("Schedule an invited meeting bot. Defaults to dry-run.")
+        .argument("<meeting_url>", "Zoom, Google Meet, or Teams meeting URL.")
+        .option("--title <title>", "Meeting title for the CRM timeline.")
+        .option("--join-at <iso>", "ISO date-time for scheduled bot join.")
+        .option("--max-minutes <n>", "Maximum meeting minutes to reserve.")
+        .option("--max-credits <n>", "Required spend cap for live schedules.")
+        .option("--crm-links-json <json>", "JSON array of CRM links: [{\"object\":\"companies\",\"row_id\":\"...\",\"role\":\"account\"}].")
+        .option("--approved", "Approve the live paid Recall bot schedule.")
+        .option("--dry-run", "Preview schedule and credit estimate without creating a bot.")
+        .option("--live", "Create the Recall bot after approval and credit reservation.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (meetingUrl, options) => {
+        await handleAsyncAction("notetaker schedule", options, () => requestOxygen("/api/cli/notetaker/schedule", {
+            method: "POST",
+            body: buildNotetakerScheduleBody(meetingUrl, options),
+        }));
+    }))
+        .addCommand(new Command("status")
+        .description("Get one notetaker session with artifacts and credit state.")
+        .argument("<session_id>", "Notetaker session id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (sessionId, options) => {
+        await handleAsyncAction("notetaker status", options, () => requestOxygen(`/api/cli/notetaker/sessions/${encodeURIComponent(sessionId)}`));
+    }));
     program
         .command("crm")
         .description("Agent-native CRM object setup and metadata commands.")
@@ -1029,12 +1312,56 @@ export function createProgram() {
             body: buildCrmSetupBody(options),
         }));
     }))
-        .addCommand(new Command("objects")
-        .description("List configured CRM objects in the current tenant database.")
+        .addCommand(
+    // `crm objects` lists (parent action runs when no subcommand matches);
+    // `crm objects create` / `crm objects add-attr` create custom objects.
+    new Command("objects")
+        .description("List configured CRM objects, or create/extend custom objects.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("crm objects", options, () => requestOxygen("/api/cli/crm/objects"));
+    })
+        .addCommand(new Command("create")
+        .description("Create or repair a custom CRM object. Defaults to dry-run.")
+        .requiredOption("--slug <slug>", "Object slug (snake_case), such as projects or tasks.")
+        .requiredOption("--display-name <name>", "Human-readable object name, such as Projects.")
+        .requiredOption("--columns-json <json>", "JSON array of column definitions {key,label,dataType,semanticType,...}.")
+        .option("--identities-json <json>", "JSON array of identity definitions {columnKey,normalization,isPrimary?}.")
+        .option("--relationships-json <json>", "JSON array of relationship definitions (not yet supported).")
+        .option("--label-column <key>", "Column key to use as the record label. Defaults to the isRecordLabel column or the first column.")
+        .option("--singular-name <name>", "Singular display name, such as Project.")
+        .option("--plural-name <name>", "Plural display name, such as Projects.")
+        .option("--project <project>", "Project id or slug for the created CRM table.")
+        .option("--dry-run", "Preview the object plan without creating tables.")
+        .option("--live", "Apply the object creation. Default is dry-run.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options, command) => {
+        // The `crm objects` parent declares its own --json + a default
+        // action, so commander binds `objects create --json` to the parent
+        // and options.json is undefined here. optsWithGlobals() reads --json
+        // wherever it landed, so the envelope is emitted like every other
+        // crm_* command instead of printing the bare result.
+        await handleAsyncAction("crm object create", { json: Boolean(command.optsWithGlobals().json) }, () => requestOxygen("/api/cli/crm/objects", {
+            method: "POST",
+            body: buildCrmObjectCreateBody(options),
+        }));
     }))
+        .addCommand(new Command("add-attr")
+        .description("Add one attribute to an existing custom CRM object, optionally as an identity. Defaults to dry-run.")
+        .argument("<object>", "Custom CRM object slug, such as projects or tasks. Standard objects are managed by `crm setup`.")
+        .requiredOption("--column-json <json>", "JSON column definition {key,label,dataType,semanticType,...}.")
+        .option("--as-identity-json <json>", "JSON identity definition {columnKey,normalization,isPrimary?} promoting the new column.")
+        .option("--dry-run", "Preview the attribute plan without altering the table.")
+        .option("--live", "Apply the attribute. Default is dry-run.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, options, command) => {
+        // See `objects create` above: optsWithGlobals() recovers --json,
+        // which the parent command otherwise swallows.
+        await handleAsyncAction("crm object add-attr", { json: Boolean(command.optsWithGlobals().json) }, () => requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}/attributes`, {
+            method: "POST",
+            body: buildCrmObjectAddAttrBody(options),
+        }));
+    })))
         .addCommand(new Command("search")
         .description("Search CRM records by identity or record label.")
         .argument("<query>", "Domain, email, LinkedIn URL, or record name to search for.")
@@ -1086,6 +1413,55 @@ export function createProgram() {
             method: "POST",
             body: buildCrmRelationshipUpsertBody(object, rowId, options),
         }));
+    })))
+        .addCommand(new Command("activity")
+        .description("Log and read CRM record timeline activities.")
+        .addCommand(new Command("log")
+        .description("Log a timeline activity on a CRM record. Defaults to dry-run.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .argument("<row_id>", "CRM record row id.")
+        .requiredOption("--type <type>", "Activity type, such as note, call, meeting_booked, stage_changed.")
+        .option("--summary <summary>", "Short one-line summary of the activity.")
+        .option("--body <body>", "Longer activity body or details.")
+        .option("--channel <channel>", "Channel, such as email, linkedin, or phone.")
+        .option("--direction <direction>", "inbound, outbound, internal, or system.")
+        .option("--occurred-at <iso>", "ISO-8601 timestamp the activity occurred. Defaults to now.")
+        .option("--role <role>", "Link role for the record. Defaults to actor.")
+        .option("--source-provider <provider>", "Provider that produced the activity (for idempotency).")
+        .option("--provider-event-id <id>", "Provider event id (dedupes redelivered events).")
+        .option("--metadata-json <json>", "JSON object of extra activity metadata.")
+        .option("--dry-run", "Preview the activity without writing it.")
+        .option("--live", "Write the activity. Default is dry-run.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, rowId, options) => {
+        await handleAsyncAction("crm activity log", options, () => requestOxygen("/api/cli/crm/activities", {
+            method: "POST",
+            body: buildCrmActivityBody(object, rowId, options),
+        }));
+    }))
+        .addCommand(new Command("note")
+        .description("Log a free-text note on a CRM record. Defaults to dry-run.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .argument("<row_id>", "CRM record row id.")
+        .argument("<text>", "Note text.")
+        .option("--dry-run", "Preview the note without writing it.")
+        .option("--live", "Write the note. Default is dry-run.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, rowId, text, options) => {
+        await handleAsyncAction("crm activity note", options, () => requestOxygen("/api/cli/crm/activities", {
+            method: "POST",
+            body: buildCrmActivityNoteBody(object, rowId, text, options),
+        }));
+    }))
+        .addCommand(new Command("timeline")
+        .description("Show a CRM record's activity timeline, newest first.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .argument("<row_id>", "CRM record row id.")
+        .option("--limit <limit>", "Maximum activities to return.")
+        .option("--cursor <cursor>", "Pagination cursor from a previous page.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, rowId, options) => {
+        await handleAsyncAction("crm activity timeline", options, () => requestOxygen(buildCrmTimelinePath(object, rowId, options)));
     })))
         .addCommand(new Command("describe")
         .description("Describe one configured CRM object.")
@@ -1093,7 +1469,166 @@ export function createProgram() {
         .option("--json", "Print a JSON envelope.")
         .action(async (object, options) => {
         await handleAsyncAction("crm describe", options, () => requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}`));
-    }));
+    }))
+        .addCommand(new Command("duplicates")
+        .description("List ranked duplicate-candidate record pairs for one CRM object (identity-overlap + fuzzy-label). Read-only.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .option("--limit <limit>", "Maximum candidate pairs to return. Defaults to 25, max 100.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, options) => {
+        await handleAsyncAction("crm duplicates", options, () => requestOxygen(buildCrmDuplicatesPath(object, options)));
+    }))
+        .addCommand(new Command("merge")
+        .description("Merge two CRM records: survivor-wins-with-loser-fill field write + relink/tombstone. Defaults to dry-run; --live requires --confirm.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .argument("<survivor_row_id>", "Row id of the record to KEEP (older record by default).")
+        .argument("<loser_row_id>", "Row id of the record to MERGE AWAY and tombstone.")
+        .option("--field-overrides-json <json>", "JSON object of resolved field values keyed by column key, overriding survivor-wins-with-loser-fill.")
+        .option("--dry-run", "Preview the field-level diff and relink plan without writing. Default.")
+        .option("--live", "Apply the merge. Requires --confirm.")
+        .option("--confirm", "Confirm the live merge after inspecting the dry-run diff.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, survivorRowId, loserRowId, options) => {
+        await handleAsyncAction("crm merge", options, () => requestOxygen("/api/cli/crm/merge", {
+            method: "POST",
+            body: buildCrmMergeBody(object, survivorRowId, loserRowId, options),
+        }));
+    }))
+        .addCommand(new Command("pipeline")
+        .description("Show the deals pipeline grouped by stage, with per-stage counts and amount totals.")
+        .option("--pipeline <name>", "Filter to one pipeline, such as sales, expansion, or renewal.")
+        .option("--limit <limit>", "Maximum deals to return per stage.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("crm pipeline", options, () => requestOxygen(buildCrmPipelinePath(options)));
+    }))
+        .addCommand(new Command("lists")
+        .description("Static and dynamic CRM lists over companies, people, deals, and custom objects.")
+        .addCommand(new Command("create")
+        .description("Create a static or dynamic CRM list. Defaults to dry-run.")
+        .argument("<slug>", "List slug, such as vip_accounts.")
+        .requiredOption("--base <object>", "Base CRM object slug the list draws from, such as people.")
+        .requiredOption("--kind <kind>", "List kind: static (materialized) or dynamic (filter-computed).")
+        .option("--filter-json <json>", "Dynamic-list filter as a JSON FilterTree object.")
+        .option("--display-name <name>", "Human-friendly list name.")
+        .option("--project <project>", "Project id or slug for the backing list table.")
+        .option("--dry-run", "Preview the list without creating it.")
+        .option("--live", "Create the list. Default is dry-run.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("crm lists create", options, () => requestOxygen("/api/cli/crm/lists", {
+            method: "POST",
+            body: buildCrmListCreateBody(slug, options),
+        }));
+    }))
+        .addCommand(new Command("add")
+        .description("Add a record to a static CRM list. Defaults to dry-run.")
+        .argument("<list>", "List slug.")
+        .argument("<object>", "Base CRM object slug, such as people.")
+        .argument("<row_id>", "Base record row id.")
+        .option("--dry-run", "Preview the add without writing it.")
+        .option("--live", "Write the membership. Default is dry-run.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (list, object, rowId, options) => {
+        await handleAsyncAction("crm lists add", options, () => requestOxygen(`/api/cli/crm/lists/${encodeURIComponent(list)}/entries`, {
+            method: "POST",
+            body: buildCrmListEntryBody(object, rowId, options),
+        }));
+    }))
+        .addCommand(new Command("remove")
+        .description("Remove a record from a static CRM list. Defaults to dry-run.")
+        .argument("<list>", "List slug.")
+        .argument("<object>", "Base CRM object slug, such as people.")
+        .argument("<row_id>", "Base record row id.")
+        .option("--dry-run", "Preview the removal without writing it.")
+        .option("--live", "Tombstone the membership. Default is dry-run.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (list, object, rowId, options) => {
+        await handleAsyncAction("crm lists remove", options, () => requestOxygen(`/api/cli/crm/lists/${encodeURIComponent(list)}/entries`, {
+            method: "DELETE",
+            body: buildCrmListEntryBody(object, rowId, options),
+        }));
+    }))
+        .addCommand(new Command("members")
+        .description("List a CRM list's members (the audience for sequence enrollment).")
+        .argument("<list>", "List slug.")
+        .option("--limit <limit>", "Maximum members to return.")
+        .option("--cursor <cursor>", "Pagination cursor from a previous page.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (list, options) => {
+        await handleAsyncAction("crm lists members", options, () => requestOxygen(buildCrmListMembersPath(list, options)));
+    }))
+        .addCommand(new Command("ls")
+        .description("List every configured CRM list.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("crm lists ls", options, () => requestOxygen("/api/cli/crm/lists"));
+    })))
+        .addCommand(new Command("automation")
+        .description("Arm / disarm standing CRM automation templates and read the audit trail.")
+        .addCommand(new Command("rules")
+        .description("List the standing CRM automation templates and their armed state.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("crm automation rules", options, () => requestOxygen("/api/cli/crm/automation"));
+    }))
+        .addCommand(new Command("set")
+        .description("Arm or disarm a standing CRM automation template. Defaults to dry-run.")
+        .argument("<template-id>", "Template id, such as crm-lead-stage-router.")
+        .option("--armed", "Arm the template (let bridged signals advance stages).")
+        .option("--disarmed", "Disarm the template.")
+        .option("--config-json <json>", "JSON object of per-template config.")
+        .option("--dry-run", "Preview the change without writing it.")
+        .option("--live", "Write the change. Default is dry-run.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (templateId, options) => {
+        await handleAsyncAction("crm automation set", options, () => requestOxygen("/api/cli/crm/automation", {
+            method: "POST",
+            body: buildCrmAutomationSetBody(templateId, options),
+        }));
+    }))
+        .addCommand(new Command("audit")
+        .description("Show recent CRM automation rule changes, newest first.")
+        .option("--template-id <id>", "Filter to one template id.")
+        .option("--limit <limit>", "Maximum audit entries to return.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("crm automation audit", options, () => requestOxygen(buildCrmAutomationAuditPath(options)));
+    })))
+        .addCommand(new Command("sync")
+        .description("Import records from a connected CRM (HubSpot/Attio) into Oxygen CRM objects, and inspect import runs and provider links.")
+        .addCommand(new Command("import")
+        .description("Import provider records into an Oxygen CRM object as a durable workflow run. Defaults to dry-run.")
+        .argument("<provider>", "Connected CRM to import from: hubspot or attio.")
+        .requiredOption("--object <object>", "Provider object: hubspot contacts|companies, or attio people|companies.")
+        .option("--into <object>", "Oxygen CRM object slug to import into. Defaults to the natural mapping.")
+        .option("--limit <n>", "Max records to pull this run.")
+        .option("--max-credits <n>", "Volume + external-quota cap (BYOK reads cost 0 Oxygen credits but use your CRM API quota).")
+        .option("--approved", "Confirm a live import after inspecting a dry run.")
+        .option("--dry-run", "Preview the import without pulling. Default.")
+        .option("--live", "Run the live import. Requires --approved and --max-credits.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (provider, options) => {
+        await handleAsyncAction("crm sync import", options, () => requestOxygen("/api/cli/crm/sync/import", {
+            method: "POST",
+            body: buildCrmSyncImportBody(provider, options),
+        }));
+    }))
+        .addCommand(new Command("status")
+        .description("Show the status of a CRM import workflow run.")
+        .argument("<run_id>", "Import workflow run id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("crm sync status", options, () => requestOxygen(buildCrmSyncStatusPath(runId)));
+    }))
+        .addCommand(new Command("links")
+        .description("Show provider record links (HubSpot/Attio ids) mapped to one Oxygen CRM record.")
+        .argument("<object>", "Oxygen CRM object slug, such as companies or people.")
+        .argument("<row_id>", "Oxygen CRM record row id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, rowId, options) => {
+        await handleAsyncAction("crm sync links", options, () => requestOxygen(buildCrmSyncLinksPath(object, rowId)));
+    })));
     const tablesCommand = program
         .command("tables")
         .description("Tenant workspace table commands.")
@@ -1621,7 +2156,7 @@ export function createProgram() {
         .description("Playbooks, strategies, campaigns, personas, and research notes.")
         .addCommand(new Command("list")
         .description("List workspace context assets.")
-        .option("--type <type>", "Filter by playbook, strategy, campaign, positioning, persona, competitor, research_note, or other.")
+        .option("--type <type>", "Filter by playbook, strategy, campaign, positioning, brand, voice, persona, competitor, research_note, message_playbook, or other.")
         .option("--status <status>", "Filter by draft, active, or archived.")
         .option("--tags <csv>", "Comma-separated tags that must be present.")
         .option("--include-archived", "Include archived assets when no status filter is set.")
@@ -1642,7 +2177,7 @@ export function createProgram() {
         .addCommand(new Command("upsert")
         .description("Create or update a context asset.")
         .option("--id <asset_id>", "Existing asset UUID to update. Omit to create.")
-        .option("--type <type>", "Asset type. Defaults to other on create.")
+        .option("--type <type>", "Asset type (positioning, brand, voice, persona, competitor, message_playbook, playbook, strategy, campaign, research_note, other). Defaults to other on create.")
         .option("--title <title>", "Asset title. Required on create.")
         .option("--status <status>", "draft, active, or archived.")
         .option("--tags <csv>", "Comma-separated asset tags.")
@@ -1650,12 +2185,24 @@ export function createProgram() {
         .option("--body <text>", "Asset body text.")
         .option("--data-json <json>", "Flexible JSON object for structured asset data.")
         .option("--asset-json <json>", "Full asset JSON object. CLI flags override matching fields.")
+        .option("--default", "Pin as the canonical default for its type (auto-applied to copy generation). brand/voice/positioning defaults are injected into AI message columns.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("context asset upsert", options, () => requestOxygen("/api/cli/context/assets/upsert", {
             method: "POST",
             body: buildContextAssetUpsertBody(options),
         }));
+    }))
+        .addCommand(new Command("set-default")
+        .description("Pin a context asset as the canonical default for its type. The canonical brand/voice/positioning docs are auto-applied to AI copy generation.")
+        .argument("<asset_id>", "Context asset UUID.")
+        .option("--off", "Unpin instead of pin (clears the canonical default for this type).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (assetId, options) => {
+        await handleAsyncAction("context asset set-default", options, () => requestOxygen("/api/cli/context/assets/set-default", {
+            method: "POST",
+            body: { id: assetId, is_default: options.off ? false : true },
+        }));
     }))
         .addCommand(new Command("archive")
         .description("Archive a context asset.")
@@ -1811,10 +2358,15 @@ export function createProgram() {
     }))
         .addCommand(new Command("archive")
         .description("Archive a saved blueprint (seed blueprints cannot be archived).")
-        .argument("<slug>", "Blueprint slug or id.")
+        .argument("<id_or_slug>", "Blueprint UUID or slug.")
         .option("--json", "Print a JSON envelope.")
-        .action(async (slug, options) => {
-        await handleAsyncAction("blueprints archive", options, () => requestOxygen("/api/cli/blueprints/archive", { method: "POST", body: { slug } }));
+        .action(async (idOrSlug, options) => {
+        await handleAsyncAction("blueprints archive", options, () => requestOxygen("/api/cli/blueprints/archive", {
+            method: "POST",
+            body: isUuid(idOrSlug)
+                ? { id: idOrSlug }
+                : { slug: idOrSlug },
+        }));
     }))
         .addCommand(new Command("share")
         .description("Create a public share URL for a saved blueprint (oxygen-agent.com/b/<code>).")
@@ -2929,7 +3481,8 @@ export function createProgram() {
         await handleAsyncAction("billing balance", options, () => requestOxygen("/api/cli/billing/balance"));
     }))
         .addCommand(new Command("usage")
-        .description("Show credit ledger events.")
+        .description("Show credit ledger events or automation action usage.")
+        .option("--meter <meter>", "credits or automation_actions. Defaults to credits.")
         .option("--days <n>", "Lookback window in days. Defaults to 30.")
         .option("--from <iso>", "Only include ledger events at or after this ISO timestamp.")
         .option("--to <iso>", "Only include ledger events at or before this ISO timestamp.")
@@ -2994,6 +3547,39 @@ export function createProgram() {
                 ...(readOption(options.description) ? { description: readOption(options.description) } : {}),
             },
         }));
+    }))
+        .addCommand(new Command("set-plan")
+        .description("Create or update an off-Stripe custom plan for an organization (staff only).")
+        .requiredOption("--organization-id <id>", "Organization id to put on the custom plan.")
+        .requiredOption("--credits <n>", "Monthly managed credits included in the plan.")
+        .option("--org-id <id>", "Alias for --organization-id.")
+        .option("--name <text>", "Display name for the plan, e.g. \"Custom Contract - $250/mo\".")
+        .option("--price <usd>", "Monthly contract price in USD (recorded for display; not charged off-Stripe).")
+        .option("--weekly-credits <n>", "Weekly spend throttle. Defaults to the monthly credits (no throttle).")
+        .option("--rollover <n>", "Max balance credits roll over to. Defaults to the monthly credits.")
+        .option("--base-tier <tier>", "Base pricing tier to inherit feature flags from. Defaults to growth_250.")
+        .option("--byok", "Enable bring-your-own-key integrations for the plan.")
+        .option("--note <text>", "Internal note stored on the contract.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("billing set-plan", options, () => requestOxygen("/api/cli/billing/set-plan", {
+            method: "POST",
+            body: {
+                organization_id: readOption(options.organizationId) ?? readOption(options.orgId),
+                monthly_credits: readPositiveNumber(options.credits),
+                ...(readOption(options.name) ? { name: readOption(options.name) } : {}),
+                ...(readOption(options.price) ? { price: readPositiveNumber(options.price) } : {}),
+                ...(readOption(options.weeklyCredits)
+                    ? { weekly_credits_limit: readPositiveNumber(options.weeklyCredits) }
+                    : {}),
+                ...(readOption(options.rollover)
+                    ? { rollover_cap: readPositiveNumber(options.rollover) }
+                    : {}),
+                ...(readOption(options.baseTier) ? { base_tier: readOption(options.baseTier) } : {}),
+                ...(options.byok ? { byok: true } : {}),
+                ...(readOption(options.note) ? { note: readOption(options.note) } : {}),
+            },
+        }));
     }));
     program
         .command("budget")
@@ -3892,7 +4478,8 @@ export function createProgram() {
         .option("--account <id>", "LinkedIn only: filter to one sender account (sender id, connection id, or Unipile account id).")
         .option("--unread", "Only show conversations with unread messages.")
         .option("--responses-only", "Email only: only conversations with an inbound reply (never sent-only threads).")
-        .option("--bucket <bucket>", "Email only: primary or others.")
+        .option("--bucket <bucket>", "Email only: primary or others (superseded by --segment).")
+        .option("--segment <segment>", "Email only: top-tab folder — primary, others, sent, warmup, or dmarc.")
         .option("--status <keys>", "Email only: comma-separated status keys (e.g. interested,meeting_booked).")
         .option("--sequence-id <ids>", "Email only: comma-separated campaign (sequence) ids.")
         .option("--provider <providers>", "Email only: comma-separated providers (google,microsoft).")
@@ -3918,6 +4505,7 @@ export function createProgram() {
                 params.set("responses_only", "true");
             for (const [flag, key] of [
                 ["bucket", "bucket"],
+                ["segment", "segment"],
                 ["status", "status"],
                 ["sequenceId", "sequence_id"],
                 ["provider", "provider"],
@@ -3985,12 +4573,17 @@ export function createProgram() {
     }))
         .addCommand(new Command("mark-read")
         .description("Mark a conversation and all its messages as read.")
-        .argument("<conversation>", "Conversation id or Unipile chat id.")
+        .argument("<conversation>", "Conversation id, Unipile chat id, or (email) Zapbox thread id.")
+        .option("--channel <channel>", "Inbox channel: linkedin (default) or email.")
         .option("--json", "Print a JSON envelope.")
         .action(async (conversation, options) => {
-        await handleAsyncAction("inbox mark-read", options, () => requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/read`, {
-            method: "POST",
-        }));
+        await handleAsyncAction("inbox mark-read", options, () => {
+            const channel = readOption(options.channel);
+            return requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/read`, {
+                method: "POST",
+                body: channel ? { channel } : {},
+            });
+        });
     }))
         .addCommand(new Command("analyze")
         .description("Run the default analysis on an email conversation now: sentiment + interest category + a drafted reply (Oxygen's default model). The worker also does this automatically on inbound mail.")
@@ -4928,7 +5521,7 @@ export function createProgram() {
         .description("Workflow event trigger utilities.")
         .addCommand(new Command("emit")
         .description("Emit a normalized workflow event and enqueue matching event-triggered workflows.")
-        .requiredOption("--source <source>", "Event source, such as instantly, calendar, or hubspot.")
+        .requiredOption("--source <source>", "Event source, such as instantly, calendar, hubspot, or oxygen.notetaker.")
         .requiredOption("--event <event>", "Event type, such as email.reply_received.")
         .requiredOption("--payload-json <json>", "Normalized event payload object.")
         .option("--raw-payload-json <json>", "Optional raw provider payload object.")
@@ -8924,6 +9517,8 @@ function buildBillingLedgerParams(options) {
         params.set("days", String(days));
     if (limit)
         params.set("limit", String(limit));
+    if (readOption(options.meter))
+        params.set("meter", readOption(options.meter));
     if (readOption(options.from))
         params.set("from", readOption(options.from));
     if (readOption(options.to))
@@ -8972,6 +9567,7 @@ function buildContextAssetUpsertBody(options) {
         ...(readOption(options.summary) ? { summary: readOption(options.summary) } : {}),
         ...(readOption(options.body) ? { body: readOption(options.body) } : {}),
         ...(options.dataJson ? { data: parseJsonObject(options.dataJson) } : {}),
+        ...(options.default ? { is_default: true } : {}),
     };
 }
 function buildEnrichColumnBody(// skipcq: JS-R1005 -- CLI body builder maps enrichment aliases, selection, provider order, and safety caps.