@oxygen-agent/cli 1.1011.1091 → 1.1013.15

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

@@ -0,0 +1,342 @@
+import { OxygenError } from "./cli-result.js";
+import { resolveDeployEnv } from "./deploy-env.js";
+export const GEO_ENGINES = [
+    "chatgpt",
+    "gemini",
+    "google-ai-mode",
+    "google-ai-overview",
+    "perplexity",
+    "copilot",
+    "claude",
+];
+/** Binary exports carry this metadata to web, CLI and MCP, even for CSV/PDF. */
+export function readGeoExportPagination(headers) {
+    const value = headers.get("x-oxygen-export-pagination");
+    if (!value || value.length > 2048)
+        return undefined;
+    try {
+        const data = JSON.parse(value);
+        if (!Number.isSafeInteger(data.returned) || data.returned < 0 ||
+            !Number.isSafeInteger(data.total) || data.total < data.returned ||
+            !(data.next_cursor === null || typeof data.next_cursor === "string" && /^[0-9a-f-]{36}$/i.test(data.next_cursor)) ||
+            data.summary_scope !== "all_filtered_answers")
+            return undefined;
+        return data;
+    }
+    catch {
+        return undefined;
+    }
+}
+export const GEO_PILOT_CAP_MICROS = 10_000_000;
+/** The initial release gate is independent of NODE_ENV and protects shadow data. */
+export function isGeoEnabled(env = process.env) {
+    return resolveDeployEnv(env).tier === "dev";
+}
+export function assertGeoEnabled(env = process.env) {
+    if (!isGeoEnabled(env))
+        throw new OxygenError("geo_unavailable", "GEO / AEO is available to staff on dev while it is being tested.", { exitCode: 1 });
+}
+export function geoDomain(value) {
+    try {
+        const url = new URL(value.includes("://") ? value : `https://${value}`);
+        if (!["http:", "https:"].includes(url.protocol) ||
+            url.username ||
+            url.password)
+            return null;
+        return url.hostname
+            .toLowerCase()
+            .replace(/^www\./, "")
+            .replace(/\.$/, "");
+    }
+    catch {
+        return null;
+    }
+}
+function matchedTerm(text, term) {
+    const escaped = term.trim().replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    if (!escaped)
+        return -1;
+    const match = new RegExp(`(^|[^\\p{L}\\p{N}])(${escaped})(?=$|[^\\p{L}\\p{N}])`, "iu").exec(text);
+    return match ? match.index + (match[1]?.length ?? 0) : -1;
+}
+export function analyzeGeoAnswer(text, brand, competitors, urls) {
+    const prose = text.replace(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g, (_link, label, url) => {
+        // A domain-only citation label is source attribution, not a recommendation.
+        return label.trim().includes(".") &&
+            geoDomain(label.trim()) === geoDomain(url)
+            ? ""
+            : label;
+    });
+    const subjects = [brand, ...competitors];
+    const mentions = subjects.map((subject) => {
+        const indices = [subject.name, ...subject.aliases, ...subject.domains]
+            .map((term) => matchedTerm(prose, term))
+            .filter((index) => index >= 0);
+        const first = indices.length ? Math.min(...indices) : -1;
+        let rank = null;
+        for (const line of prose.split("\n")) {
+            const list = /^\s*(\d{1,2})[.)]\s+(.+)$/.exec(line);
+            if (list &&
+                [subject.name, ...subject.aliases].some((term) => matchedTerm(list[2] ?? "", term) >= 0)) {
+                rank = Number(list[1]);
+                break;
+            }
+        }
+        return {
+            brand: subject.name,
+            present: first >= 0,
+            evidence: first >= 0 ? prose.slice(Math.max(0, first - 60), first + 180) : null,
+            recommendation_rank: rank,
+        };
+    });
+    const citations = [];
+    const seen = new Set();
+    for (const raw of urls) {
+        try {
+            const url = new URL(raw);
+            const domain = geoDomain(raw);
+            if (!domain)
+                continue;
+            url.hash = "";
+            for (const key of [...url.searchParams.keys()])
+                if (/^(utm_|fbclid|gclid)/i.test(key))
+                    url.searchParams.delete(key);
+            const normalized = url.href;
+            if (seen.has(normalized))
+                continue;
+            seen.add(normalized);
+            const belongs = (subject) => subject.domains.some((d) => {
+                const owned = geoDomain(d);
+                return owned && (domain === owned || domain.endsWith(`.${owned}`));
+            });
+            const category = belongs(brand)
+                ? "owned"
+                : competitors.some(belongs)
+                    ? "competitor"
+                    : /(^|\.)(reddit\.com|linkedin\.com|youtube\.com|quora\.com)$/.test(domain)
+                        ? "community"
+                        : /(^|\.)(g2\.com|capterra\.com|trustpilot\.com)$/.test(domain)
+                            ? "review"
+                            : "other";
+            citations.push({
+                url: normalized,
+                domain,
+                position: citations.length + 1,
+                category,
+            });
+        }
+        catch {
+            /* An invalid provider URL is retained in raw evidence, not made clickable. */
+        }
+    }
+    return {
+        mentions,
+        citations,
+        measurement: structuredClone({ brand, competitors }),
+    };
+}
+/** Exact capture-time configuration, canonicalized for matched comparisons. */
+export function geoMeasurementKey(answer) {
+    if (!answer.measurement)
+        return "unknown";
+    const subject = (value) => ({
+        name: value.name.trim().toLowerCase(),
+        aliases: [
+            ...new Set(value.aliases.map((a) => a.trim().toLowerCase())),
+        ].sort(),
+        domains: [
+            ...new Set(value.domains.map((d) => geoDomain(d) ?? d.toLowerCase())),
+        ].sort(),
+    });
+    return JSON.stringify({
+        brand: subject(answer.measurement.brand),
+        competitors: answer.measurement.competitors
+            .map(subject)
+            .sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b))),
+    });
+}
+/** A scraper's question heading is not answer prose, including old stored captures. */
+export function isGeoPromptEcho(text, prompt) {
+    const normalized = (value) => value.replace(/^[#>\s]+/gm, "").replace(/[*_`]/g, "").replace(/\s+/g, " ").trim().toLowerCase();
+    return Boolean(normalized(prompt)) && normalized(text) === normalized(prompt);
+}
+export function isGeoControlledAnswer(answer) {
+    return answer.collection === "consumer" && answer.outcome === "answer" &&
+        typeof answer.text === "string" && Boolean(answer.text.trim()) &&
+        !isGeoPromptEcho(answer.text, answer.prompt ?? "");
+}
+export function summarizeGeoAnswers(answers, brand, failedSamples = 0) {
+    const samples = answers.filter(isGeoControlledAnswer);
+    const measurementContexts = new Set(samples.map(geoMeasurementKey)).size;
+    const comparable = measurementContexts <= 1;
+    const brands = new Map();
+    for (const sample of samples) {
+        const presentBrands = new Set(sample.mentions
+            .filter((m) => m.present)
+            .map((m) => m.brand === sample.measurement?.brand.name ? brand : m.brand));
+        for (const name of presentBrands)
+            brands.set(name, (brands.get(name) ?? 0) + 1);
+    }
+    const totalMentions = [...brands.values()].reduce((a, b) => a + b, 0);
+    const present = brands.get(brand) ?? 0;
+    const cited = samples.filter((a) => a.citations.some((c) => c.category === "owned")).length;
+    const sources = new Map();
+    for (const answer of samples)
+        for (const citation of answer.citations) {
+            const source = sources.get(citation.domain) ?? {
+                domain: citation.domain,
+                count: 0,
+                category: citation.category,
+                urls: [],
+            };
+            source.count++;
+            if (!source.urls.includes(citation.url))
+                source.urls.push(citation.url);
+            sources.set(citation.domain, source);
+        }
+    return {
+        successful_samples: samples.length,
+        measurement_contexts: measurementContexts,
+        failed_samples: failedSamples,
+        invalid_answer_samples: answers.filter((a) => a.collection === "consumer" && a.outcome === "answer" && !isGeoControlledAnswer(a)).length,
+        imported_samples: answers.filter((a) => a.collection === "import").length,
+        no_overview_samples: answers.filter((a) => a.outcome === "no_overview")
+            .length,
+        mentioned_samples: present,
+        visibility: comparable && samples.length ? present / samples.length : null,
+        cited_samples: cited,
+        citation_coverage: comparable && samples.length ? cited / samples.length : null,
+        share_of_voice: comparable && totalMentions ? present / totalMentions : null,
+        competitors: [...brands].map(([name, count]) => ({
+            name,
+            mentioned_samples: count,
+            share_of_voice: comparable && totalMentions ? count / totalMentions : null,
+        })),
+        sources: [...sources.values()].sort((a, b) => b.count - a.count),
+    };
+}
+/** No fetching or execution: customer wording and citations are evidence only. */
+export function parseGeoTranscript(input, redactions = []) {
+    if (new TextEncoder().encode(input).byteLength > 1_000_000)
+        throw new OxygenError("geo_import_too_large", "Import one conversation of at most 1 MB.", { exitCode: 2 });
+    const redact = (value) => redactions.reduce((text, term) => term.trim() ? text.split(term).join("[redacted]") : text, value);
+    const messages = [];
+    let parsed;
+    try {
+        parsed = JSON.parse(input);
+    }
+    catch {
+        parsed = null;
+    }
+    if (Array.isArray(parsed) && parsed.length > 1)
+        throw new OxygenError("geo_conversation_required", "Import one selected conversation instead of a full account export.", { exitCode: 2 });
+    const root = Array.isArray(parsed) ? parsed[0] : parsed;
+    if (root && typeof root === "object") {
+        const data = root;
+        if (data.mapping && typeof data.mapping === "object") {
+            const mapping = data.mapping;
+            const branch = [];
+            let node = typeof data.current_node === "string" ? data.current_node : null;
+            if (!node || !Object.hasOwn(mapping, node))
+                throw new OxygenError("geo_conversation_branch_required", "Import a conversation export with a valid selected branch.", { exitCode: 2 });
+            const visited = new Set();
+            while (node) {
+                if (!Object.hasOwn(mapping, node) || visited.has(node) || !mapping[node] || typeof mapping[node] !== "object")
+                    throw new OxygenError("geo_conversation_branch_invalid", "The selected conversation branch is incomplete or invalid.", { exitCode: 2 });
+                visited.add(node);
+                const entry = mapping[node];
+                branch.unshift(entry);
+                node = entry.parent ?? null;
+            }
+            for (const entry of branch) {
+                const role = entry.message?.author?.role;
+                if (role === "user" || role === "assistant")
+                    messages.push({
+                        role,
+                        text: (entry.message?.content?.parts ?? [])
+                            .filter((x) => typeof x === "string")
+                            .join("\n"),
+                    });
+            }
+            if (!messages.length)
+                throw new OxygenError("geo_conversation_branch_invalid", "The selected conversation branch contains no readable messages.", { exitCode: 2 });
+        }
+        else {
+            const rows = data.chat_messages ?? data.messages;
+            if (Array.isArray(rows))
+                for (const row of rows) {
+                    if (!row || typeof row !== "object")
+                        continue;
+                    const role = row.sender === "human" || row.role === "user"
+                        ? "user"
+                        : row.sender === "assistant" || row.role === "assistant"
+                            ? "assistant"
+                            : null;
+                    if (role)
+                        messages.push({
+                            role,
+                            text: typeof row.text === "string"
+                                ? row.text
+                                : typeof row.content === "string"
+                                    ? row.content
+                                    : Array.isArray(row.content)
+                                        ? row.content
+                                            .map((c) => c.text ?? "")
+                                            .join("\n")
+                                        : "",
+                        });
+                }
+        }
+    }
+    if (!messages.length)
+        messages.push({ role: "user", text: input });
+    for (const message of messages)
+        message.text = redact(message.text);
+    // Retain only the selected conversation branch and reviewed text. Hidden JSON
+    // metadata, sibling chats, attachments and discarded branches are never saved.
+    return {
+        messages,
+        prompts: messages
+            .filter((m) => m.role === "user")
+            .map((m) => m.text)
+            .filter(Boolean),
+        sources: [
+            ...new Set(messages.flatMap((m) => m.text.match(/https?:\/\/[^\s<>"\])]+/g) ?? [])),
+        ],
+        redacted_text: messages.map((m) => `${m.role}: ${m.text}`).join("\n\n"),
+    };
+}
+/** Compare only common collection cohorts; imports and missing AIOs are excluded. */
+export function compareGeoExperiment(before, after, brand) {
+    const eligible = (answers) => answers.filter((a) => isGeoControlledAnswer(a) &&
+        a.measurement !== undefined);
+    const key = (a) => JSON.stringify([
+        a.prompt_id,
+        a.prompt_revision ?? null,
+        a.engine,
+        a.provider,
+        a.market?.country,
+        a.market?.language,
+        geoMeasurementKey(a),
+    ]);
+    const baseline = eligible(before);
+    const followup = eligible(after);
+    const baselineKeys = new Set(baseline.map(key));
+    const followupKeys = new Set(followup.map(key));
+    const common = [...baselineKeys].filter((k) => followupKeys.has(k));
+    const matchedBefore = baseline.filter((a) => common.includes(key(a)));
+    const matchedAfter = followup.filter((a) => common.includes(key(a)));
+    return {
+        before: summarizeGeoAnswers(matchedBefore, brand),
+        after: summarizeGeoAnswers(matchedAfter, brand),
+        comparable_cohorts: common.length,
+        excluded_before: before.length - matchedBefore.length,
+        excluded_after: after.length - matchedAfter.length,
+        cohorts: common.map((k) => ({
+            cohort: JSON.parse(k),
+            before: summarizeGeoAnswers(baseline.filter((a) => key(a) === k), brand),
+            after: summarizeGeoAnswers(followup.filter((a) => key(a) === k), brand),
+        })),
+        interpretation: "Observed association within matching prompt revision, engine, provider, locale and capture-time brand definitions. Unknown definitions are excluded. Compare individual cohorts; changing their sample mix can change aggregate rates. This does not establish causation.",
+    };
+}

package/node_modules/@oxygen/shared/dist/linkedin-countries.d.ts

@@ -20,6 +20,15 @@
  */
 /** Canonical LinkedIn country name for each ISO 3166-1 alpha-2 code, A→Z by name. */
 export declare const LINKEDIN_COUNTRIES: ReadonlyArray<readonly [code: string, name: string]>;
+/**
+ * Spellings a provider may return that are not the canonical name. Lowercased
+ * keys; the resolver lowercases its input before the lookup. Kept deliberately
+ * short — it covers the CLDR spellings this table overrides (so a payload
+ * carrying the un-overridden name still resolves), the common colloquial forms,
+ * and the alpha-3 codes, because Up2Data's `hq.country` is not contractually
+ * alpha-2 and has been observed carrying a display name.
+ */
+export declare const COUNTRY_ALIASES: Readonly<Record<string, string>>;
 /**
  * Resolve a provider value — an alpha-2 code, a canonical name, or a known
  * alias — to its canonical LinkedIn country name.

package/node_modules/@oxygen/shared/dist/linkedin-countries.js

@@ -279,7 +279,7 @@ export const LINKEDIN_COUNTRIES = [
  * and the alpha-3 codes, because Up2Data's `hq.country` is not contractually
  * alpha-2 and has been observed carrying a display name.
  */
-const COUNTRY_ALIASES = {
+export const COUNTRY_ALIASES = {
     // CLDR spellings this table overrides.
     "hong kong sar china": "HK",
     "macao sar china": "MO",

package/node_modules/@oxygen/shared/dist/managed-email-branding.d.ts

@@ -0,0 +1,15 @@
+/** Public vocabulary for OXYGEN-managed email services. Backend ids stay in storage. */
+export type ManagedEmailProduct = "warmup" | "placement";
+export declare const OXYGEN_WARMUP_PROVIDER = "oxygen_warmup";
+export declare const OXYGEN_PLACEMENT_PROVIDER = "oxygen_placement";
+export declare function managedEmailProviderInput(value: unknown, product: ManagedEmailProduct): unknown;
+export declare function isManagedWarmupProvider(value: unknown): boolean;
+export declare function isManagedPlacementProvider(value: unknown): boolean;
+export declare function managedEmailMessage(value: string, product?: ManagedEmailProduct): string;
+/**
+ * Project only service identifiers and copy. Preserve URLs, ids, hashes, dates,
+ * customer-authored subject/body/configuration, and provider evidence verbatim.
+ * The caller must choose a managed email surface; do not apply to generic BYOK tools.
+ */
+export declare function publicManagedEmail<T>(value: T, product?: ManagedEmailProduct): T;
+export declare function publicManagedEmailCommand<T>(command: string, value: T): T;

package/node_modules/@oxygen/shared/dist/managed-email-branding.js

@@ -0,0 +1,81 @@
+export const OXYGEN_WARMUP_PROVIDER = "oxygen_warmup";
+export const OXYGEN_PLACEMENT_PROVIDER = "oxygen_placement";
+export function managedEmailProviderInput(value, product) {
+    const publicId = product === "warmup" ? OXYGEN_WARMUP_PROVIDER : OXYGEN_PLACEMENT_PROVIDER;
+    return typeof value === "string" && value.trim().toLowerCase() === publicId ? "sendkit" : value;
+}
+export function isManagedWarmupProvider(value) {
+    return value === "sendkit" || value === OXYGEN_WARMUP_PROVIDER;
+}
+export function isManagedPlacementProvider(value) {
+    return value === "sendkit" || value === OXYGEN_PLACEMENT_PROVIDER;
+}
+// These are service-owned fields, never arbitrary customer content or opaque receipts.
+const IDENTIFIER_FIELDS = new Set([
+    "provider", "active_provider", "warmup_provider", "warmupProvider", "warmupRail",
+    "action", "code", "failure_code", "error_code", "credential_source", "credentialSource",
+    "method", "handoff", "reason_code", "kind", "type", "source",
+]);
+const COPY_FIELDS = new Set([
+    "message", "note", "reason", "description", "hint", "transport_hint", "next_step",
+    "next_action", "nextAction", "label", "title", "instruction", "instructions", "warnings",
+    "recommendation", "recommendations", "limitations", "next_external_write", "price_note",
+    "error", "errors", "summary", "blocker", "blockers", "detail", "details_text", "provider_label",
+]);
+export function managedEmailMessage(value, product = "warmup") {
+    const label = product === "warmup" ? "OXYGEN Warm-up" : "OXYGEN placement evaluation";
+    if (product === "placement") {
+        value = value.replace(/(?:SendKit|OXYGEN placement evaluation) does not document whether inbox, spam, and missing summary values are counts or percentages; Oxygen preserves the values without conversion\./gi, "Summary units are unverified (counts or percentages); values are shown as recorded, without conversion.");
+    }
+    return value.replace(/SendKit(?:'s)?\s+warm-?up/gi, label).replace(/SendKit/gi, label);
+}
+/**
+ * Project only service identifiers and copy. Preserve URLs, ids, hashes, dates,
+ * customer-authored subject/body/configuration, and provider evidence verbatim.
+ * The caller must choose a managed email surface; do not apply to generic BYOK tools.
+ */
+export function publicManagedEmail(value, product = "warmup") {
+    const opaqueFields = new Set(["plan_hash", "id", "subject", "body", "body_text", "body_html", "config", "warmupConfig", "rampConfig", "email_address", "emailAddress", "tags", "displayName", "signatureHtml"]);
+    function project(entry, field = "", context = product) {
+        const publicId = context === "warmup" ? OXYGEN_WARMUP_PROVIDER : OXYGEN_PLACEMENT_PROVIDER;
+        if (opaqueFields.has(field))
+            return entry;
+        if (typeof entry === "string") {
+            if (field === "source_id" || field === "sourceId") {
+                return entry.replace(/^warmup:sendkit:/, "warmup:oxygen_warmup:");
+            }
+            if (IDENTIFIER_FIELDS.has(field)) {
+                if (entry.toLowerCase() === "sendkit")
+                    return publicId;
+                return entry.replace(/sendkit_/gi, `${publicId}_`).replace(/_sendkit/gi, `_${publicId}`);
+            }
+            return COPY_FIELDS.has(field) ? managedEmailMessage(entry, context) : entry;
+        }
+        if (Array.isArray(entry))
+            return entry.map((item) => project(item, field, context));
+        if (!entry || typeof entry !== "object" || entry instanceof Date)
+            return entry;
+        const record = entry;
+        // Existing customer-owned bindings stay private; never label their usage managed warmup.
+        const groupKey = record.key && typeof record.key === "object" && !Array.isArray(record.key)
+            ? record.key : null;
+        const privateUsage = (record.provider === "sendkit" || groupKey?.provider === "sendkit") &&
+            (record.type === "byok_usage" || (typeof record.byok_usage_events === "number" && record.byok_usage_events > 0));
+        return Object.fromEntries(Object.entries(record).map(([key, item]) => [
+            { sendkit_google: "oxygen_warmup_google", sendkit_microsoft: "oxygen_warmup_microsoft", sendkit_binding: "oxygen_placement_binding", sendkitBinding: "oxygen_placement_binding" }[key] ?? key,
+            privateUsage && key === "provider" ? "private_integration"
+                : privateUsage && key === "key" ? project({ ...groupKey, provider: "private_integration" }, key, context)
+                    : privateUsage && key === "tool_id" ? null
+                        : privateUsage && key === "description" ? "Existing private integration usage."
+                            : project(item, key, /^warmup/i.test(key) ? "warmup" : /^placement/i.test(key) ? "placement" : context),
+        ]));
+    }
+    return project(value);
+}
+export function publicManagedEmailCommand(command, value) {
+    if (/^(mailboxes|managed-inboxes|billing)(?: |$)/.test(command))
+        return publicManagedEmail(value);
+    if (/^deliverability(?: |$)/.test(command))
+        return publicManagedEmail(value, "placement");
+    return value;
+}

package/node_modules/@oxygen/shared/dist/onboarding-first-leads.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The table the onboarding consultant saves its ranked first leads into (founder, current
+ * chat, 2026-10-09), so a first session leaves a durable record the user can open, enrich
+ * and enroll instead of a chat transcript. The onboarding read (web) and the ChatGPT
+ * connector's onboarding hint (MCP) both build it from here; the served onboarding skill
+ * shows the same shape, and `apps/web/src/lib/agent-skills.test.ts` holds it to this one.
+ *
+ * The upsert refuses a row without its key, so every row carries `lead_key`: the LinkedIn
+ * profile URL, or the email when there is no profile. The key also keeps a re-run from
+ * adding anyone twice. Creating the table and writing its rows cost 0 credits.
+ */
+export declare const FIRST_LEADS_TABLE = "First leads";
+export declare const FIRST_LEADS_UPSERT_KEY = "lead_key";
+export type FirstLeadsColumn = {
+    key: string;
+    label: string;
+    dataType: "text";
+};
+export declare const FIRST_LEADS_COLUMNS: readonly FirstLeadsColumn[];

package/node_modules/@oxygen/shared/dist/onboarding-first-leads.js

@@ -0,0 +1,25 @@
+/**
+ * The table the onboarding consultant saves its ranked first leads into (founder, current
+ * chat, 2026-10-09), so a first session leaves a durable record the user can open, enrich
+ * and enroll instead of a chat transcript. The onboarding read (web) and the ChatGPT
+ * connector's onboarding hint (MCP) both build it from here; the served onboarding skill
+ * shows the same shape, and `apps/web/src/lib/agent-skills.test.ts` holds it to this one.
+ *
+ * The upsert refuses a row without its key, so every row carries `lead_key`: the LinkedIn
+ * profile URL, or the email when there is no profile. The key also keeps a re-run from
+ * adding anyone twice. Creating the table and writing its rows cost 0 credits.
+ */
+export const FIRST_LEADS_TABLE = "First leads";
+export const FIRST_LEADS_UPSERT_KEY = "lead_key";
+export const FIRST_LEADS_COLUMNS = [
+    ["name", "Name"],
+    ["title", "Title"],
+    ["company", "Company"],
+    ["linkedin_url", "LinkedIn URL"],
+    ["email", "Email"],
+    [FIRST_LEADS_UPSERT_KEY, "Lead key"],
+    ["why_warm", "Why warm"],
+    ["icp_fit", "ICP fit"],
+    ["next_step", "Next step"],
+    ["draft_message", "Draft message"],
+].map(([key, label]) => ({ key, label, dataType: "text" }));

package/node_modules/@oxygen/shared/dist/otlp-log-sink.d.ts

@@ -60,7 +60,7 @@ export type OtlpLogSinkOptions = {
  * `worker.log_shipper.stats` is the Axiom shipper's once-a-minute loss accounting,
  * which by design never reaches Axiom (OXP-1.6.126).
  */
-export declare const OTLP_MONITOR_INFO_EVENTS: readonly ["tenant.migrations.cron.done", "outbound_send.sent", "worker_workflow_cron_overlap_skipped", "worker_workflow_cron_enqueued", "copilot.turn.finished", "worker.queue.heartbeat", "worker.queue.ledger", "worker.queue.redis", "worker.queue.unregistered_kind", "automation_usage.reconcile_completed", "provider_health.cron_completed", "provider_balances.cron_completed", "cost_snapshot.cron_completed", "worker.egress_order_reconcile_sweep", "posthog_canary.round_trip_ok", "web.log_volume", "worker.log_shipper.stats"];
+export declare const OTLP_MONITOR_INFO_EVENTS: readonly ["diagnostics.capture_stored", "diagnostics.invocation_completed", "diagnostics.canary_completed", "diagnostics.digest_completed", "tenant.migrations.cron.done", "outbound_send.sent", "worker_workflow_cron_overlap_skipped", "worker_workflow_cron_enqueued", "copilot.turn.finished", "worker.queue.heartbeat", "worker.queue.ledger", "worker.queue.redis", "worker.queue.unregistered_kind", "automation_usage.reconcile_completed", "provider_health.cron_completed", "provider_balances.cron_completed", "cost_snapshot.cron_completed", "worker.egress_order_reconcile_sweep", "posthog_canary.round_trip_ok", "web.log_volume", "worker.log_shipper.stats"];
 export type OtlpLogSinkHandle = {
     sink: LogSink;
     flush: () => Promise<void>;

package/node_modules/@oxygen/shared/dist/otlp-log-sink.js

@@ -12,6 +12,10 @@ import { telemetryEndpointForLog } from "./telemetry-export-observer.js";
  * which by design never reaches Axiom (OXP-1.6.126).
  */
 export const OTLP_MONITOR_INFO_EVENTS = [
+    "diagnostics.capture_stored",
+    "diagnostics.invocation_completed",
+    "diagnostics.canary_completed",
+    "diagnostics.digest_completed",
     "tenant.migrations.cron.done",
     "outbound_send.sent",
     "worker_workflow_cron_overlap_skipped",

package/node_modules/@oxygen/shared/dist/pricing-sheet.d.ts

@@ -137,11 +137,7 @@ export declare const RESEARCH_DEPTH_MODEL_CREDITS: {
     readonly standard: 4.3;
     readonly deep: 7.6;
 };
-/** The tier whose model each loop depth runs on, whatever tier the column stores. */
-export declare const RESEARCH_DEPTH_MODEL_TIER: {
-    readonly standard: "low";
-    readonly deep: "medium";
-};
+/** The tier whose model each loop depth runs on lives in ./research-depth.ts: a routing fact, not a price. */
 /**
  * The tool half of a standard/deep row. `typical` is the ratified planning shape —
  * standard: 2 serper searches + 2 native page reads; deep: 3 serper searches + 4
@@ -177,18 +173,18 @@ export declare const RESEARCH_DEPTH_TYPICAL_ROW_CREDITS: {
  */
 export { AUTOMATION_STEP_CREDITS_REPRICING } from "./repricing.js";
 /**
- * The flat mailbox line of a managed Google inbox after the 2026-09 repricing
- * (400, decision 3.1, slice S32). Its 100-credit mailbox connection, warm-up
- * included, bills beside it: 500 all-in. The all-in price waits for the S07
- * switch, so a surface that quotes it uses `managedInboxAllInCredits()` from
- * `@oxygen/shared/repricing`, resolved on the server. Kept as an object
- * (min/typical/max all equal) so callers that destructure any field need no
- * shape change.
+ * The flat mailbox line of a managed Google or Microsoft 365 inbox: 300 (founder,
+ * 2026-10-07; repricing decision 3.1 had set 400 for Google alone). Its 100-credit
+ * mailbox connection, warm-up included, bills beside it: 400 all-in, which
+ * `managedInboxAllInCredits()` from `@oxygen/shared/repricing` quotes. The price
+ * charged is the pricing book's row; this is its committed default. Kept as an
+ * object (min/typical/max all equal) so callers that destructure any field need
+ * no shape change.
  */
 export declare const MANAGED_INBOX_CREDITS_PER_MONTH: {
-    readonly min: 400;
-    readonly typical: 400;
-    readonly max: 400;
+    readonly min: 300;
+    readonly typical: 300;
+    readonly max: 300;
 };
 /**
  * VOICE (the call channel). One price per connected minute, 5 credits ($0.05),
@@ -221,17 +217,17 @@ export declare const SENDING_DOMAIN_CREDITS_PER_YEAR_TYPICAL = 1250;
  * THE ALLOWANCE IS LOAD-BEARING, not a perk. Placement COGS is per TEST
  * ($0.1327 on EmailGuard's Agency plan), not per inbox, so an unbounded seat
  * inverts its own margin: at $1.00/inbox-month the EIGHTH test in a cycle was
- * already sold at a loss. Two included tests cost $0.265 against $1.35 of
- * revenue at the 2026-09 price, and everything past them bills
+ * already sold at a loss. Two included tests cost $0.265 against $1.00 of
+ * revenue at today's price, and everything past them bills
  * PLACEMENT_TEST_OVERAGE_CREDITS. Orgs on their own EmailGuard key (BYOK) pay 0.
  *
- * These two prices are the RATIFIED list prices from the 2026-09 repricing
- * (135 and 66, slice S30). The rises wait for the S07 effective-date switch, so
- * a surface that quotes or bills uses `deliverabilitySeatCredits()` and
- * `placementTestCredits()` from `@oxygen/shared/repricing` (100 and 16.6 until
- * the switch's instant), never these constants.
+ * Monitoring is 100 credits per inbox-month (founder, 2026-10-07; the 2026-09
+ * repricing had set 135). The extra test is the RATIFIED 66 (slice S30), whose rise
+ * waits for the S07 effective-date switch, so a surface that quotes or bills uses
+ * `deliverabilitySeatCredits()` and `placementTestCredits()` from
+ * `@oxygen/shared/repricing` (16.6 for the test until the switch's instant).
  */
-export declare const DELIVERABILITY_SEAT_CREDITS_PER_MONTH = 135;
+export declare const DELIVERABILITY_SEAT_CREDITS_PER_MONTH = 100;
 export declare const DELIVERABILITY_INCLUDED_TESTS_PER_INBOX = 2;
 export declare const PLACEMENT_TEST_OVERAGE_CREDITS = 66;
 /**
@@ -262,7 +258,7 @@ export declare const LINKEDIN_TYPICAL_ACTIONS_CREDITS_PER_MONTH = 0;
  * Seeded at the 2026-09 repricing's price (3,000, decision 2.3); resolve the
  * price in force with repricedChargeCredits.
  */
-export declare const WHATSAPP_ACCOUNT_CREDITS_PER_MONTH = 3000;
+export declare const WHATSAPP_ACCOUNT_CREDITS_PER_MONTH = 3400;
 /**
  * X accounts: monthly credit reservation per connected account (2026-09
  * repricing, decision 2.2). Like the LinkedIn and WhatsApp constants above this