@oxygen-agent/cli 1.887.5 → 1.893.0

package/README.md

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

package/dist/command-manifest.js

@@ -39,7 +39,17 @@ const MUTATING_VERBS = new Set([
     // Exact leaves, not the `billing` prefix — `orgs billing-owners` is a read.
     // Both move a workspace's billing owner, so an agent must treat them as writes.
     "billing-link", "billing-unlink",
-    "bind", "buy", "call", "cancel", "chat-action", "claim", "clear",
+    "bind",
+    // `knowledge bootstrap --live` researches the workspace's own company and
+    // WRITES the typed company profile plus a cited wiki page, on paid provider
+    // and AI calls. Its bare form previews (see PREVIEW_BY_DEFAULT via --live),
+    // which the rule above already covers: an approval-gated command is a
+    // mutation. `knowledge bootstrap status` keeps the leaf verb `status` and
+    // stays a read.
+    "bootstrap",
+    // `support chat` starts or continues a customer-authored Plain Thread. The
+    // conversational noun is still a real external write.
+    "buy", "call", "cancel", "chat", "chat-action", "claim", "clear",
     "comment", "configure", "connect", "create", "decide", "delete", "delist", "disable",
     "disconnect", "dispatch", "done", "draft", "duplicate", "edit", "emit", "enable", "enroll",
     // Exact leaf, not a `field` prefix: `support admin field-set` writes a Plain

package/dist/index.js

@@ -9,7 +9,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { Command, CommanderError, Option } from "commander";
 import { applyOxygenHelp } from "./help.js";
 import { buildCommandManifest, getCommandManifestEntry, searchCommandManifest, suggestCommandNames, } from "./command-manifest.js";
-import { AGENCY_DIRECTORY_REGIONS, AGENCY_DIRECTORY_SERVICES, COLLAB_GATE_KINDS, COLLAB_GATE_PROSE, COLLAB_SUBJECT_KINDS, COLLAB_SUBJECT_KINDS_PROSE, COLLAB_SUBJECT_LABELS, COLLAB_SUBJECT_PROSE, GATE_KIND_SUBJECTS, describeWorkflowStatusChange, formatCellForDisplay, formatPublicBudgetScopes, SUBJECT_PATH_FORMS_PROSE, formatSubjectPath, exitCodeForOxygenError, parseSubjectPath, parseSubjectRef, parseWorkflowStatusChange, isVersionGreater, isVersionLess, MAX_MCP_TOOL_NAME_LENGTH, OXYGEN_CAPABILITY_ROUTES, OXYGEN_VERSION, OxygenError, getCapabilityRouteMatch, inferUserCapabilityRoute, parseKnowledgePageMarkdown, PLAN_LIMITS, serializeCapabilityRoute, sleep, success, TABLE_IMPORT_ROW_LIMIT, TAG_KINDS_PROSE, toFailure, workflowMcpToolName, } from "@oxygen/shared";
+import { AGENCY_DIRECTORY_REGIONS, AGENCY_DIRECTORY_SERVICES, COLLAB_GATE_KINDS, COLLAB_GATE_PROSE, COLLAB_SUBJECT_KINDS, COLLAB_SUBJECT_KINDS_PROSE, COLLAB_SUBJECT_LABELS, COLLAB_SUBJECT_PROSE, GATE_KIND_SUBJECTS, describeWorkflowStatusChange, formatCellForDisplay, formatPublicBudgetScopes, SUBJECT_PATH_FORMS_PROSE, formatSubjectPath, exitCodeForOxygenError, parseSubjectPath, parseSubjectRef, parseWorkflowStatusChange, isVersionGreater, isVersionLess, KNOWLEDGE_BOOTSTRAP_MAX_CREDITS, MAX_MCP_TOOL_NAME_LENGTH, OXYGEN_CAPABILITY_ROUTES, OXYGEN_VERSION, OxygenError, getCapabilityRouteMatch, inferUserCapabilityRoute, parseKnowledgePageMarkdown, PLAN_LIMITS, serializeCapabilityRoute, sleep, success, TABLE_IMPORT_ROW_LIMIT, TAG_KINDS_PROSE, toFailure, workflowMcpToolName, } from "@oxygen/shared";
 import { TAG_COLORS } from "@oxygen/shared/select-options";
 import { inferImportColumnLabels, inferRowsFileFormat, normalizeImportColumnKey, normalizeRowsForNewTable, normalizeRowsFormat, parseRowsFileBuffer, parseXlsxWorkbookBuffer, } from "@oxygen/shared/file-import";
 import { MAILBOX_IMPORT_FILE_MAX_BYTES as SHARED_MAILBOX_IMPORT_FILE_MAX_BYTES, MAILBOX_IMPORT_ROW_LIMIT as SHARED_MAILBOX_IMPORT_ROW_LIMIT, normalizeMailboxImportFile as normalizeSharedMailboxImportFile, normalizeMailboxImportVendor as normalizeSharedMailboxImportVendor, normalizeMailboxWorkbookRows, parseMailboxImportText, summarizeMailboxImportValidation as summarizeSharedMailboxImportValidation, } from "@oxygen/shared/mailbox-import";
@@ -2720,6 +2720,7 @@ export function createProgram() {
                 query,
                 route: serializeCapabilityRoute(inferUserCapabilityRoute(query)),
                 hint: "Hydrate one exact CLI command with `oxygen commands get <exact-command> --json`, or one MCP tool with `oxygen_capabilities_schema`.",
+                alternate_search_hint: `If this route does not fit the outcome, run \`oxygen skills search ${JSON.stringify(query)} --json\` for a narrower operational play.`,
             };
         });
     }))
@@ -2866,9 +2867,40 @@ export function createProgram() {
     }));
     program
         .command("support")
-        .description("Open and track Plain support conversations for the active OXYGEN organization. In the app, the support chat is the widget in the bottom-right corner of every page. Retry is the only recovery control; it returns after each failed connection attempt and never creates a Thread. CLI filing is a zero-credit write to the canonical Plain queue. Guide: https://oxygen-agent.com/docs/surfaces/support.")
+        .description("Open and track Plain support conversations for the active OXYGEN organization. In the app, the support chat is the widget in the bottom-right corner of every page. Retry is the only recovery control; it returns after each failed connection attempt and never creates a Thread. `support chat` starts or continues a zero-credit conversation without making you write a ticket title. Guide: https://oxygen-agent.com/docs/surfaces/support.")
+        .addCommand(new Command("chat")
+        .description("Start a Plain Chat conversation from one message, or pass an existing Thread ID to continue it. New conversations derive Plain's internal title from the message; you never have to file each message as a separate titled ticket.")
+        .argument("[threadId]", "Existing Plain Thread ID (th_...) to continue. Omit to start a new conversation.")
+        .requiredOption("-m, --message <message>", "Your message to OXYGEN support.")
+        .option("--severity <severity>", "New conversation only: low | normal | high. Defaults to normal.")
+        .option("--category <category>", "New conversation only: question, bug, feature_request, billing, security_data, configuration, agency_directory, or other. Defaults to question.")
+        .option("--json", "Print a JSON envelope.")
+        .addHelpText("after", `
+Examples:
+  oxygen support chat --message "The dedicated IP is not being assigned" --category bug
+  oxygen support chat th_... --message "Here is the additional evidence"
+`)
+        .action(async (threadId, options) => {
+        const message = readOption(options.message);
+        if (threadId) {
+            await handleAsyncAction("support chat", options, () => requestOxygen(`/api/cli/support/tickets/${encodeURIComponent(threadId)}/messages`, {
+                method: "POST",
+                body: { body: message },
+            }));
+            return;
+        }
+        const severity = readOption(options.severity);
+        await handleAsyncAction("support chat", options, () => requestOxygen("/api/cli/support/tickets", {
+            method: "POST",
+            body: {
+                message,
+                category: readOption(options.category) ?? "question",
+                ...(severity ? { severity } : {}),
+            },
+        }));
+    }))
         .addCommand(new Command("file")
-        .description("Create a real, zero-credit Plain support Thread immediately. This is a separate filing action, not the in-app Retry, and can create a second Thread: check `support list --status open` first and reply to the existing Thread for the same issue. There is no preview: review the exact subject, body, category, and severity before running it. Use when you're stuck on an OXYGEN operation.")
+        .description("Create a structured, titled Plain support Thread immediately. Prefer `support chat` for an ordinary conversation; use this zero-credit filing path when explicit subject, operation, error, run, or table metadata helps triage. Check `support list --status open` first because a new filing can create a second Thread.")
         .requiredOption("--subject <subject>", "One-line summary of the problem.")
         .option("--body <body>", "What you were doing, what happened, and what you tried.")
         .option("--severity <severity>", "low | normal | high. Defaults to normal.")
@@ -3224,7 +3256,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     }), { hidden: true }));
     program
         .command("feedback")
-        .description("Send feedback or a bug report to the OXYGEN team. This is the same immediate, zero-credit canonical Plain Thread write as `support file`; transcripts are never attached unless explicitly requested.")
+        .description("Send feedback or a bug report to the OXYGEN team. This is the same immediate, zero-credit canonical Plain conversation write as `support chat`; transcripts are never attached unless explicitly requested.")
         .option("-m, --message <message>", "Your feedback or bug report.")
         .option("--severity <severity>", "low | normal | high. Defaults to normal.")
         .option("--category <category>", "Optional category label. Defaults to 'feedback'.")
@@ -6022,6 +6054,51 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             body: { id: assetId },
         }));
     })));
+    // `knowledge bootstrap` is declared here, not inline in the group chain,
+    // because it is a command that both ACTS and owns a subcommand, and both
+    // levels take --json. Commander resolves a repeated option to the outer
+    // command, so `knowledge bootstrap status --json` sets the flag on THIS
+    // command, not on `status` — the same collision the `commands` group above
+    // handles. The named reference lets `status` read the parent's flag back.
+    const knowledgeBootstrapCommand = new Command("bootstrap")
+        .description(`Research THIS workspace's own company from its domain and fill the typed company profile plus one cited wiki page — the empty-Knowledge-Graph fix, so a founder never has to type their own positioning back at us. Two authorization paths, and they are NOT the same: running this command manually is authorized by --live (plus --max-credits), like every other paid Oxygen action; the identical pass that runs ONCE automatically after signup is authorized by the consent recorded at signup instead, and is capped (<= ${KNOWLEDGE_BOOTSTRAP_MAX_CREDITS} credits), journalled (a marker, a system run, and immutable page sources), kill-switched fleet-wide, and reversible. A bare call previews: it resolves the domain, plans the reads, estimates the cost, and spends nothing. Once per workspace ever — any existing marker (completed, partial, skipped, failed) blocks a second pass until --force clears it.`)
+        .option("--domain <domain>", "Company apex domain to research. Defaults to the workspace domain resolved at signup from the org's Clerk metadata or the creator's email; a personal-email signup has none, and a preview says so instead of guessing.")
+        .option("--linkedin <url>", "Company LinkedIn URL, as a second identity signal alongside the domain.")
+        .option("--live", "Authorize this manual run to spend and write. Requires --max-credits. Without it the command previews and nothing is billed.")
+        .option("--approved", "Same as --live. Accepted because the global help footer names --approved as the way to authorize a credit-spending command.")
+        .option("--max-credits <credits>", `Hard credit ceiling for the whole pass. Required with --live, and clamped server-side to ${KNOWLEDGE_BOOTSTRAP_MAX_CREDITS}.`)
+        .option("--force", "Clear an existing once-ever marker first and re-arm the pass. This is the one deliberate way to research the same workspace twice — pair it with --live to actually spend again.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("knowledge bootstrap", options, () => requestOxygen("/api/cli/knowledge/bootstrap", {
+            method: "POST",
+            body: {
+                mode: options.live || options.approved ? "live" : "dry_run",
+                ...(readOption(options.domain) ? { domain: readOption(options.domain) } : {}),
+                ...(readOption(options.linkedin) ? { linkedin_url: readOption(options.linkedin) } : {}),
+                ...(readPositiveNumber(options.maxCredits) !== undefined
+                    ? { max_credits: readPositiveNumber(options.maxCredits) }
+                    : {}),
+                ...(options.force ? { force: true } : {}),
+            },
+        }));
+    })
+        .addCommand(new Command("status")
+        .description("Report the once-ever bootstrap marker for this workspace: status (queued, running, completed, partial, skipped, failed, or never attempted), when it ran, its system run id, the credits it actually spent, the domain researched, the reason it stopped, and the pages it wrote. Free, reads only, and the honest way to find out whether the automatic pass already happened before you spend on a manual one.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        // Commander hands a repeated --json to the outer command, so read the
+        // parent's flag back before deciding the output shape. Without this a
+        // machine caller asking for an envelope silently gets bare JSON.
+        const outputOptions = {
+            ...options,
+            json: options.json || Boolean(knowledgeBootstrapCommand.opts().json),
+        };
+        await handleAsyncAction("knowledge bootstrap status", outputOptions, () => requestOxygen("/api/cli/knowledge/bootstrap", {
+            method: "POST",
+            body: { status: true },
+        }));
+    }));
     program
         .command("knowledge")
         .description("Company knowledge wiki: slug-addressed pages, a [[wikilink]] graph, and a decision log.")
@@ -6181,7 +6258,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         }));
     }))
         .addCommand(new Command("lint")
-        .description("Structural wiki health report: orphans, dead-ends, unresolved links, missing canonicals, untagged pages, duplicate titles, oversized hubs, unfilled seed stubs, decisions missing a reversal condition, stale/oversized pages, and aged proposals.")
+        .description("Structural wiki health report: orphans (unfilled seed stubs excluded), dead-ends, unresolved links, contradictions (disputed pages, conflicting trust tags, competing live-copy pages), missing canonicals, untagged pages, duplicate titles, oversized hubs, unfilled seed stubs (total plus the most-linked-to), researchable stubs, decisions missing a reversal condition, stale pages (untouched or superseded by newer sources), oversized bodies, and aged proposals.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("knowledge lint", options, () => requestOxygen("/api/cli/knowledge/lint"));
@@ -6298,7 +6375,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         }));
     })))
         .addCommand(new Command("seed")
-        .description("Seed or upgrade the knowledge wiki scaffold: on first run creates the starter page set — a start-here guide, a conventions schema page, and stub hubs (icp, positioning, offers, competitors, playbooks, campaign-learnings, decisions), all [[wikilinked]]. Idempotent; never overwrites your edits.")
+        .description("Seed or upgrade the knowledge wiki scaffold: on first run creates the starter page set — a start-here guide, a conventions schema page, and 19 draft stub hubs (icp, positioning, offers, competitors, playbooks, campaign-learnings, decisions, voice, brand, messaging, objections, playbook-outbound, playbook-inbound, playbook-nurture, qualification, personas, customers, research, metrics), all [[wikilinked]]. Idempotent; never overwrites your edits.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("knowledge seed", options, () => requestOxygen("/api/cli/knowledge/seed", {
@@ -6306,6 +6383,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             body: {},
         }));
     }))
+        .addCommand(knowledgeBootstrapCommand)
         .addCommand(new Command("synthesize")
         .description("Synthesize knowledge from workspace evidence (one low-cost AI call): campaign learnings from auto-filed outreach outcomes, or a voice guide from sent messages. Previews by default; --approved writes the result.")
         .option("--kind <kind>", "What to synthesize: campaign_learnings (default) or voice.", "campaign_learnings")
@@ -9293,7 +9371,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .requiredOption("--instructions <text>", "Workspace Agent instructions for this version.")
         .option("--model-policy-json <json>", AGENT_MODEL_POLICY_HELP)
         .option("--tool-policy-json <json>", AGENT_TOOL_POLICY_HELP)
-        .option("--context-policy-json <json>", "Context policy JSON: on_demand or prefetch, optional resolve_args and file_ids.")
+        .option("--context-policy-json <json>", "Context policy JSON: on_demand, prefetch, or grounded (seeds the run from the workspace knowledge wiki); 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.")
@@ -9322,7 +9400,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--description <text>", "Optional one-line description of the agent's job.")
         .option("--model-policy-json <json>", AGENT_MODEL_POLICY_HELP)
         .option("--tool-policy-json <json>", AGENT_TOOL_POLICY_HELP)
-        .option("--context-policy-json <json>", "Context policy JSON: on_demand or prefetch, optional resolve_args and file_ids.")
+        .option("--context-policy-json <json>", "Context policy JSON: on_demand, prefetch, or grounded (seeds the run from the workspace knowledge wiki); 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.")
@@ -12115,17 +12193,21 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     program.addCommand(new Command("sequences")
         .description("Multichannel outreach sequences: one enrollment per lead can span LinkedIn, email, WhatsApp, human call tasks, and connected-CRM tasks. LinkedIn steps dispatch natively (rate-limited, credit-capped); email steps send natively or place/move/stop the lead in a bound Instantly campaign (BYOK); crm_task can exact-match/upsert/link CRM records and create a mapped external follow-up (HubSpot first), with replay-safe per-operation receipts. Cross-channel reply-stop is intrinsic.")
         .addCommand(new Command("list")
-        .description("List sequences with status, channels, tags, and credit usage. --stats joins each row's LIFETIME funnel (enrolled, sent, replies, reply rate, email opens/clicks, opportunities) — the same shape `sequences stats` returns for one sequence.")
+        .description("List sequences with persisted launch status kept separate from current operational state. Fleet counts report marked-active versus operationally-live (active with nonterminal work), and rows explain flowing, paced, blocked, degraded, drained, or empty work without SQL. --stats joins each row's LIFETIME funnel.")
         .option("--status <status>", "Filter by status: draft, active, paused, or archived.")
+        .addOption(new Option("--operational-state <state>", "Filter by current work state; fleet counts remain unfiltered: empty, drained, blocked, degraded, flowing, or paced.").choices(["empty", "drained", "blocked", "degraded", "flowing", "paced"]))
         .option("--tag <tag>", "Only sequences carrying this workspace tag (see `oxygen tags list`).")
         .option("--stats", "Attach lifetime stats per sequence (a stats pass per row — slower on large workspaces).")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("sequences list", options, () => {
+        await handleSequenceReadAction("sequences list", options, () => {
             const params = new URLSearchParams();
             const status = readOption(options.status);
             if (status)
                 params.set("status", status);
+            const operationalState = readOption(options.operationalState);
+            if (operationalState)
+                params.set("operational_state", operationalState);
             const tag = readOption(options.tag);
             if (tag)
                 params.set("tag", tag);
@@ -12133,7 +12215,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 params.set("include", "stats");
             const suffix = params.toString();
             return requestOxygen(`/api/cli/sequences${suffix ? `?${suffix}` : ""}`);
-        });
+        }, formatSequenceListHealth);
     }))
         .addCommand(new Command("send")
         .description("Initiate one net-new LinkedIn message through a one-recipient, one-step hosted Sequence. First call without a sequence id: pass --recipient, --text/--text-file, and --sender to create the inert draft and preview (no message, no credits). After showing that preview, re-run with the returned sequence id plus --approved --max-credits N. Existing-thread replies stay in `oxygen inbox send`.")
@@ -12349,14 +12431,14 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         });
     })))
         .addCommand(new Command("analytics")
-        .description("Show organization-level sequencer analytics, per-sequence funnels, and native email attribution under analytics.emailAttribution: byMailbox, byDomain, and explicit unattributed facts. With --sequence, analytics.senderPerformance groups channel-conditional counts and rates by sending person; analytics.messagePerformance reports each copy-bearing deterministic step variant, target/actual distribution, contacted recipients, and type-specific accepted/reply/positive outcomes (absent for note-less connect-only campaigns). Message-level reply outcomes require preserved step/variant provenance, so older unattributed replies remain in campaign totals without being guessed into a message row. Provider-owned campaigns appear only after their telemetry is normalized into Oxygen's native Sequence ledgers. Also reports whether the reply → CRM automation is armed, with a link to the workflow.")
+        .description("Show selected-window sequencer analytics with persisted status kept separate from operational state, fleet marked-active versus operationally-live counts, current open work, sent/terminal-failed/deferral totals, failure classes, and action-kind breakdowns. Also includes per-sequence funnels and native email attribution under analytics.emailAttribution: byMailbox, byDomain, and explicit unattributed facts. With --sequence, analytics.senderPerformance groups channel-conditional counts and rates by sending person; analytics.messagePerformance reports each copy-bearing deterministic step variant, target/actual distribution, contacted recipients, and type-specific accepted/reply/positive outcomes (absent for note-less connect-only campaigns). Message-level reply outcomes require preserved step/variant provenance, so older unattributed replies remain in campaign totals without being guessed into a message row. Provider-owned campaigns appear only after their telemetry is normalized into Oxygen's native Sequence ledgers. Also reports whether the reply → CRM automation is armed, with a link to the workflow.")
         .option("--range <range>", "Preset range: 7d, 14d, 28d, 30d, 90d, 180d, 365d, or all. Defaults to 14d. `all` starts at the oldest campaign in scope.")
         .option("--from <date>", "Custom start date (YYYY-MM-DD). Windows up to five years are accepted.")
         .option("--to <date>", "Custom end date (YYYY-MM-DD).")
         .option("--sequence <id-or-slug>", "Limit analytics to one sequence.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("sequences analytics", options, () => {
+        await handleSequenceReadAction("sequences analytics", options, () => {
             const params = new URLSearchParams();
             const range = readOption(options.range);
             const from = readOption(options.from);
@@ -12372,7 +12454,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 params.set("sequence", sequence);
             const qs = params.toString();
             return requestOxygen(`/api/cli/sequences/analytics${qs ? `?${qs}` : ""}`);
-        });
+        }, formatSequenceAnalyticsHealth);
     }))
         .addCommand(new Command("create")
         .description("Create a draft multichannel sequence from a steps JSON file. Supports LinkedIn, email, WhatsApp, human call_task, and connected-CRM crm_task journeys. 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-*. Install/read the oxygen-sequencer skill for complete mapped CRM task examples.")
@@ -12821,11 +12903,11 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         });
     }))
         .addCommand(new Command("stats")
-        .description("Show the sequence funnel: enrolled, invites sent, connected, replied, with acceptance and reply rates.")
+        .description("Show one sequence's persisted launch status and current operational state separately, including reasons, open work, lifetime sent/terminal-failed/deferral counts, and the funnel.")
         .argument("<sequence>", "Sequence id or slug.")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
-        await handleAsyncAction("sequences stats", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/stats`));
+        await handleSequenceReadAction("sequences stats", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/stats`), formatSequenceStatsHealth);
     }))
         .addCommand(new Command("esp")
         .description("ESP breakdown of this sequence's email sending scope: which provider each enrolled lead's mail routes through (google/microsoft, plus named gateways like Proofpoint/Mimecast and non-matchable hosts), folded against your sending mailbox pool. Shows how many leads the CURRENT --esp-matching mode would defer before you turn it on. Resolves domains from MX + SPF (0 credits, DNS only) and caches the result, warming the send path. Preview before flipping strict/prefer.")
@@ -21082,6 +21164,185 @@ function renderTextTable(headers, rows) {
     const separator = `  ${widths.map((width) => "-".repeat(width)).join("  ")}`;
     return [renderRow(headers), separator, ...rows.map(renderRow)];
 }
+// Sequence state is derived only by the shared API. These helpers render those
+// facts; they never infer flowing/blocked/live client-side. JSON remains the
+// untouched API data inside the standard CLI envelope.
+const SEQUENCE_OPERATIONAL_STATE_ORDER = ["empty", "drained", "blocked", "degraded", "flowing", "paced"];
+async function handleSequenceReadAction(command, options, action, render) {
+    try {
+        const data = await action();
+        if (options.json) {
+            writeJson(success(command, data));
+            return;
+        }
+        process.stdout.write(isRecord(data) ? render(data) : `${JSON.stringify(data, null, 2)}\n`);
+    }
+    catch (error) {
+        emitCliFailure(command, error);
+    }
+}
+function formatSequenceListHealth(data) {
+    const sequences = Array.isArray(data.sequences) ? data.sequences.filter(isRecord) : [];
+    const lines = [...formatSequenceFleetSummary(data.fleet), ""];
+    if (sequences.length === 0) {
+        lines.push("No sequences match these filters.");
+    }
+    else {
+        lines.push(...renderTextTable(["SEQUENCE", "PERSISTED", "OPERATIONAL", "OPEN WORK", "SENT / FAILED", "REASONS"], sequences.map((sequence) => sequenceHealthRow(sequence))));
+        lines.push("", ...sequenceInspectionLinks(sequences));
+    }
+    const listLink = stringValue(data.web_url) ?? stringValue(data.deepLink);
+    if (listLink)
+        lines.push(listLink);
+    return `${lines.join("\n")}\n`;
+}
+function formatSequenceStatsHealth(data) {
+    const stats = recordValue(data.stats);
+    const operational = recordValue(stats.operational);
+    const lines = [
+        stringValue(data.name) ?? stringValue(data.sequence_id) ?? "Sequence",
+        `Persisted status: ${stringValue(data.status) ?? "unknown"}`,
+        `Operational state: ${stringValue(operational.operationalState) ?? "unknown (legacy response)"}`,
+        `Open work: ${formatSequenceOpenWork(operational.openWork)}`,
+        `Reasons: ${formatSequenceReasons(operational)}`,
+        `${formatFailureWindow(operational.failureAnalytics)} outcomes: ${formatSequenceFailureTotals(operational.failureAnalytics)}`,
+    ];
+    const failureMix = formatCountRecord(recordValue(recordValue(operational.failureAnalytics).byFailureClass));
+    if (failureMix !== "—")
+        lines.push(`Failure mix: ${failureMix}`);
+    lines.push(...formatActionKindBreakdown(operational.failureAnalytics));
+    lines.push("", ...renderTextTable(["FUNNEL", "COUNT"], [
+        ["Enrolled", numberText(stats.enrolled)],
+        ["Invites sent", numberText(stats.invitesSent ?? stats.connectionRequestsSent)],
+        ["Connected", numberText(stats.connected ?? stats.connectionRequestsAccepted)],
+        ["Messages sent", numberText(stats.messagesSent)],
+        ["Replies", numberText(stats.totalReplies ?? stats.replied)],
+    ]));
+    const link = stringValue(data.web_url) ?? stringValue(data.deepLink);
+    if (link)
+        lines.push("", link);
+    return `${lines.join("\n")}\n`;
+}
+function formatSequenceAnalyticsHealth(data) {
+    const analytics = recordValue(data.analytics);
+    const summary = recordValue(analytics.operationalSummary);
+    const failureAnalytics = summary.failureAnalytics;
+    const sequences = Array.isArray(analytics.sequences) ? analytics.sequences.filter(isRecord) : [];
+    const range = recordValue(analytics.range);
+    const from = stringValue(range.from);
+    const to = stringValue(range.to);
+    const rangeLabel = from || to ? `${from ?? "start"} → ${to ?? "now"}` : stringValue(range.preset) ?? "selected window";
+    const lines = [
+        `Sequencer analytics (${rangeLabel})`,
+        ...formatSequenceFleetSummary(analytics.fleet),
+        `Open work: ${formatSequenceOpenWork(summary.openWork)}`,
+        `Selected-window outcomes: ${formatSequenceFailureTotals(failureAnalytics)}`,
+        `Failure mix: ${formatCountRecord(recordValue(recordValue(failureAnalytics).byFailureClass))}`,
+        ...formatActionKindBreakdown(failureAnalytics),
+        "",
+    ];
+    if (sequences.length === 0) {
+        lines.push("No sequences in this analytics scope.");
+    }
+    else {
+        lines.push(...renderTextTable(["SEQUENCE", "PERSISTED", "OPERATIONAL", "OPEN WORK", "SENT / FAILED", "REASONS"], sequences.map((sequence) => sequenceHealthRow(sequence))));
+        lines.push("", ...sequenceInspectionLinks(sequences));
+    }
+    const link = stringValue(data.web_url) ?? stringValue(data.deepLink);
+    if (link)
+        lines.push(link);
+    return `${lines.join("\n")}\n`;
+}
+function sequenceHealthRow(sequence) {
+    const operational = recordValue(sequence.operational);
+    return [
+        stringValue(sequence.name) ?? stringValue(sequence.slug) ?? "—",
+        stringValue(sequence.status) ?? "unknown",
+        stringValue(operational.operationalState) ?? "unknown",
+        formatSequenceOpenWork(operational.openWork),
+        formatSequenceFailureTotals(operational.failureAnalytics),
+        formatSequenceReasons(operational),
+    ];
+}
+function sequenceInspectionLinks(sequences) {
+    return sequences.flatMap((sequence) => {
+        const exactLink = stringValue(sequence.web_url) ?? stringValue(sequence.deepLink);
+        return exactLink ? [`Inspect ${stringValue(sequence.name) ?? stringValue(sequence.slug) ?? "Sequence"}: ${exactLink}`] : [];
+    });
+}
+function formatSequenceFleetSummary(value) {
+    const fleet = recordValue(value);
+    if (Object.keys(fleet).length === 0)
+        return ["Fleet counts: unavailable (legacy API response)"];
+    const states = recordValue(fleet.byOperationalState);
+    return [
+        `Fleet: ${numberText(fleet.markedActive)} marked active · ${numberText(fleet.operationallyLive)} operationally live · ${numberText(fleet.total)} total`,
+        `States: ${SEQUENCE_OPERATIONAL_STATE_ORDER.map((state) => `${state} ${numberText(states[state])}`).join(" · ")}`,
+    ];
+}
+function formatSequenceOpenWork(value) {
+    const work = recordValue(value);
+    if (Object.keys(work).length === 0)
+        return "unknown";
+    return [
+        `enr ${numberText(work.enrollments)}`,
+        `act ${numberText(work.actions)}`,
+        `now ${numberText(work.actionableNow)}`,
+        `flight ${numberText(work.inFlight)}`,
+        `paced ${numberText(work.paced)}`,
+        `blocked ${numberText(work.blocked)}`,
+        `unresolved ${numberText(work.unresolvedFailures)}`,
+    ].join(" · ");
+}
+function formatSequenceFailureTotals(value) {
+    const analytics = recordValue(value);
+    if (Object.keys(analytics).length === 0)
+        return "unknown";
+    return `sent ${numberText(analytics.sent)} · failed ${numberText(analytics.terminalFailed)} · deferred ${numberText(analytics.deferrals)}`;
+}
+function formatFailureWindow(value) {
+    const windowValue = recordValue(recordValue(value).window);
+    const from = stringValue(windowValue.from);
+    const to = stringValue(windowValue.to);
+    return from || to ? `Selected-window ${from ?? "start"} → ${to ?? "now"}` : "Lifetime";
+}
+function formatSequenceReasons(operational) {
+    const reasonCodes = Array.isArray(operational.reasonCodes)
+        ? operational.reasonCodes.filter((reason) => typeof reason === "string")
+        : [];
+    if (reasonCodes.length > 0)
+        return reasonCodes.join(", ");
+    return stringValue(operational.operationalState) ? "none reported" : "unknown";
+}
+function formatActionKindBreakdown(value) {
+    const byActionKind = recordValue(recordValue(value).byActionKind);
+    const entries = Object.entries(byActionKind).filter((entry) => isRecord(entry[1])).sort(([left], [right]) => left.localeCompare(right));
+    if (entries.length === 0)
+        return [];
+    return ["By action kind:", ...entries.map(([kind, bucket]) => {
+            const mix = formatCountRecord(recordValue(bucket.byFailureClass));
+            return `  ${kind}: ${formatSequenceFailureTotals(bucket)}${mix === "—" ? "" : ` · failures ${mix}`}`;
+        })];
+}
+function formatCountRecord(value) {
+    const entries = Object.entries(value)
+        .map(([key, count]) => [key, numericValue(count)])
+        .filter((entry) => entry[1] !== null && entry[1] > 0)
+        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
+    return entries.length > 0 ? entries.map(([key, count]) => `${key} ${count}`).join(" · ") : "—";
+}
+function recordValue(value) {
+    return isRecord(value) ? value : {};
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function numericValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function numberText(value) {
+    return String(numericValue(value) ?? 0);
+}
 function formatSequenceVariants(data) {
     const styles = ansi(output.isTTY === true && !process.env.NO_COLOR);
     const byVariant = Array.isArray(data.by_variant) ? data.by_variant : [];

package/dist/skills.js

@@ -208,6 +208,13 @@ options, runtime = {}) {
     const env = runtime.env ?? process.env;
     const platform = runtime.platform ?? process.platform;
     const spawn = runtime.spawnSync ?? wrapExecFileSync(runtime.execFileSync) ?? spawnSync;
+    const installLocations = resolveSkillInstallLocations(agents, options.project === true, env);
+    // The vendored installer writes immediately once spawned. Tell humans and
+    // agents the exact destination first so a default global install is never a
+    // surprise, while keeping stdout as one stable JSON envelope under --json.
+    process.stderr.write(`note: installing Oxygen skills (${options.project ? "project" : "global"}) into ${installLocations
+        .map((location) => `${location.agent}=${location.path}`)
+        .join(", ")}\n`);
     // A specific shortcut skill can declare prerequisite skills that its SKILL.md
     // invokes (e.g. oxygen-clay-migration → oxygen-gtm, whose recipes it lives in).
     // Installing it alone would leave those missing, so pull them in too. Best-
@@ -304,6 +311,7 @@ options, runtime = {}) {
         skill,
         ...(dependencySkills.length > 0 ? { dependency_skills: dependencySkills } : {}),
         scope: options.project ? "project" : "global",
+        install_locations: installLocations,
         output: outputs.join(""),
         // Truthful counts a caller (human or scripting agent) can trust at a
         // glance: a not-detected agent is never folded into `failed`.
@@ -316,6 +324,23 @@ options, runtime = {}) {
         summary: summarizeInstallOutcome(agents.length, skippedAgents.length, 0),
     };
 }
+function resolveSkillInstallLocations(agents, project, env) {
+    const projectRoots = {
+        codex: resolve(".agents", "skills"),
+        "claude-code": resolve(".claude", "skills"),
+        cursor: resolve(".agents", "skills"),
+    };
+    const globalRoots = {
+        codex: join(env.CODEX_HOME?.trim() || join(homedir(), ".codex"), "skills"),
+        "claude-code": join(env.CLAUDE_CONFIG_DIR?.trim() || join(homedir(), ".claude"), "skills"),
+        cursor: join(homedir(), ".cursor", "skills"),
+    };
+    const roots = project ? projectRoots : globalRoots;
+    return agents.map((agent) => ({
+        agent,
+        path: roots[agent] ?? (project ? resolve(".agents", "skills") : join(homedir(), ".agents", "skills")),
+    }));
+}
 /**
  * Stages the requested skill(s) into `dir` so the installer receives a local
  * filesystem path instead of the org-bound tokenized access URL. Keeping the URL

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

@@ -25,7 +25,7 @@ export type PricingPlanDefinition = {
     features: readonly string[];
 };
 export type PricingPlanMetadata = Record<string, unknown> | null | undefined;
-export declare const CONTACT_SALES_URL = "mailto:support@oxygen-agent.com";
+export declare const CONTACT_SALES_URL = "mailto:priority@oxygen-agent.com";
 export declare const CREDITS_PER_USD = 1000;
 export declare const TOPUP_USD_CENTS_PER_1K_CREDITS = 125;
 export declare const CREDIT_TOPUP_MIN_CREDITS = 8000;
@@ -222,7 +222,7 @@ export declare const BASE_PRICING_PLANS: {
         readonly automationOverageEnabledDefault: false;
         readonly description: "For high-volume GTM teams that need custom limits and rollout support.";
         readonly ctaLabel: "Contact sales";
-        readonly contactHref: "mailto:support@oxygen-agent.com";
+        readonly contactHref: "mailto:priority@oxygen-agent.com";
         readonly features: readonly ["10,000,000+ managed credits / month", "Workflows", "Phone number enrichment on managed credits", "Custom provider routing and BYOK policies", "Dedicated onboarding"];
         readonly monthlyPriceCents: number | null;
         readonly monthlyCredits: number | null;
@@ -238,7 +238,7 @@ export declare const BASE_PRICING_PLANS: {
         readonly automationOverageEnabledDefault: false;
         readonly description: "Custom procurement, invoicing, limits, and rollout support.";
         readonly ctaLabel: "Talk to us";
-        readonly contactHref: "mailto:support@oxygen-agent.com";
+        readonly contactHref: "mailto:priority@oxygen-agent.com";
         readonly features: readonly ["Everything in Team", "Custom usage limits", "Volume pricing", "Dedicated support"];
         readonly monthlyPriceCents: number | null;
         readonly monthlyCredits: number | null;

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

@@ -4,11 +4,11 @@ export const WEEKLY_USAGE_WINDOW_DAYS = 7;
 export const BILLING_CURRENCIES = ["usd"];
 export const DEFAULT_BILLING_CURRENCY = "usd";
 // Scale/Enterprise contact routes to the shared support inbox, not to a
-// founder's calendar. support@oxygen-agent.com is the Plain Email channel
+// founder's calendar. priority@oxygen-agent.com is the Plain Email channel
 // (PLAIN_SUPPORT_EMAIL_ADDRESS), so an enterprise enquiry lands in the support
 // queue as a Thread that either founder can pick up, instead of hard-coding one
 // person's booking page into every public pricing card.
-export const CONTACT_SALES_URL = "mailto:support@oxygen-agent.com";
+export const CONTACT_SALES_URL = "mailto:priority@oxygen-agent.com";
 // One Oxygen credit is worth $0.001 of managed work: $1 = 1,000 credits.
 // Subscription plans convert at face value — every subscription dollar grants
 // exactly 1,000 credits — while on-demand top-up packs price the same credit

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

@@ -69,12 +69,12 @@ export const OXYGEN_CAPABILITY_ROUTES = [
         id: "support-and-feedback",
         layer: "Control",
         primitive: null,
-        owns: "Customer support tickets, product feedback, transcript-backed reports, and ticket follow-up.",
+        owns: "Customer support conversations, structured tickets, product feedback, transcript-backed reports, and Thread follow-up.",
         notFor: "Primitive run diagnosis when no support report is needed; inspect Observability first.",
-        execution: "File or inspect a hosted support record and return its deep link; never send a customer reply automatically.",
+        execution: "Start or continue a hosted support conversation, optionally file structured metadata, and return its deep link; never send a customer reply automatically.",
         posture: "workspace_write",
         gatewayTools: ["oxygen_feedback", "oxygen_support_ticket_create", "oxygen_support_tickets_list"],
-        gatewayCommands: ["feedback", "support file", "support list"],
+        gatewayCommands: ["feedback", "support chat", "support file", "support list"],
         skills: ["oxygen-feedback"],
         endpointSections: ["feedback", "support"],
         intentTerms: ["support", "feedback", "bug report", "feature request", "report issue", "ticket", "complaint"],

package/node_modules/@oxygen/shared/dist/feature-gates.d.ts

@@ -61,6 +61,11 @@ export type FeatureGateResolution = {
  * - OXYGEN_PUBLISHING_ENABLED — (b). Fail-closed production switch for posting
  *   to real provider accounts (`apps/web/src/app/(app)/(dashboard)/publishing/
  *   data.ts`). Wrong "on" = public posts from customer accounts.
+ * - OXYGEN_WORKER_AUTOSCALE — (b). Arms the worker fleet autoscaler, which STOPS
+ *   production Machines (`apps/worker/src/fleet-autoscaler.ts`). Its worst wrong
+ *   value takes the fleet down while work is queued, so it must never depend on a
+ *   flag service being reachable — and "the flag service is unreachable" is exactly
+ *   the kind of incident during which you least want the fleet to move.
  * - OXYGEN_AGENTS_ENABLED — (b). Authorizes autonomous Agent run execution —
  *   tool authority AND credit spend (`apps/web/src/lib/agent-runtime.ts`,
  *   `apps/worker/src/agent-cycle.ts`). Same class as publishing.

package/node_modules/@oxygen/shared/dist/feature-gates.js

@@ -52,6 +52,11 @@
  * - OXYGEN_PUBLISHING_ENABLED — (b). Fail-closed production switch for posting
  *   to real provider accounts (`apps/web/src/app/(app)/(dashboard)/publishing/
  *   data.ts`). Wrong "on" = public posts from customer accounts.
+ * - OXYGEN_WORKER_AUTOSCALE — (b). Arms the worker fleet autoscaler, which STOPS
+ *   production Machines (`apps/worker/src/fleet-autoscaler.ts`). Its worst wrong
+ *   value takes the fleet down while work is queued, so it must never depend on a
+ *   flag service being reachable — and "the flag service is unreachable" is exactly
+ *   the kind of incident during which you least want the fleet to move.
  * - OXYGEN_AGENTS_ENABLED — (b). Authorizes autonomous Agent run execution —
  *   tool authority AND credit spend (`apps/web/src/lib/agent-runtime.ts`,
  *   `apps/worker/src/agent-cycle.ts`). Same class as publishing.
@@ -60,6 +65,7 @@
  * `findFeatureGateRegistryViolations` fails the build's tests if one ever is.
  */
 export const NEVER_FLAGGABLE = [
+    "OXYGEN_WORKER_AUTOSCALE",
     "OXYGEN_PUBLISHING_ENABLED",
     "OXYGEN_AGENTS_ENABLED",
     "OXYGEN_TELEMETRY_ENABLED",

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

@@ -35,6 +35,7 @@ export * from "./feature-gates.js";
 export * from "./hosted-ai.js";
 export * from "./identifiers.js";
 export * from "./knowledge-constants.js";
+export * from "./knowledge-bootstrap.js";
 export * from "./knowledge-links.js";
 export * from "./knowledge-markdown.js";
 export * from "./knowledge-seed-content.js";

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

@@ -35,6 +35,7 @@ export * from "./feature-gates.js";
 export * from "./hosted-ai.js";
 export * from "./identifiers.js";
 export * from "./knowledge-constants.js";
+export * from "./knowledge-bootstrap.js";
 export * from "./knowledge-links.js";
 export * from "./knowledge-markdown.js";
 export * from "./knowledge-seed-content.js";