@oxygen-agent/cli 1.353.2 → 1.365.3

package/dist/index.js

@@ -6,7 +6,7 @@ import { basename, dirname, extname, join, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { Command, Option } from "commander";
+import { Command, CommanderError, Option } from "commander";
 import { applyOxygenHelp } from "./help.js";
 import { buildCommandManifest } from "./command-manifest.js";
 import { AGENCY_DIRECTORY_REGIONS, AGENCY_DIRECTORY_SERVICES, describeWorkflowStatusChange, formatCellForDisplay, formatPublicBudgetScopes, exitCodeForOxygenError, parseWorkflowStatusChange, isVersionGreater, isVersionLess, MAX_MCP_TOOL_NAME_LENGTH, OXYGEN_VERSION, OxygenError, parseKnowledgePageMarkdown, sleep, success, toFailure, workflowMcpToolName, } from "@oxygen/shared";
@@ -95,6 +95,10 @@ const TABLE_INGESTION_WAIT_DEFAULT_TIMEOUT_SECONDS = 600;
 const TABLE_INGESTION_WAIT_DEFAULT_INTERVAL_SECONDS = 5;
 const WORKFLOW_TAIL_DEFAULT_TIMEOUT_SECONDS = 600;
 const WORKFLOW_TAIL_DEFAULT_INTERVAL_SECONDS = 2;
+// `copilot send` streams a single turn: a shorter default deadline than a batch
+// workflow tail, polled every couple of seconds so assistant text feels live.
+const COPILOT_SEND_DEFAULT_TIMEOUT_SECONDS = 300;
+const COPILOT_SEND_DEFAULT_INTERVAL_SECONDS = 2;
 // Cloudflare domain sync returns partial pages under the request budget; the
 // CLI auto-continues up to this many follow-up POSTs before handing back a
 // still-partial summary.
@@ -632,7 +636,7 @@ function resolveComposioRunMode(options) {
     }
     return "dry_run";
 }
-const DEFAULT_CRM_SETUP_OBJECTS = ["companies", "people"];
+const DEFAULT_CRM_SETUP_OBJECTS = ["companies", "people", "deals"];
 function buildCrmSetupBody(options) {
     return {
         objects: readCrmSetupObjects(options.objects),
@@ -819,8 +823,7 @@ function buildPublishingPostsListPath(options) {
     const filters = {
         status: options.status,
         approval_status: options.approvalStatus,
-        label: options.label,
-        campaign_id: options.campaign,
+        tag: options.tag,
         provider: options.provider,
         limit: options.limit,
     };
@@ -844,8 +847,18 @@ function buildPublishingMentionsResolveBody(options) {
     if (!text && identifiers.length === 0) {
         throw new OxygenError("invalid_request", "Pass --text/--text-file or at least one --identifier.", { exitCode: 1 });
     }
+    const source = readOption(options.source);
+    if (source && source !== "sender" && source !== "scraper") {
+        throw new OxygenError("invalid_request", "--source must be sender or scraper.", { exitCode: 1 });
+    }
+    if ((source ?? "sender") === "sender" && !readOption(options.account)) {
+        throw new OxygenError("invalid_request", "--account is required when resolving through a sender.", { exitCode: 1 });
+    }
     return {
-        account: options.account,
+        ...(options.account ? { account: options.account } : {}),
+        ...(source ? { source } : {}),
+        ...(options.approved ? { approved: true } : {}),
+        ...(options.maxCredits ? { max_credits: Number(options.maxCredits) } : {}),
         ...(text ? { text } : {}),
         ...(identifiers.length > 0 ? {
             identifiers: identifiers.map((value) => ({
@@ -1155,22 +1168,7 @@ function buildPublishingDraftsAcceptBody(options) {
         body.timezone = timezone;
     return body;
 }
-function buildPublishingCampaignBody(options, requireName) {
-    const name = readOption(options.name);
-    if (requireName && !name) {
-        throw new OxygenError("invalid_request", "Pass --name.", { exitCode: 1 });
-    }
-    const goal = readOption(options.goal);
-    const startsAt = readOption(options.startsAt);
-    const endsAt = readOption(options.endsAt);
-    return {
-        ...(name ? { name } : {}),
-        ...(goal ? { goal } : {}),
-        ...(startsAt ? { starts_at: startsAt } : {}),
-        ...(endsAt ? { ends_at: endsAt } : {}),
-    };
-}
-function buildPublishingLabelsBody(options) {
+function buildPublishingTagsBody(options) {
     const add = splitCommaList(options.add);
     const remove = splitCommaList(options.remove);
     if (add.length === 0 && remove.length === 0) {
@@ -1209,14 +1207,12 @@ function buildPublishingImportBody(options) {
         throw new OxygenError("conflicting_flags", "Pass either --dry-run or --approved, not both.", { exitCode: 1 });
     }
     const contents = readPublishingTextFile(file, "--file");
-    const campaign = readOption(options.campaign);
-    const labels = splitCommaList(options.label);
+    const tags = splitCommaList(options.tags);
     const isJson = file.trim().toLowerCase().endsWith(".json");
     return {
         ...(isJson ? { rows: readPublishingImportRows(contents) } : { csv: contents }),
         dry_run: options.approved !== true,
-        ...(campaign ? { campaign_id: campaign } : {}),
-        ...(labels.length > 0 ? { labels } : {}),
+        ...(tags.length > 0 ? { tags } : {}),
     };
 }
 function readPublishingImportRows(contents) {
@@ -1269,12 +1265,10 @@ function buildPublishingAmplificationCreateBody(options) {
     };
 }
 function publishingAmplificationScope(options) {
-    const campaign = readOption(options.campaign);
-    const label = readOption(options.label);
+    const tag = readOption(options.tag);
     const post = readOption(options.post);
     return {
-        ...(campaign ? { scope_campaign_id: campaign } : {}),
-        ...(label ? { scope_label: label } : {}),
+        ...(tag ? { scope_tag: tag } : {}),
         ...(post ? { scope_post_id: post } : {}),
     };
 }
@@ -2314,8 +2308,11 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .addCommand(new Command("mentions")
         .description("Resolve LinkedIn identities for a publish-faithful post preview.")
         .addCommand(new Command("resolve")
-        .description("Resolve @handles, LinkedIn profile/company links, provider ids, and URNs through a connected sender (notify=false).")
-        .requiredOption("--account <account>", "LinkedIn sender id, connection id, or Unipile account id.")
+        .description("Resolve @handles, LinkedIn profile/company links, provider ids, and URNs — through a connected sender (notify=false, free) or the managed scraper (--source scraper, paid, no sender/window needed).")
+        .option("--account <account>", "LinkedIn sender id, connection id, or Unipile account id. Required unless --source scraper.")
+        .option("--source <source>", "Resolution source: sender (default, free) or scraper (managed cookieless lookup, ~10 credits per identity, needs --approved --max-credits).")
+        .option("--approved", "Approve the paid scraper lookups (required with --source scraper).")
+        .option("--max-credits <n>", "Credit ceiling for scraper lookups (required with --source scraper).")
         .option("--text <text>", "Post text containing @identifiers or LinkedIn URLs.")
         .option("--text-file <path>", "Read post text from a local file.")
         .option("--identifier <value...>", "Explicit provider id, public identifier, LinkedIn URL, or URN (repeat values after the flag).")
@@ -2334,8 +2331,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .description("List scheduled posts.")
         .option("--status <status>", "Filter by draft, scheduled, queued, publishing, published, failed, or canceled.")
         .option("--approval-status <status>", "Filter by draft, needs_approval, approved, or rejected.")
-        .option("--label <label>", "Only posts carrying this label.")
-        .option("--campaign <campaign_id>", "Only posts in this campaign.")
+        .option("--tag <tag>", "Only posts carrying this workspace tag.")
         .option("--provider <provider>", "Filter by provider: linkedin, x, instagram, tiktok, facebook, or youtube.")
         .option("--limit <n>", "Maximum posts to return.")
         .option("--json", "Print a JSON envelope.")
@@ -2612,69 +2608,18 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             body: buildPublishingMediaUploadedBody(options),
         }));
     })))
-        .addCommand(new Command("campaigns")
-        .description("Group scheduled posts under a launch or theme, then filter the queue (`publishing posts list --campaign`) or scope an amplification policy to it.")
-        .addCommand(new Command("list")
-        .description("List campaigns with their post counts.")
-        .option("--json", "Print a JSON envelope.")
-        .action(async (options) => {
-        await handleAsyncAction("publishing campaigns list", options, () => requestOxygen("/api/cli/publishing/campaigns"));
-    }))
-        .addCommand(new Command("create")
-        .description("Create a campaign.")
-        .requiredOption("--name <name>", "Campaign name.")
-        .option("--goal <goal>", "What this campaign is for.")
-        .option("--starts-at <iso>", "ISO date-time the campaign starts.")
-        .option("--ends-at <iso>", "ISO date-time the campaign ends.")
-        .option("--json", "Print a JSON envelope.")
-        .action(async (options) => {
-        await handleAsyncAction("publishing campaigns create", options, () => requestOxygen("/api/cli/publishing/campaigns", {
-            method: "POST",
-            body: buildPublishingCampaignBody(options, true),
-        }));
-    }))
-        .addCommand(new Command("get")
-        .description("Get one campaign with its posts.")
-        .argument("<campaign_id>", "Campaign id.")
-        .option("--json", "Print a JSON envelope.")
-        .action(async (campaignId, options) => {
-        await handleAsyncAction("publishing campaigns get", options, () => requestOxygen(`/api/cli/publishing/campaigns/${encodeURIComponent(campaignId)}`));
-    }))
-        .addCommand(new Command("update")
-        .description("Update a campaign's name, goal, or window.")
-        .argument("<campaign_id>", "Campaign id.")
-        .option("--name <name>", "Campaign name.")
-        .option("--goal <goal>", "What this campaign is for.")
-        .option("--starts-at <iso>", "ISO date-time the campaign starts.")
-        .option("--ends-at <iso>", "ISO date-time the campaign ends.")
-        .option("--json", "Print a JSON envelope.")
-        .action(async (campaignId, options) => {
-        await handleAsyncAction("publishing campaigns update", options, () => requestOxygen(`/api/cli/publishing/campaigns/${encodeURIComponent(campaignId)}`, {
-            method: "PATCH",
-            body: buildPublishingCampaignBody(options, false),
-        }));
-    }))
-        .addCommand(new Command("delete")
-        .description("Delete a campaign. Its posts survive — they are just unlinked from it.")
-        .argument("<campaign_id>", "Campaign id.")
-        .option("--json", "Print a JSON envelope.")
-        .action(async (campaignId, options) => {
-        await handleAsyncAction("publishing campaigns delete", options, () => requestOxygen(`/api/cli/publishing/campaigns/${encodeURIComponent(campaignId)}`, {
-            method: "DELETE",
-        }));
-    })))
-        .addCommand(new Command("labels")
-        .description("Tag scheduled posts. Labels drive queue filters and label-scoped amplification; they are never published.")
+        .addCommand(new Command("tags")
+        .description("Apply unified workspace tags to scheduled posts; tags are never published.")
         .addCommand(new Command("set")
-        .description("Add and/or remove labels on one post.")
+        .description("Add and/or remove workspace tags on a post.")
         .argument("<post_id>", "Scheduled post id.")
-        .option("--add <labels>", "Comma-separated labels to add.")
-        .option("--remove <labels>", "Comma-separated labels to remove.")
+        .option("--add <tags>", "Comma-separated workspace tags to add.")
+        .option("--remove <tags>", "Comma-separated workspace tags to remove.")
         .option("--json", "Print a JSON envelope.")
         .action(async (postId, options) => {
-        await handleAsyncAction("publishing labels set", options, () => requestOxygen(`/api/cli/publishing/posts/${encodeURIComponent(postId)}/labels`, {
+        await handleAsyncAction("publishing tags set", options, () => requestOxygen(`/api/cli/publishing/posts/${encodeURIComponent(postId)}/tags`, {
             method: "POST",
-            body: buildPublishingLabelsBody(options),
+            body: buildPublishingTagsBody(options),
         }));
     })))
         .addCommand(new Command("analytics")
@@ -2713,8 +2658,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .requiredOption("--file <path>", "Path to a .csv (header row) or .json file ([rows] or { rows: [...] }).")
         .option("--dry-run", "Parse, lint, and report without writing. Default.")
         .option("--approved", "Write the parsed rows into the queue as needs-approval drafts.")
-        .option("--campaign <campaign_id>", "Campaign for every imported post.")
-        .option("--label <labels>", "Comma-separated labels for every imported post.")
+        .option("--tags <tags>", "Comma-separated workspace tags for every imported post.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("publishing import", options, () => requestOxygen("/api/cli/publishing/import", {
@@ -2733,9 +2677,8 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .addCommand(new Command("create")
         .description("Create an amplification policy. It arms REAL public engagement from other people's connected accounts and SPENDS CREDITS, so it is refused (exit 7) without --approved and --max-credits — that pair is the standing grant, recorded with who/when/what scope. The policy is created DISABLED: run `amplification enable` when you actually want it to run.")
         .requiredOption("--name <name>", "Policy name.")
-        .requiredOption("--scope <kind>", "What it amplifies: all, campaign, label, or post.")
-        .option("--campaign <campaign_id>", "Campaign to scope to (with --scope campaign).")
-        .option("--label <label>", "Label to scope to (with --scope label).")
+        .requiredOption("--scope <kind>", "What it amplifies: all, tag, or post.")
+        .option("--tag <tag>", "Workspace tag to scope to (with --scope tag).")
         .option("--post <post_id>", "Post to scope to (with --scope post).")
         .requiredOption("--senders <ids>", "Comma-separated connected sender account ids that will engage.")
         .requiredOption("--actions <list>", "Comma-separated actions: reaction, comment.")
@@ -2878,7 +2821,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .description("Agent-native CRM object setup and metadata commands.")
         .addCommand(new Command("setup")
         .description("Create or repair standard CRM object-backed tables. Defaults to dry-run.")
-        .option("--objects <objects>", "Comma-separated standard CRM objects to set up. Defaults to companies,people.")
+        .option("--objects <objects>", "Comma-separated standard CRM objects to set up. Defaults to companies,people,deals.")
         .option("--project <project>", "Project id or slug for created CRM tables.")
         .option("--dry-run", "Preview CRM setup without creating or repairing tables.")
         .option("--live", "Apply CRM setup changes. Default is dry-run.")
@@ -4560,7 +4503,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     }));
     program
         .command("tags")
-        .description("Workspace tags: one label vocabulary across knowledge pages, sequences, tables, workflows, and recipes — tag a campaign's sequence, its learnings wiki page, and its lead table alike, then browse everything that shares the label. Tags normalize to lowercase (trimmed, deduped, max 50 per item; any characters). WRITING TAGS happens on each primitive, always whole-set replace (\"\" clears): `sequences update <seq> --tags q3,launch` · `tables tag <table> --tags q3` · `workflows tag <wf> --tags q3` · `knowledge page upsert --slug <s> --tags q3 ...`. Then `tags get q3` returns everything carrying the label, deep-linked.")
+        .description("Workspace tags: one vocabulary across publishing posts, knowledge pages, sequences, tables, workflows, and recipes. Tags normalize to lowercase (trimmed, deduped, max 50 per item; any characters). Write tags on the owning surface, then `tags get <tag>` returns every carrier with deep-links.")
         .addCommand(new Command("list")
         .description("List every workspace tag with per-primitive counts, most-used first.")
         .option("--json", "Print a JSON envelope.")
@@ -4568,7 +4511,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         await handleAsyncAction("tags list", options, () => requestOxygen("/api/cli/tags"));
     }))
         .addCommand(new Command("get")
-        .description("Everything carrying one tag — knowledge pages, sequences, tables, workflows, recipes — each with its deep-link.")
+        .description("Everything carrying one tag — publishing posts, knowledge pages, sequences, tables, workflows, and recipes — each with its deep-link.")
         .argument("<tag>", "The tag (case-insensitive).")
         .option("--json", "Print a JSON envelope.")
         .action(async (tag, options) => {
@@ -6007,6 +5950,16 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     program
         .command("billing")
         .description("Plan and managed credit commands.")
+        .addCommand(new Command("change")
+        .description("Preview an upgrade or downgrade and return a Stripe confirmation link. Nothing changes until confirmed in Stripe.")
+        .requiredOption("--to <tier>", "Target plan: starter, pro, or team.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("billing change", options, () => requestOxygen("/api/cli/billing/change", {
+            method: "POST",
+            body: { tier: options.to },
+        }));
+    }))
         .addCommand(new Command("balance")
         .description("Show the current plan and managed credit balance. Credits are Oxygen's native unit; the plan's price and $-per-credit are at https://oxygen-agent.com/billing.")
         .option("--json", "Print a JSON envelope.")
@@ -6133,14 +6086,19 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         }));
     }))
         .addCommand(new Command("topup")
-        .description("Buy on-demand credits at $1.25 per 1,000 (subscription credits are 20% cheaper). Run without a pack to list packs; with a pack it returns a Stripe checkout link — credits post as soon as the payment confirms and never expire.")
-        .argument("[pack]", "Pack size in USD: 10, 25, 100, or 250.")
+        .description("Buy a custom amount of on-demand credits at $1.25 per 1,000. Run without an amount to inspect the allowed range; checkout happens in Stripe and purchased credits never expire.")
+        .argument("[pack]", "Legacy pack alias in USD: 10, 25, 100, or 250.")
+        .option("--credits <n>", "Credits to buy (8,000-200,000 in 1,000-credit increments).")
         .option("--json", "Print a JSON envelope.")
         .action(async (pack, options) => {
-        await handleAsyncAction("billing topup", options, () => pack
+        const credits = readOption(options.credits);
+        await handleAsyncAction("billing topup", options, () => pack || credits
             ? requestOxygen("/api/cli/billing/topup", {
                 method: "POST",
-                body: { pack },
+                body: {
+                    ...(pack ? { pack } : {}),
+                    ...(credits ? { credits: readPositiveNumber(credits) } : {}),
+                },
             })
             : requestOxygen("/api/cli/billing/topup"));
     }));
@@ -6625,6 +6583,116 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             return requestOxygen(`/api/cli/agent/runs${suffix}`);
         });
     }));
+    program
+        .command("copilot")
+        .description("Workspace Copilot: an interactive workspace agent you drive turn by turn from the terminal. Start a session with an explicit inference budget, send it messages and watch the reply stream, approve the actions it proposes, then cancel when done. Inference bills credits at 5x the actual model cost, always inside the session budget you approve up front. Web: /copilot.")
+        .addCommand(new Command("start")
+        .description("Start a Workspace Copilot session. --budget-credits is your explicit approval of the session's inference spend cap; inference bills at 5x the actual model cost within it.")
+        .requiredOption("--budget-credits <number>", "Required: the session inference budget in credits — your explicit approval of the maximum inference spend for the whole session.")
+        .option("--tier <low|medium|high>", "Reasoning effort tier for the session's model.")
+        .option("--model <id>", "Pin a specific model id instead of the journey/tier default.")
+        .option("--per-turn-ceiling <number>", "Optional per-turn credit ceiling that caps any single turn's inference spend.")
+        .option("--journey <slug>", "Optional journey slug to seed the session's goal and context.")
+        .option("--title <text>", "Optional human title for the session.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("copilot start", options, () => {
+            const budgetCredits = readPositiveNumber(options.budgetCredits);
+            if (budgetCredits === undefined) {
+                throw new OxygenError("invalid_budget", "Pass --budget-credits as a positive number of credits to approve the session's inference spend.", { exitCode: 1 });
+            }
+            const perTurnCeiling = readPositiveNumber(options.perTurnCeiling);
+            const tier = readOption(options.tier);
+            const model = readOption(options.model);
+            const journey = readOption(options.journey);
+            const title = readOption(options.title);
+            const body = { budget_credits: budgetCredits };
+            if (tier)
+                body.tier = tier;
+            if (model)
+                body.model = model;
+            if (perTurnCeiling !== undefined)
+                body.per_turn_credit_ceiling = perTurnCeiling;
+            if (journey)
+                body.journey = journey;
+            if (title)
+                body.title = title;
+            return requestOxygen("/api/cli/copilot/sessions", { method: "POST", body });
+        });
+    }))
+        .addCommand(new Command("list")
+        .description("List your Workspace Copilot sessions with their status, budget, and credits spent.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("copilot list", options, () => requestOxygen("/api/cli/copilot/sessions"));
+    }))
+        .addCommand(new Command("get")
+        .description("Show one Workspace Copilot session: its state, turns, and event log. Use --after-seq to page through the event stream.")
+        .argument("<sessionId>", "Copilot session id.")
+        .option("--after-seq <n>", "Only return events after this sequence number.")
+        .option("--events <n>", "Maximum events to return.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (sessionId, options) => {
+        await handleAsyncAction("copilot get", options, () => {
+            const query = new URLSearchParams();
+            const afterSeq = readNonNegativeInt(options.afterSeq);
+            const eventLimit = readPositiveInt(options.events);
+            if (afterSeq !== undefined)
+                query.set("after_seq", String(afterSeq));
+            if (eventLimit !== undefined)
+                query.set("event_limit", String(eventLimit));
+            const suffix = query.toString() ? `?${query.toString()}` : "";
+            return requestOxygen(`/api/cli/copilot/sessions/${encodeURIComponent(sessionId)}${suffix}`);
+        });
+    }))
+        .addCommand(new Command("send")
+        .description("Send a message to a Workspace Copilot session and stream the reply to stderr. Waits for the turn to finish (or pause for an approval) unless --no-wait. Inference bills credits at 5x the actual model cost within the session budget.")
+        .argument("<sessionId>", "Copilot session id.")
+        .argument("<message...>", "Message to send (all words joined with spaces).")
+        .option("--no-wait", "Post the turn and return immediately without streaming the reply.")
+        .option("--context <json>", "Optional JSON object of surface context to attach to the turn.")
+        .option("--timeout-seconds <n>", "Maximum time to wait for the turn to finish. Defaults to 300.")
+        .option("--interval-seconds <n>", "Polling interval while streaming. Defaults to 2.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (sessionId, messageParts, options) => {
+        await handleAsyncAction("copilot send", options, async () => {
+            const message = messageParts.join(" ");
+            const context = readJsonObjectOption(options.context);
+            const posted = await requestOxygen(`/api/cli/copilot/sessions/${encodeURIComponent(sessionId)}/turns`, { method: "POST", body: { message, ...(context ? { context } : {}) } });
+            // Commander maps --no-wait to `wait: false` (default true).
+            if (options.wait === false)
+                return posted;
+            const turn = isRecord(posted.turn) ? posted.turn : {};
+            const turnId = typeof turn.id === "string" ? turn.id : "";
+            const latestSeq = posted.latest_seq;
+            const initialSeq = typeof latestSeq === "number" && Number.isFinite(latestSeq) ? latestSeq : 0;
+            const finalData = await waitForCopilotTurn({
+                sessionId,
+                turnId,
+                initialSeq,
+                requestedTimeoutSeconds: options.timeoutSeconds,
+                requestedIntervalSeconds: options.intervalSeconds,
+            });
+            writeCopilotTurnCreditsSummary(finalData, turnId);
+            return finalData;
+        });
+    }))
+        .addCommand(new Command("approve")
+        .description("Approve (or, with --reject, reject) an action a Workspace Copilot session is waiting on; approving re-queues the paused turn.")
+        .argument("<sessionId>", "Copilot session id.")
+        .argument("<approvalId>", "Approval id from the approval_requested event.")
+        .option("--reject", "Reject the action instead of approving it.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (sessionId, approvalId, options) => {
+        await handleAsyncAction("copilot approve", options, () => requestOxygen(`/api/cli/copilot/sessions/${encodeURIComponent(sessionId)}/approvals/${encodeURIComponent(approvalId)}`, { method: "POST", body: { decision: options.reject ? "reject" : "approve" } }));
+    }))
+        .addCommand(new Command("cancel")
+        .description("Cancel a Workspace Copilot session, stopping any in-flight turn.")
+        .argument("<sessionId>", "Copilot session id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (sessionId, options) => {
+        await handleAsyncAction("copilot cancel", options, () => requestOxygen(`/api/cli/copilot/sessions/${encodeURIComponent(sessionId)}/cancel`, { method: "POST" }));
+    }));
     program
         .command("runs")
         .description("Tenant run provenance commands.")
@@ -8618,14 +8686,14 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         });
     }))
         .addCommand(new Command("create")
-        .description("Create a draft multichannel sequence from a steps JSON file. Assign LinkedIn senders with --senders (required when the journey has LinkedIn steps); bind an Instantly email track with --email-*.")
+        .description("Create a draft multichannel sequence from a steps JSON file. Assign LinkedIn senders with --senders (optional at create — a draft can sit senderless, but enroll/start require at least one for LinkedIn journeys); bind an Instantly email track with --email-*.")
         .requiredOption("--name <name>", "Human-readable sequence name.")
         .requiredOption("--slug <slug>", "Unique slug for the sequence.")
         .requiredOption("--steps-file <path>", "Path to a JSON file: { \"steps\": [...] }. LinkedIn steps (visit_profile | invite | wait_for_connection | message | inmail | follow | like_post | comment_post | withdraw_invite), email steps (email_send | email_reply | email_enroll | email_move | email_stop), and control steps (wait | wait_for_signal | branch | stop), each with an `id`. Copy templates support {{column}} interpolation from the lead's row. Native email sends (email_send/email_reply) also expose three reserved sender variables from the sending mailbox: {{sender_name}} (mailbox display name), {{sender_first_name}} (its first word), and {{sender_email}} (the from address); a row column of the same name WINS on collision, and a missing display name renders empty. comment_post takes text_template and/or ai_prompt — a KG-grounded comment generated at send time (a paid AI call) that falls back to text_template if generation fails. A `branch` routes on signals (then/else) or the legacy connection_accepted/already_connected sugar (then_id/else_id). A signal condition can also branch on the LEAD'S DATA: a data leaf { has_column: \"email\" } is true when that row_values column has a non-empty value (add present:false for \"missing\") — e.g. route leads that have an email down an email arm and the rest down a LinkedIn arm.MINIMAL EMAIL STEP SHAPE: { \"id\": \"s1\", \"channel\": \"email\", \"kind\": \"email_send\", \"subject_template\": \"...\", \"body_template\": \"...\" } — subject_template + body_template are REQUIRED on email_send; A/B tests use an explicit `variants` array of copy partials on the step (up to 25 alternates, a–z; spintax varies wording INSIDE one variant and is not A/B-tracked).")
         .option("--channels <list>", "Comma-separated channels: linkedin,email,whatsapp. Defaults to the channels the journey touches.")
         .option("--whatsapp-cold-initiate", "WhatsApp: allow cold-initiating new chats (no prior conversation). Required to start a WhatsApp sequence live — WhatsApp via Unipile is unofficial WhatsApp Web, so cold-initiating is an explicit ban-risk opt-in.")
         .option("--phone-column-key <key>", "WhatsApp: row_values key holding each lead's phone number (else falls back to phone/phone_number/mobile).")
-        .option("--senders <ids>", "Comma-separated LinkedIn sender account ids (or connection / Unipile ids). Required when the journey has LinkedIn steps.")
+        .option("--senders <ids>", "Comma-separated LinkedIn sender account ids (or connection / Unipile ids). Optional at create; enroll and start require at least one when the journey has LinkedIn steps (attach later with `sequences update --senders`).")
         .option("--table <id>", "Source table id whose rows supply {{column}} template values.")
         .option("--url-column <key>", "Column key holding each lead's LinkedIn URL/provider id.")
         .option("--email-provider <provider>", "Email provider for the email track. Only 'instantly' is supported.")
@@ -8638,7 +8706,6 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--max-emails-per-day <n>", "Sequence-wide daily live-send fleet cap (positive integer) across every sender/mailbox.")
         .option("--max-new-enrollments-per-day <n>", "Daily drip cap on NEW first-touch leads the planner starts (positive integer).")
         .option("--sequence-prioritization <mode>", "Under a tight daily budget, serve 'followups' or 'new_leads' first.")
-        .option("--schedule-template <name>", "Name of a saved schedule template (oxygen schedules) backing the sending window.")
         .option("--esp-matching <mode>", "Native-email ESP matching: 'off' (default) rotates mailboxes freely; 'prefer' biases toward a mailbox on the recipient's own provider; 'strict' requires a same-provider mailbox and defers the send when none exists.")
         .option("--sender-failover <mode>", "What happens when an enrollment's LinkedIn/WhatsApp sender goes unavailable: 'wait' (default) resumes when the sender recovers; 'rebind' moves UNTOUCHED enrollments (no thread, no pending invite, no lead binding) to the least-loaded healthy sender in the pool after ~5h of confirmed outage.")
         .option("--email-min-gap-minutes <n>", "Minimum minutes between two live emails from the SAME mailbox for this sequence (Instantly's 'time gap between emails'; integer 0-720, 0 = none). A humanization gap that only WIDENS the derived per-mailbox spacing — it never bypasses the daily caps or the send window.")
@@ -8647,7 +8714,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--no-stop-on-bounce", "Keep a lead's enrollment running after a hard bounce (default: stop it). The bounce is still recorded as an email_bounced signal either way.")
         .option("--exclude-contacted", "Default every enroll into this sequence to cross-campaign exclusion — skip leads any OTHER active sequence is already contacting. A per-enroll `sequences enroll --exclude-contacted` / `--no-exclude-contacted` always overrides this default. Off by default.")
         .option("--no-exclude-contacted", "Turn the sequence-level exclude-contacted default back OFF (enrollments then exclude cross-campaign only when a call opts in).")
-        .option("--tags <csv>", "Comma-separated workspace tags (Tags primitive) — the labels that link this campaign to wiki pages, tables, and workflows carrying the same tag.")
+        .option("--tags <csv>", "Comma-separated workspace tags linking this sequence to tables, workflows, and knowledge.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("sequences create", options, () => {
@@ -8728,7 +8795,6 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--max-emails-per-day <n>", "Sequence-wide daily live-send fleet cap (positive integer) across every sender/mailbox.")
         .option("--max-new-enrollments-per-day <n>", "Daily drip cap on NEW first-touch leads the planner starts (positive integer).")
         .option("--sequence-prioritization <mode>", "Under a tight daily budget, serve 'followups' or 'new_leads' first.")
-        .option("--schedule-template <name>", "Name of a saved schedule template (oxygen schedules) backing the sending window.")
         .option("--esp-matching <mode>", "Native-email ESP matching: 'off' (default) rotates mailboxes freely; 'prefer' biases toward a mailbox on the recipient's own provider; 'strict' requires a same-provider mailbox and defers the send when none exists.")
         .option("--sender-failover <mode>", "What happens when an enrollment's LinkedIn/WhatsApp sender goes unavailable: 'wait' (default) resumes when the sender recovers; 'rebind' moves UNTOUCHED enrollments (no thread, no pending invite, no lead binding) to the least-loaded healthy sender in the pool after ~5h of confirmed outage.")
         .option("--email-min-gap-minutes <n>", "Minimum minutes between two live emails from the SAME mailbox for this sequence (Instantly's 'time gap between emails'; integer 0-720, 0 = none). A humanization gap that only WIDENS the derived per-mailbox spacing — it never bypasses the daily caps or the send window.")
@@ -8980,39 +9046,6 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .action(async (sequence, options) => {
         await handleSequenceVariantsAction(sequence, options);
     })));
-    program.addCommand(new Command("schedules")
-        .description("Named, reusable sending-schedule templates (timezone + weekdays + from/to). Reference one from a sequence via --schedule-template so a single 'US business hours' window backs many sequences.")
-        .addCommand(new Command("list")
-        .description("List the org's saved schedule templates.")
-        .option("--json", "Print a JSON envelope.")
-        .action(async (options) => {
-        await handleAsyncAction("schedules list", options, () => requestOxygen("/api/cli/schedules"));
-    }))
-        .addCommand(new Command("create")
-        .description("Create (or update by name) a schedule template. Partial windows get sensible defaults.")
-        .requiredOption("--name <name>", "Unique template name (e.g. 'US business hours').")
-        .requiredOption("--timezone <tz>", "IANA timezone (e.g. America/New_York).")
-        .option("--start <HH:MM>", "Inclusive daily start time.", "09:00")
-        .option("--end <HH:MM>", "Exclusive daily end time.", "17:00")
-        .option("--days <csv>", "Allowed ISO weekdays, 1=Mon..7=Sun (e.g. 1,2,3,4,5). Omit → weekdays default.")
-        .option("--json", "Print a JSON envelope.")
-        .action(async (options) => {
-        await handleAsyncAction("schedules create", options, () => {
-            const days = readCsvOption(options.days).map((d) => Number(d)).filter((d) => Number.isInteger(d));
-            return requestOxygen("/api/cli/schedules", {
-                method: "POST",
-                body: {
-                    name: readOption(options.name),
-                    definition: {
-                        timezone: readOption(options.timezone),
-                        ...(readOption(options.start) ? { start: readOption(options.start) } : {}),
-                        ...(readOption(options.end) ? { end: readOption(options.end) } : {}),
-                        ...(days.length > 0 ? { days } : {}),
-                    },
-                },
-            });
-        });
-    })));
     program.addCommand(new Command("suppressions")
         .description("Do-not-contact + email blocklist. People/multichannel: lead provider ids the sequencer enroller skips at plan time (list | add | remove); list rows carry a resolved identity (name / picture / profile URL) when the workspace knows the person. Email blocklist (Instantly parity): addresses + whole-domain blocks the native email dispatcher skips before sending (addresses | domains | remove-address | remove-domain). `import` bulk-loads a mixed file: emails, bare domains, LinkedIn profile URLs, and LinkedIn member ids. Consumes 0 credits.")
         .addCommand(new Command("list")
@@ -11034,6 +11067,133 @@ function waitForWorkflowRun(runId, options) {
         },
     });
 }
+function isTerminalCopilotTurnStatus(status) {
+    // Terminal here means "stop streaming this turn": completed/failed/cancelled
+    // are final, and awaiting_input parks the turn on a human decision (an
+    // approval) that the caller surfaces rather than polling through.
+    return status === "completed" || status === "failed"
+        || status === "cancelled" || status === "awaiting_input";
+}
+function readCopilotTurnStatus(data, turnId) {
+    const turns = Array.isArray(data.turns) ? data.turns : [];
+    for (const turn of turns) {
+        if (isRecord(turn) && turn.id === turnId) {
+            return typeof turn.status === "string" ? turn.status : null;
+        }
+    }
+    return null;
+}
+function readCopilotTurnCreditsCaptured(data, turnId) {
+    const turns = Array.isArray(data.turns) ? data.turns : [];
+    for (const turn of turns) {
+        if (isRecord(turn) && turn.id === turnId && typeof turn.credits_captured === "number") {
+            return turn.credits_captured;
+        }
+    }
+    return null;
+}
+// The session-detail payload carries no top-level `credits` block, so the shared
+// writeCreditsReceipt (which handleAsyncAction runs on the returned data) is a
+// no-op for `copilot send`. Mirror the sent turn's own captured spend as one
+// stderr line so a terminal still shows what the turn cost.
+function writeCopilotTurnCreditsSummary(data, turnId) {
+    const captured = readCopilotTurnCreditsCaptured(data, turnId);
+    if (captured === null)
+        return;
+    process.stderr.write(`credits used this turn: ${captured.toLocaleString("en-US")}\n`);
+}
+// Print one appended copilot event to stderr as it streams in. assistant_delta
+// text is written verbatim — no prefix, no trailing newline — so the model's
+// output flows as one continuous block; every other kind is a one-line human
+// notice. billing_settled is intentionally silent (its spend lands in the
+// end-of-turn credits summary); tool_call_* surface as brief progress so a turn
+// that pauses on a slow capability does not look frozen.
+function printCopilotEvent(event, sessionId) {
+    if (!isRecord(event))
+        return;
+    const kind = typeof event.kind === "string" ? event.kind : "";
+    const payload = isRecord(event.payload) ? event.payload : {};
+    switch (kind) {
+        case "assistant_delta": {
+            const text = typeof payload.text === "string" ? payload.text : "";
+            if (text)
+                process.stderr.write(text);
+            return;
+        }
+        case "tool_call_started": {
+            const capability = typeof payload.capability === "string" ? payload.capability : "tool";
+            process.stderr.write(`\n[tool] ${capability}…\n`);
+            return;
+        }
+        case "tool_call_finished": {
+            const capability = typeof payload.capability === "string" ? payload.capability : "tool";
+            const summary = typeof payload.summary === "string" ? payload.summary : "";
+            process.stderr.write(`[tool] ${capability} ${payload.ok === true ? "ok" : "failed"}${summary ? ` — ${summary}` : ""}\n`);
+            return;
+        }
+        case "approval_requested": {
+            const capability = typeof payload.capability === "string" ? payload.capability : "action";
+            const preview = typeof payload.preview === "string" ? payload.preview : "";
+            const estimated = typeof payload.estimated_credits === "number" ? payload.estimated_credits : null;
+            const approvalId = typeof payload.approval_id === "string" ? payload.approval_id : "";
+            process.stderr.write(`\n[approval required] ${capability}${preview ? ` — ${preview}` : ""}`
+                + `${estimated !== null ? ` (~${estimated.toLocaleString("en-US")} credits)` : ""}. `
+                + `Approve with: ${resolveCliBinaryName()} copilot approve ${sessionId} ${approvalId}\n`);
+            return;
+        }
+        case "fallback_engaged": {
+            const from = typeof payload.from === "string" ? payload.from : "?";
+            const to = typeof payload.to === "string" ? payload.to : "?";
+            const reason = typeof payload.reason === "string" ? payload.reason : "";
+            process.stderr.write(`[model fallback] ${from} → ${to}${reason ? ` (${reason})` : ""}\n`);
+            return;
+        }
+        case "error": {
+            const code = typeof payload.code === "string" ? payload.code : "error";
+            const message = typeof payload.message === "string" ? payload.message : "";
+            process.stderr.write(`[error] ${code}${message ? `: ${message}` : ""}\n`);
+            return;
+        }
+        default:
+            return;
+    }
+}
+// `copilot send` is the CLI's one streaming wait surface. It reuses the shared
+// waitForCliRun poll loop (timeout/interval parsing, deadline, bounded sleep,
+// typed timeout throw) but injects a fetch that GETs the session detail after a
+// moving `after_seq` cursor, prints each newly appended event to stderr, and
+// advances the cursor to latest_seq. The SENT TURN's status — not the session's
+// — is the terminal signal, so fetchRun returns a record whose `status` mirrors
+// that turn while shapeTerminal returns the last full GET payload for scripts.
+function waitForCopilotTurn(options) {
+    let cursor = options.initialSeq;
+    let latestData = {};
+    return waitForCliRun({
+        runId: options.turnId,
+        requestedTimeoutSeconds: options.requestedTimeoutSeconds,
+        requestedIntervalSeconds: options.requestedIntervalSeconds,
+        defaultTimeoutSeconds: COPILOT_SEND_DEFAULT_TIMEOUT_SECONDS,
+        defaultIntervalSeconds: COPILOT_SEND_DEFAULT_INTERVAL_SECONDS,
+        fetchRun: async () => {
+            const query = new URLSearchParams({ after_seq: String(cursor) });
+            latestData = await requestOxygen(`/api/cli/copilot/sessions/${encodeURIComponent(options.sessionId)}?${query.toString()}`);
+            const events = Array.isArray(latestData.events) ? latestData.events : [];
+            for (const event of events)
+                printCopilotEvent(event, options.sessionId);
+            const latestSeq = latestData.latest_seq;
+            if (typeof latestSeq === "number" && Number.isFinite(latestSeq))
+                cursor = latestSeq;
+            // waitForCliRun reads terminality off `status`; mirror the sent turn's
+            // status there while leaving latestData itself untouched for shapeTerminal.
+            return { ...latestData, status: readCopilotTurnStatus(latestData, options.turnId) };
+        },
+        isTerminal: isTerminalCopilotTurnStatus,
+        shapeTerminal: () => latestData,
+        timeoutCode: "copilot_send_timeout",
+        timeoutMessage: "Timed out waiting for the copilot turn to finish.",
+        timeoutDetailIdKey: "turn_id",
+    });
+}
 function workflowTemplateActionBody(templateId, options) {
     const inputJson = readOption(options.inputJson);
     const maxCredits = readPositiveNumber(options.maxCredits);
@@ -16344,9 +16504,6 @@ function readSequenceSettings(options) {
     const prioritization = readOption(options.sequencePrioritization);
     if (prioritization)
         settings.sequence_prioritization = prioritization;
-    const scheduleTemplate = readOption(options.scheduleTemplate);
-    if (scheduleTemplate)
-        settings.schedule_template = scheduleTemplate;
     const espMatching = readOption(options.espMatching);
     if (espMatching)
         settings.esp_matching = espMatching;
@@ -16408,4 +16565,23 @@ process.stdout.on("error", (error) => {
     process.stderr.write(`stdout error: ${error.message}\n`);
     process.exit(1);
 });
-await createProgram().parseAsync(process.argv);
+const program = createProgram();
+program.exitOverride();
+try {
+    await program.parseAsync(process.argv);
+}
+catch (error) {
+    if (error instanceof CommanderError) {
+        process.exitCode = error.exitCode;
+    }
+    else {
+        throw error;
+    }
+}
+// Commander can emit >16 KiB of grouped help. When stdout is a child-process
+// pipe, wait for the queued write callback before Node exits or the tail of
+// `oxygen --help` can be truncated at the pipe high-water mark.
+await Promise.all([flushWritable(process.stdout), flushWritable(process.stderr)]);
+function flushWritable(stream) {
+    return new Promise((resolve) => stream.write("", () => resolve()));
+}