@oxygen-agent/cli 1.1014.136 → 1.1014.619

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

@@ -1,136 +1,17 @@
-import { createHash, randomUUID } from "node:crypto";
-import { mkdir, open, readFile, readdir, rename, stat, unlink } from "node:fs/promises";
-import { join } from "node:path";
+import { createHash } from "node:crypto";
 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 { createDiagnosticRecord, credentialSafeDiagnostic, DIAGNOSTIC_RECORD_MAX_BYTES, DIAGNOSTIC_RETENTION_MS, diagnosticId, diagnosticSummary, parseDiagnosticRecord, sanitizeDiagnosticContent } from "./diagnostics.js";
+import { admitDiagnosticSpool, lockDiagnosticUpload, readUploadProgress, retryDiagnosticSpool, saveDiagnosticUploadProgress } from "./diagnostic-spool.js";
+import { diagnosticRole, StorageFailure, storageFailureFields as diagnosticStorageFailureFields, storageStage } from "./diagnostic-storage-failure.js";
 import { log } from "./log.js";
 import { recordTelemetryCounter } from "./telemetry.js";
+export { storageFailureFields as diagnosticStorageFailureFields } from "./diagnostic-storage-failure.js";
 let cached;
 let warned = false;
 let flushing = null;
 let timer;
 let onStored;
-const admissions = new Map();
-class StorageFailure extends Error {
-    stage;
-    failure;
-    constructor(stage, failure) {
-        super("Diagnostic storage failed");
-        this.stage = stage;
-        this.failure = failure;
-    }
-}
-async function storageStage(stage, action) {
-    try {
-        return await action();
-    }
-    catch (error) {
-        throw error instanceof StorageFailure ? error : new StorageFailure(stage, error);
-    }
-}
-function storageFailureFields(error) {
-    const stage = error instanceof StorageFailure ? error.stage : "encode";
-    const failure = error instanceof StorageFailure ? error.failure : error;
-    const value = failure && typeof failure === "object" ? failure : {};
-    const code = typeof value.code === "string" && /^(?:E[A-Z0-9_]{1,30}|SQLITE_[A-Z_]{1,30}|spool_full|lock_timeout)$/.test(value.code) ? value.code : null;
-    const sqlite = typeof value.errcode === "number" ? value.errcode : null;
-    const cause = code === "lock_timeout" ? "lock_timeout" : code === "spool_full" ? "spool_limit"
-        : ["EACCES", "EPERM", "EROFS"].includes(code ?? "") || (sqlite !== null && [3, 8, 23].includes(sqlite & 255)) ? "permission"
-            : ["ENOSPC", "EDQUOT"].includes(code ?? "") || (sqlite !== null && (sqlite & 255) === 13) ? "filesystem_capacity" : "other";
-    const status = value.$metadata?.httpStatusCode;
-    return { cause, stage, error_code: code, sqlite_code: sqlite, errno: typeof value.errno === "number" ? value.errno : null,
-        http_status: typeof status === "number" && status >= 100 && status <= 599 ? status : null, queue_role: diagnosticRole() };
-}
-function diagnosticRole() {
-    const role = process.env.OXYGEN_WORKER_QUEUE_ROLE;
-    return role && ["relay", "bulk", "maintenance", "interactive", "provider", "outbound"].includes(role) ? role
-        : process.env.OXYGEN_PROCESS_ROLE === "worker" ? "legacy" : "web";
-}
-/** Coalesce local contenders; the kernel mutex still owns cross-process admission. */
-function admitDiagnostic(directory, record, encoded) {
-    return new Promise((resolve, reject) => {
-        const pending = admissions.get(directory);
-        const admission = { record, encoded, deadline: performance.now() + 5_000, resolve, reject };
-        if (pending)
-            pending.pending.push(admission);
-        else {
-            const queue = { pending: [admission] };
-            admissions.set(directory, queue);
-            queueMicrotask(() => { void drainAdmissions(directory, queue); });
-        }
-    });
-}
-async function drainAdmissions(directory, queue) {
-    try {
-        while (queue.pending.length) {
-            const batch = queue.pending.splice(0, 32);
-            let release = null;
-            try {
-                release = await storageStage("lock", () => acquireDiagnosticStorageLock(join(directory, ".admission.lock"), Math.max(0, batch[0].deadline - performance.now())));
-                if (!release)
-                    throw new StorageFailure("lock", { code: "lock_timeout" });
-                const started = performance.now();
-                let { used, files } = await storageStage("inspect", () => inspectDiagnosticSpool(directory));
-                queue.files = files;
-                const scanMs = performance.now() - started;
-                for (const admission of batch) {
-                    try {
-                        if (performance.now() >= admission.deadline)
-                            throw new StorageFailure("lock", { code: "lock_timeout" });
-                        if (used + admission.encoded.compressed.length > DIAGNOSTIC_MAX_BYTES)
-                            throw new StorageFailure("capacity", { code: "spool_full" });
-                        // Reserve conservatively even if cleanup of a failed partial write fails.
-                        used += admission.encoded.compressed.length;
-                        admission.resolve(await writeDiagnosticSpool(directory, admission.record.id, admission.encoded.compressed));
-                    }
-                    catch (error) {
-                        admission.reject(error);
-                    }
-                }
-                log("info", "diagnostics.spool_admitted", { queue_role: diagnosticRole(), batch_records: batch.length, spool_files: files.length,
-                    spool_bytes: used, scan_ms: scanMs, admission_wait_ms: performance.now() - (batch[0].deadline - 5_000) });
-            }
-            catch (error) {
-                for (const admission of batch)
-                    admission.reject(error);
-            }
-            finally {
-                await release?.();
-            }
-        }
-    }
-    catch (error) {
-        for (const admission of queue.pending.splice(0))
-            admission.reject(error);
-    }
-    finally {
-        admissions.delete(directory);
-    }
-}
-async function writeDiagnosticSpool(directory, id, compressed) {
-    const path = join(directory, `${id}.json.gz`);
-    const temporary = join(directory, `${id}.${randomUUID()}.tmp`);
-    let handle;
-    try {
-        handle = await storageStage("open", () => open(temporary, "wx", 0o600));
-        await storageStage("write", () => handle.writeFile(compressed));
-        await storageStage("sync", () => handle.sync());
-        await handle.close();
-        handle = undefined;
-        await storageStage("rename", () => rename(temporary, path));
-        return path;
-    }
-    finally {
-        try {
-            await handle?.close();
-        }
-        finally {
-            await unlink(temporary).catch(() => undefined);
-        }
-    }
-}
 export function observeDiagnosticStorage(observer) {
     onStored = observer;
     startDiagnosticRetry();
@@ -210,7 +91,7 @@ export async function storeDiagnostic(record) {
         return null;
     }
     const directory = process.env.OXYGEN_DIAGNOSTICS_SPOOL_DIR;
-    let path;
+    let acknowledge;
     try {
         let encoded;
         try {
@@ -221,26 +102,64 @@ export async function storeDiagnostic(record) {
             encoded = encodeDiagnostic(record);
         }
         record = parseDiagnosticRecord(JSON.parse(encoded.bytes.toString("utf8")));
-        await storageStage("mkdir", () => mkdir(directory, { recursive: true, mode: 0o700 }));
-        path = await admitDiagnostic(directory, record, encoded);
+        acknowledge = await admitDiagnosticSpool(directory, record, encoded.compressed);
         startDiagnosticRetry();
-        const receipt = await storageStage("upload", () => uploadEncodedDiagnostic(record, encoded));
-        await unlink(path).catch(() => undefined);
+        const receipt = await uploadEncodedDiagnostic(directory, record, encoded, acknowledge);
         return receipt;
     }
     catch (error) {
         // Neither storage credentials nor upstream exception text belong in logs.
-        const fields = storageFailureFields(error);
-        log("warn", path ? "diagnostics.capture_deferred" : "diagnostics.capture_lost", { diagnostic_id: record.id, reason: path ? "upload_failed" : "spool_admission_failed", ...fields });
-        recordTelemetryCounter(path ? "oxygen.diagnostics.deferred" : "oxygen.diagnostics.lost", 1, { source: record.surface, cause: fields.cause, queue_role: diagnosticRole() });
+        const fields = diagnosticStorageFailureFields(error);
+        log("warn", acknowledge ? "diagnostics.capture_deferred" : "diagnostics.capture_lost", { diagnostic_id: record.id,
+            reason: acknowledge ? fields.stage === "observer" ? "metadata_publication_failed" : fields.stage === "receipt" ? "receipt_failed" : "upload_failed" : "spool_admission_failed", ...fields });
+        recordTelemetryCounter(acknowledge ? "oxygen.diagnostics.deferred" : "oxygen.diagnostics.lost", 1, { source: record.surface, cause: fields.cause, queue_role: diagnosticRole() });
         return null;
     }
 }
-async function uploadEncodedDiagnostic(record, encoded) {
+async function uploadEncodedDiagnostic(directory, record, encoded, acknowledge) {
+    const release = await lockDiagnosticUpload(directory, record.id, 5_000);
+    try {
+        const receipt = await publishEncodedDiagnostic(directory, record, encoded);
+        await acknowledge();
+        return receipt;
+    }
+    finally {
+        await release();
+    }
+}
+function diagnosticStoreFingerprint() {
+    return createHash("sha256").update(`${process.env.OXYGEN_DIAGNOSTICS_S3_ENDPOINT}\0${process.env.OXYGEN_DIAGNOSTICS_S3_BUCKET}`).digest("hex");
+}
+async function publishEncodedDiagnostic(directory, record, encoded, reservation) {
+    // Upload acknowledgement never extends the captured record's retry window.
+    if (Date.now() - Date.parse(record.started_at) >= 72 * 60 * 60 * 1000)
+        throw new StorageFailure("upload", new Error("Diagnostic upload has expired"));
+    const receipt = { key: diagnosticObjectKey(record), sha256: encoded.sha256, bytes: encoded.bytes.length, compressed_bytes: encoded.compressed.length, record };
+    // The checksum binds the acknowledged upload to these exact evidence bytes;
+    // a receipt from another bucket or endpoint cannot suppress its upload.
+    let progress = await storageStage("receipt", async () => {
+        const value = await readUploadProgress(directory, record.id, diagnosticStoreFingerprint());
+        if (value && value.sha256 !== encoded.sha256)
+            throw new Error("Diagnostic upload receipt integrity mismatch");
+        return value;
+    });
+    if (!progress) {
+        await storageStage("upload", () => uploadDiagnosticObject(record, encoded));
+        progress = { sha256: encoded.sha256, store: diagnosticStoreFingerprint(), published: false };
+        await storageStage("receipt", () => saveDiagnosticUploadProgress(directory, record, progress, reservation));
+    }
+    if (!progress.published) {
+        if (onStored)
+            await storageStage("observer", () => onStored(receipt));
+        // A crash after an ambiguous observer acknowledgement can retry metadata
+        // with the same UUID; the destination owns deduplication of that UUID.
+        await storageStage("receipt", () => saveDiagnosticUploadProgress(directory, record, { ...progress, published: true }, reservation));
+    }
+    return receipt;
+}
+async function uploadDiagnosticObject(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)));
@@ -254,10 +173,6 @@ async function uploadEncodedDiagnostic(record, encoded) {
     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, queue_role: diagnosticRole() });
     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 storageStage("observer", () => onStored(receipt));
-    return receipt;
 }
 export function flushDiagnosticSpool() {
     if (flushing)
@@ -266,82 +181,13 @@ export function flushDiagnosticSpool() {
         if (!diagnosticsConfigured())
             return;
         const directory = process.env.OXYGEN_DIAGNOSTICS_SPOOL_DIR;
-        const release = await storageStage("lock", () => 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.
-            let files;
-            const local = admissions.get(directory);
-            if (local) {
-                // Reuse the active writer's protected inspection. Waiting for local idle
-                // can starve retained evidence indefinitely under sustained capture.
-                files = local.files?.slice(0, 20) ?? [];
-            }
-            else {
-                const admission = await storageStage("lock", () => acquireDiagnosticStorageLock(join(directory, ".admission.lock")));
-                if (!admission)
-                    return;
-                try {
-                    files = (await storageStage("inspect", () => inspectDiagnosticSpool(directory))).files.slice(0, 20);
-                }
-                finally {
-                    await admission();
-                }
-            }
-            for (const name of files) {
-                const path = join(directory, name);
-                try {
-                    const compressed = await storageStage("read", () => readFile(path));
-                    const record = await storageStage("decode", async () => decodeDiagnostic(compressed));
-                    await storageStage("upload", () => uploadEncodedDiagnostic(record, encodeDiagnostic(record)));
-                    await unlink(path).catch(() => undefined);
-                }
-                catch (error) {
-                    log("warn", "diagnostics.spool_upload_deferred", { diagnostic_id: name.slice(0, -8), ...storageFailureFields(error) });
-                }
-            }
-        }
-        finally {
-            await release();
-        }
-    })().catch(error => { log("warn", "diagnostics.spool_retry_failed", storageFailureFields(error)); }).finally(() => { flushing = null; });
+        await retryDiagnosticSpool(directory, diagnosticStoreFingerprint(), async (compressed, reservation) => {
+            const record = await storageStage("decode", async () => decodeDiagnostic(compressed));
+            await publishEncodedDiagnostic(directory, record, encodeDiagnostic(record), reservation);
+        });
+    })().catch(error => { log("warn", "diagnostics.spool_retry_failed", diagnosticStorageFailureFields(error)); }).finally(() => { flushing = null; });
     return flushing;
 }
-/** Caller holds admission lock; count retained bytes and expire actual filenames. */
-async function inspectDiagnosticSpool(directory) {
-    let used = 0;
-    const retained = [];
-    const names = (await readdir(directory)).filter(name => /^[0-9a-f-]+\.json\.gz$/.test(name) || /^[0-9a-f-]+(?:\.[0-9a-f-]+)?\.tmp$/.test(name));
-    for (let offset = 0; offset < names.length; offset += 64) {
-        const inspected = await Promise.all(names.slice(offset, offset + 64).map(async (name) => {
-            const path = join(directory, name);
-            const info = await stat(path).catch(error => { if (error?.code === "ENOENT")
-                return null; throw error; });
-            return { name, path, info };
-        }));
-        for (const { name, path, info } of inspected) {
-            const record = /^[0-9a-f-]+\.json\.gz$/.test(name);
-            if (!info)
-                continue;
-            if (Date.now() - info.mtimeMs >= 72 * 60 * 60 * 1000) {
-                const removed = await unlink(path).then(() => true).catch(error => { if (error?.code === "ENOENT")
-                    return false; throw error; });
-                if (removed) {
-                    log("warn", "diagnostics.capture_lost", { reason: "spool_expired", bytes: info.size, queue_role: diagnosticRole() });
-                    recordTelemetryCounter("oxygen.diagnostics.lost", 1, { reason: "spool_expired" });
-                }
-            }
-            else {
-                used += info.size;
-                if (record)
-                    retained.push({ name, mtimeMs: info.mtimeMs });
-            }
-        }
-    }
-    return { used, files: retained.sort((a, b) => a.mtimeMs - b.mtimeMs || a.name.localeCompare(b.name)).map(file => file.name) };
-}
 /** 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.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { credentialBearingOperation } from "./diagnostic-credentials.js";
+import { credentialBearingOperation, SPOKEN_OUTPUT_OPERATIONS } 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;
@@ -205,7 +205,8 @@ export function credentialSafeDiagnostic(record) {
     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 };
+        output: credentialBearingOperation(selectedName, "output") ? { withheld: "credential_bearing_operation" }
+            : SPOKEN_OUTPUT_OPERATIONS.has(record.operation) ? { withheld: "dictated_speech" } : record.output };
 }
 /** Bound the diagnostic branch of a response tee without delaying its consumer. */
 export async function readDiagnosticProtocolText(body) {

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

@@ -46,6 +46,14 @@ export type DeliveryStatusNotification = {
     /** Enhanced status code (5.7.1) when present, else the bare SMTP reply (550). */
     smtpCode: string | null;
 };
+/** Bounds HTML hydration for the health rollup and pure fallback alike. */
+export declare const MAX_DELIVERY_STATUS_HTML_CHARS = 20000;
+type DsnInput = {
+    fromAddress?: string | null;
+    subject?: string | null;
+    bodyText?: string | null;
+    bodyHtml?: string | null;
+};
 /**
  * Classify one stored inbound message as a delivery-status notification.
  *
@@ -53,8 +61,11 @@ export type DeliveryStatusNotification = {
  * is intentionally wide, and a false positive here would invent a deliverability
  * incident out of a customer reply.
  */
-export declare function classifyDeliveryStatusNotification(input: {
-    fromAddress?: string | null;
-    subject?: string | null;
-    bodyText?: string | null;
-}): DeliveryStatusNotification | null;
+export declare function classifyDeliveryStatusNotification(input: DsnInput): DeliveryStatusNotification | null;
+/**
+ * A bounce generator is not necessarily the server that rejected delivery.
+ * Gmail can relay a Mimecast/Sophos refusal. Require receiving-server evidence;
+ * an absent or truncated diagnostic remains unattributed, never a Google block.
+ */
+export declare function isGoogleDeliveryStatusRejection(input: DsnInput): boolean;
+export {};

package/node_modules/@oxygen/shared/dist/email-dsn.js

@@ -24,6 +24,86 @@ export const DELIVERY_STATUS_NOTIFICATION_KINDS = [
     "unclassified",
     "other",
 ];
+/** Bounds HTML hydration for the health rollup and pure fallback alike. */
+export const MAX_DELIVERY_STATUS_HTML_CHARS = 20_000;
+/** Consume each tag once, including malformed input; a byte cap alone cannot bound regex rescanning. */
+function dsnHtmlText(html) {
+    const parts = [];
+    let cursor = 0;
+    while (cursor < html.length) {
+        const start = html.indexOf("<", cursor);
+        if (start < 0) {
+            parts.push(html.slice(cursor));
+            break;
+        }
+        parts.push(html.slice(cursor, start));
+        if (html.startsWith("<!--", start)) {
+            const end = html.indexOf("-->", start + 4);
+            if (end < 0)
+                break;
+            cursor = end + 3;
+            continue;
+        }
+        let end = start + 1;
+        let quote = "";
+        for (; end < html.length; end++) {
+            const char = html[end];
+            if (quote) {
+                if (char === quote)
+                    quote = "";
+            }
+            else if (char === '"' || char === "'")
+                quote = char;
+            else if (char === ">")
+                break;
+        }
+        if (end === html.length) {
+            parts.push(html.slice(start));
+            break;
+        }
+        const tag = html.slice(start + 1, end).trim();
+        const name = /^\/?([a-z][a-z0-9:-]*)/i.exec(tag)?.[1]?.toLowerCase() ?? "";
+        const closing = tag.startsWith("/");
+        if (!closing && ["head", "style", "script"].includes(name)) {
+            const close = new RegExp(`</${name}\\s*>`, "gi");
+            close.lastIndex = end + 1;
+            if (!close.exec(html))
+                break;
+            cursor = close.lastIndex;
+            parts.push(" ");
+            continue;
+        }
+        const line = name === "br" || name === "hr"
+            || (closing && ["div", "p", "table", "tr", "li", "blockquote", "h1", "h2", "h3", "h4", "h5", "h6"].includes(name));
+        parts.push(line ? "\n" : " ");
+        cursor = end + 1;
+    }
+    return parts.join("");
+}
+function readDsnBody(input) {
+    if (typeof input.bodyText === "string" && input.bodyText.trim())
+        return input.bodyText;
+    if (typeof input.bodyHtml !== "string")
+        return "";
+    // Unlike a human reply, an NDR may put the actual diagnostic in a blockquote.
+    // Keep it and preserve line boundaries for Remote-MTA; never read scripts,
+    // styles or markup as diagnostic content. This is text extraction, not HTML rendering.
+    const entities = {
+        nbsp: " ", amp: "&", lt: "<", gt: ">", quot: '"', apos: "'",
+    };
+    return dsnHtmlText(input.bodyHtml.slice(0, MAX_DELIVERY_STATUS_HTML_CHARS))
+        .replace(/&(#x[\da-f]{1,6}|#\d{1,7}|nbsp|amp|lt|gt|quot|apos);/gi, (_, entity) => {
+        const key = entity.toLowerCase();
+        if (!key.startsWith("#"))
+            return entities[key] ?? " ";
+        const code = key.startsWith("#x") ? Number.parseInt(key.slice(2), 16) : Number.parseInt(key.slice(1), 10);
+        return code > 0 && code <= 0x10ffff && !(code >= 0xd800 && code <= 0xdfff)
+            ? String.fromCodePoint(code) : " ";
+    })
+        .replace(/[^\S\n]+/g, " ")
+        .replace(/\n */g, "\n")
+        .trim();
+}
 // A message only enters classification when its envelope looks like a DSN. The
 // SQL prefilter that feeds this is deliberately loose (ILIKE), so this gate is
 // what keeps an ordinary customer reply that happens to contain the word
@@ -106,7 +186,7 @@ function readKind(subject, haystack, hasBody) {
 export function classifyDeliveryStatusNotification(input) {
     const from = typeof input.fromAddress === "string" ? input.fromAddress : "";
     const subject = typeof input.subject === "string" ? input.subject : "";
-    const body = typeof input.bodyText === "string" ? input.bodyText : "";
+    const body = readDsnBody(input);
     if (!DSN_FROM_PATTERN.test(from) && !DSN_SUBJECT_PATTERN.test(subject))
         return null;
     const haystack = `${subject}\n${body}`;
@@ -118,3 +198,19 @@ export function classifyDeliveryStatusNotification(input) {
         smtpCode,
     };
 }
+/**
+ * A bounce generator is not necessarily the server that rejected delivery.
+ * Gmail can relay a Mimecast/Sophos refusal. Require receiving-server evidence;
+ * an absent or truncated diagnostic remains unattributed, never a Google block.
+ */
+export function isGoogleDeliveryStatusRejection(input) {
+    if (classifyDeliveryStatusNotification(input)?.kind !== "provider_rejected")
+        return false;
+    const body = readDsnBody(input);
+    const remote = /^Remote-MTA:\s*(?:dns|rfc822);\s*([a-z0-9.-]+)/im.exec(body)?.[1];
+    if (remote) {
+        return /(?:^|\.)(?:google|googlemail)\.com$/i.test(remote.replace(/\.$/, ""));
+    }
+    return GOOGLE_BLOCK_URL.test(body)
+        || /\b5\.7\.\d{1,3}\b[^\n]*(?:\bgsmtp\b|https?:\/\/support\.google\.com\/mail\/answer\/)/i.test(body);
+}

package/node_modules/@oxygen/shared/dist/emailguard-placement-probe.js

@@ -42,6 +42,11 @@ function headerLine(value, fallback) {
 }
 function messageBody(value, phrase) {
     const base = value?.trim() || DEFAULT_BODY;
+    // Explicit placement copy can put the required matching phrase in a neutral
+    // reference line. Keep legacy bodies byte-identical for durable send hashes.
+    if (base.includes("{{placement_test_phrase}}")) {
+        return base.replaceAll("{{placement_test_phrase}}", phrase);
+    }
     if (base.includes(phrase))
         return base;
     return `${base}\n\nEmailGuard test phrase: ${phrase}`;

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

@@ -596,11 +596,10 @@ export const ENRICHMENT_INTENT_TAXONOMY = [
         rank: 340,
         aliases: ["lookalike", "similar companies", "companies like", "more like these"],
         inputShapes: ["seed_accounts"],
-        outputFields: [f("company_name", "Company", "company.name"), f("company_domain", "Domain", "company.domain")],
-        surfaces: {},
-        status: "coming_soon",
-        statusReason: "Coming soon (D51, 2026-09-19): the catalogue ships the default chains customers need most first; this data type returns once its lane is measured.",
-        decision: "D51",
+        outputFields: [f("lookalike_companies", "Similar companies", null, "jsonb"), f("lookalike_company_count", "Number returned", null, "numeric")],
+        surfaces: { preset: "company_lookalikes", catalogEntry: "preset:company_lookalikes", registryFunction: "company_search", registryIntent: "find_lookalikes" },
+        status: "selectable",
+        decision: "D54",
         candidateProviders: ["leadmagic"],
     },
     // ── Signals (streams and watch-lists; referenced) ─────────────────────────

package/node_modules/@oxygen/shared/dist/file-import.d.ts

@@ -67,6 +67,14 @@ export declare function parseRowsSampleText(text: string, format: Exclude<RowsFi
 }): RowsSample;
 export declare function inferImportColumnLabels(rows: Record<string, unknown>[]): string[];
 export declare function normalizeRowsForNewTable(rows: Record<string, unknown>[]): NewTableImportRows;
+/**
+ * The row without its blank cells, for an import that must leave a record's
+ * existing value alone where the file has nothing ("skip blank cells"): an
+ * upsert writes only the keys a row carries. Blank is null, undefined or text
+ * that is only whitespace. The upsert key always stays, so a row without one is
+ * still reported as missing its key instead of quietly dropping out.
+ */
+export declare function dropBlankImportCells(row: Record<string, unknown>, keepKey?: string | null): Record<string, unknown>;
 export declare function normalizeImportColumnKey(value: string): string;
 /**
  * Refuse a JSON or XLSX file over the buffered-parse ceiling before anything is

package/node_modules/@oxygen/shared/dist/file-import.js

@@ -217,6 +217,22 @@ export function normalizeRowsForNewTable(rows) {
 // it MATCHES imported file headers back to the column key MINTED by tenant-db's
 // toSnakeIdentifier, and has call sites across web/CLI/API. The two must never
 // diverge \u2014 see packages/shared/src/identifiers.ts + identifiers.test.ts.
+/**
+ * The row without its blank cells, for an import that must leave a record's
+ * existing value alone where the file has nothing ("skip blank cells"): an
+ * upsert writes only the keys a row carries. Blank is null, undefined or text
+ * that is only whitespace. The upsert key always stays, so a row without one is
+ * still reported as missing its key instead of quietly dropping out.
+ */
+export function dropBlankImportCells(row, keepKey) {
+    const kept = {};
+    for (const [key, value] of Object.entries(row)) {
+        const blank = value === null || value === undefined || (typeof value === "string" && value.trim() === "");
+        if (!blank || key === keepKey)
+            kept[key] = value;
+    }
+    return kept;
+}
 export function normalizeImportColumnKey(value) {
     return toSnakeIdentifier(value, "column");
 }
@@ -332,14 +348,17 @@ async function* iterateCsvRowStreamBatches(chunks, batchSize) {
         if (!combined)
             continue;
         const processUntil = Math.max(0, combined.length - 1);
-        for (let index = 0; index < processUntil; index += 1) {
+        let index = 0;
+        for (; index < processUntil; index += 1) {
             const ready = applyCsvTextCharacter(state, combined, index, batchSize);
             if (ready.skipNext)
                 index += 1;
             if (ready.batch)
                 yield ready.batch;
         }
-        carry = combined.charAt(combined.length - 1);
+        // An escaped quote can consume the lookahead character too. Carry only
+        // unread text, or that quote is parsed again at the next stream boundary.
+        carry = combined.slice(index);
     }
     const tail = carry + decoder.decode();
     for (let index = 0; index < tail.length; index += 1) {

package/node_modules/@oxygen/shared/dist/hosted-ai.d.ts

@@ -77,6 +77,36 @@ export declare const HOSTED_AI_MODEL_REGISTRY: {
  * own key and choice. Retired 2026-09-26 (see the ai_column block above).
  */
 export declare const LEGACY_MANAGED_AI_COLUMN_MODELS: Readonly<Record<string, HostedAiLevel>>;
+/**
+ * The exact managed model a code-owned background pass dispatches to, chosen and
+ * measured for that pass rather than inherited from a customer tier. A pin moves
+ * the model only: the run still bills at its column's tier. It is a function
+ * argument (`runAiColumnForOrganization`'s `managedModelPin`), never a stored
+ * column field, so no customer column can select it.
+ */
+export type ManagedModelPin = {
+    model: string;
+    /** OpenRouter fallbacks, tried in order when `model` is unavailable. */
+    fallbackModels: readonly string[];
+    /** Send `reasoning: {enabled: false}`, as the pass was measured. */
+    disableReasoning: boolean;
+};
+/**
+ * Signup research synthesis (knowledge bootstrap): the company profile, cited
+ * research note and GTM hypotheses written once per new workspace, plus the
+ * creator's private research summary.
+ *
+ * Pinned because inheriting the Balanced AI-column tier broke it silently. The
+ * 2026-10-10 tier refresh (#5115) moved Balanced to claude-haiku-5.5 at medium
+ * reasoning. In production through 2026-10-12, 30 of 30 traced syntheses then
+ * returned the company/offering/icp/market sections as `{}`, 26 left the research
+ * note empty, and 30 of 35 signup research runs ended `partial` with no
+ * `company-research` page. From 2026-09-12 to 2026-10-10 this configuration
+ * (deepseek-v4.1-flash, reasoning off, gpt-6-luna fallback, i.e. Balanced before
+ * the refresh) wrote the note in 199 of 211 runs. Change it only after replaying the
+ * synthesis on production-shaped evidence and comparing note and section fill rates.
+ */
+export declare const KNOWLEDGE_BOOTSTRAP_SYNTHESIS_MODEL: ManagedModelPin;
 /** The tier a retired managed AI-column model id billed at, or null. */
 export declare function legacyManagedAiColumnLevel(model: string): HostedAiLevel | null;
 /**

package/node_modules/@oxygen/shared/dist/hosted-ai.js

@@ -268,6 +268,26 @@ export const LEGACY_MANAGED_AI_COLUMN_MODELS = {
     "deepseek/deepseek-v4.1-flash": "medium",
     "openai/gpt-6-sol": "high",
 };
+/**
+ * Signup research synthesis (knowledge bootstrap): the company profile, cited
+ * research note and GTM hypotheses written once per new workspace, plus the
+ * creator's private research summary.
+ *
+ * Pinned because inheriting the Balanced AI-column tier broke it silently. The
+ * 2026-10-10 tier refresh (#5115) moved Balanced to claude-haiku-5.5 at medium
+ * reasoning. In production through 2026-10-12, 30 of 30 traced syntheses then
+ * returned the company/offering/icp/market sections as `{}`, 26 left the research
+ * note empty, and 30 of 35 signup research runs ended `partial` with no
+ * `company-research` page. From 2026-09-12 to 2026-10-10 this configuration
+ * (deepseek-v4.1-flash, reasoning off, gpt-6-luna fallback, i.e. Balanced before
+ * the refresh) wrote the note in 199 of 211 runs. Change it only after replaying the
+ * synthesis on production-shaped evidence and comparing note and section fill rates.
+ */
+export const KNOWLEDGE_BOOTSTRAP_SYNTHESIS_MODEL = {
+    model: "deepseek/deepseek-v4.1-flash",
+    fallbackModels: ["openai/gpt-6-luna"],
+    disableReasoning: true,
+};
 /**
  * Managed model ids OXYGEN ran that never sat in the registry above, mapped to
  * the tier they read as. Labeling only: unlike LEGACY_MANAGED_AI_COLUMN_MODELS,