@oxygen-agent/cli 1.1014.1225 → 1.1014.1341

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.1014.1225
+Version: 1.1014.1341

package/dist/browser-login.js

@@ -2,7 +2,10 @@ import { execFileSync } from "node:child_process";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { createServer } from "node:http";
 import { hostname } from "node:os";
-import { OXYGEN_VERSION, OxygenError, deriveCliLoginConfirmationCode, sleep } from "@oxygen/shared";
+import { OXYGEN_VERSION } from "@oxygen/shared/version";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { deriveCliLoginConfirmationCode } from "@oxygen/shared/cli-login-code";
+import { sleep } from "@oxygen/shared/timing";
 import { requestOxygen } from "./http-client.js";
 import { readErrorMessage } from "./util.js";
 const CALLBACK_HOST = "127.0.0.1";

package/dist/cli-output.js

@@ -6,6 +6,7 @@ import { formatMailboxRampNotice } from "./mailbox-ramp-notice.js";
 import { formatSearchAiFilterTotalsNotice } from "./search-ai-filter-notice.js";
 import { isRecord } from "./util.js";
 import { exitCodeForOxygenError, OxygenError, success, toFailure } from "@oxygen/shared/cli-result";
+import { renderLineageDigest } from "@oxygen/shared/conversation-lineage";
 export function writeJson(value) {
     process.stdout.write(serializeCliJson(value, process.argv.includes("--pretty")));
 }
@@ -32,6 +33,7 @@ export async function handleAsyncAction(command, options, action) {
         writeSearchAiFilterTotalsNotice(data);
         writeInboxNeedsReplyNotice(data);
         writeMailboxRampNotice(data);
+        writeLineageNotice(data);
     }
     catch (error) {
         emitCliFailure(command, error);
@@ -233,6 +235,18 @@ function writeInboxNeedsReplyNotice(data) {
     if (notice)
         process.stderr.write(`${notice}\n`);
 }
+// Network Mining (DEV-only): where an opened conversation came from, as the
+// same short digest agents read. Present only when the server sent `lineage`.
+function writeLineageNotice(data) {
+    if (!data || typeof data !== "object")
+        return;
+    const lineage = data.lineage;
+    if (!lineage || typeof lineage !== "object" || lineage.schema_version !== 1)
+        return;
+    const digest = renderLineageDigest(lineage);
+    if (digest)
+        process.stderr.write(`Lineage: ${digest}\n`);
+}
 function writeMailboxRampNotice(data) {
     const notice = formatMailboxRampNotice(data);
     if (notice)

package/dist/cli-values.js

@@ -4,7 +4,7 @@
 // leaf `OxygenError` primitive plus `readOption` from `./util.js`, so this module
 // is a dependency-free leaf that index.ts and run-wait.ts can both import without
 // a cycle. All symbols throw the same typed OxygenError codes the copies did.
-import { OxygenError } from "@oxygen/shared";
+import { OxygenError } from "@oxygen/shared/cli-result";
 import { readOption } from "./util.js";
 /** Parse a `--limit`/`--interval`-style flag into a positive integer, or undefined when absent. */
 export function readPositiveInt(value) {

package/dist/command-manifest.js

@@ -1,6 +1,9 @@
 import { OPERATION_SPECS } from "@oxygen/shared/contracts/operations";
 import { SPINTAX_GENERATION_CREDITS } from "@oxygen/shared/contracts/spintax";
-import { CLI_EXIT_CODE_TABLE, OXYGEN_VERSION, inferUserCapabilityRoute, serializeCapabilityRoute, } from "@oxygen/shared";
+import { CLI_EXIT_CODE_TABLE } from "@oxygen/shared/cli-result";
+import { OXYGEN_VERSION } from "@oxygen/shared/version";
+import { inferUserCapabilityRoute } from "@oxygen/shared/user-capability-routing";
+import { serializeCapabilityRoute } from "@oxygen/shared/capability-discovery";
 const DEFAULT_COMMAND_SEARCH_LIMIT = 10;
 const MAX_COMMAND_SEARCH_LIMIT = 25;
 const COMMAND_SEARCH_STOP_WORDS = new Set([

package/dist/commands/billing.js

@@ -62,7 +62,7 @@ export function registerBillingFamily(program, handleAsyncAction, billingDocsUrl
         .command("billing")
         .description("Plan and managed credit commands. Credits reserved but not yet charged are listed hold by hold with `billing usage --meter holds`. Spend splits into FLEXIBLE (ad-hoc: enrichment, AI, automation — drawn from your free-to-spend balance) and FIXED recurring per-resource monthly commitments blocked out of it; see `billing commitments`. THREE CLOCKS, deliberately different: the CREDIT CYCLE that `billing allowance` reports against (your plan's monthly grant window); each resource's own COMMITMENT RENEWAL, anchored to the day you connected it, so `billing commitments --json` next_due_at rarely matches the cycle end; and your SUBSCRIPTION PERIOD in `billing balance` (annual plans span many credit cycles). A number from one clock will not reconcile against another. On a plan that pays for several workspaces, `billing usage --group-by workspace` totals what each one spent. To price a month of outreach before building it (leads, enrichment, sequence steps, senders), run `billing estimate`. Failed-payment grace, suspension, and recovery: " + billingDocsUrl + ".")
         .addCommand(new Command("change")
-        .description("Create an approval link (`approval_url`) to start or change a plan; no charge or plan change until confirmation. First purchase needs an admin/owner; existing-plan changes allow any unrestricted member. Compare all six prices, credits and yearly terms with `billing balance` first. Use --interval year --term year to pay the full discounted year upfront: the $99 plan costs $990 per year before tax. Credits arrive monthly during the paid year. On a workspace that has never had a plan, the Checkout for any monthly plan from $99 up carries the first-month offer, half its first month, while its 24-hour window is open (`offer`; `billing balance` lists every size under `first_month_offer.plans`): `amount_due_now` is then the discounted first month and `next_invoice_total` the regular price, both before tax. Creating that Checkout starts the window if nothing has started it yet. Prepaid yearly upgrades apply immediately with proration; downgrades and switching to monthly wait until the paid year ends. Switching from monthly to yearly starts at the next paid-period boundary. Existing yearly installment plans keep their payments until conversion at the yearly commitment end. Omit interval and term to preserve the current contract. For an existing subscription, a yearly preview returns charges, start and term-end dates; nothing changes until separate confirmation.")
+        .description("Create an approval link (`approval_url`) to start or change a plan; no charge or plan change until confirmation. First purchase needs an admin/owner; existing-plan changes allow any unrestricted member. Compare all six prices, credits and yearly terms with `billing balance` first. Use --interval year --term year to pay the full discounted year upfront: the $99 plan costs $990 per year before tax. Credits arrive monthly during the paid year. On a workspace that has never had a plan, the Checkout for any monthly plan from $99 up carries the first-month offer, half its first month, while its 24-hour window is open (`offer`; `billing balance` lists every size under `first_month_offer.plans`): `amount_due_now` is then the discounted first month and `next_invoice_total` the regular price, both before tax. Creating that Checkout starts the window if nothing has started it yet. `first_month_offer` says whether the offer covers the chosen plan (`applies`) and names the plan it does cover (`plan`, the $99 plan by default: $49 for its first month); a plan it misses (the $49 plan, or yearly) still gets its own Checkout, so relay the offer before the human pays. Prepaid yearly upgrades apply immediately with proration; downgrades and switching to monthly wait until the paid year ends. Switching from monthly to yearly starts at the next paid-period boundary. Existing yearly installment plans keep their payments until conversion at the yearly commitment end. Omit interval and term to preserve the current contract. For an existing subscription, a yearly preview returns charges, start and term-end dates; nothing changes until separate confirmation.")
         .requiredOption("--to <plan>", 
     // Derived from the catalog, never retyped: this help text is the only
     // place a customer's agent learns which plans exist, and it named
@@ -94,7 +94,7 @@ export function registerBillingFamily(program, handleAsyncAction, billingDocsUrl
         }));
     }))
         .addCommand(new Command("balance")
-        .description("May apply due plan grants or credit expiry. Compare all six subscription sizes in `available_plans`: monthly prices, full upfront yearly prices, credit allowances and savings. `annual_billing_available` says whether yearly billing is offered; deprecated `annual_monthly_billing_available` is false for new purchases. `annual_terms` explains upfront payment, monthly credits and plan-change timing. `first_month_offer` is the first-month offer this workspace can still claim: every size it applies to (`plans`, from `minimum_plan` up) with its first-month and regular price before tax, and `ends_at`, null until its 24-hour window starts. The window starts the first time the workspace meets the offer: the app showing it, signup from a browser that saw it on the website, or creating its Checkout with `billing change`. Also show the current plan, commitment, subscription entitlement, and managed credit balance: available and reserved credits, FIXED credits committed to recurring per-resource charges, and the FLEXIBLE free-to-spend remainder. `next_renewal` answers \"will I be charged?\": read `will_charge` first — true only when this workspace's own Stripe plan is going to charge its card, in which case `charge_at` and the subscription's recurring amount in money say when and roughly how much (the exact amount, with any promotion code or tax, is on the invoice); `period_ends_at` is the trial or period end either way, `cancellation_scheduled` says whether a cancellation is already set, and `stop_command` names the one command that changes it (`billing cancel`, undone by `billing resume`) or is null when nothing here can stop it (staff-invoiced, billed through another workspace, not active). `billing_interval` is payment cadence. New yearly plans charge the full year upfront; `commitment` identifies existing yearly installment contracts and is null for monthly and prepaid yearly plans. Credits are granted monthly; `next_credit_grant_at` is the next grant. For an existing yearly installment commitment, cancellation stops annual renewal but remaining monthly payments continue until commitment.ends_at. `renewals_past_due` lists infrastructure renewals (managed-inbox domains, warm-ups) OXYGEN could NOT charge this month, what they cost, and the exact top-up that clears them — nothing is cancelled and billing retries automatically after a top-up. `warnings` also flags a recurring_shortfall when your connected infrastructure costs more per month than the plan grants. `partner_bonus` says whether this workspace earns the agency partner bonus (+15% credits a month for a published directory partner on $99 or above), how many credits, and why not when it does not; the bonus arrives as its own ledger line (`billing usage --category partner_bonus`), never inside plan.monthly_credits. Its basis is the plan face value; `first_grant_timing` explains unknown processing time separately from the next scheduled grant. PARTNERS2026 ends on cancellation or effective plan change; `partner_bonus.conditions` and `coupon_authority` describe the separate prospective exclusion when it applies. See the agency-partner-bonus section of the billing policy. A workspace linked to another organization (`orgs billing-link`) reads its billing at that owner: the balance is the owner's pool, `shared_billing` is true and `billing_owner_organization_id` names the owner. After failed-payment grace expires, mutations stop while read/export and billing recovery remain available. Recovery: " + oxygenAppUrl(defaultApiUrl(), "/billing") + ". Policy: " + billingDocsUrl + ". 0 credits; reserves nothing.")
+        .description("May apply due plan grants or credit expiry. Compare all six subscription sizes in `available_plans`: monthly prices, full upfront yearly prices, credit allowances and savings. `annual_billing_available` says whether yearly billing is offered; deprecated `annual_monthly_billing_available` is false for new purchases. `annual_terms` explains upfront payment, monthly credits and plan-change timing. `first_month_offer` is the first-month offer this workspace can still claim: every size it applies to (`plans`, from `minimum_plan` up) with its first-month and regular price before tax, `default_plan` (the size the web proposes while the offer runs; propose it unless the human names another), and `ends_at`, null until its 24-hour window starts. The window starts the first time the workspace meets the offer: the app showing it, signup from a browser that saw it on the website, or creating its Checkout with `billing change`. Also show the current plan, commitment, subscription entitlement, and managed credit balance: available and reserved credits, FIXED credits committed to recurring per-resource charges, and the FLEXIBLE free-to-spend remainder. `next_renewal` answers \"will I be charged?\": read `will_charge` first — true only when this workspace's own Stripe plan is going to charge its card, in which case `charge_at` and the subscription's recurring amount in money say when and roughly how much (the exact amount, with any promotion code or tax, is on the invoice); `period_ends_at` is the trial or period end either way, `cancellation_scheduled` says whether a cancellation is already set, and `stop_command` names the one command that changes it (`billing cancel`, undone by `billing resume`) or is null when nothing here can stop it (staff-invoiced, billed through another workspace, not active). `billing_interval` is payment cadence. New yearly plans charge the full year upfront; `commitment` identifies existing yearly installment contracts and is null for monthly and prepaid yearly plans. Credits are granted monthly; `next_credit_grant_at` is the next grant. For an existing yearly installment commitment, cancellation stops annual renewal but remaining monthly payments continue until commitment.ends_at. `renewals_past_due` lists infrastructure renewals (managed-inbox domains, warm-ups) OXYGEN could NOT charge this month, what they cost, and the exact top-up that clears them — nothing is cancelled and billing retries automatically after a top-up. `warnings` also flags a recurring_shortfall when your connected infrastructure costs more per month than the plan grants. `partner_bonus` says whether this workspace earns the agency partner bonus (+15% credits a month for a published directory partner on $99 or above), how many credits, and why not when it does not; the bonus arrives as its own ledger line (`billing usage --category partner_bonus`), never inside plan.monthly_credits. Its basis is the plan face value; `first_grant_timing` explains unknown processing time separately from the next scheduled grant. PARTNERS2026 ends on cancellation or effective plan change; `partner_bonus.conditions` and `coupon_authority` describe the separate prospective exclusion when it applies. See the agency-partner-bonus section of the billing policy. A workspace linked to another organization (`orgs billing-link`) reads its billing at that owner: the balance is the owner's pool, `shared_billing` is true and `billing_owner_organization_id` names the owner. After failed-payment grace expires, mutations stop while read/export and billing recovery remain available. Recovery: " + oxygenAppUrl(defaultApiUrl(), "/billing") + ". Policy: " + billingDocsUrl + ". 0 credits; reserves nothing.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("billing balance", options, () => requestOxygen("/api/cli/billing/balance"));

package/dist/commands/crm.js

@@ -9,7 +9,7 @@ import { CRM_RECORD_BRIEF_SECTIONS } from "@oxygen/shared/crm-record-brief";
 import { isRecord, readClearableOption, readOption } from "../util.js";
 import { OxygenError, success } from "@oxygen/shared/cli-result";
 import { CRM_ENRICHMENT_READ_CONTRACT } from "@oxygen/shared/contracts/crm-enrichment-read";
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { stdout as output } from "node:process";
 const DEFAULT_CRM_SETUP_OBJECTS = ["companies", "people", "deals"];
 function buildCrmSetupBody(options) {
@@ -129,6 +129,7 @@ function buildCrmSyncImportBody(provider, options) {
         object: options.object,
         mode: resolveLiveDryRunMode(options),
         ...(options.into ? { into: options.into } : {}),
+        ...(readOption(options.types) ? { types: readOption(options.types) } : {}),
         ...(readPositiveInt(options.limit) !== undefined ? { limit: readPositiveInt(options.limit) } : {}),
         ...(readPositiveNumber(options.maxCredits) !== undefined ? { max_credits: readPositiveNumber(options.maxCredits) } : {}),
         ...(options.approved ? { approved: true } : {}),
@@ -1275,7 +1276,7 @@ export function registerCrmFamily(program, handleAsyncAction) {
         .argument("<object>", "CRM object slug, such as people or companies.")
         .argument("<record>", "CRM record row id, an identity value such as sarah@acme.com or acme.com, or the record's exact name.")
         .option("--sections <list>", `Comma-separated subset: ${CRM_RECORD_BRIEF_SECTIONS.join(", ")}. Default all.`)
-        .option("--max-chars <n>", "Character budget for the whole brief, 3000-20000. Default 8000.")
+        .option("--max-chars <n>", "Character budget for the whole brief, 3000-20000. Default 16000.")
         .option("--json", "Print a JSON envelope.")
         .action(async (object, record, options) => {
         await handleAsyncAction("crm brief", options, () => requestOxygen(buildCrmBriefPath(object, record, options)));
@@ -1414,10 +1415,14 @@ export function registerCrmFamily(program, handleAsyncAction) {
         .argument("<object>", "CRM object slug, such as companies or people.")
         .option("--field <key>", "Narrow the answer to one field by its key, e.g. --field pipeline_stage. Also accepted as --attribute.")
         .option("--attribute <key>", "Alias for --field.")
+        // Network Mining (DEV-only): hidden from help, refused by the server while the gate is off.
+        .addOption(new Option("--view <view>", "audiences: the Tables bound to an Audience object, with cold, in-CRM and graduated counts.").choices(["audiences"]).hideHelp())
         .option("--json", "Print a JSON envelope.")
         .action(async (object, options) => {
         const field = readOption(options.field) ?? readOption(options.attribute);
-        await handleAsyncAction("crm describe", options, () => requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}${field ? `?attribute=${encodeURIComponent(field)}` : ""}`));
+        const view = readOption(options.view);
+        const query = new URLSearchParams({ ...(field ? { attribute: field } : {}), ...(view ? { view } : {}) }).toString();
+        await handleAsyncAction("crm describe", options, () => requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}${query ? `?${query}` : ""}`));
     }))
         .addCommand(new Command("duplicates")
         .description("List ranked duplicate-candidate record pairs for one CRM object (identity-overlap + fuzzy-label), across every record. Read-only.")
@@ -1521,7 +1526,10 @@ export function registerCrmFamily(program, handleAsyncAction) {
         .addCommand(new Command("import")
         .description("Import provider records into an Oxygen CRM object (canonical CRM truth) as a durable workflow run. Defaults to dry-run. This pulls the WHOLE object and has no list/segment filter; to import one HubSpot saved list or one Pipedrive saved filter into a new table you can filter and enrich, use `oxygen tables hubspot import` or `oxygen tables pipedrive import` instead.")
         .argument("<provider>", "Connected CRM to import from: hubspot, attio, or pipedrive.")
-        .requiredOption("--object <object>", "Provider object: hubspot contacts|companies, attio people|companies, or pipedrive persons|organizations|deals. Import Pipedrive persons and organizations before deals so each deal links to them.")
+        .requiredOption("--object <object>", networkMiningHostServed()
+        ? "Provider object: hubspot contacts|companies|engagements, attio people|companies, or pipedrive persons|organizations|deals. Import Pipedrive persons and organizations before deals so each deal links to them. hubspot engagements (calls, meetings, notes, emails, tasks) land as historical timeline activities on contacts and companies imported earlier."
+        : "Provider object: hubspot contacts|companies, attio people|companies, or pipedrive persons|organizations|deals. Import Pipedrive persons and organizations before deals so each deal links to them.")
+        .addOption(new Option("--types <list>", "hubspot engagements only: comma-separated calls,meetings,notes,emails,tasks. Defaults to all.").hideHelp(!networkMiningHostServed()))
         .option("--into <object>", "Oxygen CRM object slug to import into. Defaults to the natural mapping.")
         .option("--limit <n>", "Max records to pull this run.")
         .option("--max-credits <n>", "OXYGEN credit ceiling for the run. Review the current quote: own-API-key calls cost 0.05 credits each after repricing takes effect; OAuth follows its tool quote. Workflow steps count toward the ceiling after repricing takes effect. Use --limit for rows; provider billing and API quota are separate.")

package/dist/commands/db.js

@@ -113,6 +113,36 @@ export function registerDbFamily(program, handleAsyncAction) {
                 },
             });
         });
+    }))
+        .addCommand(new Command("backfill-conversation-enrollments")
+        .description("Link LinkedIn and WhatsApp conversations to the Sequence enrollment that owns them, for one workspace: a thread links when exactly one enrollment of its sender names its chat. Staff only; 0 credits. Defaults to a dry run that reports linkable, ambiguous and unmatched counts.")
+        .option("--org <id>", "The organization id to backfill. Required.")
+        .option("--live", "Write the links. Requires --confirm.")
+        .option("--revert", "Unlink exactly the conversations a --live run linked. Requires --confirm.")
+        .option("--confirm", "Confirm --live or --revert.")
+        .option("--limit <n>", "Maximum conversations to write in this batch. Defaults to 5000; hard cap is 50000.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("db backfill-conversation-enrollments", options, () => {
+            if (options.live && options.revert) {
+                throw new OxygenError("invalid_request", "Pass --live or --revert, not both.", { exitCode: 1 });
+            }
+            const mode = options.live ? "live" : options.revert ? "revert" : "dry_run";
+            if (mode !== "dry_run" && !options.confirm) {
+                throw new OxygenError("confirmation_required", `Refusing to run --${mode} without --confirm.`, { exitCode: 1 });
+            }
+            const limit = readPositiveInt(options.limit);
+            const organizationId = readOption(options.org) ?? readOption(program.opts().org);
+            return requestOxygen("/api/cli/db/backfill-conversation-enrollments", {
+                method: "POST",
+                body: {
+                    mode,
+                    confirm: Boolean(options.confirm),
+                    ...(organizationId ? { organization_id: organizationId } : {}),
+                    ...(limit !== undefined ? { limit } : {}),
+                },
+            });
+        });
     }))
         .addCommand(new Command("backfill-table-order-indexes")
         .description("Converge stable row-order indexes on existing customer tables. Staff only; the default dry-run uses 0 credits and makes no database changes.")

package/dist/commands/domains.js

@@ -437,7 +437,7 @@ export function registerDomainsFamily(program, handleAsyncAction) {
         await handleAsyncAction("domains get", options, () => requestOxygen(`/api/cli/domains/${encodeURIComponent(domain)}`));
     }))
         .addCommand(new Command("dns")
-        .description("Read domain DNS health, 0 credits. --cached reads saved daily authentication evidence without external calls; --authentication checks public SPF/DKIM/DMARC/MX/nameservers and saves the observation. Otherwise check the domain's live records: Cloudflare persists its verdict; managed domains contact their provider; external domains query public DNS. DNS records are never changed by this command. Add --deep for content-level checks (SPF DNS-lookup budget, DMARC enforcement, MX provider) plus an external DNS-over-HTTPS nameserver-authority check. An Oxygen-managed domain reads its vendor-held records and verdict instead (--deep ignored). A domain hosted outside Oxygen that you send from returns rail=external: the records public DNS resolves — the mail set, delegation, policy records and web root — with health.enumerable=false, because public DNS cannot list a zone (a DKIM key is probed at common selectors, so dkim=unknown means unproven, never missing). `dns plan`/`dns apply` edit your own Cloudflare zones only. DNS editing is unavailable for Oxygen-bought domains; keep their nameservers and contact support.")
+        .description("Check domain DNS health, 0 credits. --cached reads the latest saved authentication evidence without external calls; --authentication checks public SPF/DKIM/DMARC/MX/nameservers and saves the observation. Every saved check, kept 400 days, is in `mailboxes deliverability checks list --subject <domain>`. Otherwise check the domain's live records: Cloudflare persists its verdict; managed domains contact their provider; external domains query public DNS. DNS records are never changed by this command. Add --deep for content-level checks (SPF DNS-lookup budget, DMARC enforcement, MX provider) plus an external DNS-over-HTTPS nameserver-authority check. An Oxygen-managed domain reads its vendor-held records and verdict instead (--deep ignored). A domain hosted outside Oxygen that you send from returns rail=external: the records public DNS resolves — the mail set, delegation, policy records and web root — with health.enumerable=false, because public DNS cannot list a zone (a DKIM key is probed at common selectors, so dkim=unknown means unproven, never missing). `dns plan`/`dns apply` edit your own Cloudflare zones only. DNS editing is unavailable for Oxygen-bought domains; keep their nameservers and contact support.")
         .argument("[domain]", "Domain name, such as acme.com.")
         // NOT --provider: commander parses parent options greedily by default,
         // so a --provider here would swallow the `dns plan`/`dns apply`

package/dist/commands/feeds.js

@@ -6,7 +6,8 @@ import { requestOxygen } from "../http-client.js";
 import { isRecord, readOption } from "../util.js";
 import { OxygenError } from "@oxygen/shared/cli-result";
 import { TABLE_FEED_UPDATE_CONTRACT, tableFeedUpdateIssues } from "@oxygen/shared/contracts/table-feed-update";
-import { Command } from "commander";
+import { Command, Option } from "commander";
+import { networkMiningHostServed } from "../network-mining-host.js";
 function feedsListPath(options, tableArgument) {
     const params = feedReadWindowParams(options);
     const table = readOption(tableArgument) ?? readOption(options.table);
@@ -128,6 +129,25 @@ const FEED_BIND_WEB_INTENT_REFUSED_FLAGS = [
 // --request-json were requiredOptions and <table> was required: same messages, same
 // order (mandatory options before the argument), same stderr + exit 1 path. They
 // stopped being commander-required only because a push feed must not carry them.
+/** Network Mining (DEV-only): the lead-post watch's source is fixed server-side; only its leads, cadence and cap are chosen. */
+const LEAD_POST_WATCH_KIND = "lead_post_watch";
+function readLeadPostWatchBindBody(table, options) {
+    const every = readOption(options.every);
+    const maxCreditsPerCycle = readPositiveNumber(options.maxCredits);
+    const focusTopK = readPositiveInt(options.focusTopK);
+    return {
+        ...(table ? { table } : {}),
+        transport: "pull",
+        feed_kind: LEAD_POST_WATCH_KIND,
+        sync: {
+            ...(every ? { every } : {}),
+            ...(maxCreditsPerCycle !== undefined ? { max_credits_per_cycle: maxCreditsPerCycle } : {}),
+        },
+        ...(focusTopK !== undefined ? { focus_top_k: focusTopK } : {}),
+        ...(readOption(options.name) ? { name: readOption(options.name) } : {}),
+        ...(options.approved ? { approved: true } : {}),
+    };
+}
 function assertPullFeedBindArguments(table, options, command) {
     for (const [key, flag] of FEED_BIND_PUSH_ONLY_FLAGS) {
         if (options[key] !== undefined) {
@@ -359,6 +379,8 @@ export function registerFeedsFamily(program, handleAsyncAction) {
         .option("--registry-version <version>", "Routing-registry revision from the plan, retained with the frozen feed provenance.")
         .option("--source-prompt <text-or-file>", "The prompt this feed was planned from, or a path to a prompt file.")
         .option("--approved", "Approve the recurring paid pull. Required with --every and --max-credits on a paid provider.")
+        .addOption(new Option("--focus-top-k <n>", "--kind lead_post_watch only (Network Mining): how many focus leads to watch each cycle, default 25. The source is fixed: each watched lead's posts of the last week, one page per lead, trimmed to what --max-credits affords.")
+        .hideHelp(!networkMiningHostServed()))
         .option("--json", "Print a JSON envelope.")
         .addHelpText("after", `
 Examples:
@@ -367,6 +389,12 @@ Examples:
   oxygen feeds bind --source rb2b --create "Website visitors"
 `)
         .action((table, options, command) => {
+        if (options.kind === LEAD_POST_WATCH_KIND) {
+            return handleAsyncAction("feeds bind", options, () => requestOxygen("/api/cli/tables/feeds", {
+                method: "POST",
+                body: readLeadPostWatchBindBody(table, options),
+            }));
+        }
         const webIntent = options.source !== undefined;
         const push = options.schemaJson !== undefined;
         // Pull usage errors keep commander's exact wording and path (stderr, exit 1),

package/dist/commands/knowledge.js

@@ -13,7 +13,8 @@ import { knowledgeProposalWindowContract } from "@oxygen/shared/contracts/knowle
 import { KNOWLEDGE_BOOTSTRAP_MAX_CREDITS } from "@oxygen/shared/knowledge-bootstrap";
 import { KNOWLEDGE_PAGE_TYPES } from "@oxygen/shared/knowledge-constants";
 import { parseKnowledgePageMarkdown } from "@oxygen/shared/knowledge-markdown";
-import { Command } from "commander";
+import { Command, Option } from "commander";
+import { networkMiningHostServed } from "../network-mining-host.js";
 import { existsSync, readFileSync } from "node:fs";
 // The wiki index counts the whole wiki even when the page list is a window, so
 // name both numbers: "200 of 512 pages" is honest, "200 pages" is not.
@@ -107,6 +108,7 @@ function buildKnowledgeSearchBody(query, options) {
         ...(readOption(options.status) ? { status: readOption(options.status) } : {}),
         ...(tags.length > 0 ? { tags } : {}),
         ...(limit !== undefined ? { limit } : {}),
+        ...(readOption(options.sources) ? { sources: readOption(options.sources) } : {}),
     };
 }
 // Post-write staleness hook for `knowledge page upsert|pin|archive`: clearing
@@ -616,6 +618,7 @@ export function registerKnowledgeFamily(program, handleAsyncAction) {
         .option("--status <status>", "Filter by draft, active, or archived. Omitted, archived pages are excluded.")
         .option("--tags <csv>", "Comma-separated tags that must be present.")
         .option("--limit <n>", "Maximum pages to return.")
+        .addOption(new Option("--sources <sources>", "Network Mining (dev): knowledge (default), crm (CRM activities and record digests, cited by record), or all.").hideHelp(!networkMiningHostServed()))
         .option("--json", "Print a JSON envelope.")
         .action(async (query, options) => {
         await handleAsyncAction("knowledge search", options, () => requestOxygen("/api/cli/knowledge/search", {
@@ -837,6 +840,26 @@ export function registerKnowledgeFamily(program, handleAsyncAction) {
             return requestOxygen("/api/cli/knowledge/agent", { method: "POST", body });
         });
     })))
+        .addCommand(new Command("crm-index")
+        .description("Network Mining (dev): the semantic CRM index behind `knowledge search --sources crm`. Shows whether it is armed, its spend and documents. --quote counts what it would embed and the worst-case cost; --max-credits N --approved arms it with that cap (Oxygen's embedding budget, never your credits); --off stops new spend.")
+        .option("--quote", "Add the quote: sources to embed, chunks and worst-case credits. Read-only.")
+        .option("--max-credits <n>", "Arm the index with this cap in credits (needs --approved after the quote).")
+        .option("--approved", "Confirm arming after reviewing the quote.")
+        .option("--off", "Disarm: stop new embedding spend. Indexed documents stay searchable.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("knowledge crm-index", options, () => {
+            if (options.off)
+                return requestOxygen("/api/cli/knowledge/agent", { method: "POST", body: { crm_index: false } });
+            if (options.maxCredits !== undefined) {
+                return requestOxygen("/api/cli/knowledge/agent", {
+                    method: "POST",
+                    body: { crm_index: { max_credits: Number(options.maxCredits), ...(options.approved ? { approved: true } : {}) } },
+                });
+            }
+            return requestOxygen(`/api/cli/knowledge/agent?crm_index=${options.quote ? "quote" : "status"}`);
+        });
+    }), { hidden: !networkMiningHostServed() })
         .addCommand(new Command("sync")
         .description("Clone or refresh the local knowledge mirror: server-rendered page markdown under the CLI config dir. Pass --all to mirror every workspace the credential can access.")
         .option("--all", "Sync every organization the credential can access, each into its own mirror; one org's failure never aborts the rest.")

package/dist/commands/sequences.js

@@ -3,6 +3,7 @@ import { parseJsonObject, readNonNegativeInt, readPositiveInt } from "../cli-val
 import { ansi, collectRepeatable, handleReadActionWithLens, parseJsonValue, readCreditCeilingOrZero, readCsvOption, readJsonFileValue, readPositiveNumber, readPublishingPostText, renderTextTable, splitCommaList } from "../command-support.js";
 import { addContractFlags, readContractFlags } from "../contract-flags.js";
 import { requestOxygen } from "../http-client.js";
+import { networkMiningHostServed } from "../network-mining-host.js";
 import { parseWorkingDaysOption } from "../sender-limits-flags.js";
 import { isRecord, readOption } from "../util.js";
 import { OxygenError, success } from "@oxygen/shared/cli-result";
@@ -1332,28 +1333,28 @@ export function registerSequencesFamily(program, handleAsyncAction) {
         }, 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`.")
+        .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. Existing-thread replies stay in `oxygen inbox send`.")
         .argument("[sequence]", "Sequence id returned by the preview call. Omit when creating the preview; required with --approved.")
         .option("--recipient <url-or-id>", "LinkedIn personal-profile URL or provider member id. Preview call only.")
         .option("--recipient-name <name>", "Optional display name stored on the enrollment. Preview call only.")
         .option("--text <text>", "Message body. Preview call only; use either --text or --text-file.")
         .option("--text-file <path>", "Read the message body from a file. Preview call only; use either --text-file or --text.")
         .option("--sender <ref>", "Connected LinkedIn sender id, connection id, or Unipile account id. List choices with `oxygen senders list`.")
-        .option("--approved", "Approve the previewed Sequence for live dispatch. Requires the returned sequence id and --max-credits.")
-        .option("--max-credits <n>", "Positive credit ceiling for the live LinkedIn dispatch.")
+        .option("--approved", "Approve the previewed Sequence for live dispatch. Requires the returned sequence id.")
+        .option("--max-credits <n>", "Optional credit ceiling (0 or more); the message costs 0 credits.")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
         await handleAsyncAction("sequences send", options, () => {
             const sequenceId = readOption(sequence);
-            const maxCredits = readPositiveNumber(options.maxCredits);
+            const maxCredits = readCreditCeilingOrZero(options.maxCredits);
             if (sequenceId) {
                 if (readOption(options.recipient) || readOption(options.recipientName) || readOption(options.text) || readOption(options.textFile) || readOption(options.sender)) {
-                    throw new OxygenError("conflicting_flags", "With a sequence id, pass only --approved and --max-credits; recipient, copy, and sender are fixed by the previewed draft.", { exitCode: 1 });
+                    throw new OxygenError("conflicting_flags", "With a sequence id, pass only --approved (and an optional --max-credits); recipient, copy, and sender are fixed by the previewed draft.", { exitCode: 1 });
                 }
                 return requestOxygen("/api/cli/sequences/send", { method: "POST", body: { sequence: sequenceId, ...(options.approved ? { approved: true } : {}), ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}) } });
             }
             if (options.approved)
-                throw new OxygenError("sequence_preview_required", "Preview first without --approved; then pass the returned sequence id with --approved --max-credits N.", { exitCode: 1 });
+                throw new OxygenError("sequence_preview_required", "Preview first without --approved; then pass the returned sequence id with --approved.", { exitCode: 1 });
             const recipient = readOption(options.recipient);
             const sender = readOption(options.sender);
             const text = readPublishingPostText(options, true);
@@ -1867,9 +1868,9 @@ export function registerSequencesFamily(program, handleAsyncAction) {
         await handleAsyncAction("sequences get", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}${query}`));
     }))
         .addCommand(new Command("enroll")
-        .description("Enroll leads into a sequence. Enrolling spends no credits. An active sequence contacts the new leads on its next dispatch tick; a draft or paused one holds them until `sequences start`. --from-table enrolls every not-yet-enrolled row of the sequence's bound source table (up to 500 per run; the response's from_table.has_more says whether to run again) — for a LinkedIn sequence the profile is read from the bound table's URL column, where a full /in/ URL and a bare public handle carrying a hyphen or digit (ada-lovelace) both work, so no pre-resolved provider ids are needed; each handle Oxygen canonicalized is echoed in linkedin_handles_canonicalized (value + url) to check before start, and every row that still cannot be resolved is named in unresolved_linkedin_lead_details (row, value, reason) rather than only counted in unresolved_linkedin_leads. In a LinkedIn + email sequence a row with no usable profile but a recipient email is still enrolled for the email steps (its LinkedIn steps are skipped as no_linkedin_profile, a connection wait passes at once and a connection branch takes its not-connected path) and is listed in linkedin_unavailable_lead_details instead; unresolved_linkedin_leads names only rows that were not enrolled. --leads-file enrolls an explicit JSON list { leads: [...] }: for an email/WhatsApp sequence a lead identified only by an email (row_values.email) or phone (row_values.phone) is auto-filed as a row in the sequence's leads table (auto-creating and binding one if there is none), deduped by email/phone, so no table has to exist first (the table is returned as leads_table with a web_url); a LinkedIn + email sequence auto-files an email-only lead the same way; a LinkedIn lead needs a lead_provider_id, a lead_profile_url (a /in/ URL or a bare public handle with a hyphen or digit), or a table_row_id whose row carries one of those. A CRM-only lead needs a stable table_row_id or lead_provider_id in addition to mapped row_values; a HubSpot contact id used in crm_task associations identifies the destination record, not the Oxygen enrollment. When the sequence is bound to a source table, a lead's table_row_id auto-snapshots that row's columns (incl. AI/tool outputs) into row_values for {{column}} copy — explicit row_values win. Idempotent per table row (and per email/phone for auto-filed leads). WhatsApp-only campaigns also enroll each normalized number once across all source rows and enrollment statuses; mixed campaigns keep other channels and skip duplicate WhatsApp actions. Duplicate protection defaults to this campaign; --whatsapp-duplicate-scope on create/update can additionally block identical copy across all campaigns. The org do-not-contact list is always enforced; --exclude-contacted and --suppress-list add further opt-in skips (reported under skipped_by_reason). Leads already owned by a sender account (from an earlier real send) are routed back to that same account; a lead owned by a sender NOT on this sequence is skipped (bound_to_other_sender) unless --ignore-sender-bindings. This enrolls into an OXYGEN Sequence; to put the same rows into a campaign you already run in Smartlead, Instantly, lemlist or HeyReach, use `sequences push-external`. esp.pool_scope identifies the active workspace inventory used for routing and strict_deferred_leads estimates; these estimates omit sequence sender restrictions, readiness and daily limits. A zero estimate does not guarantee readiness. Review sequences preview before launch.")
+        .description("Enroll leads into a sequence. Enrolling spends no credits. An active sequence contacts the new leads on its next dispatch tick; a draft or paused one holds them until `sequences start`. --from-table enrolls every not-yet-enrolled row of the sequence's bound source table (up to 500 per run; the response's from_table.has_more says whether to run again) — for a LinkedIn sequence the profile is read from the bound table's URL column, where a full /in/ URL and a bare public handle carrying a hyphen or digit (ada-lovelace) both work, so no pre-resolved provider ids are needed; each handle Oxygen canonicalized is echoed in linkedin_handles_canonicalized (value + url) to check before start, and every row that still cannot be resolved is named in unresolved_linkedin_lead_details (row, value, reason) rather than only counted in unresolved_linkedin_leads. In a LinkedIn + email sequence a row with no usable profile but a recipient email is still enrolled for the email steps (its LinkedIn steps are skipped as no_linkedin_profile, a connection wait passes at once and a connection branch takes its not-connected path) and is listed in linkedin_unavailable_lead_details instead; unresolved_linkedin_leads names only rows that were not enrolled. --leads-file enrolls an explicit JSON list { leads: [...] }: for an email/WhatsApp sequence a lead identified only by an email (row_values.email) or phone (row_values.phone) is auto-filed as a row in the sequence's leads table (auto-creating and binding one if there is none), deduped by email/phone, so no table has to exist first (the table is returned as leads_table with a web_url); a LinkedIn + email sequence auto-files an email-only lead the same way; a LinkedIn lead needs a lead_provider_id, a lead_profile_url (a /in/ URL or a bare public handle with a hyphen or digit), or a table_row_id whose row carries one of those; in a sequence with LinkedIn steps a lead with a lead_profile_url and no table_row_id is filed the same way, onto the person's existing row in the bound table (another spelling of the same profile URL matches) or as a new row, deduped by profile URL, and a person the sequence already holds keeps that enrollment; where the sequence has no table and every new table needs a client signoff the enroll is refused instead (sequence_leads_table_needs_signoff). Like any table-row lead a filed one cannot re-enroll in that sequence once its enrollment ends; leads_without_table_row counts the leads in the request that no table lists (those given only a lead_provider_id, and people the sequence already holds without a row). A CRM-only lead needs a stable table_row_id or lead_provider_id in addition to mapped row_values; a HubSpot contact id used in crm_task associations identifies the destination record, not the Oxygen enrollment. When the sequence is bound to a source table, a lead's table_row_id auto-snapshots that row's columns (incl. AI/tool outputs) into row_values for {{column}} copy — explicit row_values win. Idempotent per table row (and per email/phone or profile URL for auto-filed leads). WhatsApp-only campaigns also enroll each normalized number once across all source rows and enrollment statuses; mixed campaigns keep other channels and skip duplicate WhatsApp actions. Duplicate protection defaults to this campaign; --whatsapp-duplicate-scope on create/update can additionally block identical copy across all campaigns. The org do-not-contact list is always enforced; --exclude-contacted and --suppress-list add further opt-in skips (reported under skipped_by_reason). Leads already owned by a sender account (from an earlier real send) are routed back to that same account; a lead owned by a sender NOT on this sequence is skipped (bound_to_other_sender) unless --ignore-sender-bindings. This enrolls into an OXYGEN Sequence; to put the same rows into a campaign you already run in Smartlead, Instantly, lemlist or HeyReach, use `sequences push-external`. esp.pool_scope identifies the active workspace inventory used for routing and strict_deferred_leads estimates; these estimates omit sequence sender restrictions, readiness and daily limits. A zero estimate does not guarantee readiness. Review sequences preview before launch.")
         .argument("<sequence>", "Sequence id or slug.")
-        .option("--leads-file <path>", "Path to a JSON file: { \"leads\": [{ row_values: { email }, lead_name }] } for cold email; { lead_provider_id, lead_name, table_row_id, row_values } for LinkedIn/existing rows; CRM-only leads require table_row_id or a stable lead_provider_id alongside mapped row_values. A CRM association object id is not the enrollment identity. Exactly one of --leads-file or --from-table.")
+        .option("--leads-file <path>", "Path to a JSON file: { \"leads\": [{ row_values: { email }, lead_name }] } for cold email; { lead_profile_url, lead_name, row_values } or { lead_provider_id, lead_name, table_row_id, row_values } for LinkedIn/existing rows; CRM-only leads require table_row_id or a stable lead_provider_id alongside mapped row_values. A CRM association object id is not the enrollment identity. Exactly one of --leads-file or --from-table.")
         .option("--from-table", "Enroll every not-yet-enrolled row of the sequence's bound source table (up to 500 per run; re-run to continue). Exactly one of --leads-file or --from-table.")
         .option("--exclude-contacted", "Also skip leads any OTHER active sequence is already contacting (cross-campaign exclusion), for THIS enroll. Off by default; forces exclusion on even if the sequence's exclude_contacted default is off.")
         .option("--no-exclude-contacted", "Force-INCLUDE cross-campaign leads for this enroll even when the sequence's exclude_contacted default is on (per-call override).")
@@ -1999,6 +2000,41 @@ export function registerSequencesFamily(program, handleAsyncAction) {
         // 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("standing-approval")
+        .description("Network Mining (dev): approval tiers for one Sequence. Without flags, previews a batch of the first 10-30 pending leads' exact drafts, each run through the automatic check (empty, placeholder, sender named in the third person, length), with the review state of every reviewed AI cell and a preview_hash; it changes nothing. A person then approves the batch (--approve-batch <hash>): its pending drafts are accepted together and it becomes the pilot. After the first launch, which always needs a person, a person grants standing approval (--approve-standing <hash>): later starts, resumes and Agent enrolls need no person while sources, qualification, enrichment, sender, copy and voice, brief schema, schedule, recipient limits and credit ceiling stay within what was approved. Agents and Auto-approve can preview and --revoke only.")
+        .argument("<sequence>", "Sequence id or slug.")
+        .option("--sample-size <n>", "Drafts in the batch, 1-30 (default 10). A pilot needs at least 10.")
+        .option("--draft-samples", "Draft every AI-written invite note and DM of the batch now, as dispatch would (paid; needs --max-credits). Without it the drafts of the last paid preview are shown.")
+        .option("--max-credits <n>", "Credit ceiling for --draft-samples.")
+        .option("--approve-batch <hash>", "Accept the previewed batch as the pilot. Pass its preview_hash and the same --sample-size.")
+        .option("--approve-standing <hash>", "Grant standing approval on the reviewed pilot, by its preview_hash.")
+        .option("--revoke", "Revoke the standing approval. Needs no person; the pilot and first launch stay on record.")
+        .option("--status", "Read the approval state only.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (sequence, options) => {
+        await handleAsyncAction("sequences standing-approval", options, () => {
+            const path = `/api/cli/sequences/${encodeURIComponent(sequence)}/standing-approval`;
+            const chosen = [options.approveBatch !== undefined, options.approveStanding !== undefined, options.revoke === true, options.status === true].filter(Boolean).length;
+            if (chosen > 1)
+                throw new OxygenError("invalid_request", "Choose one of --approve-batch, --approve-standing, --revoke or --status.", { exitCode: 2 });
+            if (options.status)
+                return requestOxygen(path);
+            const sampleSize = readPositiveInt(options.sampleSize);
+            const maxCredits = readPositiveNumber(options.maxCredits);
+            const body = options.revoke
+                ? { action: "revoke" }
+                : options.approveStanding !== undefined
+                    ? { action: "approve_standing", preview_hash: options.approveStanding }
+                    : {
+                        action: options.approveBatch !== undefined ? "approve_batch" : "preview",
+                        ...(options.approveBatch !== undefined ? { preview_hash: options.approveBatch } : {}),
+                        ...(sampleSize !== undefined ? { sample_size: sampleSize } : {}),
+                        ...(options.draftSamples ? { draft_samples: true } : {}),
+                        ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
+                    };
+            return requestOxygen(path, { method: "POST", body });
+        });
+    }), { hidden: !networkMiningHostServed() })
         .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.")

package/dist/deliverability-evidence-commands.js

@@ -21,14 +21,14 @@ function readTextOption(options, inline, file, label) {
 /** Adds the evidence leaves to the `mailboxes deliverability` group and returns it. */
 export function withDeliverabilityEvidenceCommands(root, handle) {
     root.addCommand(new Command("checks")
-        .description("Stored deliverability check runs: DNS authentication, BIMI, tracking CNAME, blacklist, copy score and header proof, each with typed findings. 0 credits; runs no check.")
+        .description("Stored deliverability check runs: DNS authentication (SPF, DKIM, DMARC, MX), BIMI, tracking CNAME, blacklist, copy score and header proof, each with typed findings. 0 credits; runs no check.")
         .addCommand(new Command("list")
-        .description("List stored check runs, newest first, with pass/warn/fail/unknown finding counts. Follow next_cursor with the same filters.")
-        .addOption(new Option("--kind <kind>", "Check kind.").choices([...DELIVERABILITY_SURFACE_CHECK_KINDS]))
-        .addOption(new Option("--subject-type <type>", "What was checked.").choices([...DELIVERABILITY_SURFACE_SUBJECT_TYPES]))
+        .description("List stored check runs, newest first, with pass/warn/fail/unknown finding counts. Follow next_cursor with the same filters. Placement results are `observations list`, not check runs.")
+        .addOption(new Option("--kind <kind>", `Check kind: ${DELIVERABILITY_SURFACE_CHECK_KINDS.join(", ")}.`).choices([...DELIVERABILITY_SURFACE_CHECK_KINDS]))
+        .addOption(new Option("--subject-type <type>", `What was checked: ${DELIVERABILITY_SURFACE_SUBJECT_TYPES.join(", ")}.`).choices([...DELIVERABILITY_SURFACE_SUBJECT_TYPES]))
         .option("--subject <subject>", "Exact subject: a domain, mailbox id or copy content hash.")
-        .addOption(new Option("--status <status>", "Run status.").choices([...DELIVERABILITY_SURFACE_RUN_STATUSES]))
-        .addOption(new Option("--finding-status <status>", "Only runs with at least one finding of this status.").choices([...DELIVERABILITY_SURFACE_FINDING_STATUSES]))
+        .addOption(new Option("--status <status>", `Run status: ${DELIVERABILITY_SURFACE_RUN_STATUSES.join(", ")}.`).choices([...DELIVERABILITY_SURFACE_RUN_STATUSES]))
+        .addOption(new Option("--finding-status <status>", `Only runs with at least one finding of this status: ${DELIVERABILITY_SURFACE_FINDING_STATUSES.join(", ")}.`).choices([...DELIVERABILITY_SURFACE_FINDING_STATUSES]))
         .option("--since <time>", `Started at or after. ${WINDOW_HELP}`)
         .option("--until <time>", `Started before. ${WINDOW_HELP}`)
         .option("--limit <n>", LIMIT_HELP)

package/dist/functions-commands.js

@@ -1,4 +1,4 @@
-import { OxygenError } from "@oxygen/shared";
+import { OxygenError } from "@oxygen/shared/cli-result";
 import { FUNCTION_LIBRARY_FILTER } from "@oxygen/shared/contracts/function-library-read";
 import { parseJsonObject } from "./cli-values.js";
 import { requestOxygen } from "./http-client.js";

package/dist/help.js

@@ -1,5 +1,5 @@
 import { CommanderError } from "commander";
-import { CLI_EXIT_CODE_TABLE } from "@oxygen/shared";
+import { CLI_EXIT_CODE_TABLE } from "@oxygen/shared/cli-result";
 import { exitCodeForErrorCode, failure } from "@oxygen/shared/cli-result";
 // Grouped `--help` for the ~70 top-level command groups: commander's default
 // registration-order wall (login, auth, profiles, ... before any GTM noun) is

package/dist/local-custom-http-column.js

@@ -1,5 +1,5 @@
 import { Buffer } from "node:buffer";
-import { OxygenError } from "@oxygen/shared";
+import { OxygenError } from "@oxygen/shared/cli-result";
 import { readJsonPath, walkJsonPath } from "@oxygen/shared/json-path";
 import { CustomHttpUrlSafetyError, assertCustomHttpPublicUrlSyntax, assertCustomHttpResolvedHostAllowed, } from "@oxygen/shared/custom-http-safety";
 import { requestOxygen } from "./http-client.js";

package/dist/runtime.js

@@ -1,5 +1,5 @@
 import { basename } from "node:path";
-import { OxygenError } from "@oxygen/shared";
+import { OxygenError } from "@oxygen/shared/cli-result";
 const PROD_API_HOSTNAME = "oxygen-agent.com";
 const DEV_CLI_BINARY = "oxygen-dev";
 const PROD_CLI_BINARY = "oxygen";

package/dist/session.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { OxygenError } from "@oxygen/shared";
+import { OxygenError } from "@oxygen/shared/cli-result";
 export function startSession(input) {
     const now = new Date().toISOString();
     const session = {

package/dist/transcript.js

@@ -2,7 +2,7 @@ import { gzipSync } from "node:zlib";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { OXYGEN_VERSION } from "@oxygen/shared";
+import { OXYGEN_VERSION } from "@oxygen/shared/version";
 // Keep at most the most-recent ~2MB of JSONL. gzip of conversational JSON lands
 // ~5–10x smaller, so the base64 payload stays well under Vercel's ~4.5MB body
 // limit without needing chunked upload. Past the cap we drop the oldest events.

package/dist/util.d.ts

@@ -1,4 +1,4 @@
-export { isRecord } from "@oxygen/shared";
+export { isRecord } from "@oxygen/shared/type-guards";
 export declare function readOption(value: string | undefined): string | null;
 /**
  * A flag whose ABSENCE and whose EMPTY value mean different things: absent

package/dist/util.js

@@ -1,4 +1,4 @@
-export { isRecord } from "@oxygen/shared";
+export { isRecord } from "@oxygen/shared/type-guards";
 export function readOption(value) {
     return typeof value === "string" && value.trim() ? value.trim() : null;
 }

package/dist/visual-commands.js

@@ -2,7 +2,7 @@ import { Option } from "commander";
 import { createHash } from "node:crypto";
 import { readFileSync, statSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { OxygenError } from "@oxygen/shared";
+import { OxygenError } from "@oxygen/shared/cli-result";
 import { requestOxygen } from "./http-client.js";
 import { waitForVisualRender } from "./visual-render-wait.js";
 export function registerVisualCommands(program, handle) {

package/dist/visual-render-wait.js

@@ -1,4 +1,4 @@
-import { OxygenError } from "@oxygen/shared";
+import { OxygenError } from "@oxygen/shared/cli-result";
 import { readPositiveInt, readRecordString } from "./cli-values.js";
 import { requestOxygen } from "./http-client.js";
 import { waitForCliRun } from "./run-wait.js";