@oxygen-agent/cli 1.354.0 → 1.377.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,11 +636,12 @@ 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),
         mode: resolveLiveDryRunMode(options),
+        ...(options.withEnrichment === true ? { with_enrichment: true } : {}),
         ...(readOption(options.project) ? { project: readOption(options.project) } : {}),
     };
 }
@@ -819,8 +824,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 +848,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 +1169,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 +1208,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 +1266,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 +2309,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 +2332,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 +2609,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 +2659,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 +2678,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,8 +2822,9 @@ 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("--with-enrichment", "Also arm the standing cheap-enrichment auto-run on objects that already existed (fresh-created tables arm it by default). New rows then auto-enrich within the per-batch credit cap.")
         .option("--dry-run", "Preview CRM setup without creating or repairing tables.")
         .option("--live", "Apply CRM setup changes. Default is dry-run.")
         .option("--json", "Print a JSON envelope.")
@@ -2951,7 +2896,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         }));
     }))
         .addCommand(new Command("assert")
-        .description("Create or update one CRM record by object identity. Defaults to dry-run.")
+        .description("Create or update one CRM record by object identity. Defaults to dry-run. Note: the table's standing auto-run (auto-enrichment) fires on `tables insert|upsert|import`, not on assert — after asserting new records, run the enrichment columns (`oxygen columns run <table> <column>`) or insert via `oxygen tables insert` when you want them enriched hands-free.")
         .argument("<object>", "CRM object slug, such as companies or people.")
         .requiredOption("--identity <key=value>", "Identity key/value, for example domain=acme.com or email=ceo@acme.com.")
         .option("--values-json <json>", "JSON object of CRM attribute values keyed by column key.")
@@ -2971,6 +2916,29 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--json", "Print a JSON envelope.")
         .action(async (object, rowId, options) => {
         await handleAsyncAction("crm get", options, () => requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}`));
+    }))
+        .addCommand(new Command("tag")
+        .description("Add/remove workspace tags on one CRM record (Tags primitive — the same vocabulary as sequences, tables, conversations; see `oxygen tags list`). Delta semantics: --add unions, --remove subtracts, remove wins. Standard objects carry the tags attribute after `oxygen crm setup`.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .argument("<row_id>", "CRM record row id.")
+        .option("--add <tags>", "Comma-separated tags to add.")
+        .option("--remove <tags>", "Comma-separated tags to remove.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, rowId, options) => {
+        await handleAsyncAction("crm tag", options, () => {
+            const add = splitCommaList(options.add);
+            const remove = splitCommaList(options.remove);
+            if (add.length === 0 && remove.length === 0) {
+                throw new OxygenError("invalid_request", "Pass --add and/or --remove.", { exitCode: 1 });
+            }
+            return requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/tags`, {
+                method: "POST",
+                body: {
+                    ...(add.length > 0 ? { add } : {}),
+                    ...(remove.length > 0 ? { remove } : {}),
+                },
+            });
+        });
     }))
         .addCommand(new Command("relationships")
         .description("Define CRM relationships and manage record relationship edges.")
@@ -3490,11 +3458,20 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .addCommand(new Command("list")
         .description("List workspace tables in the current tenant database.")
         .option("--project <project>", "Project id or slug to filter by.")
+        .option("--tag <tag>", "Only tables carrying this workspace tag (see `oxygen tags list`).")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("tables list", options, () => requestOxygen(readOption(options.project)
-            ? `/api/cli/tables?project=${encodeURIComponent(readOption(options.project))}`
-            : "/api/cli/tables"));
+        await handleAsyncAction("tables list", options, () => {
+            const params = new URLSearchParams();
+            const project = readOption(options.project);
+            if (project)
+                params.set("project", project);
+            const tag = readOption(options.tag);
+            if (tag)
+                params.set("tag", tag);
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/tables${qs}`);
+        });
     }))
         .addCommand(new Command("query")
         .description("Query a workspace table by id or slug.")
@@ -4560,7 +4537,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, recipes, and inbox conversations. Tags normalize to lowercase (trimmed, deduped, max 50 per item; any characters). Write tags on the owning surface (e.g. `oxygen inbox tag`, `oxygen tables tag`), 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,11 +4545,23 @@ 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, recipes, and inbox conversations — each with its deep-link.")
         .argument("<tag>", "The tag (case-insensitive).")
         .option("--json", "Print a JSON envelope.")
         .action(async (tag, options) => {
         await handleAsyncAction("tags get", options, () => requestOxygen(`/api/cli/tags/${encodeURIComponent(tag)}`));
+    }))
+        .addCommand(new Command("rename")
+        .description("Rename one tag EVERYWHERE it appears (every primitive, archived rows included). Preview-first: without --apply, prints per-kind would-change counts and mutates nothing. Idempotent — safe to re-run after a partial failure.")
+        .argument("<from>", "The current tag (case-insensitive).")
+        .argument("<to>", "The new tag (normalized lowercase).")
+        .option("--apply", "Execute the rename. Without this flag, returns a preview of the counts only.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (from, to, options) => {
+        await handleAsyncAction("tags rename", options, () => requestOxygen("/api/cli/tags/rename", {
+            method: "POST",
+            body: { from, to, ...(options.apply ? { apply: true } : {}) },
+        }));
     }));
     program
         .command("blueprints")
@@ -4596,6 +4585,17 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             const qs = params.toString() ? `?${params.toString()}` : "";
             return requestOxygen(`/api/cli/blueprints${qs}`);
         });
+    }))
+        .addCommand(new Command("tag")
+        .description("Replace a saved blueprint's workspace tags (whole set; `--tags \"\"` clears). Works on already-saved blueprints — no re-export needed. See `oxygen tags list` for the vocabulary.")
+        .argument("<blueprint>", "Blueprint slug or id.")
+        .requiredOption("--tags <tags>", "Comma-separated workspace tags (replaces the whole set; empty clears).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (blueprint, options) => {
+        await handleAsyncAction("blueprints tag", options, () => requestOxygen("/api/cli/blueprints/tags", {
+            method: "POST",
+            body: { blueprint, tags: splitCommaList(options.tags) },
+        }));
     }))
         .addCommand(new Command("describe")
         .description("Describe one blueprint (seed or saved) by slug.")
@@ -5046,7 +5046,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .argument("<table>", "Table id or slug.")
         .argument("<column>", "Column id or key.")
         .option("--row-id <row_id>", "Workspace row id to run.")
-        .option("--limit <n>", "Maximum rows to inspect when row-id is omitted. Defaults to 10; sync hard cap is 25.")
+        .option("--limit <n>", "Run the next N rows whose target cell is still empty (--force runs the first N regardless). Repeat until rowCount is 0 to page through a table. Defaults to 10; inline (non-background) hard cap is 25.")
         .option("--all", "Run all rows. Requires --background.")
         .option("--filter-json <json>", "Row selector filter object or array for background runs. Do not combine with --all, --limit, or --row-id.")
         .option("--force", "Run even when the target cell already has a value.")
@@ -6007,6 +6007,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 +6143,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"));
     }));
@@ -6579,37 +6594,37 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     // `oxygen knowledge agent`, which configures the AI Knowledge Agent itself.)
     program
         .command("agent")
-        .description("Agents: your workspace agents (AI Sales Agent, AI Meeting Notetaker, AI Knowledge Agent) that work inside your workspace as approval-gated runs. List them, inspect run history, and enable or disable each one; each agent's `configCommand` (e.g. `oxygen inbox reply-agent set` for the AI Sales Agent) tunes its behavior. Web: /agents.")
+        .description("Agents: the programmable Workspace Agent plus built-in specialist agents. Publish versioned instructions and policies, start durable runs, trigger them by cron/event/webhook, inspect every event, and control approvals. Web: /agents.")
         .addCommand(new Command("list")
-        .description("List the built-in specialist agents with their enabled state and recent run history.")
+        .description("List the Workspace Agent and built-in specialists with state and recent run history.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("agent list", options, () => requestOxygen("/api/cli/agent"));
     }))
         .addCommand(new Command("get")
-        .description("Show one specialist agent: its state, approval boundary, config command, and recent runs.")
-        .argument("<slug>", "Specialist slug: inbox-reply-drafts, meeting-notetaker, or knowledge-synthesis.")
+        .description("Show one agent, including the Workspace Agent's active version and recent runs.")
+        .argument("<slug>", "Agent slug: workspace, inbox-reply-drafts, meeting-notetaker, or knowledge-synthesis.")
         .option("--json", "Print a JSON envelope.")
         .action(async (slug, options) => {
         await handleAsyncAction("agent get", options, () => requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}`));
     }))
         .addCommand(new Command("enable")
-        .description("Enable a specialist agent so it resumes its approval-gated drafts/runs.")
+        .description("Enable a workspace or specialist agent so it resumes its governed runs.")
         .argument("<slug>", "Specialist slug: inbox-reply-drafts, meeting-notetaker, or knowledge-synthesis.")
         .option("--json", "Print a JSON envelope.")
         .action(async (slug, options) => {
         await handleAsyncAction("agent enable", options, () => requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/enable`, { method: "POST" }));
     }))
         .addCommand(new Command("disable")
-        .description("Disable a specialist agent so it stops its drafts/runs on the next worker tick.")
+        .description("Disable a workspace or specialist agent so it stops new runs on the next worker tick.")
         .argument("<slug>", "Specialist slug: inbox-reply-drafts, meeting-notetaker, or knowledge-synthesis.")
         .option("--json", "Print a JSON envelope.")
         .action(async (slug, options) => {
         await handleAsyncAction("agent disable", options, () => requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/disable`, { method: "POST" }));
     }))
         .addCommand(new Command("runs")
-        .description("List recent runs across the specialist agents (or one via <slug>), newest first.")
-        .argument("[slug]", "Optional specialist slug to filter to one agent.")
+        .description("List recent runs across all agents (or one via <slug>), newest first.")
+        .argument("[slug]", "Optional agent slug to filter to one agent.")
         .option("--limit <n>", "Maximum runs to return (1-100). Defaults to 25.")
         .option("--json", "Print a JSON envelope.")
         .action(async (slug, options) => {
@@ -6624,6 +6639,316 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             const suffix = params.toString() ? `?${params.toString()}` : "";
             return requestOxygen(`/api/cli/agent/runs${suffix}`);
         });
+    }))
+        .addCommand(new Command("set")
+        .description("Publish an immutable version (reconfigure) for a runtime agent: the Workspace Agent or a custom agent.")
+        .argument("<slug>", "workspace, or a custom agent slug (from `oxygen agent create`).")
+        .requiredOption("--instructions <text>", "Workspace Agent instructions for this version.")
+        .option("--model-policy-json <json>", "Model policy JSON. Defaults to managed OpenRouter medium.")
+        .option("--tool-policy-json <json>", "Tool policy JSON. Omit restrictions for full eligible catalog access.")
+        .option("--context-policy-json <json>", "Context policy JSON: on_demand or prefetch, optional resolve_args and file_ids.")
+        .option("--skills <csv>", "Comma-separated product skill slugs snapshotted into this immutable version.")
+        .option("--sandbox-policy-json <json>", "Sandbox policy JSON.")
+        .option("--limits-json <json>", "Optional limits JSON; platform hard ceilings still apply.")
+        .option("--confirm-full-access", "Acknowledge standing full catalog access when the policy mode is full.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("agent set", options, () => requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}`, {
+            method: "PATCH",
+            body: {
+                instructions: options.instructions,
+                ...(options.modelPolicyJson ? { model_policy: parseJsonObject(options.modelPolicyJson) } : {}),
+                ...(options.toolPolicyJson ? { tool_policy: parseJsonObject(options.toolPolicyJson) } : {}),
+                ...(options.contextPolicyJson ? { context_policy: parseJsonObject(options.contextPolicyJson) } : {}),
+                ...(options.skills ? { skill_slugs: options.skills.split(",").map((value) => value.trim()).filter(Boolean) } : {}),
+                ...(options.sandboxPolicyJson ? { sandbox_policy: parseJsonObject(options.sandboxPolicyJson) } : {}),
+                ...(options.limitsJson ? { limits: parseJsonObject(options.limitsJson) } : {}),
+                confirm_full_access: options.confirmFullAccess === true,
+            },
+        }));
+    }))
+        .addCommand(new Command("create")
+        .description("Create a custom agent and publish its first immutable version. Schedule it with `oxygen agent trigger create`.")
+        .argument("<slug>", "User-minted agent slug: a lowercase letter then letters, digits, or hyphens (2-49 chars).")
+        .requiredOption("--name <name>", "Display name for the agent.")
+        .requiredOption("--instructions <text>", "Durable standing instructions for the first immutable version.")
+        .option("--description <text>", "Optional one-line description of the agent's job.")
+        .option("--model-policy-json <json>", "Model policy JSON. Defaults to managed OpenRouter medium.")
+        .option("--tool-policy-json <json>", "Tool policy JSON. Omit restrictions for full eligible catalog access.")
+        .option("--context-policy-json <json>", "Context policy JSON: on_demand or prefetch, optional resolve_args and file_ids.")
+        .option("--skills <csv>", "Comma-separated product skill slugs snapshotted into this immutable version.")
+        .option("--sandbox-policy-json <json>", "Sandbox policy JSON.")
+        .option("--limits-json <json>", "Optional limits JSON; platform hard ceilings still apply.")
+        .option("--confirm-full-access", "Acknowledge standing full catalog access when the policy mode is full.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("agent create", options, () => requestOxygen("/api/cli/agent/create", {
+            method: "POST",
+            body: {
+                slug,
+                name: options.name,
+                instructions: options.instructions,
+                ...(options.description ? { description: options.description } : {}),
+                ...(options.modelPolicyJson ? { model_policy: parseJsonObject(options.modelPolicyJson) } : {}),
+                ...(options.toolPolicyJson ? { tool_policy: parseJsonObject(options.toolPolicyJson) } : {}),
+                ...(options.contextPolicyJson ? { context_policy: parseJsonObject(options.contextPolicyJson) } : {}),
+                ...(options.skills ? { skill_slugs: options.skills.split(",").map((value) => value.trim()).filter(Boolean) } : {}),
+                ...(options.sandboxPolicyJson ? { sandbox_policy: parseJsonObject(options.sandboxPolicyJson) } : {}),
+                ...(options.limitsJson ? { limits: parseJsonObject(options.limitsJson) } : {}),
+                confirm_full_access: options.confirmFullAccess === true,
+            },
+        }));
+    }))
+        .addCommand(new Command("custom")
+        .description("List the org's user-defined custom agents (distinct from `agent list`, which shows the built-in roster).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("agent custom", options, () => requestOxygen("/api/cli/agent/custom"));
+    }))
+        .addCommand(new Command("run")
+        .description("Start a durable Workspace Agent run on the Fly worker.")
+        .argument("<slug>", "Currently: workspace.")
+        .option("--goal <text>", "Natural-language goal.")
+        .option("--input-json <json>", "Structured run input instead of --goal.")
+        .option("--idempotency-key <key>", "Deduplicate retries of the same source event.")
+        .option("--thread-id <id>", "Continue an existing persistent Agent thread.")
+        .option("--thread-mode <isolated|persistent>", "Create a persistent thread for this run. Defaults to isolated.")
+        .option("--file-ids <csv>", "Comma-separated workspace file UUIDs attached to context and eligible for sandbox input.")
+        .requiredOption("--max-credits <credits>", "Hard credit ceiling for this run.")
+        .requiredOption("--approved", "Explicitly approve managed inference up to --max-credits.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("agent run", options, () => {
+            const maxCredits = readPositiveNumber(options.maxCredits);
+            if (maxCredits === undefined)
+                throw new OxygenError("invalid_request", "--max-credits must be positive.", { exitCode: 2 });
+            return requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/runs`, {
+                method: "POST",
+                body: {
+                    ...(options.goal ? { goal: options.goal } : {}),
+                    ...(options.inputJson ? { input: parseJsonObject(options.inputJson) } : {}),
+                    ...(options.idempotencyKey ? { idempotency_key: options.idempotencyKey } : {}),
+                    ...(options.threadId ? { thread_id: options.threadId } : {}),
+                    thread_mode: options.threadMode ?? "isolated",
+                    ...(options.fileIds ? { file_ids: options.fileIds.split(",").map((value) => value.trim()).filter(Boolean) } : {}),
+                    max_credits: maxCredits,
+                    approved: options.approved === true,
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("run-get")
+        .description("Inspect one Workspace Agent run and its append-only event ledger.")
+        .argument("<slug>", "Currently: workspace.")
+        .argument("<run-id>", "Agent run id.")
+        .option("--after-seq <n>", "Return events after this sequence number.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, runId, options) => {
+        await handleAsyncAction("agent run get", options, () => {
+            const params = new URLSearchParams();
+            if (options.afterSeq)
+                params.set("after_seq", options.afterSeq);
+            const suffix = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/runs/${encodeURIComponent(runId)}${suffix}`);
+        });
+    }))
+        .addCommand(new Command("cancel")
+        .description("Request cancellation of an active Workspace Agent run.")
+        .argument("<slug>", "Currently: workspace.")
+        .argument("<run-id>", "Agent run id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, runId, options) => {
+        await handleAsyncAction("agent run cancel", options, () => requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/runs/${encodeURIComponent(runId)}/cancel`, { method: "POST" }));
+    }))
+        .addCommand(new Command("approval-decide")
+        .description("Approve or reject one pending Workspace Agent tool call, then resume its durable run.")
+        .argument("<slug>", "Currently: workspace.")
+        .argument("<run-id>", "Agent run id.")
+        .argument("<approval-id>", "Approval id from the run event ledger.")
+        .requiredOption("--decision <approved|rejected>", "Decision.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, runId, approvalId, options) => {
+        await handleAsyncAction("agent approval decide", options, () => requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/runs/${encodeURIComponent(runId)}/approvals/${encodeURIComponent(approvalId)}`, { method: "POST", body: { decision: options.decision } }));
+    }))
+        .addCommand(new Command("trigger-create")
+        .description("Create a cron, internal event, or signed-webhook trigger for the Workspace Agent.")
+        .argument("<slug>", "Currently: workspace.")
+        .requiredOption("--type <cron|event|webhook>", "Trigger type.")
+        .requiredOption("--instruction <text>", "Goal template run for each delivery.")
+        .option("--cron <expression>", "Five-field cron expression for cron triggers.")
+        .option("--timezone <iana>", "IANA timezone. Defaults to UTC.")
+        .option("--event-source <source>", "Internal workflow-event source for event triggers.")
+        .option("--event-type <event>", "Internal workflow-event type for event triggers.")
+        .option("--thread-mode <isolated|persistent>", "Reuse a bounded thread across deliveries. Defaults to isolated.")
+        .requiredOption("--max-credits <credits>", "Standing per-delivery credit ceiling.")
+        .requiredOption("--approved", "Authorize each trigger delivery up to --max-credits.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("agent trigger create", options, () => {
+            const maxCredits = readPositiveNumber(options.maxCredits);
+            if (maxCredits === undefined)
+                throw new OxygenError("invalid_request", "--max-credits must be positive.", { exitCode: 2 });
+            return requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/triggers`, { method: "POST", body: {
+                    type: options.type, instruction_template: options.instruction,
+                    ...(options.cron ? { cron_expression: options.cron } : {}),
+                    ...(options.timezone ? { timezone: options.timezone } : {}),
+                    ...(options.eventSource ? { event_source: options.eventSource } : {}),
+                    ...(options.eventType ? { event_type: options.eventType } : {}),
+                    thread_mode: options.threadMode ?? "isolated",
+                    max_credits: maxCredits,
+                    approved: options.approved === true,
+                } });
+        });
+    }))
+        .addCommand(new Command("triggers")
+        .description("List Workspace Agent cron, internal event, and webhook triggers.")
+        .argument("<slug>", "Currently: workspace.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, options) => {
+        await handleAsyncAction("agent triggers", options, () => requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/triggers`));
+    }))
+        .addCommand(new Command("trigger-set")
+        .description("Activate, pause, or archive one Workspace Agent trigger.")
+        .argument("<slug>", "Currently: workspace.")
+        .argument("<trigger-id>", "Agent trigger id.")
+        .requiredOption("--status <active|paused|archived>", "New trigger status.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (slug, triggerId, options) => {
+        await handleAsyncAction("agent trigger set", options, () => requestOxygen(`/api/cli/agent/${encodeURIComponent(slug)}/triggers/${encodeURIComponent(triggerId)}`, { method: "PATCH", body: { status: options.status } }));
+    }))
+        .addCommand(new Command("file-create")
+        .description("Store a tenant-owned text file for Agent context and sandbox input.")
+        .requiredOption("--name <name>", "Workspace filename.")
+        .requiredOption("--text <text>", "Inline text content (max 1.5 MB).")
+        .option("--mime-type <type>", "MIME type. Defaults to text/plain.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("agent file create", options, () => requestOxygen("/api/cli/agent/files", {
+            method: "POST", body: { name: options.name, text: options.text, mime_type: options.mimeType ?? "text/plain" },
+        }));
+    }))
+        .addCommand(new Command("files")
+        .description("List tenant-owned Agent context files.")
+        .option("--limit <n>", "Maximum files (1-500).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("agent files", options, () => {
+            const limit = readPositiveInt(options.limit);
+            return requestOxygen(`/api/cli/agent/files${limit ? `?limit=${limit}` : ""}`);
+        });
+    }));
+    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("--auto-approve", "Start with auto-approve ON for paid, workspace-internal actions (cards are still created and decided automatically within each action's credit cap). External sends, enrollments, publishes, DNS, and external CRM pushes always stay human-gated.")
+        .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;
+            if (options.autoApprove)
+                body.auto_approve = true;
+            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")
@@ -7309,7 +7634,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         await handleAsyncAction("senders checkpoints", options, () => requestOxygen("/api/cli/senders/checkpoints"));
     }))
         .addCommand(new Command("connect")
-        .description("Get a Unipile hosted-auth URL to connect a new LinkedIn account (or reconnect with --reconnect). Use --count to mint several links at once for bulk onboarding. Open each URL in a browser to complete authentication.")
+        .description("Get a Unipile hosted-auth URL to connect a new LinkedIn account (or reconnect with --reconnect). Use --count to mint several links at once for bulk onboarding. Open each URL in a browser to complete authentication. Links are shareable: send one to the account owner (e.g. a client) — no Oxygen login is needed to complete it, and the account lands in this workspace's sender list. Each link is valid for 30 minutes and connects one account.")
         .option("--reconnect <connection_id>", "Reconnect an existing connection instead of creating a new one. Accepts a connection id.")
         .option("--sales-nav", "Request Classic + Sales Navigator access during Unipile hosted authentication.")
         .option("--count <n>", "Mint N hosted-auth links in one call for bulk onboarding (1-25, default 1). Each link connects a different account. Ignored when reconnecting.")
@@ -7334,6 +7659,17 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--json", "Print a JSON envelope.")
         .action(async (id, options) => {
         await handleAsyncAction("senders get", options, () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}`));
+    }))
+        .addCommand(new Command("tag")
+        .description("Replace a sender account's workspace tags (whole set; `--tags \"\"` clears) — e.g. pool the senders behind one campaign tag. See `oxygen tags list` for the vocabulary.")
+        .argument("<id>", "Sender account id or Unipile account id.")
+        .requiredOption("--tags <tags>", "Comma-separated workspace tags (replaces the whole set; empty clears).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("senders tag", options, () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}/tags`, {
+            method: "POST",
+            body: { tags: splitCommaList(options.tags) },
+        }));
     }))
         .addCommand(new Command("health")
         .description("Show a one-call health snapshot for a LinkedIn sender: status, the latest error reason, any open security checkpoint, today's usage, the warm-up ramp, and when the daily quota resets. Read-only — no provider call, no credits. <id> accepts a sender account id, connection id, or Unipile account id.")
@@ -8079,6 +8415,8 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .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>", "Comma-separated status keys (e.g. interested,meeting_booked). Cross-channel — filters email + LinkedIn + WhatsApp by the shared taxonomy.")
+        .option("--sentiment <values>", "Comma-separated AI sentiment: positive, neutral, negative. Cross-channel; not-yet-analyzed conversations never match.")
+        .option("--tag <tags>", "Comma-separated campaign tags — matches email conversations whose campaign (sequence) carries any of these tags. DMs have no campaign link, so a tag filter shows email only.")
         .option("--since <iso>", "Only conversations whose last message is on/after this ISO date/timestamp. Cross-channel.")
         .option("--until <iso>", "Only conversations whose last message is on/before this ISO date/timestamp. Cross-channel.")
         .option("--sequence-id <ids>", "Email only: comma-separated campaign (sequence) UUIDs (not slugs — get the id from `sequences get <slug>`).")
@@ -8089,6 +8427,8 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--search <text>", "Filter by attendee name or last-message text. Cross-channel.")
         .option("--include-archived", "Include archived conversations.")
         .option("--limit <n>", "Maximum conversations to return (1-200). Defaults to 50.")
+        .option("--cursor <cursor>", "channel=all only: the previous page's next_cursor — resumes the merged stream after that row.")
+        .option("--no-counts", "channel=all only: skip the sidebar facet counts for a faster paged read (total_conversations/unread_conversations/sidebar_counts omitted from the envelope). Other channels ignore it.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("inbox list", options, () => {
@@ -8108,6 +8448,8 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 ["segment", "segment"],
                 ["channels", "channels"],
                 ["status", "status"],
+                ["sentiment", "sentiment"],
+                ["tag", "tag"],
                 ["since", "since"],
                 ["until", "until"],
                 ["sequenceId", "sequence_id"],
@@ -8115,6 +8457,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 ["domain", "domain"],
                 ["excludeDomain", "exclude_domain"],
                 ["mailboxId", "mailbox_id"],
+                ["cursor", "cursor"],
             ]) {
                 const value = readOption(options[flag]);
                 if (value)
@@ -8128,6 +8471,10 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             const limit = readOption(options.limit);
             if (limit)
                 params.set("limit", limit);
+            // Commander's --no-counts sets counts:false; absent leaves the
+            // server default (counts included) untouched.
+            if (options.counts === false)
+                params.set("include_counts", "false");
             const suffix = params.toString();
             return requestOxygen(`/api/cli/inbox${suffix ? `?${suffix}` : ""}`);
         });
@@ -8274,6 +8621,31 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 body: { status, channel },
             });
         });
+    }))
+        .addCommand(new Command("tag")
+        .description("Add/remove workspace tags on a conversation (Tags primitive — the same vocabulary as sequences, tables, posts; see `oxygen tags list`). Delta semantics: --add unions, --remove subtracts, remove wins on conflict. Internal metadata, never sent to the counterpart. --channel linkedin/whatsapp tags a DM conversation.")
+        .argument("<conversation>", "Conversation id, Unipile chat id, or (email) Zapbox thread id.")
+        .option("--add <tags>", "Comma-separated tags to add.")
+        .option("--remove <tags>", "Comma-separated tags to remove.")
+        .option("--channel <channel>", "Inbox channel: email (default), linkedin, or whatsapp.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (conversation, options) => {
+        await handleAsyncAction("inbox tag", options, () => {
+            const add = splitCommaList(options.add);
+            const remove = splitCommaList(options.remove);
+            if (add.length === 0 && remove.length === 0) {
+                throw new OxygenError("invalid_request", "Pass --add and/or --remove.", { exitCode: 1 });
+            }
+            const channel = readOption(options.channel) ?? "email";
+            return requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/tags`, {
+                method: "POST",
+                body: {
+                    ...(add.length > 0 ? { add } : {}),
+                    ...(remove.length > 0 ? { remove } : {}),
+                    channel,
+                },
+            });
+        });
     }))
         .addCommand(new Command("rescan")
         .description("Re-queue conversations for AI re-classification (status + sentiment + drafted reply). Without --yes, previews the counts that would be re-flipped. With --yes, the worker re-classifies the pending rows (free for opt-outs, low-tier model otherwise, credit-capped).")
@@ -8494,6 +8866,37 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 body.max_drafts_per_day = Number(options.maxDraftsPerDay);
             return requestOxygen("/api/cli/inbox/reply-agent", { method: "POST", body });
         });
+    })))
+        .addCommand(new Command("auto-tagger")
+        .description("The auto-tagging agent (the 'AI Inbox Tagger'): classifies each new inbound conversation against your workspace tag allowlist and auto-applies matches — additive, never re-adds a tag you removed, zero extra model calls (rides the analysis pass). Roster + run history: `oxygen agent get inbox-auto-tagger`; web home: /agents/inbox-auto-tagger.")
+        .addCommand(new Command("get")
+        .description("Show the auto-tagger config (enabled, tag allowlist, channels).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox auto-tagger get", options, () => requestOxygen("/api/cli/inbox/auto-tagger"));
+    }))
+        .addCommand(new Command("set")
+        .description("Update the auto-tagger. --tags replaces the whole allowlist (max 50; `--tags \"\"` clears, which pauses tagging while keeping the agent enabled).")
+        .option("--enabled", "Enable the agent.")
+        .option("--disabled", "Disable the agent.")
+        .option("--tags <tags>", "Comma-separated tag allowlist the classifier may apply (replaces the whole set).")
+        .option("--channels <list>", "Comma-separated channels to tag: a non-empty subset of email, linkedin, whatsapp (default all three).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox auto-tagger set", options, () => {
+            const body = {};
+            if (options.enabled)
+                body.enabled = true;
+            if (options.disabled)
+                body.enabled = false;
+            if (options.tags !== undefined) {
+                body.tags = options.tags.split(",").map((tag) => tag.trim()).filter(Boolean);
+            }
+            if (options.channels !== undefined) {
+                body.channels = options.channels.split(",").map((c) => c.trim()).filter(Boolean);
+            }
+            return requestOxygen("/api/cli/inbox/auto-tagger", { method: "POST", body });
+        });
     }))));
     program.addCommand(new Command("messages")
         .description("Cross-channel message corpus: every individual email + LinkedIn + WhatsApp message as one searchable stream (Postgres full-text search over bodies, keyset paginated by recency), plus reply-rate/campaign analytics. Message-level, unlike inbox (conversation-level triage).")
@@ -8508,6 +8911,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--sequence-id <id>", "Email only: campaign (sequence) id (restricts the result to email).")
         .option("--status <keys>", "Comma-separated conversation status keys (e.g. interested,meeting_booked).")
         .option("--sentiment <sentiment>", "Filter by sentiment: positive, neutral, or negative.")
+        .option("--tag <tag>", "Only messages whose conversation carries this workspace tag (see `oxygen tags list`).")
         .option("--since <iso>", "Only messages sent at or after this ISO timestamp.")
         .option("--until <iso>", "Only messages sent before this ISO timestamp.")
         .option("--limit <n>", "Maximum messages to return (1-200). Defaults to 50.")
@@ -8528,6 +8932,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 ["sequenceId", "sequence_id"],
                 ["status", "status"],
                 ["sentiment", "sentiment"],
+                ["tag", "tag"],
                 ["since", "since"],
                 ["until", "until"],
                 ["limit", "limit"],
@@ -8618,14 +9023,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 +9043,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 +9051,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 +9132,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 +9383,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")
@@ -9463,6 +9833,17 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 body: { mailboxes: parsed.mailboxes ?? [] },
             });
         });
+    }))
+        .addCommand(new Command("tag")
+        .description("Replace a sending mailbox's workspace tags (whole set; `--tags \"\"` clears) — e.g. pool the mailboxes behind one campaign tag. See `oxygen tags list` for the vocabulary.")
+        .argument("<mailbox>", "Mailbox id or email address.")
+        .requiredOption("--tags <tags>", "Comma-separated workspace tags (replaces the whole set; empty clears).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (mailbox, options) => {
+        await handleAsyncAction("mailboxes tag", options, () => requestOxygen(`/api/cli/mailboxes/${encodeURIComponent(mailbox)}/tags`, {
+            method: "POST",
+            body: { tags: splitCommaList(options.tags) },
+        }));
     }))
         .addCommand(new Command("status")
         .description("Set a sending mailbox's status. Pausing/disabling takes the inbox out of the rotation pool without losing its warmup state.")
@@ -10084,10 +10465,18 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .addCommand(new Command("list")
         .description("List workflow automations. Archived workflows are hidden unless you pass --include-archived.")
         .option("--include-archived", "Also list archived workflows, which are hidden by default.")
+        .option("--tag <tag>", "Only workflows carrying this workspace tag (see `oxygen tags list`).")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("workflows list", options, async () => {
-            const data = await requestOxygen(`/api/cli/workflows${options.includeArchived ? "?include_archived=true" : ""}`);
+            const params = new URLSearchParams();
+            if (options.includeArchived)
+                params.set("include_archived", "true");
+            const tag = readOption(options.tag);
+            if (tag)
+                params.set("tag", tag);
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            const data = await requestOxygen(`/api/cli/workflows${qs}`);
             writeDisabledWorkflowNotices(data);
             return data;
         });
@@ -11034,6 +11423,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 +16860,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 +16921,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()));
+}