@oxygen-agent/cli 1.1013.94 → 1.1014.18

package/README.md

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

package/dist/index.js

@@ -67,6 +67,7 @@ import { TABLE_LIST_QUERY_CONTRACT, tableListQueryParams } from "@oxygen/shared/
 import { TABLE_QUERY_GRID_CONTRACT } from "@oxygen/shared/contracts/table-query-grid";
 import { WHATSAPP_ACCOUNTS_READ_CONTRACT } from "@oxygen/shared/contracts/whatsapp-reads";
 import { WORKFLOW_RUN_LIST_CONTRACT, workflowRunListQueryParams } from "@oxygen/shared/contracts/workflow-run-list";
+import { COPILOT_ASK_USER_TOOL_NAME, normalizeCopilotQuestions } from "@oxygen/shared/copilot-questions";
 import { MANAGED_DATA_SUPPLIERS } from "@oxygen/shared/data-suppliers";
 import { MAX_BUFFERED_IMPORT_PARSE_BYTES, assertImportFormatWithinBufferedLimit, inferImportColumnLabels, inferRowsFileFormat, normalizeImportColumnKey, normalizeRowsForNewTable, normalizeRowsFormat, parseRowsFileBuffer, parseXlsxWorkbookBuffer, } from "@oxygen/shared/file-import";
 import { KNOWLEDGE_PAGE_TYPES } from "@oxygen/shared/knowledge-constants";
@@ -1275,7 +1276,8 @@ function writeListCapNotice(data, noun, hint) {
     if (record.capped !== true)
         return;
     const returned = typeof record.returned === "number" ? record.returned : null;
-    process.stderr.write(`note: showing ${returned === null ? "a window of" : returned} ${noun}; more exist — raise --limit (max 1000) or pass --all${hint ? `; ${hint}` : ""}.\n`);
+    const total = typeof record.total === "number" ? ` of ${record.total}` : "";
+    process.stderr.write(`note: showing ${returned === null ? "a window of" : returned}${total} ${noun}; more exist — raise --limit (max 1000) or pass --all${hint ? `; ${hint}` : ""}.\n`);
 }
 // The map is bounded twice over — a scan window per kind, then a character
 // budget across all of them — and both bounds are invisible in the rendered
@@ -12706,12 +12708,12 @@ Examples:
     }));
     program
         .command("copilot")
-        .description("Workspace Copilot: an attended workspace agent you drive turn by turn from the terminal. Start a session, 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 and is bounded by a 3,000-credit internal platform safety backstop; paid or external actions keep their own approval gates. Web: /copilot.")
+        .description("Workspace Copilot: an attended workspace agent you drive turn by turn from the terminal. Start a session, send it messages and watch the reply stream, approve the actions it proposes, then cancel when done. Managed inference uses workspace credits; paid or external actions keep their own approval gates. Web: /copilot.")
         .addCommand(new Command("start")
-        .description("Start an attended Workspace Copilot session on Oxygen Auto — Oxygen picks the model, keeps one conversation on one model, and runs its own errands on a cheaper one. Starting is free; the next send starts inference. No inference budget is required; inference bills at 5x actual model cost under a 3,000-credit internal platform safety backstop. Legacy budget and tier flags remain accepted for older clients but do not authorize or cap spend. Paid or external actions require separate approval.")
+        .description("Start an attended Workspace Copilot session on Oxygen Balanced by default. Starting is free; the next send starts inference using workspace credits. No inference budget is required. Legacy budget flags remain accepted but do not authorize or cap spend. Paid or external actions require separate approval.")
         .option("--budget-credits <number>", "Legacy compatibility only: accepted and clamped, but does not authorize or cap attended Copilot inference.")
-        .option("--tier <auto|low|medium|high>", "Legacy. Sessions run on Oxygen Auto; Oxygen picks the model. The three older tiers are still accepted so existing scripts keep working.")
-        .option("--model <id>", "Pin a specific priced model id instead of letting Oxygen choose. An id Oxygen does not price is ignored and the session runs on Oxygen Auto.")
+        .option("--tier <auto|low|medium|high>", "Model tier: auto=Oxygen Auto, low=Oxygen Fast, medium=Oxygen Balanced (default), high=Oxygen Max.")
+        .option("--model <id>", "Pin a specific priced model id. Unknown ids fall back to the selected tier.")
         .option("--per-turn-ceiling <number>", "Legacy compatibility only: accepted and clamped, but does not cap an attended turn.")
         .option("--journey <slug>", "Optional journey slug to seed the session's goal and context.")
         .option("--title <text>", "Optional human title for the session.")
@@ -12813,7 +12815,7 @@ Examples:
         }));
     }))
         .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 under the attended platform safety backstop.")
+        .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. Managed inference uses workspace credits.")
         .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.")
@@ -16374,14 +16376,15 @@ Examples:
         .addHelpText("after", "\nSenders: email_send.sender_profile_id sends one email from any inbox of a selected person (a lead already assigned to that person keeps its own inbox), and email_send.sender_mailbox_id from one exact inbox of a selected sender; a LinkedIn step's sender_profile_id sends it from a selected person (invite, message, inmail and withdraw_invite share one or none). Omit both to use the lead's assigned person. An email whose From changes needs its own subject_template. `sequences start <sequence>` without --approved shows who sends each step; nothing changes.\n")
         .argument("<sequence>", "Sequence id or slug.")
         .option("--name <name>", "New human-readable sequence name.")
-        .option("--steps-file <path>", "Draft only: path to a JSON file: { \"steps\": [...] } replacing the journey. Copy supports {{column}} interpolation; every step also takes {{sender_first_name}} / {{sender_last_name}} / {{sender_full_name}} for the person who sends it, and email adds {{sender_email}} (a same-named row column wins). A `branch` can also route on the lead's data with a data leaf { has_column: \"email\" } (true when that row_values column is non-empty; present:false for \"missing\").")
+        .option("--steps-file <path>", "Path to a JSON file: { \"steps\": [...] } replacing the journey. Once started, only wait timing may change: same steps, same order (zero a delay, never delete its step). Copy supports {{column}} interpolation; every step also takes {{sender_first_name}} / {{sender_last_name}} / {{sender_full_name}} for the person who sends it, and email adds {{sender_email}} (a same-named row column wins). A `branch` can also route on the lead's data with a data leaf { has_column: \"email\" } (true when that row_values column is non-empty; present:false for \"missing\").")
         .option("--channels <list>", "Draft only: comma-separated channels: linkedin,email,whatsapp,call,crm.")
         .option("--whatsapp-cold-initiate", "WhatsApp: allow cold-initiating new chats (no prior conversation). Required to start a WhatsApp sequence live (draft-editable).")
+        .option("--no-whatsapp-cold-initiate", "WhatsApp: stop allowing cold chats; a live WhatsApp start then refuses.")
         .addOption(new Option("--whatsapp-duplicate-scope <scope>", "Prevent duplicate WhatsApp copy in this campaign (default) or all campaigns.").choices(["campaign", "workspace"]))
-        .option("--phone-column-key <key>", "WhatsApp: row_values key holding each lead's phone number (else falls back to phone/phone_number/mobile).")
-        .option("--email-column-key <key>", "Native email: row_values key holding each lead's email (else falls back to email/email_address/work_email). Maps a non-English header (e.g. E-Mail).")
+        .option("--phone-column-key <key>", "WhatsApp: row_values key holding each lead's phone number (else falls back to phone/phone_number/mobile). \"\" clears it back to auto-detect.")
+        .option("--email-column-key <key>", "Native email: row_values key holding each lead's email (else falls back to email/email_address/work_email). Maps a non-English header (e.g. E-Mail). \"\" clears it back to auto-detect.")
         .option("--linkedin-url-column-key <key>", "LinkedIn: row_values key holding each lead's profile URL (else falls back to linkedin_url/linkedinUrl/linkedin/profile_url). \"\" clears it back to auto-detect.")
-        .option("--senders <ids>", "Comma-separated LinkedIn or WhatsApp sender account ids (or connection / Unipile ids; `senders list` / `whatsapp accounts` list them).")
+        .option("--senders <ids>", "LinkedIn or WhatsApp accounts attached directly, besides the --sender-profiles people's own accounts: comma-separated sender account ids (or connection / Unipile ids; `senders list` / `whatsapp accounts` list them). Replaces the directly attached set; \"\" removes them all and keeps the selected senders. `sequences get` lists both under sender_pool. Draft/paused only.")
         .option("--source-table <idOrSlug>", "Bind the table this sequence enrolls leads from (id or slug). Only lands while the sequence has no source table yet (first-writer-wins); its rows become enrollable leads. Draft/paused only.")
         .option("--email-provider <provider>", "Optional linked-campaign provider: 'instantly'. Omit to preserve the existing binding; --clear-email removes it on a draft. Native email needs no provider binding and sends through connected Google/Microsoft mailboxes, including Microsoft SMTP transport.")
         .option("--email-connection <id>", "Instantly connection id for the email track.")
@@ -16389,7 +16392,7 @@ Examples:
         .option("--clear-email", "Remove the email binding from the sequence (draft only).")
         .option("--max-credits <n>", "Stored draft credit ceiling (0 or more); 0 is valid. Changing a started sequence's cap requires its normal live-start approval.")
         .option("--max-live-sends <n>", "Draft-time total live-send and CRM-write ceiling across channels, including LinkedIn invites/messages (positive integer). After first start, change it through `sequences start`.")
-        .option("--max-emails-per-mailbox-per-day <n>", "Per-mailbox daily email cap (positive integer) applied across the sending pool; also sets each mailbox's send pace (send window ÷ cap, catching up when a slot is missed). Daily capacity = this cap × sendable mailboxes; `sequences stats` reports it under daily_budget.")
+        .option("--max-emails-per-mailbox-per-day <n>", "Per-mailbox daily email cap (0 or more) applied across the sending pool; also sets each mailbox's send pace (send window ÷ cap, catching up when a slot is missed). Daily capacity = this cap × sendable mailboxes; `sequences stats` reports it under daily_budget.")
         .option("--schedule-timezone <tz>", "One sending schedule for every channel, the same as Launch's Sending schedule: IANA zone, e.g. Europe/Berlin. Give it with --schedule-days, --schedule-hours-start and --schedule-hours-end; it sets the email window and the LinkedIn/WhatsApp window together. Use it instead of --send-window-file and the --linkedin-* flags. Email set to send in each recipient's own timezone keeps doing so, with this zone for leads that have none.")
         .option("--schedule-days <days>", "Sending schedule days: mon-fri, mon,wed,fri, or ISO numbers 1-7 (1 = Monday).")
         .option("--schedule-hours-start <HH:MM>", "Sending schedule start, local to --schedule-timezone, e.g. 09:00.")
@@ -16399,15 +16402,15 @@ Examples:
         .option("--linkedin-days <days>", "LinkedIn sending schedule days: mon-fri, mon,wed,fri, or ISO numbers 1-7 (1 = Monday).")
         .option("--linkedin-hours-start <HH:MM>", "LinkedIn sending schedule start, local to --linkedin-timezone, e.g. 06:45.")
         .option("--linkedin-hours-end <HH:MM>", "LinkedIn sending schedule end (exclusive), e.g. 18:30. Must be after the start. For LinkedIn the window only narrows each account's working hours (default 07:00-22:00, see senders limits get), never widens them.")
-        .option("--max-emails-per-day <n>", "Sequence-wide daily live-send cap across all senders/mailboxes. Unset means no additional sequence-wide cap; mailbox caps still apply. Omit on update to keep the current setting.")
-        .option("--max-new-enrollments-per-day <n>", "Daily cap on NEW first-touch leads. Unset means no additional intake cap; sending limits still apply. Omit on update to keep the current setting.")
+        .option("--max-emails-per-day <n|none>", "Sequence-wide daily cap on live sends across every channel (email, LinkedIn, WhatsApp) and sender; 0 sends nothing. `none` removes the cap; mailbox and account caps still apply. Omit to keep the current setting.")
+        .option("--max-new-enrollments-per-day <n|none>", "Daily cap on NEW first-touch leads (0 or more). `none` removes it; sending limits still apply. Omit to keep the current setting.")
         .option("--sequence-prioritization <mode>", "Under a tight daily budget, serve 'followups' or 'new_leads' first.")
-        .option("--esp-matching <mode>", "Native-email ESP matching: 'prefer' (DEFAULT) biases toward a mailbox on the recipient's own provider, falling back to any; 'off' rotates mailboxes freely; 'strict' requires a same-provider mailbox and defers the send when none exists.")
+        .option("--esp-matching <mode>", "Native-email ESP matching: 'prefer' (DEFAULT) biases toward a mailbox on the recipient's own provider, falling back to any; 'off' rotates mailboxes freely; 'strict' requires a same-provider mailbox and defers the send when none exists. Changes only the mode: routes saved by --esp-routing-file or the web stay.")
         .option("--esp-routing-file <path>", "Path to a JSON file holding the WHOLE native-email routing policy: { mode?, routes? }. `routes` is keyed by the RECIPIENT's provider and its values are relative send shares per sending provider, so { \"google\": { \"microsoft\": 100 } } sends Google-hosted recipients from Microsoft inboxes. Replaces --esp-matching and the file is the complete policy, not a patch. To stop sending from a domain, leave its inboxes out with --mailboxes.")
         .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 same-mailbox gap, default 12 minutes (integer 0-720; 0 disables the extra gap). Sends are spread across the window and may be farther apart. Daily caps and windows still apply.")
         .option("--opportunity-value <usd>", "Estimated USD value of one positive-reply opportunity (>= 0). Analytics-only: sequence stats multiply it by the positive-reply count to report pipeline $ (stats.opportunities). Never gates a send or spends a credit.")
-        .option("--mailboxes <ids>", "Per-sequence sending-account allowlist for native email (Instantly's 'Accounts to use'): comma-separated mailbox ids. Native email sends rotate ONLY over these mailboxes instead of the whole pool. Note: a narrow allowlist plus --esp-matching strict can starve sends when no allowed same-provider mailbox exists (surfaced as blocked defer reasons in stats).")
+        .option("--mailboxes <ids>", "Per-sequence sending-account allowlist for native email (Instantly's 'Accounts to use'): comma-separated mailbox ids. Native email sends rotate ONLY over these mailboxes instead of the whole pool. Note: a narrow allowlist plus --esp-matching strict can starve sends when no allowed same-provider mailbox exists (surfaced as blocked defer reasons in stats). \"\" removes the allowlist.")
         .option("--sender-profiles <ids>", "Send from these sender profiles (unified LinkedIn/WhatsApp/inbox identities): comma-separated profile ids (`oxygen senders profiles list` lists them). The server resolves each into its senders + inboxes. Live start is blocked if a selected profile lacks an account for a channel the journey uses.")
         .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.")
@@ -16415,7 +16418,7 @@ Examples:
         .option("--company-reply-pause <off|default|statuses>", "Pause the replier's company in this campaign when a reply has one of these statuses. Oxygen detects the company from work-email domains or explicit company fields; with no company identity, only the replier stops. New sequences start with this setting off. 'default' = interested,neutral,not_now,not_interested; or comma-separated Inbox status keys (`inbox labels list`); 'off' disables it. Read the saved setting with `sequences get`.")
         .option("--stop-on-reply-scope <scope>", "(deprecated: use --company-reply-pause) 'company_domain' = --company-reply-pause interested,neutral,not_now,not_interested,wrong_person; 'lead' = off.")
         .option("--bounce-protection <json>", "Sequence bounce policy JSON (partial updates merge): enabled=true, warning_rate=.02, pause_rate=.03, min_sends=20, window_days=7. Hard bounces / accepted sends in the rolling window; pauses this sequence, not the fleet. Rates are fractions; mailbox protection is separate.")
-        .option("--auto-optimize", "Enable the sequence-wide A/B auto-winner (default on).")
+        .option("--auto-optimize", "Turn the A/B auto-winner on (the default): every step with variants is judged on replies, pausing losers once each variant has 100 sends and 5 replies, unless the step sets its own auto_optimize.")
         .option("--no-auto-optimize", "Disable the sequence-wide A/B auto-winner; manual variant decisions stay available.")
         .option("--include-unsubscribe", "Add an unsubscribe option to emails, the same as Launch's switch: a visible recipient-bound link (plain text shows the URL, HTML a linked Unsubscribe label) plus one-click headers that mail apps show as an Unsubscribe button, both on first-touch cold emails; in-thread follow-ups carry neither. Zapbox sends (mailboxes imported from Zapmail, `transport: \"zapbox\"` in `mailboxes list --json`) carry the link only. Off by default. There is no separate opt-out text: write any reply-to-stop line into the email copy.")
         .option("--no-include-unsubscribe", "Turn off both the visible unsubscribe link and the one-click headers.")
@@ -16446,9 +16449,10 @@ Examples:
             const channels = readCsvOption(options.channels);
             if (channels.length > 0)
                 body.channels = channels;
-            const senders = readCsvOption(options.senders);
-            if (senders.length > 0)
-                body.senders = senders;
+            // The directly attached accounts, replaced as a set; `--senders ""`
+            // sends [] to remove them (the selected senders keep theirs).
+            if (options.senders !== undefined)
+                body.senders = readCsvOption(options.senders);
             const sourceTable = readOption(options.sourceTable);
             if (sourceTable)
                 body.source_table_id = sourceTable;
@@ -16613,13 +16617,25 @@ Examples:
         });
     }))
         .addCommand(new Command("preview")
-        .description("The free launch check, as a read: the same preview sequences start returns without --approved. It returns launch_readiness (blockers and warnings), sender_journey (who sends each step and how an inbox is picked), copy_preview (rendered pending-lead LinkedIn/WhatsApp copy, character counts and scan), caps and estimated credits. Email copy is not rendered; inspect its saved templates and unsubscribe settings with sequences get. Changes nothing and costs 0 credits; it never starts, resumes or dry-runs the sequence. Start with sequences start <sequence> --approved after review. Planned counts include only leads each step's channel can reach; skipped_actions_by_reason, channel_coverage and copy_preview.skipped_leads show the rest.")
+        .description("The free launch check, as a read: the same preview sequences start returns without --approved. It returns launch_readiness (blockers and warnings), sender_journey (who sends each step and how an inbox is picked), copy_preview (rendered pending-lead LinkedIn/WhatsApp copy, character counts and scan), caps and estimated credits. Email copy is not rendered here: `sequences render` shows it, and every A/B variant, for leads of the bound table. Changes nothing and costs 0 credits; it never starts, resumes or dry-runs the sequence. Start with sequences start <sequence> --approved after review. Planned counts include only leads each step's channel can reach; skipped_actions_by_reason, channel_coverage and copy_preview.skipped_leads show the rest.")
         .argument("<sequence>", "Sequence id or slug.")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
         await handleAsyncAction("sequences preview", options, () => 
         // The start route's preview branch: no approved, no dry_run, no ceilings.
         requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/start`, { method: "POST", body: {} }));
+    }))
+        .addCommand(new Command("render")
+        .description("Render a sequence's copy as the web step editor's Preview does: every A/B variant of each step (email subject/body, LinkedIn note/message/InMail, WhatsApp, comments) for leads of the bound table, or sample values when it has none, signed by one eligible sender. Works on a draft with nobody enrolled. Read-only, 0 credits. Each lead gets one variant at send; this shows all of them side by side, and spintax shows one pick per lead.")
+        .argument("<sequence>", "Sequence id or slug.")
+        .option("--step <stepId>", "Render only this step.")
+        .option("--variant <id>", "Render only this variant (a is the base step, then b, c, ...).")
+        .option("--row <ids>", "Comma-separated table_row_ids of the bound table to render for (at most 10). Default: its first rows.")
+        .option("--sender <profileId>", "Sign as this sender profile (one the step may send from; the response lists eligible_senders). Default: the first eligible.")
+        .option("--limit <n>", "How many leads to render when --row is not given (1-10, default 3).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (sequence, options) => {
+        await handleSequenceRenderAction(sequence, options);
     }))
         .addCommand(new Command("signal")
         .description("Record an external GTM signal (e.g. linkedin_connected, email_replied, company_raised_funds, job_change, web_visit, intent) onto a running sequence's enrollment(s) to drive signal-triggered branch/wait control. Target an enrollment by --enrollment or --lead (at least one is required); the server validates the signal name.")
@@ -16632,10 +16648,10 @@ Examples:
         await handleSequenceSignalAction(sequence, options);
     }))
         .addCommand(new Command("duplicate")
-        .description("Duplicate a sequence as a new DRAFT: copies the step definition, settings, channels, source table, and sender pool. Never copies enrollments, stats, or an Instantly email binding (re-bind with `sequences update` if the source used one; native email steps need no binding). Client-side composition of get + create — the copy starts fully inert until you `sequences start` it.")
+        .description("Duplicate a sequence as a new DRAFT: copies the steps, settings, channels, source table, caps, tags and sender pool. Never copies enrollments, stats, A/B decisions or an Instantly email binding (re-bind with `sequences update` if the source used one; native email steps need no binding). The copy is inert until you `sequences start` it; this is how a started journey gets new steps.")
         .argument("<sequence>", "Source sequence id or slug.")
-        .requiredOption("--name <name>", "Name for the copy.")
-        .option("--slug <slug>", "Slug for the copy. Defaults to the source slug + '-copy'.")
+        .option("--name <name>", "Name for the copy. Defaults to '<source name> (copy)'.")
+        .option("--slug <slug>", "Slug for the copy. Defaults to the source slug + '-copy' (then -copy-2, ...).")
         .option("--no-senders", "Do not copy the source's sender pool onto the copy.")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
@@ -16973,7 +16989,7 @@ Examples:
         .addCommand(new Command("variants")
         .description("Generic per-step action/base-variant scoreboard for one sequence, plus native email by_mailbox, by_domain, reply types, rates, and explicit unattributed facts. This rollup is not the copy-only analytics.messagePerformance view; base rows can represent non-message actions, and campaign replies may lack step/variant provenance. Provider-owned campaigns appear only after normalization into Oxygen's native Sequence ledgers. Also returns reversible auto-winner state (paused variants + evidence); flags run or override/reset that state.")
         .argument("<sequence>", "Sequence id or slug.")
-        .option("--auto-optimize", "Run the auto-winner now: pause the statistically-losing variant(s) of any step carrying an auto_optimize config, once every variant clears its thresholds, on that step's configured metric — reply (the recommended default), click, or open (click/open need native open/click tracking; opens are soft signals under Apple Mail Privacy Protection). Reversible.")
+        .option("--auto-optimize", "Run the auto-winner now on every step with variants (the whole sequence): once each active variant clears its thresholds (default 100 sends and 5 replies), pause the variants converting below the leader, on the step's metric — reply by default, or the click/open its own auto_optimize names (click/open need native open/click tracking; opens are soft signals under Apple Mail Privacy Protection). Nothing is evaluated while the sequence's auto-winner is off. Reversible.")
         .option("--pause <variant>", "Manually pause one variant (requires --step). Overrides the auto-winner.")
         .option("--activate <variant>", "Manually reactivate one paused variant (requires --step).")
         .option("--reset [variant]", "Clear an auto/manual decision: one variant (with --step), a whole step (--step only), or the entire sequence (no value). Reactivates the affected variants.")
@@ -21303,11 +21319,18 @@ function printCopilotEvent(event, sessionId) {
             return;
         }
         case "tool_call_started": {
+            // A question prints whole once it is asked; "[tool] ask_user…" says nothing.
+            if (payload.tool === COPILOT_ASK_USER_TOOL_NAME)
+                return;
             const capability = typeof payload.capability === "string" ? payload.capability : "tool";
             process.stderr.write(`\n[tool] ${capability}…\n`);
             return;
         }
         case "tool_call_finished": {
+            if (payload.tool === COPILOT_ASK_USER_TOOL_NAME) {
+                printCopilotQuestion(payload, sessionId);
+                return;
+            }
             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`);
@@ -21353,6 +21376,29 @@ function printCopilotEvent(event, sessionId) {
             return;
     }
 }
+/**
+ * The Copilot ended its turn on a question (`ask_user`). The web answers it on a
+ * card; here the options print numbered and the answer is the next message, so
+ * nothing about it needs a command of its own.
+ */
+function printCopilotQuestion(payload, sessionId) {
+    const result = isRecord(payload.result) ? payload.result : {};
+    if (result.ok === false)
+        return;
+    const asked = normalizeCopilotQuestions(result.questions);
+    if (!asked.ok)
+        return;
+    const lines = [];
+    for (const question of asked.questions) {
+        lines.push(`\n[question] ${question.question}${question.multiSelect ? " (choose any)" : ""}`);
+        question.options.forEach((option, index) => {
+            lines.push(`  ${index + 1}. ${option.label}${option.recommended ? " (recommended)" : ""}`
+                + `${option.description ? ` — ${option.description}` : ""}`);
+        });
+    }
+    lines.push(`Answer with: ${resolveCliBinaryName()} copilot send ${sessionId} <your answer>\n`);
+    process.stderr.write(lines.join("\n"));
+}
 // `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
@@ -26793,34 +26839,13 @@ function formatProfileUseSuccess(profile, options) {
 async function handleSequenceDuplicateAction(sequence, options) {
     try {
         const name = readOption(options.name);
-        if (!name)
-            throw new Error("--name is required.");
-        const source = await requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}`, { method: "GET" });
-        const src = source.sequence;
-        if (!src || src.definition === undefined) {
-            throw new Error(`Sequence '${sequence}' was found but returned no definition to copy.`);
-        }
-        const slug = readOption(options.slug) ?? `${src.slug ?? sequence}-copy`;
-        const copySenders = options.senders !== false;
-        const created = await requestOxygen("/api/cli/sequences", {
+        const slug = readOption(options.slug);
+        const created = await requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/duplicate`, {
             method: "POST",
-            // The create route reads snake_case keys (source_table_id, max_credits,
-            // senders, …). This handler used to POST camelCase, so the copy silently
-            // dropped the sender pool, table binding, URL column, and caps.
             body: {
-                slug,
-                name,
-                definition: src.definition,
-                ...(src.channels ? { channels: src.channels } : {}),
-                ...(src.sourceTableId ? { source_table_id: src.sourceTableId } : {}),
-                ...(src.linkedinUrlColumnKey ? { linkedin_url_column_key: src.linkedinUrlColumnKey } : {}),
-                ...(src.settings ? { settings: src.settings } : {}),
-                ...(src.maxCredits != null ? { max_credits: src.maxCredits } : {}),
-                ...(src.maxLiveSends != null ? { max_live_sends: src.maxLiveSends } : {}),
-                ...(Array.isArray(src.tags) && src.tags.length > 0 ? { tags: src.tags } : {}),
-                ...(copySenders && src.senderAccountIds && src.senderAccountIds.length > 0
-                    ? { senders: src.senderAccountIds }
-                    : {}),
+                ...(name ? { name } : {}),
+                ...(slug ? { slug } : {}),
+                ...(options.senders === false ? { include_senders: false } : {}),
             },
         });
         if (options.json) {
@@ -26828,15 +26853,76 @@ async function handleSequenceDuplicateAction(sequence, options) {
             return;
         }
         const link = created.deepLink ?? created.web_url;
-        const note = src.emailProvider
-            ? " Note: the source's email binding was NOT copied — re-bind with `sequences update` if needed."
-            : "";
-        process.stdout.write(`Duplicated '${sequence}' as draft '${created.sequence?.slug ?? slug}'.${note}${link ? ` ${link}` : ""}\n`);
+        const notCopied = created.not_copied?.length ? ` Not copied: ${created.not_copied.join("; ")}.` : "";
+        process.stdout.write(`Duplicated '${sequence}' as draft '${created.sequence?.slug ?? slug ?? "copy"}'.${notCopied}${link ? ` ${link}` : ""}\n`);
     }
     catch (error) {
         emitCliFailure("sequences duplicate", error);
     }
 }
+async function handleSequenceRenderAction(sequence, options) {
+    try {
+        const params = new URLSearchParams();
+        const step = readOption(options.step);
+        if (step)
+            params.set("step", step);
+        const variant = readOption(options.variant);
+        if (variant)
+            params.set("variant", variant);
+        const rows = readCsvOption(options.row);
+        if (rows.length > 0)
+            params.set("row", rows.join(","));
+        const sender = readOption(options.sender);
+        if (sender)
+            params.set("sender", sender);
+        const limit = readPositiveInt(options.limit);
+        if (limit !== undefined)
+            params.set("limit", String(limit));
+        const query = params.toString();
+        const data = await requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/render${query ? `?${query}` : ""}`);
+        if (options.json) {
+            writeJson(success("sequences render", data));
+            return;
+        }
+        process.stdout.write(formatSequenceRender(data));
+    }
+    catch (error) {
+        emitCliFailure("sequences render", error);
+    }
+}
+function formatSequenceRender(data) {
+    const lines = [];
+    for (const step of data.steps ?? []) {
+        const signer = step.sender ? ` · from ${step.sender.name}` : "";
+        lines.push(`Step ${step.step_index + 1} ${step.step_id} (${step.kind}${step.threaded ? ", continues the thread" : ""})${signer}`);
+        if (step.note)
+            lines.push(`  ${step.note}`);
+        for (const variant of step.variants) {
+            lines.push(`  Variant ${variant.variant_id}${variant.status === "paused" ? " (paused)" : ""}`);
+            for (const render of variant.renders) {
+                lines.push(`    ${render.lead}`);
+                for (const field of render.fields) {
+                    const limit = field.character_limit !== null && field.character_count > field.character_limit
+                        ? ` [${field.character_count}/${field.character_limit} characters]`
+                        : "";
+                    const missing = field.missing_variables.length > 0
+                        ? ` [missing ${field.missing_variables.map((key) => `{{${key}}}`).join(", ")}]`
+                        : "";
+                    const text = field.text.replace(/\n/g, "\n        ") || "(empty)";
+                    lines.push(`      ${field.key}: ${text}${limit}${missing}`);
+                }
+            }
+        }
+    }
+    if (lines.length === 0)
+        lines.push("No step has copy to render.");
+    if (data.note)
+        lines.push("", data.note);
+    const link = data.deepLink ?? data.web_url;
+    if (link)
+        lines.push(link);
+    return `${lines.join("\n")}\n`;
+}
 async function handleSequenceSignalAction(sequence, options) {
     try {
         const signal = readOption(options.signal);
@@ -26943,6 +27029,22 @@ function formatSequenceEvents(data) {
 async function handleSequenceVariantsAction(sequence, options) {
     try {
         const path = `/api/cli/sequences/${encodeURIComponent(sequence)}/variants`;
+        // One change per call: extra flags used to be dropped without a word, and a
+        // lone --step read the whole scoreboard.
+        const actions = [
+            options.autoOptimize ? "--auto-optimize" : null,
+            options.pause !== undefined ? "--pause" : null,
+            options.activate !== undefined ? "--activate" : null,
+            options.reset !== undefined ? "--reset" : null,
+        ].filter((flag) => flag !== null);
+        if (actions.length > 1) {
+            throw new OxygenError("invalid_request", `Pass one of ${actions.join(", ")} per call.`, { details: { flags: actions }, exitCode: 2 });
+        }
+        if (options.step && (actions.length === 0 || options.autoOptimize)) {
+            throw new OxygenError("invalid_request", options.autoOptimize
+                ? "--auto-optimize runs on the whole sequence; drop --step."
+                : "--step scopes --pause, --activate or --reset; add one of them.", { details: { step: options.step }, exitCode: 2 });
+        }
         let body = null;
         if (options.autoOptimize)
             body = { action: "auto_optimize" };
@@ -30360,9 +30462,29 @@ function readCompanyReplyPauseOption(value, legacyScope) {
 // The server shallow-merges this fragment over the sequence's current settings
 // (apps/web .../sequences/[sequenceId]/route.ts), so a throttle-only PATCH
 // preserves other settings the server already holds, e.g. dispatch_mode/schedule.
+/**
+ * A sequence daily cap flag: a whole number (0 is a real cap) or `none`, which
+ * sends null to remove the cap, as clearing the web's Sends per day field does.
+ */
+function readDailyCapOption(value, flag) {
+    const trimmed = value?.trim();
+    if (trimmed === undefined || trimmed === "")
+        return undefined;
+    if (trimmed.toLowerCase() === "none")
+        return null;
+    const parsed = Number(trimmed);
+    if (!Number.isSafeInteger(parsed) || parsed < 0) {
+        throw new OxygenError("invalid_number", `${flag} takes a whole number (0 or more) or none.`, {
+            details: { flag, value },
+            exitCode: 1,
+        });
+    }
+    return parsed;
+}
 function readSequenceSettings(options) {
     const settings = {};
-    const maxPerMailbox = readPositiveInt(options.maxEmailsPerMailboxPerDay);
+    // 0 is a real cap, as on the web's Sending limits (0-50).
+    const maxPerMailbox = readNonNegativeInt(options.maxEmailsPerMailboxPerDay);
     if (maxPerMailbox !== undefined) {
         settings.max_emails_per_mailbox_per_day = maxPerMailbox;
     }
@@ -30374,20 +30496,18 @@ function readSequenceSettings(options) {
     if (linkedinSchedule) {
         settings.schedule = linkedinSchedule;
     }
-    if (options.whatsappColdInitiate === true) {
-        settings.whatsapp_cold_initiate = true;
+    // Tri-state: `--no-whatsapp-cold-initiate` (update) turns the opt-in off.
+    if (options.whatsappColdInitiate !== undefined) {
+        settings.whatsapp_cold_initiate = options.whatsappColdInitiate;
     }
     const whatsappDuplicateScope = readOption(options.whatsappDuplicateScope);
     if (whatsappDuplicateScope)
         settings.whatsapp_duplicate_scope = whatsappDuplicateScope;
-    const phoneColumnKey = readOption(options.phoneColumnKey);
-    if (phoneColumnKey) {
-        settings.phone_column_key = phoneColumnKey;
-    }
-    const emailColumnKey = readOption(options.emailColumnKey);
-    if (emailColumnKey) {
-        settings.email_column_key = emailColumnKey;
-    }
+    // "" is sent as "": back to auto-detect, as the web's Lead identifiers save it.
+    if (options.phoneColumnKey !== undefined)
+        settings.phone_column_key = options.phoneColumnKey.trim();
+    if (options.emailColumnKey !== undefined)
+        settings.email_column_key = options.emailColumnKey.trim();
     // stop_on_bounce defaults ON server-side; commander's `--no-stop-on-bounce`
     // sets this to false, so only send the key when the user explicitly opts OUT.
     // Leaving it absent keeps the safe default and a settings PATCH clean.
@@ -30415,10 +30535,10 @@ function readSequenceSettings(options) {
     const companyReplyPause = readCompanyReplyPauseOption(options.companyReplyPause, options.stopOnReplyScope);
     if (companyReplyPause)
         settings.company_reply_pause = companyReplyPause;
-    const maxEmailsPerDay = readPositiveInt(options.maxEmailsPerDay);
+    const maxEmailsPerDay = readDailyCapOption(options.maxEmailsPerDay, "--max-emails-per-day");
     if (maxEmailsPerDay !== undefined)
         settings.max_emails_per_day = maxEmailsPerDay;
-    const maxNewEnrollmentsPerDay = readPositiveInt(options.maxNewEnrollmentsPerDay);
+    const maxNewEnrollmentsPerDay = readDailyCapOption(options.maxNewEnrollmentsPerDay, "--max-new-enrollments-per-day");
     if (maxNewEnrollmentsPerDay !== undefined)
         settings.max_new_enrollments_per_day = maxNewEnrollmentsPerDay;
     const prioritization = readOption(options.sequencePrioritization);
@@ -30459,9 +30579,9 @@ function readSequenceSettings(options) {
     // Per-sequence sending-account allowlist (--mailboxes id1,id2). Split + trim +
     // drop empties client-side (light); the server validates each is a UUID and caps
     // the count. An all-empty list omits the key so a stray "--mailboxes ," is a no-op.
-    const mailboxIds = readCsvOption(options.mailboxes);
-    if (mailboxIds.length > 0)
-        settings.mailbox_ids = mailboxIds;
+    // `--mailboxes ""` sends [] (no allowlist: the whole pool rotates again).
+    if (options.mailboxes !== undefined)
+        settings.mailbox_ids = readCsvOption(options.mailboxes);
     // Sender profiles (--sender-profiles id1,id2): the sequence sends from these
     // unified identities. The server resolves them into senderAccountIds + mailbox_ids.
     const senderProfileIds = readCsvOption(options.senderProfiles);

package/node_modules/@oxygen/shared/dist/agent-sessions.d.ts

@@ -0,0 +1,115 @@
+export type AgentSessionStatus = "draft" | "active" | "paused" | "budget_wait" | "completed" | "archived";
+export type AgentSessionResources = {
+    sequences: string[];
+    tables: string[];
+    conversations: string[];
+    mailboxes: string[];
+    records: string[];
+    objects: string[];
+    knowledge: string[];
+    domains: string[];
+};
+export type AgentSessionConfig = {
+    title: string;
+    goal: string;
+    template: string;
+    resources: AgentSessionResources;
+    actions: string[];
+    schedule: {
+        interval_minutes: number;
+        min_interval_minutes: number;
+        max_interval_minutes: number;
+    };
+    budget: {
+        per_run_credits: number;
+        daily_credits: number;
+        lifetime_credits?: number;
+    };
+    ends_at?: string | undefined;
+    events: string[];
+};
+export declare function agentSessionsEnabled(env?: Record<string, string | undefined>): boolean;
+export declare function agentSessionsAvailableTo(env: Record<string, string | undefined>, viewer: {
+    email: string | null | undefined;
+    member: boolean;
+    oxygenRole?: string | null | undefined;
+}): boolean;
+/** Reviewed native adapters. Unknown tools (including generic dispatch and agent management) fail closed. */
+export declare const AGENT_SESSION_ADAPTERS: Readonly<Record<string, {
+    resource: keyof AgentSessionResources;
+    field: string;
+    read: boolean;
+    fixed?: string;
+    array?: boolean;
+}>>;
+export declare function isAgentSessionCapability(name: string): boolean;
+export declare function agentSessionCapabilityDecision(config: AgentSessionConfig, name: string, args: Record<string, unknown>): "allow" | "ask" | "deny";
+export declare const EMPTY_AGENT_SESSION_RESOURCES: AgentSessionResources;
+export declare const AGENT_SESSION_EVENT_RESOURCES: {
+    readonly sequence_id: "sequences";
+    readonly table_id: "tables";
+    readonly conversation_id: "conversations";
+    readonly mailbox_id: "mailboxes";
+    readonly row_id: "records";
+    readonly record_id: "records";
+};
+export declare const AGENT_SESSION_EVENTS: import("./workspace-event-catalog.js").WorkspaceEventCatalogEntry[];
+export declare function agentSessionEventIsScoped(config: AgentSessionConfig, payload: Record<string, unknown>): boolean;
+export declare const AGENT_SESSION_TEMPLATES: readonly [{
+    readonly id: "campaign-monitor";
+    readonly title: "Campaign monitor";
+    readonly goal: "Watch this native campaign. Compare sends, replies and meetings with earlier reviews; explain changes, propose improvements and schedule the next review.";
+    readonly resources: readonly ["sequences"];
+    readonly actions: readonly ["oxygen_sequences_set_status"];
+    readonly events: readonly ["sequencer.contact_activity.any"];
+}, {
+    readonly id: "lead-replenishment";
+    readonly title: "Lead replenishment";
+    readonly goal: "Maintain a qualified lead pool in the selected Table for this native campaign. Research gaps, deduplicate and enroll only qualified leads within the approved scope.";
+    readonly resources: readonly ["tables", "sequences"];
+    readonly actions: readonly ["oxygen_rows_upsert", "oxygen_sequences_enroll"];
+    readonly events: readonly [];
+}, {
+    readonly id: "reply-handling";
+    readonly title: "Reply handling";
+    readonly goal: "Review the selected conversations, remember prior responses, qualify intent and draft replies. Send only when explicitly authorized; hand off uncertain or sensitive replies.";
+    readonly resources: readonly ["conversations"];
+    readonly actions: readonly ["oxygen_inbox_set_status"];
+    readonly events: readonly ["crm.email_reply_classified"];
+}, {
+    readonly id: "deliverability";
+    readonly title: "Deliverability";
+    readonly goal: "Watch the selected mailboxes for sending health changes. Explain evidence and recommend or apply only approved cap and status adjustments.";
+    readonly resources: readonly ["mailboxes"];
+    readonly actions: readonly ["oxygen_mailboxes_set_cap", "oxygen_mailboxes_set_status"];
+    readonly events: readonly [];
+}, {
+    readonly id: "account-research";
+    readonly title: "Account research";
+    readonly goal: "Maintain cited account research for the selected records and knowledge pages. Track changes and recommend next actions; keep facts separate from hypotheses.";
+    readonly resources: readonly ["records", "knowledge"];
+    readonly actions: readonly ["oxygen_crm_notes_add", "oxygen_knowledge_page_upsert"];
+    readonly events: readonly [];
+}, {
+    readonly id: "inbound-qualification";
+    readonly title: "Inbound qualification";
+    readonly goal: "Qualify the selected inbound conversations and records against workspace ICP and product knowledge. Record evidence and recommendations; hand off high intent to a person.";
+    readonly resources: readonly ["conversations", "records"];
+    readonly actions: readonly ["oxygen_inbox_set_status", "oxygen_crm_notes_add"];
+    readonly events: readonly ["crm.email_reply_classified"];
+}, {
+    readonly id: "crm-hygiene";
+    readonly title: "CRM hygiene";
+    readonly goal: "Review the selected CRM objects for duplicates and missing or inconsistent fields. Propose repairs with evidence, and apply only explicitly authorized changes.";
+    readonly resources: readonly ["objects"];
+    readonly actions: readonly ["oxygen_crm_merge"];
+    readonly events: readonly [];
+}, {
+    readonly id: "pipeline-review";
+    readonly title: "Pipeline review";
+    readonly goal: "Review the selected pipeline and lifecycle stages. Remember earlier reviews, identify stalled opportunities and recommend the next action with evidence.";
+    readonly resources: readonly ["objects", "records"];
+    readonly actions: readonly ["oxygen_crm_notes_add"];
+    readonly events: readonly [];
+}];
+export declare function validateAgentSessionConfig(config: AgentSessionConfig, requireResources?: boolean): void;