@oxygen-agent/cli 1.1012.2 → 1.1013.15

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

@@ -0,0 +1,253 @@
+import { randomUUID } from "node:crypto";
+import { credentialBearingOperation } from "./diagnostic-credentials.js";
+import { redactSecretsInString } from "./redaction.js";
+/** Internal diagnostic evidence, distinct from customer run state and usage counts. */
+export const DIAGNOSTIC_VERSION = 1;
+export const DIAGNOSTIC_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+export const DIAGNOSTIC_INVOCATION_HEADER = "X-Oxygen-Invocation-Id";
+export const DIAGNOSTIC_UPLOAD_CHUNK_BYTES = 1024 * 1024;
+export const DIAGNOSTIC_MAX_BYTES = 512 * 1024 * 1024;
+// Total spool capacity is separate from the bounded JSON materialization of one
+// record. Larger contents explicitly become partial evidence, never a full claim.
+export const DIAGNOSTIC_RECORD_MAX_BYTES = 16 * 1024 * 1024;
+export const DIAGNOSTIC_UPLOAD_MAX_CHUNKS = 17; // Includes gzip/envelope overhead.
+export function diagnosticId(value) {
+    return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value) ? value.toLowerCase() : null;
+}
+export function diagnosticOutcome(ok, status, code) {
+    if (ok)
+        return "ok";
+    if (code && /^(network_|.*timeout$)/.test(code))
+        return "network_error";
+    if (code && /^(cancelled|aborted|interrupted)$/.test(code))
+        return "cancelled";
+    if (status === 401 || status === 403 || status === 402 || status === 409 || status === 429
+        || (code && /approval|budget|credit|quota|rate_limit|permission|forbidden|not_logged_in|unauthorized|update_required|read_only/.test(code)))
+        return "refused";
+    if ((status && status >= 400 && status < 500) || (code && /invalid|missing|unknown_(command|option|tool)|not_found|commander\./.test(code)))
+        return "invalid_input";
+    return "platform_error";
+}
+export function createDiagnosticRecord(input) {
+    const id = diagnosticId(input.id) ?? randomUUID();
+    return {
+        version: DIAGNOSTIC_VERSION, id, invocation_id: diagnosticId(input.invocation_id) ?? id,
+        parent_id: input.parent_id ?? null, layer: input.layer ?? "invocation", surface: input.surface,
+        operation: input.operation, started_at: input.started_at ?? new Date().toISOString(),
+        ended_at: input.ended_at ?? null, outcome: input.outcome ?? "pending", error_code: input.error_code ?? null,
+        status: input.status ?? null, organization_id: input.organization_id ?? null, user_id: input.user_id ?? null,
+        identity_verified: input.identity_verified ?? false, client_version: input.client_version ?? null,
+        trace_id: input.trace_id ?? null, traceparent: input.traceparent ?? null,
+        capture_state: input.capture_state ?? "complete", input: input.input ?? null, output: input.output ?? null,
+        metadata: input.metadata ?? {},
+    };
+}
+const SECRET_FIELD = /(?:^|_)(?:authorization|cookie|cookies|password|passwd|passphrase|secret|api_key|access_key|private_key|token|otp|security_code|connection_string|ciphertext|dsn|connection_uri|database_url|x_key|signature)(?:$|_)/i;
+function credentialField(key) {
+    return SECRET_FIELD.test(key.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[- .]/g, "_"));
+}
+function binaryField(key) {
+    return /(?:^|_)(?:base64|b64)(?:$|_)/i.test(key.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[- .]/g, "_"));
+}
+function binaryMetadata(value) {
+    return { withheld: "binary", bytes: Buffer.byteLength(value, "base64") };
+}
+export function sanitizeDiagnosticText(value, knownSecrets = []) {
+    // CLI stdout and MCP text often contain serialized JSON rather than objects.
+    // Filter its credential fields without changing the surrounding business text.
+    for (const secret of knownSecrets)
+        if (secret)
+            value = value.split(secret).join("[credential excluded]");
+    // Text blocks may contain serialized tool results, including binary blocks.
+    try {
+        const parsed = JSON.parse(value);
+        if (parsed && typeof parsed === "object") {
+            const sanitized = sanitizeDiagnosticContent(parsed, knownSecrets);
+            if (JSON.stringify(parsed) !== JSON.stringify(sanitized))
+                value = JSON.stringify(sanitized);
+        }
+    }
+    catch { /* preserve ordinary business text */ }
+    value = value.replace(/data:[\w/+.-]+(?:;[\w=.-]+)*;base64,[A-Za-z0-9+/=]+/g, match => JSON.stringify(binaryMetadata(match.slice(match.indexOf(",") + 1))));
+    const redacted = redactSecretsInString(value)
+        .replace(/([?&#][\w.-]*(?:api[_-]?key|token|secret|password|signature|credential|code|auth)[\w.-]*=)[^&#\s"'<>]+/gi, "$1[credential excluded]")
+        .replace(/\b(?:oxy_(?:live|sess|user)_|gh[pousr]_|xox[baprs]-)[A-Za-z0-9_.-]+/g, "[credential excluded]");
+    return redacted.replace(/("(?:[^"\\]|\\.)*"\s*:\s*)("(?:[^"\\]|\\.)*")/g, (match, prefix) => {
+        try {
+            return credentialField(JSON.parse(prefix.slice(0, prefix.lastIndexOf(":"))).trim()) ? `${prefix}"[credential excluded]"` : match;
+        }
+        catch {
+            return match;
+        }
+    });
+}
+/** No business-content, array, string, field-count or depth truncation. */
+export function sanitizeDiagnosticContent(value, knownSecrets = []) {
+    const ancestors = new Set();
+    const walk = (item) => {
+        if (typeof item === "string")
+            return sanitizeDiagnosticText(item, knownSecrets);
+        if (item === null || typeof item === "number" || typeof item === "boolean")
+            return item;
+        if (item === undefined)
+            return null;
+        if (typeof item !== "object")
+            throw new Error("Non-JSON diagnostic value");
+        if (ancestors.has(item))
+            throw new Error("Cyclic diagnostic value");
+        ancestors.add(item);
+        try {
+            if (item instanceof Date)
+                return item.toISOString();
+            if (item instanceof Error)
+                return walk({ name: item.name, message: item.message, stack: item.stack });
+            if (ArrayBuffer.isView(item) || item instanceof ArrayBuffer)
+                return { withheld: "binary", bytes: item.byteLength };
+            if (Array.isArray(item))
+                return item.map(walk);
+            if (("type" in item && (item.type === "image" || item.type === "audio")) && "data" in item && typeof item.data === "string") {
+                return { type: item.type, withheld: "binary", bytes: Buffer.byteLength(item.data, "base64"), ...("mimeType" in item ? { mimeType: item.mimeType } : {}) };
+            }
+            const result = Object.create(null);
+            for (const [key, entry] of Object.entries(item)) {
+                const encoded = typeof entry === "string" && (binaryField(key)
+                    || ((key === "data" || key === "content") && "encoding" in item && item.encoding === "base64")
+                    || (key === "content" && "filename" in item && "content_type" in item)
+                    || (key === "blob" && "uri" in item && typeof item.uri === "string"));
+                result[key] = credentialField(key) ? "[credential excluded]" : encoded ? binaryMetadata(entry) : walk(entry);
+            }
+            return result;
+        }
+        finally {
+            ancestors.delete(item);
+        }
+    };
+    return walk(value);
+}
+export function sanitizeDiagnosticArgv(argv) {
+    let credentialValue = false;
+    let binaryValue = false;
+    return argv.map((argument) => {
+        if (credentialValue) {
+            credentialValue = false;
+            return "[credential excluded]";
+        }
+        if (binaryValue) {
+            binaryValue = false;
+            return JSON.stringify(binaryMetadata(argument));
+        }
+        if (argument.startsWith("--")) {
+            const [flag] = argument.slice(2).split("=");
+            if (credentialField(flag)) {
+                if (argument.includes("="))
+                    return argument.slice(0, argument.indexOf("=") + 1) + "[credential excluded]";
+                credentialValue = true;
+            }
+            else if (binaryField(flag)) {
+                if (argument.includes("="))
+                    return argument.slice(0, argument.indexOf("=") + 1) + JSON.stringify(binaryMetadata(argument.slice(argument.indexOf("=") + 1)));
+                binaryValue = true;
+            }
+        }
+        // JSON-valued arguments need keyed filtering as well as token scanning.
+        if (/^[\[{]/.test(argument)) {
+            try {
+                return JSON.stringify(sanitizeDiagnosticContent(JSON.parse(argument)));
+            }
+            catch { /* ordinary text */ }
+        }
+        return sanitizeDiagnosticText(argument);
+    });
+}
+export function parseDiagnosticRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Invalid diagnostic record");
+    const row = value;
+    if (row.version !== 1 || !diagnosticId(row.id) || !diagnosticId(row.invocation_id)
+        || !["cli", "mcp", "web", "worker"].includes(row.surface)
+        || !["invocation", "api", "worker", "protocol"].includes(row.layer)
+        || !["ok", "invalid_input", "refused", "platform_error", "network_error", "cancelled", "pending"].includes(row.outcome)
+        || !["complete", "partial"].includes(row.capture_state)
+        || typeof row.operation !== "string" || row.operation.length > 512
+        || !Number.isFinite(Date.parse(row.started_at))
+        || (row.ended_at !== null && !Number.isFinite(Date.parse(row.ended_at)))
+        || typeof row.identity_verified !== "boolean"
+        || (row.organization_id !== null && !diagnosticId(row.organization_id))
+        || (row.user_id !== null && typeof row.user_id !== "string")
+        || (row.parent_id !== null && !diagnosticId(row.parent_id))
+        || (row.status !== null && (!Number.isInteger(row.status) || row.status < 0 || row.status > 599))
+        || (row.error_code !== null && (typeof row.error_code !== "string" || row.error_code.length > 512))
+        || !row.metadata || typeof row.metadata !== "object" || Array.isArray(row.metadata))
+        throw new Error("Invalid diagnostic record");
+    return row;
+}
+export function diagnosticSummary(record) {
+    return {
+        diagnostic_id: record.id, invocation_id: record.invocation_id, parent_id: record.parent_id,
+        layer: record.layer, source: record.surface, operation: record.operation, outcome: record.outcome,
+        error_code: record.error_code, status: record.status, capture_state: record.capture_state,
+        identity_verified: record.identity_verified, client_version: record.client_version, trace_id: record.trace_id,
+        duration_ms: record.ended_at ? Math.max(0, Date.parse(record.ended_at) - Date.parse(record.started_at)) : null,
+    };
+}
+export function credentialSafeDiagnostic(record) {
+    const input = record.input;
+    if (Array.isArray(input)) {
+        const members = input.map(member => credentialSafeDiagnostic({ ...record, input: member }));
+        const withheld = (value) => Boolean(value && typeof value === "object" && "withheld" in value && value.withheld === "credential_bearing_operation");
+        return { ...record,
+            input: members.some(member => withheld(member.input)) ? { withheld: "credential_bearing_operation" } : input,
+            output: members.some(member => withheld(member.output)) ? { withheld: "credential_bearing_operation" } : record.output };
+    }
+    const params = input && typeof input === "object" && "params" in input ? input.params : null;
+    const toolName = params && typeof params.name === "string" ? params.name : record.operation;
+    const args = params?.arguments ?? input;
+    const selectedName = ["oxygen_capabilities_read", "oxygen_capabilities_call"].includes(toolName) && args && typeof args === "object" && "tool" in args
+        ? String(args.tool) : toolName;
+    return { ...record, input: credentialBearingOperation(selectedName, "input") ? { withheld: "credential_bearing_operation" } : record.input,
+        output: credentialBearingOperation(selectedName, "output") ? { withheld: "credential_bearing_operation" } : record.output };
+}
+/** Bound the diagnostic branch of a response tee without delaying its consumer. */
+export async function readDiagnosticProtocolText(body) {
+    if (!body)
+        return null;
+    const reader = body.getReader();
+    const chunks = [];
+    let bytes = 0;
+    try {
+        while (true) {
+            const part = await reader.read();
+            if (part.done)
+                return Buffer.concat(chunks, bytes).toString("utf8");
+            bytes += part.value.byteLength;
+            if (bytes > DIAGNOSTIC_RECORD_MAX_BYTES) {
+                void reader.cancel().catch(() => undefined);
+                return null;
+            }
+            chunks.push(part.value);
+        }
+    }
+    catch {
+        return null;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+/** Finite POST SSE is decoded before credential/binary filtering, like JSON. */
+export function parseDiagnosticProtocolBody(text, contentType) {
+    if (text === null)
+        return null;
+    if (contentType?.includes("text/event-stream")) {
+        return text.split(/\r?\n\r?\n/).filter(Boolean).map(event => ({
+            event: event.split(/\r?\n/).find(line => line.startsWith("event:"))?.slice(6).trim() ?? null,
+            data: parseDiagnosticProtocolBody(event.split(/\r?\n/).filter(line => line.startsWith("data:")).map(line => line.slice(5).trimStart()).join("\n")),
+        }));
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}

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

@@ -70,6 +70,14 @@ export type GeoAnswer = {
     prompt_revision?: number;
     topic?: string;
 };
+export type GeoExportPagination = {
+    returned: number;
+    total: number;
+    next_cursor: string | null;
+    summary_scope: "all_filtered_answers";
+};
+/** Binary exports carry this metadata to web, CLI and MCP, even for CSV/PDF. */
+export declare function readGeoExportPagination(headers: Pick<Headers, "get">): GeoExportPagination | undefined;
 export type GeoDocumentKind = "prompt" | "competitor" | "answer" | "evidence" | "opportunity" | "experiment" | "audit";
 export type GeoDocument = {
     id: string;
@@ -96,6 +104,7 @@ export type GeoRunItem = {
     error: string | null;
     attempt: number;
     terminal_before_dispatch?: boolean;
+    submission_rejected?: boolean;
     submission_cost_micros?: number | null;
 };
 export declare const GEO_PILOT_CAP_MICROS = 10000000;
@@ -110,10 +119,14 @@ export declare function analyzeGeoAnswer(text: string, brand: GeoCompetitor, com
 };
 /** Exact capture-time configuration, canonicalized for matched comparisons. */
 export declare function geoMeasurementKey(answer: Pick<GeoAnswer, "measurement">): string;
+/** A scraper's question heading is not answer prose, including old stored captures. */
+export declare function isGeoPromptEcho(text: string, prompt: string): boolean;
+export declare function isGeoControlledAnswer(answer: GeoAnswer): boolean;
 export declare function summarizeGeoAnswers(answers: GeoAnswer[], brand: string, failedSamples?: number): {
     successful_samples: number;
     measurement_contexts: number;
     failed_samples: number;
+    invalid_answer_samples: number;
     imported_samples: number;
     no_overview_samples: number;
     mentioned_samples: number;
@@ -149,6 +162,7 @@ export declare function compareGeoExperiment(before: GeoAnswer[], after: GeoAnsw
         successful_samples: number;
         measurement_contexts: number;
         failed_samples: number;
+        invalid_answer_samples: number;
         imported_samples: number;
         no_overview_samples: number;
         mentioned_samples: number;
@@ -172,6 +186,7 @@ export declare function compareGeoExperiment(before: GeoAnswer[], after: GeoAnsw
         successful_samples: number;
         measurement_contexts: number;
         failed_samples: number;
+        invalid_answer_samples: number;
         imported_samples: number;
         no_overview_samples: number;
         mentioned_samples: number;
@@ -200,6 +215,7 @@ export declare function compareGeoExperiment(before: GeoAnswer[], after: GeoAnsw
             successful_samples: number;
             measurement_contexts: number;
             failed_samples: number;
+            invalid_answer_samples: number;
             imported_samples: number;
             no_overview_samples: number;
             mentioned_samples: number;
@@ -223,6 +239,7 @@ export declare function compareGeoExperiment(before: GeoAnswer[], after: GeoAnsw
             successful_samples: number;
             measurement_contexts: number;
             failed_samples: number;
+            invalid_answer_samples: number;
             imported_samples: number;
             no_overview_samples: number;
             mentioned_samples: number;

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

@@ -9,6 +9,24 @@ export const GEO_ENGINES = [
     "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) {
@@ -137,8 +155,18 @@ export function geoMeasurementKey(answer) {
             .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((a) => a.collection === "consumer" && a.outcome === "answer");
+    const samples = answers.filter(isGeoControlledAnswer);
     const measurementContexts = new Set(samples.map(geoMeasurementKey)).size;
     const comparable = measurementContexts <= 1;
     const brands = new Map();
@@ -170,6 +198,7 @@ export function summarizeGeoAnswers(answers, brand, failedSamples = 0) {
         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,
@@ -279,8 +308,7 @@ export function parseGeoTranscript(input, redactions = []) {
 }
 /** Compare only common collection cohorts; imports and missing AIOs are excluded. */
 export function compareGeoExperiment(before, after, brand) {
-    const eligible = (answers) => answers.filter((a) => a.collection === "consumer" &&
-        a.outcome === "answer" &&
+    const eligible = (answers) => answers.filter((a) => isGeoControlledAnswer(a) &&
         a.measurement !== undefined);
     const key = (a) => JSON.stringify([
         a.prompt_id,

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/product-analytics-events.d.ts

@@ -15,6 +15,8 @@
  * set, so adding one is a deliberate edit there too.
  */
 export declare const PRODUCT_EVENTS: {
+    /** Internal diagnostic receipt, never counted as an additional customer action. */
+    readonly DIAGNOSTIC_CAPTURE: "diagnostic_capture";
     /** Acquisition. */
     readonly USER_SIGNED_UP: "user_signed_up";
     readonly WORKSPACE_CREATED: "workspace_created";

package/node_modules/@oxygen/shared/dist/product-analytics-events.js

@@ -15,6 +15,8 @@
  * set, so adding one is a deliberate edit there too.
  */
 export const PRODUCT_EVENTS = {
+    /** Internal diagnostic receipt, never counted as an additional customer action. */
+    DIAGNOSTIC_CAPTURE: "diagnostic_capture",
     /** Acquisition. */
     USER_SIGNED_UP: "user_signed_up",
     WORKSPACE_CREATED: "workspace_created",

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

@@ -1,2 +1,3 @@
 export declare const OXYGEN_VERSION: string;
 export declare const OXYGEN_MINIMUM_CLI_VERSION = "1.922.14";
+export declare const GEO_EXPORT_MINIMUM_CLI_VERSION = "1.1013.0";

package/node_modules/@oxygen/shared/dist/version.generated.d.ts

@@ -1 +1 @@
-export declare const OXYGEN_BUILD_VERSION = "1.1012.2";
+export declare const OXYGEN_BUILD_VERSION = "1.1013.15";

package/node_modules/@oxygen/shared/dist/version.generated.js

@@ -1,2 +1,2 @@
 // GENERATED by scripts/ci/version-stamp.mjs from VERSION + git history. Do not edit; do not commit.
-export const OXYGEN_BUILD_VERSION = "1.1012.2";
+export const OXYGEN_BUILD_VERSION = "1.1013.15";

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

@@ -50,3 +50,6 @@ export const OXYGEN_VERSION = OXYGEN_BUILD_VERSION;
 // highest CLI version published on npm for at least 30 days. It never lowers
 // the floor. The source change lands on dev before the next production release.
 export const OXYGEN_MINIMUM_CLI_VERSION = "1.922.14";
+// The internal GEO export first gains required pagination in this dev version.
+// Earlier pilot clients would save a partial file without its continuation.
+export const GEO_EXPORT_MINIMUM_CLI_VERSION = "1.1013.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.1012.2",
+  "version": "1.1013.15",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",