@oxygen-agent/cli 1.1011.1091 → 1.1013.15

package/node_modules/@oxygen/shared/dist/diagnostic-storage-lock.js

@@ -0,0 +1,39 @@
+import { chmod } from "node:fs/promises";
+/** Server mutex for shared host volumes; kernel locks span container PID namespaces. */
+export async function acquireDiagnosticStorageLock(path, waitMs = 0) {
+    // Ask the supported Node runtime directly: server bundlers rewrite even
+    // createRequire calls to an unsupported URL external for node:sqlite.
+    // Browser-side Server Action analysis never needs to resolve this built-in.
+    const { DatabaseSync } = process.getBuiltinModule("node:sqlite");
+    const databasePath = path + ".sqlite";
+    const deadline = performance.now() + waitMs;
+    let database;
+    while (true) {
+        try {
+            // SQLite owns every descriptor: closing a separate descriptor for this inode
+            // would release POSIX locks held by another connection in this process.
+            database = new DatabaseSync(databasePath, { timeout: 0 });
+            await chmod(databasePath, 0o600);
+            database.exec("BEGIN EXCLUSIVE");
+            break;
+        }
+        catch (error) {
+            database?.close();
+            database = undefined;
+            const busy = error && typeof error === "object" && "errcode" in error && (error.errcode === 5 || error.errcode === 6);
+            if (!busy || performance.now() >= deadline)
+                return null;
+            // A synchronous SQLite busy timeout would block the same-process owner
+            // from finishing its asynchronous fsync and releasing this lock.
+            await new Promise(resolve => setTimeout(resolve, Math.min(20, Math.max(1, deadline - performance.now()))));
+        }
+    }
+    const held = database;
+    let closed = false;
+    return async () => {
+        if (!closed) {
+            closed = true;
+            held.close();
+        }
+    };
+}

package/node_modules/@oxygen/shared/dist/diagnostic-storage.d.ts

@@ -0,0 +1,31 @@
+import { S3Client } from "@aws-sdk/client-s3";
+import { type DiagnosticRecord } from "./diagnostics.js";
+export type DiagnosticStoredReceipt = {
+    key: string;
+    sha256: string;
+    bytes: number;
+    compressed_bytes: number;
+    record: DiagnosticRecord;
+};
+type Store = {
+    client: S3Client;
+    bucket: string;
+};
+export declare function observeDiagnosticStorage(observer: (receipt: DiagnosticStoredReceipt) => Promise<void>): void;
+export declare function startDiagnosticRetry(): void;
+export declare function diagnosticsConfigured(): boolean;
+export declare function diagnosticStore(): Store;
+export declare function diagnosticObjectKey(record: Pick<DiagnosticRecord, "id" | "organization_id">): string;
+export declare function encodeDiagnostic(record: DiagnosticRecord): {
+    bytes: Buffer;
+    sha256: string;
+    compressed: Buffer;
+};
+export declare function decodeDiagnostic(compressed: Uint8Array, expectedHash?: string): DiagnosticRecord;
+export declare function readDiagnostic(id: string, organizationId: string | null): Promise<DiagnosticStoredReceipt>;
+/** Durable local write precedes upload. Retries replay telemetry bytes only. */
+export declare function storeDiagnostic(record: DiagnosticRecord): Promise<DiagnosticStoredReceipt | null>;
+export declare function flushDiagnosticSpool(): Promise<void>;
+/** A metadata-only fallback for an unsupported value never claims full capture. */
+export declare function partialDiagnostic(record: DiagnosticRecord, reason: string): DiagnosticRecord;
+export {};

package/node_modules/@oxygen/shared/dist/diagnostic-storage.js

@@ -0,0 +1,233 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, open, readFile, readdir, rename, stat, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { gzipSync, gunzipSync } from "node:zlib";
+import { GetObjectCommand, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { createDiagnosticRecord, credentialSafeDiagnostic, DIAGNOSTIC_MAX_BYTES, DIAGNOSTIC_RECORD_MAX_BYTES, DIAGNOSTIC_RETENTION_MS, diagnosticId, diagnosticSummary, parseDiagnosticRecord, sanitizeDiagnosticContent } from "./diagnostics.js";
+import { acquireDiagnosticStorageLock } from "./diagnostic-storage-lock.js";
+import { log } from "./log.js";
+import { recordTelemetryCounter } from "./telemetry.js";
+let cached;
+let warned = false;
+let flushing = null;
+let timer;
+let onStored;
+export function observeDiagnosticStorage(observer) {
+    onStored = observer;
+    startDiagnosticRetry();
+    void flushDiagnosticSpool();
+}
+export function startDiagnosticRetry() {
+    if (!timer && diagnosticsConfigured()) {
+        timer = setInterval(() => { void flushDiagnosticSpool(); }, 30_000);
+        timer.unref();
+    }
+}
+export function diagnosticsConfigured() {
+    return process.env.OXYGEN_DIAGNOSTICS_ENABLED !== "0" && Boolean(process.env.OXYGEN_DIAGNOSTICS_S3_ENDPOINT
+        && process.env.OXYGEN_DIAGNOSTICS_S3_BUCKET && process.env.OXYGEN_DIAGNOSTICS_S3_ACCESS_KEY_ID
+        && process.env.OXYGEN_DIAGNOSTICS_S3_SECRET_ACCESS_KEY && process.env.OXYGEN_DIAGNOSTICS_SPOOL_DIR);
+}
+export function diagnosticStore() {
+    if (!diagnosticsConfigured())
+        throw new Error("Diagnostics storage is not configured");
+    const endpoint = process.env.OXYGEN_DIAGNOSTICS_S3_ENDPOINT;
+    const bucket = process.env.OXYGEN_DIAGNOSTICS_S3_BUCKET;
+    const accessKeyId = process.env.OXYGEN_DIAGNOSTICS_S3_ACCESS_KEY_ID;
+    const secretAccessKey = process.env.OXYGEN_DIAGNOSTICS_S3_SECRET_ACCESS_KEY;
+    const key = createHash("sha256").update([endpoint, bucket, accessKeyId, secretAccessKey].join("\0")).digest("hex");
+    if (cached?.key !== key)
+        cached = { key, store: { bucket, client: new S3Client({
+                    endpoint, region: "us-east-1", forcePathStyle: true, maxAttempts: 2,
+                    credentials: { accessKeyId, secretAccessKey },
+                }) } };
+    return cached.store;
+}
+export function diagnosticObjectKey(record) {
+    if (!diagnosticId(record.id) || (record.organization_id !== null && !diagnosticId(record.organization_id)))
+        throw new Error("Invalid diagnostic scope");
+    return `records/${record.organization_id ?? "unknown"}/${record.id}.json.gz`;
+}
+export function encodeDiagnostic(record) {
+    const bytes = Buffer.from(JSON.stringify(sanitizeDiagnosticContent(credentialSafeDiagnostic(parseDiagnosticRecord(record)))));
+    if (bytes.length > DIAGNOSTIC_RECORD_MAX_BYTES)
+        throw new Error("Diagnostic record capacity exceeded");
+    return { bytes, sha256: createHash("sha256").update(bytes).digest("hex"), compressed: gzipSync(bytes) };
+}
+export function decodeDiagnostic(compressed, expectedHash) {
+    const bytes = gunzipSync(compressed, { maxOutputLength: DIAGNOSTIC_RECORD_MAX_BYTES });
+    if (expectedHash && createHash("sha256").update(bytes).digest("hex") !== expectedHash)
+        throw new Error("Diagnostic integrity mismatch");
+    const record = parseDiagnosticRecord(JSON.parse(bytes.toString("utf8")));
+    if (Date.now() - Date.parse(record.started_at) >= DIAGNOSTIC_RETENTION_MS)
+        throw Object.assign(new Error("Diagnostic content has expired"), { code: "diagnostic_content_expired" });
+    return record;
+}
+export async function readDiagnostic(id, organizationId) {
+    const { client, bucket } = diagnosticStore();
+    const key = diagnosticObjectKey({ id, organization_id: organizationId });
+    const result = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }), { abortSignal: AbortSignal.timeout(15_000) });
+    if (!result.Body)
+        throw new Error("Diagnostic body missing");
+    const compressed = await result.Body.transformToByteArray();
+    if (!result.Metadata?.sha256 || !/^[0-9a-f]{64}$/.test(result.Metadata.sha256))
+        throw new Error("Diagnostic integrity manifest missing");
+    const record = decodeDiagnostic(compressed, result.Metadata.sha256);
+    const bytes = gunzipSync(compressed, { maxOutputLength: DIAGNOSTIC_RECORD_MAX_BYTES }).length;
+    if (String(bytes) !== result.Metadata.bytes)
+        throw new Error("Diagnostic byte manifest mismatch");
+    if (record.id !== id || record.organization_id !== organizationId)
+        throw new Error("Diagnostic scope mismatch");
+    return { key, sha256: result.Metadata.sha256, bytes, compressed_bytes: compressed.length, record };
+}
+/** Durable local write precedes upload. Retries replay telemetry bytes only. */
+export async function storeDiagnostic(record) {
+    recordTelemetryCounter("oxygen.diagnostics.attempted", 1, { source: record.surface, layer: record.layer });
+    if (!diagnosticsConfigured()) {
+        if (!warned && process.env.NODE_ENV !== "test") {
+            warned = true;
+            log("warn", "diagnostics.not_configured", { capture_state: "unavailable" });
+        }
+        return null;
+    }
+    const directory = process.env.OXYGEN_DIAGNOSTICS_SPOOL_DIR;
+    let path;
+    try {
+        let encoded;
+        try {
+            encoded = encodeDiagnostic(record);
+        }
+        catch {
+            record = partialDiagnostic(record, "unsupported_or_oversized_content");
+            encoded = encodeDiagnostic(record);
+        }
+        record = parseDiagnosticRecord(JSON.parse(encoded.bytes.toString("utf8")));
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        // Admission and expiry share one lock across web/worker processes on a host.
+        const lockPath = join(directory, ".admission.lock");
+        const release = await acquireDiagnosticStorageLock(lockPath, 5_000);
+        if (!release)
+            throw new Error("Diagnostic spool admission busy");
+        try {
+            const { used } = await inspectDiagnosticSpool(directory);
+            if (used + encoded.compressed.length > DIAGNOSTIC_MAX_BYTES)
+                throw new Error("Diagnostic spool is full");
+            path = join(directory, `${record.id}.json.gz`);
+            const temporary = join(directory, `${record.id}.${randomUUID()}.tmp`);
+            const handle = await open(temporary, "wx", 0o600);
+            try {
+                await handle.writeFile(encoded.compressed);
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            await rename(temporary, path);
+        }
+        finally {
+            await release();
+        }
+        startDiagnosticRetry();
+        const receipt = await uploadEncodedDiagnostic(record, encoded);
+        await unlink(path).catch(() => undefined);
+        return receipt;
+    }
+    catch {
+        // Neither storage credentials nor upstream exception text belong in logs.
+        log("warn", path ? "diagnostics.capture_deferred" : "diagnostics.capture_lost", { diagnostic_id: record.id, reason: path ? "upload_failed" : "spool_admission_failed" });
+        recordTelemetryCounter(path ? "oxygen.diagnostics.deferred" : "oxygen.diagnostics.lost", 1, { source: record.surface });
+        return null;
+    }
+}
+async function uploadEncodedDiagnostic(record, encoded) {
+    const captured = Date.parse(record.started_at);
+    const now = Date.now();
+    if (now - captured >= 72 * 60 * 60 * 1000)
+        throw new Error("Diagnostic upload has expired");
+    // S3 day-based expiry rounds to the next UTC midnight. Tagged age bands
+    // leave that final day inside the 30-day deadline measured from capture.
+    const retentionDays = Math.min(29, 29 - (Math.floor(now / 86_400_000) - Math.floor(captured / 86_400_000)));
+    const { client, bucket } = diagnosticStore();
+    const key = diagnosticObjectKey(record);
+    await client.send(new PutObjectCommand({ Bucket: bucket, Key: key, Body: encoded.compressed,
+        ContentType: "application/gzip",
+        Tagging: `diagnostic_retention_days=${retentionDays}`,
+        Metadata: { sha256: encoded.sha256, bytes: String(encoded.bytes.length), expires_at: new Date(Date.parse(record.started_at) + DIAGNOSTIC_RETENTION_MS).toISOString() },
+    }), { abortSignal: AbortSignal.timeout(15_000) });
+    log("info", "diagnostics.capture_stored", { ...diagnosticSummary(record), org_id: record.organization_id, user_id: record.user_id,
+        diagnostic_key: key, bytes: encoded.bytes.length, compressed_bytes: encoded.compressed.length, sha256: encoded.sha256 });
+    recordTelemetryCounter("oxygen.diagnostics.stored", 1, { source: record.surface, layer: record.layer });
+    const receipt = { key, sha256: encoded.sha256, bytes: encoded.bytes.length, compressed_bytes: encoded.compressed.length, record };
+    if (onStored)
+        await onStored(receipt);
+    return receipt;
+}
+export function flushDiagnosticSpool() {
+    if (flushing)
+        return flushing;
+    flushing = (async () => {
+        if (!diagnosticsConfigured())
+            return;
+        const directory = process.env.OXYGEN_DIAGNOSTICS_SPOOL_DIR;
+        const release = await acquireDiagnosticStorageLock(join(directory, ".upload.lock"));
+        if (!release)
+            return;
+        try {
+            // Idle workers enforce the same expiry as new admissions. The admission
+            // lock protects cleanup against a writer replacing an old record path.
+            const admission = await acquireDiagnosticStorageLock(join(directory, ".admission.lock"));
+            if (!admission)
+                return;
+            let files;
+            try {
+                files = (await inspectDiagnosticSpool(directory)).files.slice(0, 20);
+            }
+            finally {
+                await admission();
+            }
+            for (const name of files) {
+                const path = join(directory, name);
+                try {
+                    const compressed = await readFile(path);
+                    const record = decodeDiagnostic(compressed);
+                    await uploadEncodedDiagnostic(record, encodeDiagnostic(record));
+                    await unlink(path).catch(() => undefined);
+                }
+                catch { /* retain failed uploads; admission expires them visibly */ }
+            }
+        }
+        finally {
+            await release();
+        }
+    })().catch(() => undefined).finally(() => { flushing = null; });
+    return flushing;
+}
+/** Caller holds admission lock; count retained bytes and expire actual filenames. */
+async function inspectDiagnosticSpool(directory) {
+    let used = 0;
+    const files = [];
+    for (const name of await readdir(directory)) {
+        const record = /^[0-9a-f-]+\.json\.gz$/.test(name);
+        if (!record && !/^[0-9a-f-]+(?:\.[0-9a-f-]+)?\.tmp$/.test(name))
+            continue;
+        const path = join(directory, name);
+        const info = await stat(path).catch(() => null);
+        if (!info)
+            continue;
+        if (Date.now() - info.mtimeMs >= 72 * 60 * 60 * 1000) {
+            await unlink(path);
+            log("warn", "diagnostics.capture_lost", { reason: "spool_expired", bytes: info.size });
+            recordTelemetryCounter("oxygen.diagnostics.lost", 1, { reason: "spool_expired" });
+        }
+        else {
+            used += info.size;
+            if (record)
+                files.push(name);
+        }
+    }
+    return { used, files };
+}
+/** A metadata-only fallback for an unsupported value never claims full capture. */
+export function partialDiagnostic(record, reason) {
+    return createDiagnosticRecord({ ...record, input: null, output: null, capture_state: "partial", metadata: { capture_reason: reason } });
+}

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

@@ -0,0 +1,49 @@
+/** Internal diagnostic evidence, distinct from customer run state and usage counts. */
+export declare const DIAGNOSTIC_VERSION = 1;
+export declare const DIAGNOSTIC_RETENTION_MS: number;
+export declare const DIAGNOSTIC_INVOCATION_HEADER = "X-Oxygen-Invocation-Id";
+export declare const DIAGNOSTIC_UPLOAD_CHUNK_BYTES: number;
+export declare const DIAGNOSTIC_MAX_BYTES: number;
+export declare const DIAGNOSTIC_RECORD_MAX_BYTES: number;
+export declare const DIAGNOSTIC_UPLOAD_MAX_CHUNKS = 17;
+export type DiagnosticOutcome = "ok" | "invalid_input" | "refused" | "platform_error" | "network_error" | "cancelled" | "pending";
+export type DiagnosticRecord = {
+    version: 1;
+    id: string;
+    invocation_id: string;
+    parent_id: string | null;
+    layer: "invocation" | "api" | "worker" | "protocol";
+    surface: "cli" | "mcp" | "web" | "worker";
+    operation: string;
+    started_at: string;
+    ended_at: string | null;
+    outcome: DiagnosticOutcome;
+    error_code: string | null;
+    status: number | null;
+    organization_id: string | null;
+    user_id: string | null;
+    identity_verified: boolean;
+    client_version: string | null;
+    trace_id: string | null;
+    traceparent: string | null;
+    capture_state: "complete" | "partial";
+    input: unknown;
+    output: unknown;
+    metadata: Record<string, unknown>;
+};
+export declare function diagnosticId(value: unknown): string | null;
+export declare function diagnosticOutcome(ok: boolean, status?: number | null, code?: string | null): DiagnosticOutcome;
+export declare function createDiagnosticRecord(input: {
+    [K in keyof DiagnosticRecord]?: DiagnosticRecord[K] | undefined;
+} & Pick<DiagnosticRecord, "surface" | "operation">): DiagnosticRecord;
+export declare function sanitizeDiagnosticText(value: string, knownSecrets?: readonly string[]): string;
+/** No business-content, array, string, field-count or depth truncation. */
+export declare function sanitizeDiagnosticContent(value: unknown, knownSecrets?: readonly string[]): unknown;
+export declare function sanitizeDiagnosticArgv(argv: string[]): string[];
+export declare function parseDiagnosticRecord(value: unknown): DiagnosticRecord;
+export declare function diagnosticSummary(record: DiagnosticRecord): Record<string, string | number | boolean | null>;
+export declare function credentialSafeDiagnostic(record: DiagnosticRecord): DiagnosticRecord;
+/** Bound the diagnostic branch of a response tee without delaying its consumer. */
+export declare function readDiagnosticProtocolText(body: ReadableStream<Uint8Array> | null): Promise<string | null>;
+/** Finite POST SSE is decoded before credential/binary filtering, like JSON. */
+export declare function parseDiagnosticProtocolBody(text: string | null, contentType?: string | null): unknown;

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/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),
         ],