@oxygen-agent/cli 1.1011.974 → 1.1012.2

package/node_modules/@oxygen/shared/dist/contracts/customer-operations.js

@@ -43,7 +43,7 @@ export const CUSTOMER_OPERATIONS = [
     operation("copilot.attachments.delete", "/api/cli/copilot/sessions/{session_id}/attachments/{attachment_id}", "DELETE", "copilot attachments delete", "oxygen_copilot_attachment_delete", "agents", "Detach an unsent Copilot attachment; attachments already quoted by a turn cannot be removed."),
     operation("copilot.feedback", "/api/cli/copilot/sessions/{session_id}/turns/{turn_id}/feedback", "POST", "copilot feedback", "oxygen_copilot_feedback", "agents", "Rate one attended Copilot turn and optionally explain the rating.", { rating: enumOf(["up", "down"]), comment: text() }, ["rating"]),
     operation("copilot.interrupt", "/api/cli/copilot/sessions/{session_id}/turns/{turn_id}/interrupt", "POST", "copilot interrupt", "oxygen_copilot_interrupt", "agents", "Request cancellation of one Copilot turn. Read the session again to confirm it stopped.", {}, [], mcpOnly),
-    operation("context.canonical.get", "/api/cli/context/canonical/get", "POST", "context canonical get", "oxygen_context_canonical_get", "knowledge", "Read the pinned active context asset for a type; present=false means none is set.", { type: text() }, ["type"], { mutates: false }),
+    operation("context.canonical.get", "/api/cli/context/canonical/get", "POST", "context canonical get", "oxygen_context_canonical_get", "knowledge", "Read the current canonical (pinned) voice, brand or positioning that AI copy uses, or any type's pinned asset. present=false means none is pinned; grounding_when_absent says what AI copy uses instead.", { type: text("Type to read: voice, brand or positioning (the canonical copy AI uses), or another context type such as playbook or persona.") }, ["type"], { mutates: false }),
     operation("crm.notes.update", "/api/cli/crm/notes/{note_id}", "PATCH", "crm notes update", "oxygen_crm_note_update", "crm", "Edit a CRM note's body, title or pinned state; an empty title clears it.", { body: text(), title: nullable(text()), pinned: bool() }, [], mcpOnly),
     operation("crm.notes.delete", "/api/cli/crm/notes/{note_id}", "DELETE", "crm notes delete", "oxygen_crm_note_delete", "crm", "Delete one CRM note in this workspace.", {}, [], mcpOnly),
     operation("crm.files.attach_inline", "/api/cli/crm/objects/{object}/records/{row_id}/files", "POST", "crm files attach-inline", "oxygen_crm_file_attach", "crm", CRM_FILE_ATTACH_DESCRIPTION, CRM_FILE_ATTACH_CONTRACT.properties, [...(CRM_FILE_ATTACH_CONTRACT.required ?? [])]),
@@ -62,7 +62,7 @@ export const CUSTOMER_OPERATIONS = [
     operation("directory.apply", "/api/cli/directory/apply", "POST", "directory apply", "oxygen_directory_apply", "crm", "Apply for an agency-directory listing for this workspace; reuses an existing open application.", { message: text(), website: text() }, [], mcpOnly),
     operation("directory.logo", "/api/cli/directory/listing/logo", "POST", "directory logo upload", "oxygen_directory_logo_upload", "crm", "Upload a public agency-directory logo and read back the updated listing; PNG, JPEG, WebP or SVG, at most 2 MB.", { content_base64: text(), file_name: text(), content_type: enumOf(["image/png", "image/jpeg", "image/webp", "image/svg+xml"]) }, ["content_base64", "file_name", "content_type"], { multipart: { contentField: "content_base64", nameField: "file_name", typeField: "content_type", fileField: "file" } }),
     operation("domains.delete", "/api/cli/domains/delete", "POST", "domains delete", "oxygen_domains_delete", "deliverability", "Preview domain removal and renewal cancellation; execute only with the exact plan hash and confirmation.", { domains: list(), approved: bool(), plan_hash: text(), confirmation: text() }, ["domains"], mcpOnly),
-    operation("knowledge.pages.archive", "/api/cli/knowledge/pages/archive", "POST", "knowledge page archive", "oxygen_knowledge_page_archive", "knowledge", "Archive a knowledge page while preserving its history.", { slug: text(), id: text(), expected_revision: int({ minimum: 1 }) }, [], mcpOnly),
+    operation("knowledge.pages.archive", "/api/cli/knowledge/pages/archive", "POST", "knowledge page archive", "oxygen_knowledge_page_archive", "knowledge", "Archive a knowledge page; content/history remain, links become unresolved. Pass expected_revision for the version you reviewed.", { slug: text(), id: text(), expected_revision: int({ minimum: 1 }) }, [], mcpOnly),
     operation("knowledge.sync.manifest", "/api/cli/knowledge/sync/manifest", "POST", "knowledge sync-manifest", "oxygen_knowledge_sync_manifest", "knowledge", "Read the wiki revision and content-hash inventory without downloading instruction bodies.", {}, [], { mutates: false }),
     operation("knowledge.sync.delta", "/api/cli/knowledge/sync/delta", "POST", "knowledge sync", "oxygen_knowledge_sync_delta", "knowledge", "Read one resumable batch of wiki pages and tombstones, bounded by the server's byte budget.", { cursor: text(), limit: int({ minimum: 1, maximum: 200 }) }, [], { ...mcpOnly, mutates: false }),
     operation("limits.provider.get", "/api/cli/limits/provider", "GET", "limits provider list", "oxygen_provider_limits_list", "billing", "Read provider request limits and BYOK warning defaults. MCP defaults to bounded summary pages; follow paging.next_offset with the same filter. HTTP/CLI omit pagination for the full legacy list. 0 credits.", {}, [], { contract: providerLimitListContract, generated: { cli: false, mcp: false } }),
@@ -81,7 +81,7 @@ export const CUSTOMER_OPERATIONS = [
     operation("settings.beta.set", "/api/cli/settings/beta-features", "POST", "settings beta-features set", "oxygen_settings_beta_features_set", "workspace", "Enable or disable beta navigation for every workspace member; admin or owner only. Approve the preference change. This does not disable routes. 0 credits.", {}, [], { contract: betaFeaturesUpdateContract }),
     operation("spintax.generate", "/api/cli/spintax", "POST", "spintax generate", "oxygen_spintax_generate", "sequences", "Generate wording or copy variations as spintax: live (default) costs 3 credits and requires approval and a credit ceiling; explicit dry_run is a free preview. Preserve merge variables; send nothing. Live requires approved:true and max_credits>=3 after preview; failed generation refunds the reservation.", {}, [], { contract: spintaxContract, defaults: { mode: "live" }, spends: true }),
     operation("table_action_items.resolve", "/api/cli/table-action-items/{item_id}/resolve", "POST", "table-actions resolve", "oxygen_table_action_item_resolve", "tables", "Record a human-verified uncertain Table action outcome without repeating it. Use cells resolve for row/column coordinates.", TABLE_ITEM_RESOLVE_CONTRACT.properties, ["outcome"]),
-    operation("table_ingestions.append", "/api/cli/table-ingestion-runs/{ingestion_run_id}/items", "POST", "table-ingestions append", "oxygen_table_ingestions_append_items", "runs", "Append bounded ingestion items to an existing run; preserves the run's approved scope.", { items: rows(), max_attempts: int({ minimum: 1 }) }, ["items"], cliOnly),
+    operation("table_ingestions.append", "/api/cli/table-ingestion-runs/{ingestion_run_id}/items", "POST", "table-ingestions append", "oxygen_table_ingestions_append_items", "runs", "Append generated row chunks with items [{position:0,payload:{rows:[{column:value}]}}]. For capped provider paging, create a new approved tool_page run from the last completed item.nextCursor; preserve the Table, filters/mapping/upsert key and use a new credit cap.", { items: rows(), max_attempts: int({ minimum: 1 }) }, ["items"], cliOnly),
     operation("tables.favorites.get", "/api/cli/tables/favorite", "GET", "tables favorites", "oxygen_tables_favorites", "tables", "Read starred Tables/folders (per-member preference; free (0 credits)); next_cursor. Catalog stars differ.", TABLE_FAVORITES_LIST_CONTRACT.properties, [], { generated: { cli: true, mcp: false } }),
     operation("tables.favorite.set", "/api/cli/tables/favorite", "POST", "tables favorite", "oxygen_tables_favorite", "tables", "Star/unstar exactly one table or folder (saved per-member preference). Free (0 credits). Catalog stars differ.", TABLE_FAVORITE_CONTRACT.properties, ["favorite"]),
     operation("tables.import.csv", "/api/cli/tables/import-csv", "POST", "tables import-csv", "oxygen_tables_import_csv", "tables", "Import inline CSV into a hosted Table through its durable ingestion run. Use staged upload for large files.", { csv_text: text(), csv_base64: text(), table: text(), table_name: text(), project: text(), filename: text(), upsert_key: text(), batch_size: int({ minimum: 1, maximum: 5000 }) }, [], cliOnly),
@@ -90,7 +90,7 @@ export const CUSTOMER_OPERATIONS = [
     operation("tables.import.staged", "/api/cli/tables/import-staged", "POST", "tables import-staged", "oxygen_tables_import_staged", "tables", "Start a durable hosted import from this workspace's staged file; choose an existing table or create_name.", { table: text(), create_name: text(), project: text(), storage_key: text(), storage_bucket: text(), storage_provider: enumOf(["s3"]), file_name: text(), format: enumOf(["csv", "json", "xlsx"]), sha256: text(), upsert_key: text(), source_key_map: json, byte_length: int({ minimum: 1 }), row_count: int({ minimum: 1 }), max_concurrency: int({ minimum: 1, maximum: 1000 }), source: enumOf(["cli", "mcp", "web"]), batch_size: int({ minimum: 1, maximum: 5000 }) }, ["storage_key", "byte_length"]),
     operation("tables.import.file", "/api/cli/tables/import-file", "POST", "tables import-file", "oxygen_tables_import_file", "tables", "Import small base64 file bytes through the shared multipart import API; use staged upload for large files.", { content_base64: text(), file_name: text(), content_type: text(), table: text(), table_name: text(), project: text(), format: enumOf(["csv", "json", "xlsx"]), sheet: text(), upsert_key: text(), source_key_map: json, source_hash: text(), batch_size: int({ minimum: 1, maximum: 5000 }), max_concurrency: int({ minimum: 1 }) }, ["content_base64", "file_name"], { multipart: { contentField: "content_base64", nameField: "file_name", typeField: "content_type", fileField: "file" } }),
     operation("tables.link.suggest", "/api/cli/tables/link/suggest", "POST", "tables link-suggest", "oxygen_tables_link_suggest", "tables", "Plan column links and matching row counts between Tables; creates no relation. Apply with tables link bulk.", TABLE_LINK_SUGGEST_CONTRACT.properties, ["table", "to"], { mutates: false }),
-    operation("tables.recover_pending", "/api/cli/tables/recover-pending", "POST", "tables recover-pending", "oxygen_tables_recover_pending", "tables", "Poll pending BetterContact requests and save recovered phones; no new orders. Does not resume imports.", TABLE_RECOVER_PENDING_CONTRACT.properties, ["table"], { ...mcpOnly, annotations: { openWorldHint: true } }),
+    operation("tables.recover_pending", "/api/cli/tables/recover-pending", "POST", "tables recover-pending", "oxygen_tables_recover_pending", "tables", "Recover BetterContact email/phone requests and read verification blockers; no new orders or imports.", TABLE_RECOVER_PENDING_CONTRACT.properties, ["table"], { ...mcpOnly, annotations: { openWorldHint: true } }),
     operation("tables.webhooks.create", "/api/cli/tables/webhooks", "POST", "tables webhook create", "oxygen_table_webhook_create", "tables", "Create an inbound Table webhook or platform LinkedIn feed. Optional auto_run is standing permission with explicit or plan-default delivery ceilings.", { table: text(), name: text(), mode: enumOf(["insert", "upsert"]), upsert_key: text(), items_path: text(), event_id_path: text(), event_type_path: text(), occurred_at_path: text(), auth_mode: enumOf(["none", "secret"]), feed_kind: enumOf(["generic", "unipile"]), unipile_account_id: text(), event_types: list(), mapping: text(), auto_run: json }, ["table"], mcpOnly),
     operation("tables.webhooks.update", "/api/cli/tables/webhooks", "PATCH", "tables webhook update", "oxygen_table_webhook_update", "tables", "Edit a Table webhook's name, state or standing auto_run; auth_mode=secret rotates its secret and returns it once.", { endpoint_id: text(), name: text(), status: enumOf(["active", "disabled"]), auth_mode: enumOf(["none", "secret"]), auto_run: json, clear_auto_run: bool() }, ["endpoint_id"], mcpOnly),
     operation("whatsapp.draft", "/api/cli/whatsapp/draft", "POST", "whatsapp draft", "oxygen_whatsapp_draft", "inbox", "Generate a WhatsApp reply draft in the workspace voice, or approve a reviewed draft for an existing chat. Draft generation uses managed AI credits.", { conversation_id: text(), goal: text(), row_id: text(), object: text(), approved: bool(), draft_id: text(), text: text() }, ["conversation_id"], { ...cliOnly, spends: true }),
@@ -102,7 +102,7 @@ export const CUSTOMER_OPERATIONS = [
     operation("db.provision", "/api/cli/db/provision", "POST", "db provision", "oxygen_workspace_database_provision", "workspace", "Provision or retry this workspace database immediately; already-ready workspaces retain it. No preview or confirmation field; native workspace write access applies. May outlast the connector deadline: read oxygen_workspace_database_status before retrying. Hosting is plan-included; 0 credits.", {}, [], mcpOnly),
     operation("sessions.list", "/api/cli/sessions", "GET", "sessions list", "oxygen_sessions_list", "workspace", "List your personal CLI sessions across workspaces; OAuth or personal user session required, organization API keys are refused."),
     operation("sessions.revoke", "/api/cli/sessions/{session_id}", "DELETE", "sessions revoke", "oxygen_sessions_revoke", "workspace", "Revoke one of your personal CLI sessions; OAuth or personal user session required, organization API keys are refused."),
-    operation("billing.allowance", "/api/cli/billing/allowance", "GET", "billing allowance", "oxygen_billing_allowance", "billing", "Read this workspace's current recurring credit allowance and period.", {}, [], mcpOnly),
+    operation("billing.allowance", "/api/cli/billing/allowance", "GET", "billing allowance", "oxygen_billing_allowance", "billing", "Inspect this workspace's recurring credit allowance and period; due plan grants or credit expiry may apply. 0 credits; reserves nothing.", {}, [], { ...mcpOnly, mutates: true }),
     operation("billing.invoices", "/api/cli/billing/invoices", "GET", "billing invoices", "oxygen_billing_invoices", "billing", "Read this workspace's billing invoices and their hosted payment links.", {}, [], mcpOnly),
     operation("billing.seats.set", "/api/cli/billing/seats", "POST", "billing seats set", "oxygen_billing_seats_set", "billing", "Set purchased legacy sending-seat quantity. Retired seats cannot increase; reducing existing seats lowers the next renewal charge.", { seat_key: enumOf(["linkedin", "whatsapp", "phone_number", "email_sender"]), quantity: int({ minimum: 0 }) }, ["seat_key", "quantity"], mcpOnly),
     operation("collaboration.gates.list", "/api/cli/collab/gates", "GET", "approvals gate list", "oxygen_approval_gates_list", "collaboration", "Read this workspace's approval gates, optionally for one exact subject.", { subject: text() }, [], mcpOnly),

package/node_modules/@oxygen/shared/dist/contracts/geo.d.ts

@@ -0,0 +1,2 @@
+import type { OperationSpec } from "./operations.js";
+export declare const GEO_OPERATIONS: readonly OperationSpec[];

package/node_modules/@oxygen/shared/dist/contracts/geo.js

@@ -0,0 +1,138 @@
+import { arr, bool, enumOf, int, obj, str, } from "./schema.js";
+import { GEO_ENGINES } from "../geo.js";
+const text = (maxLength = 1000) => str({ maxLength });
+const strings = () => arr(text(), { maxItems: 100 });
+const engine = enumOf(GEO_ENGINES);
+const market = obj({
+    country: str({ minLength: 2, maxLength: 2 }),
+    language: str({ minLength: 2, maxLength: 10 }),
+}, { required: ["country", "language"] });
+const project = {
+    name: str({ minLength: 1, maxLength: 120 }),
+    aliases: strings(),
+    domains: arr(text(), { minItems: 1, maxItems: 100 }),
+    icp: text(5000),
+    engines: arr(engine, { minItems: 1, maxItems: 7 }),
+    markets: arr(market, { minItems: 1, maxItems: 10 }),
+    repetitions: int({ minimum: 1, maximum: 5 }),
+    archived: bool(),
+};
+const prompt = {
+    text: str({ minLength: 1, maxLength: 500 }),
+    topic: text(120),
+    persona: text(120),
+    stage: text(120),
+    source: enumOf(["hypothesis", "research", "customer"]),
+    evidence_id: text(),
+    enabled: bool(),
+};
+const filters = {
+    engine,
+    country: text(2),
+    language: text(10),
+    prompt_id: text(),
+    topic: text(120),
+    from: text(40),
+    to: text(40),
+    limit: int({ minimum: 1, maximum: 200 }),
+    cursor: text(100),
+};
+function operation(id, suffix, method, command, summary, fields = {}, required = [], spends = false) {
+    const route = `/api/cli/geo${suffix}`;
+    return {
+        id: `geo.${id}`,
+        route,
+        method,
+        parameters: [...route.matchAll(/\{(\w+)\}/g)].map((m) => m[1]),
+        contract: obj(fields, { required }),
+        cli: {
+            path: ["geo", ...command.split(" ")],
+            summary: `Staff-only dev pilot: ${summary}`,
+        },
+        mcp: {
+            name: `oxygen_geo_${id.replaceAll(".", "_")}`,
+            title: `Oxygen GEO: ${command}`,
+            description: `${summary} Experimental: staff in dev workspaces only.`,
+            pack: "geo",
+        },
+        mutates: method !== "GET",
+        spends,
+    };
+}
+export const GEO_OPERATIONS = [
+    operation("projects.list", "/projects", "GET", "projects list", "List GEO / AEO AI-search tracking projects."),
+    operation("projects.create", "/projects", "POST", "projects create", "Create a GEO / AEO brand tracking project.", project, ["name", "domains"]),
+    operation("projects.get", "/projects/{project_id}", "GET", "projects get", "Read a GEO / AEO project and its tracking settings."),
+    operation("projects.update", "/projects/{project_id}", "PATCH", "projects update", "Change brand aliases, ICP, markets or tracking settings.", project),
+    operation("context.get", "/context", "GET", "context get", "Read editable brand, ICP and offering context from workspace Knowledge."),
+    operation("engines.list", "/engines", "GET", "engines list", "Inspect consumer answer-engine readiness, supported markets and collection cost."),
+    operation("prompts.list", "/projects/{project_id}/prompts", "GET", "prompts list", "List tracked buyer prompts and research provenance.", { limit: filters.limit, cursor: filters.cursor }),
+    operation("prompts.create", "/projects/{project_id}/prompts", "POST", "prompts add", "Add a reviewed buyer question to GEO / AEO tracking.", prompt, ["text"]),
+    operation("prompts.update", "/projects/{project_id}/prompts/{document_id}", "PATCH", "prompts update", "Revise or pause one tracked buyer question.", prompt),
+    operation("prompts.import", "/projects/{project_id}/prompts/import", "POST", "prompts import", "Import reviewed buyer prompts in one bounded batch.", {
+        prompts: arr(obj(prompt, { required: ["text"] }), {
+            minItems: 1,
+            maxItems: 100,
+        }),
+    }, ["prompts"]),
+    operation("competitors.list", "/projects/{project_id}/competitors", "GET", "competitors list", "List brands benchmarked against this project.", { limit: filters.limit, cursor: filters.cursor }),
+    operation("competitors.create", "/projects/{project_id}/competitors", "POST", "competitors add", "Add a competitive brand and its aliases and domains.", { name: project.name, aliases: strings(), domains: strings() }, ["name"]),
+    operation("competitors.update", "/projects/{project_id}/competitors/{document_id}", "PATCH", "competitors update", "Update competitive brand aliases and owned domains.", { name: project.name, aliases: strings(), domains: strings() }),
+    operation("runs.preview", "/projects/{project_id}/runs/preview", "POST", "runs preview", "Preview consumer collection coverage and cost without spending.", { prompt_ids: strings() }),
+    operation("runs.start", "/projects/{project_id}/runs", "POST", "runs start", "Run reviewed buyer prompts against real consumer answer engines within the pilot budget.", { preview_token: text(128) }, ["preview_token"], true),
+    operation("runs.list", "/projects/{project_id}/runs", "GET", "runs list", "List tracking runs with completion and costs."),
+    operation("runs.get", "/projects/{project_id}/runs/{run_id}", "GET", "runs get", "Inspect a tracking run, provider tasks, costs, failures and retries."),
+    operation("runs.retry", "/projects/{project_id}/runs/{run_id}/retry", "POST", "runs retry", "Resume failed reads of saved provider tasks without a new paid submission."),
+    operation("runs.cancel", "/projects/{project_id}/runs/{run_id}/cancel", "POST", "runs cancel", "Stop unsubmitted samples; submitted collection retains its spend reservation."),
+    operation("schedules.set", "/projects/{project_id}/schedule", "PATCH", "schedule set", "Pause or configure daily/weekly GEO tracking within a reviewed cost ceiling.", {
+        cadence: enumOf(["paused", "daily", "weekly"]),
+        preview_token: text(128),
+    }, ["cadence"], true),
+    operation("answers.list", "/projects/{project_id}/answers", "GET", "answers list", "Inspect collected answers and imported samples with citations and mention evidence.", filters),
+    operation("answers.get", "/projects/{project_id}/answers/{document_id}", "GET", "answers get", "Read the immutable original answer and full provider payload."),
+    operation("answers.import", "/projects/{project_id}/answers", "POST", "answers import", "Import a manually observed consumer answer, separate from controlled tracker metrics.", {
+        engine,
+        prompt: text(500),
+        text: text(100000),
+        urls: strings(),
+        captured_at: text(40),
+    }, ["engine", "prompt", "text"]),
+    operation("analytics.get", "/projects/{project_id}/analytics", "GET", "analytics get", "Read AI visibility, citations, share of voice and trends with sample denominators.", filters),
+    operation("sources.list", "/projects/{project_id}/sources", "GET", "sources list", "Find domains and pages cited by AI, including competitive citation gaps.", filters),
+    operation("evidence.preview", "/projects/{project_id}/evidence/preview", "POST", "evidence preview", "Preview and redact ChatGPT/Claude conversation exports before saving.", { transcript: text(1000000), redact: strings() }, ["transcript"]),
+    operation("evidence.list", "/projects/{project_id}/evidence", "GET", "evidence list", "List customer conversation evidence and original buyer language.", { limit: filters.limit, cursor: filters.cursor }),
+    operation("evidence.create", "/projects/{project_id}/evidence", "POST", "evidence save", "Save a reviewed redacted conversation with optional CRM attribution.", {
+        transcript: text(1000000),
+        redact: strings(),
+        record_id: text(),
+        record_object: text(120),
+        engine,
+        title: text(120),
+    }, ["transcript", "engine"]),
+    operation("audits.create", "/projects/{project_id}/audits", "POST", "audits run", "Audit up to ten owned public pages for crawlability and citation readiness.", { urls: arr(text(2000), { minItems: 1, maxItems: 10 }) }, ["urls"]),
+    operation("audits.list", "/projects/{project_id}/audits", "GET", "audits list", "Read site audit findings and proposed fixes.", { limit: filters.limit, cursor: filters.cursor }),
+    operation("opportunities.list", "/projects/{project_id}/opportunities", "GET", "opportunities list", "Read prioritized GEO content, source and messaging opportunities.", { limit: filters.limit, cursor: filters.cursor }),
+    operation("opportunities.refresh", "/projects/{project_id}/opportunities/refresh", "POST", "opportunities refresh", "Derive actionable content briefs and citation gaps from stored tracking evidence."),
+    operation("opportunities.draft", "/projects/{project_id}/opportunities/{document_id}/draft", "POST", "opportunities draft", "Save a reviewed content brief as a Knowledge page or an unapproved social draft.", {
+        target: enumOf(["knowledge", "post"]),
+        content: text(50000),
+        channel: enumOf(["linkedin", "x"]),
+    }, ["target"]),
+    operation("experiments.list", "/projects/{project_id}/experiments", "GET", "experiments list", "List optimization experiments and observed before/after changes.", { limit: filters.limit, cursor: filters.cursor }),
+    operation("experiments.create", "/projects/{project_id}/experiments", "POST", "experiments create", "Record an optimization hypothesis, baseline and target buyer questions.", {
+        title: text(120),
+        hypothesis: text(5000),
+        prompt_ids: strings(),
+        opportunity_id: text(),
+        proposed_change: text(10000),
+    }, ["title", "hypothesis"]),
+    operation("experiments.update", "/projects/{project_id}/experiments/{document_id}", "PATCH", "experiments update", "Record a reviewed change or evaluate an experiment against subsequent samples.", {
+        status: enumOf(["planned", "changed", "evaluated", "cancelled"]),
+        change_url: text(2000),
+        notes: text(10000),
+    }),
+    {
+        ...operation("exports.get", "/projects/{project_id}/export", "GET", "export", "Download GEO evidence, metrics or an internal PDF report.", { format: enumOf(["json", "csv", "pdf"]), ...filters }),
+        binary: { maxBytes: 20_000_000 },
+    },
+];

package/node_modules/@oxygen/shared/dist/contracts/operations.d.ts

@@ -61,6 +61,12 @@ export type OperationSpec<C extends ContractObject = ContractObject> = {
     };
     mutates: boolean;
     spends: boolean;
+    /**
+     * MCP only: what a trimmed result should advise instead of the generic
+     * "smaller limit / a cursor", for a read whose single row can exceed the
+     * result ceiling (OXP-1.11.67).
+     */
+    truncationHint?: string;
 };
 /** The route with its `{param}` segments filled in, each URL-encoded. */
 export declare function operationPath(spec: Pick<OperationSpec, "route">, params: Readonly<Record<string, string>>): string;

package/node_modules/@oxygen/shared/dist/contracts/operations.js

@@ -10,6 +10,7 @@ import { SENDER_LIMITS_SET_OPERATION } from "./sender-limits.js";
 import { WORKSPACE_PAGES_GET_OPERATION, WORKSPACE_PAGES_UPDATE_OPERATION } from "./workspace-pages.js";
 import { BROWSER_OPERATIONS } from "./browser-operations.js";
 import { TABLE_FEED_UPDATE_OPERATION } from "./table-feed-update.js";
+import { GEO_OPERATIONS } from "./geo.js";
 import { CUSTOMER_OPERATIONS } from "./customer-operations.js";
 /** The route with its `{param}` segments filled in, each URL-encoded. */
 export function operationPath(spec, params) {
@@ -80,6 +81,6 @@ export function operationFormData(spec, body) {
     }
     return form;
 }
-export const OPERATION_SPECS = [SENDER_LIMITS_SET_OPERATION, CONNECTOR_UPDATE_OPERATION, CONNECTOR_EVENTS_REVOKE_OPERATION, WORKSPACE_PAGES_GET_OPERATION, WORKSPACE_PAGES_UPDATE_OPERATION, TABLE_FEED_UPDATE_OPERATION, ...CUSTOMER_OPERATIONS, ...BROWSER_OPERATIONS];
-export const CLI_OPERATIONS = [...CUSTOMER_OPERATIONS, ...BROWSER_OPERATIONS].filter((spec) => spec.generated?.cli !== false);
-export const MCP_OPERATIONS = [...CUSTOMER_OPERATIONS, ...BROWSER_OPERATIONS].filter((spec) => spec.generated?.mcp !== false);
+export const OPERATION_SPECS = [SENDER_LIMITS_SET_OPERATION, CONNECTOR_UPDATE_OPERATION, CONNECTOR_EVENTS_REVOKE_OPERATION, WORKSPACE_PAGES_GET_OPERATION, WORKSPACE_PAGES_UPDATE_OPERATION, TABLE_FEED_UPDATE_OPERATION, ...CUSTOMER_OPERATIONS, ...GEO_OPERATIONS, ...BROWSER_OPERATIONS];
+export const CLI_OPERATIONS = [...CUSTOMER_OPERATIONS, ...GEO_OPERATIONS, ...BROWSER_OPERATIONS].filter((spec) => spec.generated?.cli !== false);
+export const MCP_OPERATIONS = [...CUSTOMER_OPERATIONS, ...GEO_OPERATIONS, ...BROWSER_OPERATIONS].filter((spec) => spec.generated?.mcp !== false);

package/node_modules/@oxygen/shared/dist/contracts/publishing-reads.js

@@ -12,6 +12,7 @@ export const PUBLISHING_AMPLIFICATION_SCOPE_KINDS = ["all", "tag", "post", "ugc_
  * closed. Coarse tool annotations remain mixed; native identity/schema checks
  * still run after this call-level classification. */
 export const PUBLISHING_STORED_READ_SELECTORS = {
+    oxygen_publishing_comments: { argument: "action", values: ["list", "get"] },
     oxygen_publishing_notes: { argument: "action", values: ["list"] },
     oxygen_publishing_revisions: { argument: "action", values: ["list"] },
     oxygen_publishing_analytics: { argument: "scope", values: ["summary", "timeseries", "post", "account"] },

package/node_modules/@oxygen/shared/dist/contracts/table-row-removal.d.ts

@@ -0,0 +1,16 @@
+export declare const TABLE_ROW_REMOVAL_FIELDS: {
+    row_ids: import("./schema.js").ArrayProperty<import("./schema.js").StringProperty>;
+    filter_tree: {
+        type?: never;
+        description?: string;
+    };
+    selection: import("./schema.js").OneOfProperty;
+};
+export declare const TABLE_ROW_REMOVAL_CONTRACT: import("./schema.js").ContractObject<{
+    row_ids: import("./schema.js").ArrayProperty<import("./schema.js").StringProperty>;
+    filter_tree: {
+        type?: never;
+        description?: string;
+    };
+    selection: import("./schema.js").OneOfProperty;
+}, never>;

package/node_modules/@oxygen/shared/dist/contracts/table-row-removal.js

@@ -0,0 +1,27 @@
+import { arr, enumOf, int, jsonValue, obj, str } from "./schema.js";
+const rowIds = () => arr(str({ minLength: 1 }), { minItems: 1 });
+// Removal uses the grid's scope, not the broader execution selection. In
+// particular, execution's `filters` array is not a serialized browser filter.
+const selection = {
+    description: '{"mode":"row_ids","row_ids":["id"]} or {"mode":"all_matching","filter_tree":{...}}, with optional search, sort, range {offset,limit}, excluded_row_ids, crm_object. Unreadable filter nodes and filters/limit are refused. Unqualified all_matching removes every row.',
+    oneOf: [
+        obj({ mode: enumOf(["row_ids"]), row_ids: rowIds() }, { required: ["mode", "row_ids"] }),
+        obj({
+            mode: enumOf(["all_matching"]),
+            filter_tree: jsonValue({ description: "Readable filter tree, as tables query takes. Not with filter." }),
+            filter: str({ description: "Browser URL filter (f). Not with filter_tree." }),
+            search: str(),
+            sort: str(),
+            range: obj({ offset: int({ minimum: 0 }), limit: int({ minimum: 1 }) }, { required: ["offset", "limit"] }),
+            excluded_row_ids: arr(str({ minLength: 1 })),
+            crm_object: str(),
+        }, { required: ["mode"] }),
+    ],
+};
+// The readable filtered scope (OXP-1.1.12): removes exactly the rows this
+// filter tree matches. Shorthand for an all_matching selection.
+const filterTree = jsonValue({
+    description: 'Remove the rows this filter tree matches (as tables query takes), e.g. {"type":"group","children":[{"type":"leaf","columnKey":"status","operator":"is","value":"churned"}]} (text: is/is_not/contains; numbers: eq/gt/lt). Unreadable nodes are refused. Not with row_ids/selection.',
+});
+export const TABLE_ROW_REMOVAL_FIELDS = { row_ids: rowIds(), filter_tree: filterTree, selection };
+export const TABLE_ROW_REMOVAL_CONTRACT = obj(TABLE_ROW_REMOVAL_FIELDS);

package/node_modules/@oxygen/shared/dist/cost-estimate.d.ts

@@ -82,6 +82,7 @@ export type CostEstimatePriceSheet = {
     topupStepCredits: number;
     sending: {
         emailPerMailboxPerDay: number;
+        /** Inclusive completed sending days, starting at 0, as in email-campaign-ramp. */
         emailRamp: readonly {
             throughDay: number;
             perDay: number;
@@ -133,6 +134,11 @@ export type CostEstimateLimit = {
     capacity_per_month: number;
     /** What a newly connected sender manages in its first month (email ramp). */
     first_month_capacity: number | null;
+    /** Sender need when all entered mailboxes start at the beginning of the ramp. */
+    first_month_senders_needed: number | null;
+    /** null when this channel has no modeled first-month capacity. */
+    first_month_hit: boolean | null;
+    /** Steady-state sender need and hit; the first-month ramp does not change these. */
     senders_needed: number;
     hit: boolean;
     note: string;

package/node_modules/@oxygen/shared/dist/cost-estimate.js

@@ -115,8 +115,8 @@ function cheapestRung(credits, usdSeats, sheet) {
 function rampFirstMonthCapacity(sheet) {
     const { emailRamp, emailPerMailboxPerDay, sendingDaysPerMonth } = sheet.sending;
     let total = 0;
-    for (let day = 1; day <= sendingDaysPerMonth; day += 1) {
-        const tier = emailRamp.find((step) => day <= step.throughDay);
+    for (let completedDays = 0; completedDays < sendingDaysPerMonth; completedDays += 1) {
+        const tier = emailRamp.find((step) => completedDays <= step.throughDay);
         total += tier ? Math.min(tier.perDay, emailPerMailboxPerDay) : emailPerMailboxPerDay;
     }
     return total;
@@ -125,11 +125,19 @@ function limitRow(input) {
     const capacity = input.senders * input.perSender;
     const sendersNeeded = input.needed === 0 || input.perSender <= 0 ? 0 : Math.ceil(input.needed / input.perSender);
     const hit = input.needed > capacity;
-    const note = input.needed === 0
+    const firstMonthCapacity = input.firstMonthPerSender === null ? null : input.senders * input.firstMonthPerSender;
+    const firstMonthSendersNeeded = input.firstMonthPerSender === null || input.firstMonthPerSender <= 0
+        ? null
+        : Math.ceil(input.needed / input.firstMonthPerSender);
+    const firstMonthHit = firstMonthCapacity === null ? null : input.needed > firstMonthCapacity;
+    const steadyNote = input.needed === 0
         ? "Not used by this scenario."
         : hit
             ? `${formatInt(input.needed)} ${input.unit} a month needs ${formatInt(sendersNeeded)}; you entered ${formatInt(input.senders)}. Each sends ${formatInt(input.perSender)} a month (${input.bindingLimit}). ${input.addWith}`
             : `${formatInt(input.needed)} of ${formatInt(capacity)} ${input.unit} a month (${input.bindingLimit} each).`;
+    const rampNote = firstMonthHit && input.firstMonthPerSender !== null && input.firstMonthPerSender < input.perSender
+        ? ` If these mailboxes are newly connected, their first-month capacity is ${formatInt(firstMonthCapacity)} ${input.unit}; ${formatInt(input.needed)} needs ${firstMonthSendersNeeded === null ? "more mailboxes" : `${formatInt(firstMonthSendersNeeded)} mailboxes`}. This quote prices the ${formatInt(input.senders)} entered mailboxes; request a new estimate after adding mailboxes.`
+        : "";
     return {
         key: input.key,
         label: input.label,
@@ -138,10 +146,12 @@ function limitRow(input) {
         per_sender_per_month: input.perSender,
         binding_limit: input.bindingLimit,
         capacity_per_month: capacity,
-        first_month_capacity: input.firstMonthPerSender === null ? null : input.senders * input.firstMonthPerSender,
+        first_month_capacity: firstMonthCapacity,
+        first_month_senders_needed: firstMonthSendersNeeded,
+        first_month_hit: firstMonthHit,
         senders_needed: sendersNeeded,
         hit,
-        note,
+        note: steadyNote + rampNote,
     };
 }
 /** Clamp a scenario into the accepted bounds: whole, non-negative numbers. */
@@ -316,6 +326,8 @@ export function estimateScenarioCost(rawScenario, sheet) {
         }),
     ].filter((row) => row.needed_per_month > 0);
     const limitsHit = limits.filter((row) => row.hit).map((row) => row.key);
+    const firstMonthRampHit = limits.find((row) => row.key === "email_per_mailbox"
+        && row.first_month_hit && row.first_month_capacity !== null && row.first_month_capacity < row.capacity_per_month);
     const assumptions = [
         "Every lead is already in a table and goes through each enrichment and every sequence step. Finding new leads is priced separately.",
         `Sending limits use ${sending.sendingDaysPerMonth} sending days a month and the defaults for a newly connected account (a sender you already run may be set lower): ${sending.emailPerMailboxPerDay} emails a mailbox a day, ${sending.linkedinInvitesPerDay} LinkedIn invites a day and ${sending.linkedinInvitesPerWeek} a week, ${sending.linkedinMessagesPerDay} LinkedIn messages a day.`,
@@ -323,9 +335,9 @@ export function estimateScenarioCost(rawScenario, sheet) {
         "While senders are paid as sending seats (sender_billing: sending_seats) they reserve no credits; once seats are retired each connected sender reserves its monthly price in credits instead, never both.",
         `Credits are shown at face value, ${formatInt(sheet.creditsPerUsd)} credits to $1; top-ups cost ${formatUsd(sheet.topupUsdCentsPer100 / 100)} per 100 credits.`,
     ];
-    if (totalMailboxes > 0 && emails > 0) {
+    if (totalMailboxes > 0 && emails > 0 && sending.emailRamp.length > 0) {
         const ramp = sending.emailRamp.map((step) => step.perDay).join(", ");
-        assumptions.push(`A newly connected mailbox ramps up (${ramp} a day) before it sends at its full daily limit; first_month_capacity shows that month.`);
+        assumptions.push(`A newly connected mailbox ramps up (${ramp} a day) before it sends at its full daily limit; first_month_capacity, first_month_senders_needed and first_month_hit show that first ${sending.sendingDaysPerMonth}-sending-day window. The other capacity and hit fields describe steady state.`);
     }
     const planText = recommended
         ? `cheapest all in: the ${recommended.expected.label} plan${recommended.expected.topup_credits > 0 ? " with top-ups" : ""}${usdSeats > 0 ? " and seats" : ""}, ${formatUsd(recommended.expected.monthly_usd ?? 0)} a month`
@@ -337,7 +349,10 @@ export function estimateScenarioCost(rawScenario, sheet) {
         `About ${formatInt(credits)} credits a month expected (up to ${formatInt(worstCredits)} worst case)${usdSeats > 0 ? ` plus ${formatUsd(usdSeats)} a month in sending seats` : ""}; ${planText}.`,
         limitsHit.length > 0
             ? `Limits hit: ${limits.filter((row) => row.hit).map((row) => `${row.label.toLowerCase()} (needs ${formatInt(row.senders_needed)})`).join(", ")}.`
-            : limits.length > 0 ? "No sending limit is hit." : "",
+            : limits.length > 0 ? firstMonthRampHit ? "No steady-state sending limit is hit." : "No sending limit is hit." : "",
+        firstMonthRampHit
+            ? `New-mailbox ramp shortfall: ${formatInt(firstMonthRampHit.first_month_capacity)} of ${formatInt(firstMonthRampHit.needed_per_month)} emails in the first ${sending.sendingDaysPerMonth} sending days${firstMonthRampHit.first_month_senders_needed === null ? "" : ` (needs ${formatInt(firstMonthRampHit.first_month_senders_needed)} mailboxes)`}. Prices cover the entered mailboxes; request a new estimate after adding mailboxes.`
+            : "",
     ].filter(Boolean).join(" ");
     return {
         lines,

package/node_modules/@oxygen/shared/dist/enrichment-intents.js

@@ -56,7 +56,8 @@ export const ENRICHMENT_INTENT_TAXONOMY = [
             f("job_start_date", "Job start date", null),
             f("person_location", "Location", "person.location"),
             f("person_bio", "Bio", "person.bio"),
-            f("person_linkedin_followers", "LinkedIn followers", "person.linkedin_followers", "numeric"),
+            // Blitz publishes no follower count; only the fallback lane fills it (OXP-1.27.6).
+            f("person_linkedin_followers", "LinkedIn followers (only when the fallback lane answers)", "person.linkedin_followers", "numeric"),
             f("education", "Education", null, "jsonb"),
             f("school_name", "School", null),
         ],

package/node_modules/@oxygen/shared/dist/external-effect-arming.d.ts

@@ -0,0 +1,54 @@
+import { type DeployTier } from "./deploy-env.js";
+/**
+ * Which background EXTERNAL EFFECTS each deployment is armed to dispatch, declared
+ * here per environment rather than implied by whichever credentials a box holds.
+ *
+ * OXP-1.6.190 (classify-A P-05). Three background families write outside OXYGEN with
+ * no human in the loop: the off-session Stripe writes of `inbox_billing_reconcile`,
+ * the Zapmail writes of `mailbox_connection_repair`, and the dedicated-egress vendor
+ * release (IPRoyal `toggle-auto-extend`) of the egress order reconcile and lifecycle.
+ * Before this table their arming was implicit: present credentials meant armed.
+ *
+ * Chosen design (coordinator, 2026-10-07, "option 2"): every CURRENT default is kept, so
+ * dev billing reconcile, Zapmail repair and egress releases keep working for dev flows,
+ * but the state is now explicit, reviewable and read back, and two mismatches fail
+ * closed outside production-data environments: a LIVE Stripe key, and a vendor release
+ * whose family is not armed here. Production stays armed; nothing here changes a
+ * production default or touches a secret. A default-off posture outside production
+ * was considered and not chosen, because other dev workflows depend on these effects.
+ *
+ * Changing an entry is a reviewed code change. `OXYGEN_WORKER_MAILBOX_CONNECTION_REPAIR`
+ * remains the existing runtime kill switch for the repair family (`false` disarms it).
+ */
+export declare const EXTERNAL_EFFECT_FAMILIES: readonly ["inbox_billing_stripe", "mailbox_connection_repair", "egress_vendor_release"];
+export type ExternalEffectFamily = typeof EXTERNAL_EFFECT_FAMILIES[number];
+export type ExternalEffectArmingState = "armed" | "disarmed";
+/** The checked-in declaration, per deploy tier (see `resolveDeployEnv`). */
+export declare const EXTERNAL_EFFECT_ARMING: Readonly<Record<ExternalEffectFamily, Readonly<Record<DeployTier, ExternalEffectArmingState>>>>;
+export type ExternalEffectArming = {
+    family: ExternalEffectFamily;
+    armed: boolean;
+    declared: ExternalEffectArmingState;
+    /** `declaration` = the table above; `env` = the family's kill switch disarmed it. */
+    source: "declaration" | "env";
+    tier: DeployTier;
+    deploy_env: string;
+    production_data: boolean;
+};
+export declare function resolveExternalEffectArming(family: ExternalEffectFamily, env?: NodeJS.ProcessEnv): ExternalEffectArming;
+/** The readback: every family's effective gate for this process. */
+export declare function describeExternalEffectArming(env?: NodeJS.ProcessEnv): ExternalEffectArming[];
+/**
+ * Throw before an effect is dispatched when this process is not armed for it.
+ * Production-data environments keep their declared state; the refusal names the
+ * family and environment so a skipped effect is never silent.
+ */
+export declare function assertExternalEffectArmed(family: ExternalEffectFamily, env?: NodeJS.ProcessEnv): ExternalEffectArming;
+/** Live-mode Stripe secret or restricted key. Test keys (`sk_test_`/`rk_test_`) never match. */
+export declare function isLiveStripeKey(key: string | null | undefined): boolean;
+/**
+ * Fail closed when a process that does NOT hold production data is about to write to
+ * Stripe with a LIVE key: that is a dev or local box pointed at real money. The key is
+ * never echoed; only its mode is named.
+ */
+export declare function assertStripeKeyMatchesEnvironment(key: string | null | undefined, env?: NodeJS.ProcessEnv): void;

package/node_modules/@oxygen/shared/dist/external-effect-arming.js

@@ -0,0 +1,90 @@
+import { OxygenError } from "./cli-result.js";
+import { isProductionData, resolveDeployEnv } from "./deploy-env.js";
+/**
+ * Which background EXTERNAL EFFECTS each deployment is armed to dispatch, declared
+ * here per environment rather than implied by whichever credentials a box holds.
+ *
+ * OXP-1.6.190 (classify-A P-05). Three background families write outside OXYGEN with
+ * no human in the loop: the off-session Stripe writes of `inbox_billing_reconcile`,
+ * the Zapmail writes of `mailbox_connection_repair`, and the dedicated-egress vendor
+ * release (IPRoyal `toggle-auto-extend`) of the egress order reconcile and lifecycle.
+ * Before this table their arming was implicit: present credentials meant armed.
+ *
+ * Chosen design (coordinator, 2026-10-07, "option 2"): every CURRENT default is kept, so
+ * dev billing reconcile, Zapmail repair and egress releases keep working for dev flows,
+ * but the state is now explicit, reviewable and read back, and two mismatches fail
+ * closed outside production-data environments: a LIVE Stripe key, and a vendor release
+ * whose family is not armed here. Production stays armed; nothing here changes a
+ * production default or touches a secret. A default-off posture outside production
+ * was considered and not chosen, because other dev workflows depend on these effects.
+ *
+ * Changing an entry is a reviewed code change. `OXYGEN_WORKER_MAILBOX_CONNECTION_REPAIR`
+ * remains the existing runtime kill switch for the repair family (`false` disarms it).
+ */
+export const EXTERNAL_EFFECT_FAMILIES = [
+    "inbox_billing_stripe",
+    "mailbox_connection_repair",
+    "egress_vendor_release",
+];
+/** The checked-in declaration, per deploy tier (see `resolveDeployEnv`). */
+export const EXTERNAL_EFFECT_ARMING = {
+    inbox_billing_stripe: { prod: "armed", shadow: "armed", dev: "armed", local: "armed" },
+    mailbox_connection_repair: { prod: "armed", shadow: "armed", dev: "armed", local: "armed" },
+    egress_vendor_release: { prod: "armed", shadow: "armed", dev: "armed", local: "armed" },
+};
+/** Per-family runtime kill switch: an explicit false disarms, nothing arms beyond the declaration. */
+const KILL_SWITCH_ENV = {
+    mailbox_connection_repair: "OXYGEN_WORKER_MAILBOX_CONNECTION_REPAIR",
+};
+function killSwitchDisarms(family, env) {
+    const name = KILL_SWITCH_ENV[family];
+    const raw = name ? env[name]?.trim().toLowerCase() : undefined;
+    // Exactly the worker's readBooleanEnv falsy set, so the readback and the gate agree.
+    return raw === "false" || raw === "0" || raw === "no";
+}
+export function resolveExternalEffectArming(family, env = process.env) {
+    const deploy = resolveDeployEnv(env);
+    const declared = EXTERNAL_EFFECT_ARMING[family][deploy.tier];
+    const disarmedByEnv = declared === "armed" && killSwitchDisarms(family, env);
+    return {
+        family,
+        armed: declared === "armed" && !disarmedByEnv,
+        declared,
+        source: disarmedByEnv ? "env" : "declaration",
+        tier: deploy.tier,
+        deploy_env: deploy.label,
+        production_data: isProductionData(env),
+    };
+}
+/** The readback: every family's effective gate for this process. */
+export function describeExternalEffectArming(env = process.env) {
+    return EXTERNAL_EFFECT_FAMILIES.map((family) => resolveExternalEffectArming(family, env));
+}
+/**
+ * Throw before an effect is dispatched when this process is not armed for it.
+ * Production-data environments keep their declared state; the refusal names the
+ * family and environment so a skipped effect is never silent.
+ */
+export function assertExternalEffectArmed(family, env = process.env) {
+    const arming = resolveExternalEffectArming(family, env);
+    if (!arming.armed) {
+        throw new OxygenError("external_effect_not_armed", `${family} is not armed in ${arming.deploy_env} (${arming.source === "env" ? "disarmed by its kill switch" : "declared disarmed"}), so this external effect was not dispatched.`, { details: { family, deploy_env: arming.deploy_env, source: arming.source }, exitCode: 1 });
+    }
+    return arming;
+}
+/** Live-mode Stripe secret or restricted key. Test keys (`sk_test_`/`rk_test_`) never match. */
+export function isLiveStripeKey(key) {
+    const value = key?.trim() ?? "";
+    return value.startsWith("sk_live_") || value.startsWith("rk_live_");
+}
+/**
+ * Fail closed when a process that does NOT hold production data is about to write to
+ * Stripe with a LIVE key: that is a dev or local box pointed at real money. The key is
+ * never echoed; only its mode is named.
+ */
+export function assertStripeKeyMatchesEnvironment(key, env = process.env) {
+    if (!isLiveStripeKey(key) || isProductionData(env))
+        return;
+    const deploy = resolveDeployEnv(env);
+    throw new OxygenError("external_effect_environment_mismatch", `A live-mode Stripe key is configured in ${deploy.label}, which does not hold production data; refusing the Stripe write. Use a test-mode key outside production.`, { details: { family: "inbox_billing_stripe", deploy_env: deploy.label, key_mode: "live" }, exitCode: 1 });
+}