@romiluz/clawmongo 0.1.0-rc.0

package/dist/cli/retrieval-eval.js

@@ -0,0 +1,226 @@
+import { performance } from "node:perf_hooks";
+import { loadRuntimeConfig } from "../config/env.js";
+import { RetrievalEngine } from "../retrieval/engine.js";
+import { loadRetrievalFixtureBundle } from "../retrieval/fixtures.js";
+import { AdaptiveFusionRetriever } from "../retrieval/providers/fusion.js";
+import { MongoLexicalRetriever } from "../retrieval/providers/lexical.js";
+import { MongoVectorRetriever } from "../retrieval/providers/vector.js";
+import { DEPLOYMENT_PROFILES } from "../config/deployment-profiles.js";
+function parseArgs(argv) {
+    let topK = 5;
+    let variant = "all";
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--topK") {
+            const value = Number(argv[index + 1]);
+            if (!Number.isInteger(value) || value <= 0) {
+                throw new Error(`Invalid --topK value: ${argv[index + 1]}`);
+            }
+            topK = value;
+            index += 1;
+            continue;
+        }
+        if (token === "--variant") {
+            const value = argv[index + 1];
+            if (!["lexical", "vector", "hybrid", "all"].includes(value)) {
+                throw new Error(`Invalid --variant value: ${value}`);
+            }
+            variant = value;
+            index += 1;
+            continue;
+        }
+        if (token === "--help") {
+            process.stdout.write([
+                "Usage: npm run retrieval:eval -- [--topK <n>] [--variant lexical|vector|hybrid|all]",
+                "",
+                "Options:",
+                "  --topK     retrieval cutoff for metrics (default: 5)",
+                "  --variant  run one variant or all (default: all)"
+            ].join("\n") + "\n");
+            process.exit(0);
+        }
+        throw new Error(`Unknown argument: ${token}`);
+    }
+    return { topK, variant };
+}
+function percentile(values, percentileValue) {
+    if (values.length === 0) {
+        return 0;
+    }
+    const sorted = [...values].sort((left, right) => left - right);
+    const rank = (percentileValue / 100) * (sorted.length - 1);
+    const lowIndex = Math.floor(rank);
+    const highIndex = Math.ceil(rank);
+    if (lowIndex === highIndex) {
+        return Number(sorted[lowIndex].toFixed(3));
+    }
+    const weight = rank - lowIndex;
+    const interpolated = sorted[lowIndex] * (1 - weight) + sorted[highIndex] * weight;
+    return Number(interpolated.toFixed(3));
+}
+function recallAtK(relevantIds, retrievedIds) {
+    if (relevantIds.length === 0) {
+        return 0;
+    }
+    const retrievedSet = new Set(retrievedIds);
+    const hitCount = relevantIds.filter((id) => retrievedSet.has(id)).length;
+    return hitCount / relevantIds.length;
+}
+function mrrAtK(relevantIds, retrievedIds) {
+    for (let index = 0; index < retrievedIds.length; index += 1) {
+        if (relevantIds.includes(retrievedIds[index])) {
+            return 1 / (index + 1);
+        }
+    }
+    return 0;
+}
+function ndcgAtK(relevantIds, retrievedIds) {
+    const relevanceSet = new Set(relevantIds);
+    const dcg = retrievedIds.reduce((sum, id, index) => {
+        const rel = relevanceSet.has(id) ? 1 : 0;
+        if (rel === 0) {
+            return sum;
+        }
+        return sum + 1 / Math.log2(index + 2);
+    }, 0);
+    const idealLength = Math.min(relevantIds.length, retrievedIds.length);
+    const idcg = Array.from({ length: idealLength }).reduce((sum, _, index) => sum + 1 / Math.log2(index + 2), 0);
+    if (idcg === 0) {
+        return 0;
+    }
+    return dcg / idcg;
+}
+function mean(values) {
+    if (values.length === 0) {
+        return 0;
+    }
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function buildScopeFilters(entry) {
+    return {
+        tenant_id: entry.tenant_id,
+        workspace_id: entry.workspace_id,
+        ...(entry.channel ? { channel: entry.channel } : {}),
+        ...(entry.thread_key ? { thread_key: entry.thread_key } : {}),
+        embedding_provider: "voyage",
+        embedding_model: "voyage-4-large"
+    };
+}
+async function run() {
+    const options = parseArgs(process.argv.slice(2));
+    const config = loadRuntimeConfig();
+    if (!config.mongo.uri) {
+        throw new Error("CLAWMONGO_MONGODB_URI is required for retrieval evaluation runs.");
+    }
+    const fixtureBundle = await loadRetrievalFixtureBundle();
+    const lexical = new MongoLexicalRetriever({
+        deploymentProfile: config.deploymentProfile,
+        uri: config.mongo.uri,
+        dbName: config.mongo.dbName,
+        connectTimeoutMs: config.mongo.connectTimeoutMs
+    });
+    const vector = new MongoVectorRetriever({
+        deploymentProfile: config.deploymentProfile,
+        uri: config.mongo.uri,
+        dbName: config.mongo.dbName,
+        connectTimeoutMs: config.mongo.connectTimeoutMs
+    });
+    const fusion = new AdaptiveFusionRetriever({
+        supportsNativeFusion: DEPLOYMENT_PROFILES[config.deploymentProfile].search.native_fusion,
+        uri: config.mongo.uri,
+        dbName: config.mongo.dbName,
+        connectTimeoutMs: config.mongo.connectTimeoutMs
+    });
+    const engine = new RetrievalEngine(lexical, vector, fusion);
+    const variants = options.variant === "all" ? ["lexical", "vector", "hybrid"] : [options.variant];
+    const perVariantRows = {
+        lexical: [],
+        vector: [],
+        hybrid: []
+    };
+    for (const variant of variants) {
+        for (const query of fixtureBundle.queries.queries) {
+            const scopeFilters = buildScopeFilters(query);
+            const startedAt = performance.now();
+            let retrievedIds = [];
+            if (variant === "vector") {
+                const vectorStage = await vector.searchWithTelemetry({
+                    query: query.query,
+                    scopeFilters,
+                    topK: options.topK,
+                    profile: config.deploymentProfile,
+                    preferNativeFusion: true
+                });
+                retrievedIds = vectorStage.hits.slice(0, options.topK).map((hit) => hit.id);
+            }
+            else {
+                const response = await engine.retrieve({
+                    query: query.query,
+                    scopeFilters,
+                    topK: options.topK,
+                    profile: config.deploymentProfile,
+                    preferNativeFusion: variant === "hybrid"
+                });
+                retrievedIds = response.hits.slice(0, options.topK).map((hit) => hit.id);
+            }
+            const latencyMs = Number((performance.now() - startedAt).toFixed(3));
+            const relevantIds = query.expected_chunk_ids;
+            const row = {
+                queryId: query.query_id,
+                variant,
+                relevant: relevantIds.length,
+                retrieved: retrievedIds,
+                recallAtK: Number(recallAtK(relevantIds, retrievedIds).toFixed(6)),
+                mrrAtK: Number(mrrAtK(relevantIds, retrievedIds).toFixed(6)),
+                ndcgAtK: Number(ndcgAtK(relevantIds, retrievedIds).toFixed(6)),
+                exactTokenHit: query.critical_exact
+                    ? relevantIds.some((id) => retrievedIds.includes(id))
+                    : null,
+                latencyMs
+            };
+            perVariantRows[variant].push(row);
+        }
+    }
+    const metrics = Object.fromEntries(variants.map((variant) => {
+        const rows = perVariantRows[variant];
+        const latencies = rows.map((row) => row.latencyMs);
+        const exactRows = rows.filter((row) => row.exactTokenHit !== null);
+        const exactTokenHitRate = exactRows.length === 0
+            ? null
+            : Number((exactRows.filter((row) => row.exactTokenHit === true).length / exactRows.length).toFixed(6));
+        return [
+            variant,
+            {
+                queryCount: rows.length,
+                recallAtK: Number(mean(rows.map((row) => row.recallAtK)).toFixed(6)),
+                mrrAtK: Number(mean(rows.map((row) => row.mrrAtK)).toFixed(6)),
+                ndcgAtK: Number(mean(rows.map((row) => row.ndcgAtK)).toFixed(6)),
+                exactTokenHitRateAtK: exactTokenHitRate,
+                latencyMs: {
+                    p50: percentile(latencies, 50),
+                    p95: percentile(latencies, 95),
+                    p99: percentile(latencies, 99)
+                }
+            }
+        ];
+    }));
+    process.stdout.write(`${JSON.stringify({
+        status: "PASS",
+        profile: config.deploymentProfile,
+        topK: options.topK,
+        dataset: {
+            datasetId: fixtureBundle.corpus.dataset_id,
+            version: fixtureBundle.corpus.version,
+            fingerprint: fixtureBundle.fingerprint,
+            queryCount: fixtureBundle.queries.queries.length
+        },
+        variants,
+        metrics,
+        sampleRows: Object.fromEntries(variants.map((variant) => [variant, perVariantRows[variant].slice(0, 3)]))
+    }, null, 2)}\n`);
+}
+void run().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`retrieval-eval failed: ${message}\n`);
+    process.exitCode = 1;
+});

package/dist/cli/retrieval-provider-smoke.js

@@ -0,0 +1,52 @@
+import assert from "node:assert/strict";
+import { loadRuntimeConfig } from "../config/env.js";
+import { MongoLexicalRetriever } from "../retrieval/providers/lexical.js";
+import { MongoVectorRetriever } from "../retrieval/providers/vector.js";
+const run = async () => {
+    const config = loadRuntimeConfig();
+    const lexical = new MongoLexicalRetriever({
+        deploymentProfile: config.deploymentProfile,
+        uri: config.mongo.uri,
+        dbName: config.mongo.dbName,
+        connectTimeoutMs: config.mongo.connectTimeoutMs
+    });
+    const vector = new MongoVectorRetriever({
+        deploymentProfile: config.deploymentProfile,
+        uri: config.mongo.uri,
+        dbName: config.mongo.dbName,
+        connectTimeoutMs: config.mongo.connectTimeoutMs
+    });
+    const query = {
+        query: "Slack IDs must preserve case D0ADSDZ345P",
+        scopeFilters: {
+            tenant_id: "tenant-demo",
+            workspace_id: "workspace-alpha",
+            embedding_provider: "voyage",
+            embedding_model: "voyage-4-large"
+        },
+        topK: 3,
+        profile: config.deploymentProfile,
+        preferNativeFusion: true
+    };
+    const lexicalResult = await lexical.searchWithTelemetry(query);
+    const vectorResult = await vector.searchWithTelemetry(query);
+    assert.equal(lexicalResult.telemetry.stage, "lexical");
+    assert.equal(vectorResult.telemetry.stage, "vector");
+    assert.equal(lexicalResult.telemetry.resultCount, lexicalResult.hits.length);
+    assert.equal(vectorResult.telemetry.resultCount, vectorResult.hits.length);
+    process.stdout.write(`${JSON.stringify({
+        status: "PASS",
+        profile: config.deploymentProfile,
+        lexical: {
+            hitCount: lexicalResult.hits.length,
+            topHit: lexicalResult.hits[0]?.id ?? null,
+            telemetry: lexicalResult.telemetry
+        },
+        vector: {
+            hitCount: vectorResult.hits.length,
+            topHit: vectorResult.hits[0]?.id ?? null,
+            telemetry: vectorResult.telemetry
+        }
+    }, null, 2)}\n`);
+};
+void run();

package/dist/cli/retrieval-seed-reembed-smoke.js

@@ -0,0 +1,54 @@
+import assert from "node:assert/strict";
+import { loadRetrievalFixtureBundle } from "../retrieval/fixtures.js";
+import { reembedFixtureChunks } from "../retrieval/reembed.js";
+async function run() {
+    const bundle = await loadRetrievalFixtureBundle();
+    const result = await reembedFixtureChunks(bundle.corpus.chunks, {
+        live: false
+    });
+    assert.equal(result.summary.enabled, true);
+    assert.equal(result.summary.inputType, "document");
+    assert.equal(result.summary.live, false);
+    assert.equal(result.summary.remoteBatchRequested, false);
+    assert.equal(result.summary.chunkCount, bundle.corpus.chunks.length);
+    assert.ok(result.summary.groups > 0);
+    assert.ok(Object.keys(result.summary.providers).length > 0);
+    assert.ok(Object.keys(result.summary.models).length > 0);
+    assert.ok((result.summary.backendSources.deterministic ?? 0) > 0);
+    assert.ok(result.summary.dimensions.every((value) => Number.isInteger(value) && value > 0));
+    const firstChunk = result.chunks[0];
+    const originalFirst = bundle.corpus.chunks[0];
+    assert.ok(firstChunk, "Expected at least one fixture chunk after re-embedding.");
+    assert.ok(originalFirst, "Expected at least one original fixture chunk.");
+    assert.equal(firstChunk.embedding_provider.length > 0, true);
+    assert.equal(firstChunk.embedding_model.length > 0, true);
+    assert.equal(firstChunk.embedding.length > 0, true);
+    assert.equal(firstChunk.doc_id, originalFirst.doc_id);
+    assert.equal(firstChunk.chunk_id, originalFirst.chunk_id);
+    process.stdout.write(`${JSON.stringify({
+        status: "PASS",
+        checks: [
+            {
+                id: "reembed_document_input_contract",
+                ok: true,
+                summary: result.summary
+            },
+            {
+                id: "reembed_chunk_identity_stability",
+                ok: true,
+                firstChunk: {
+                    doc_id: firstChunk.doc_id,
+                    chunk_id: firstChunk.chunk_id,
+                    embedding_provider: firstChunk.embedding_provider,
+                    embedding_model: firstChunk.embedding_model,
+                    dimensions: firstChunk.embedding.length
+                }
+            }
+        ]
+    }, null, 2)}\n`);
+}
+void run().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`retrieval-seed-reembed-smoke failed: ${message}\n`);
+    process.exitCode = 1;
+});

package/dist/cli/retrieval-seed.js

@@ -0,0 +1,312 @@
+import { MongoClient } from "mongodb";
+import { loadRuntimeConfig } from "../config/env.js";
+import { loadRetrievalFixtureBundle, summarizeRetrievalFixture } from "../retrieval/fixtures.js";
+import { reembedFixtureChunks } from "../retrieval/reembed.js";
+function parseArgs(argv) {
+    const options = {
+        apply: false,
+        reset: false,
+        reembed: false,
+        reembedLive: false,
+        reembedVoyageRemoteBatch: false,
+        reembedVoyageRemoteBatchWait: true
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--apply") {
+            options.apply = true;
+            continue;
+        }
+        if (token === "--reset") {
+            options.reset = true;
+            continue;
+        }
+        if (token === "--corpus") {
+            options.corpusPath = argv[index + 1];
+            index += 1;
+            continue;
+        }
+        if (token === "--queries") {
+            options.queriesPath = argv[index + 1];
+            index += 1;
+            continue;
+        }
+        if (token === "--reembed") {
+            options.reembed = true;
+            continue;
+        }
+        if (token === "--reembed-provider") {
+            options.reembedProvider = argv[index + 1];
+            index += 1;
+            continue;
+        }
+        if (token === "--reembed-model") {
+            options.reembedModel = argv[index + 1];
+            index += 1;
+            continue;
+        }
+        if (token === "--reembed-dimensions") {
+            options.reembedDimensions = Number(argv[index + 1]);
+            index += 1;
+            continue;
+        }
+        if (token === "--reembed-live") {
+            options.reembedLive = true;
+            continue;
+        }
+        if (token === "--reembed-voyage-remote-batch") {
+            options.reembedVoyageRemoteBatch = true;
+            continue;
+        }
+        if (token === "--reembed-voyage-remote-batch-min-texts") {
+            options.reembedVoyageRemoteBatchMinTexts = Number(argv[index + 1]);
+            index += 1;
+            continue;
+        }
+        if (token === "--reembed-voyage-remote-batch-no-wait") {
+            options.reembedVoyageRemoteBatchWait = false;
+            continue;
+        }
+        if (token === "--reembed-voyage-remote-batch-poll-ms") {
+            options.reembedVoyageRemoteBatchPollMs = Number(argv[index + 1]);
+            index += 1;
+            continue;
+        }
+        if (token === "--reembed-voyage-remote-batch-timeout-ms") {
+            options.reembedVoyageRemoteBatchTimeoutMs = Number(argv[index + 1]);
+            index += 1;
+            continue;
+        }
+        if (token === "--reembed-voyage-remote-batch-concurrency") {
+            options.reembedVoyageRemoteBatchConcurrency = Number(argv[index + 1]);
+            index += 1;
+            continue;
+        }
+        if (token === "--help") {
+            process.stdout.write([
+                "Usage: npm run retrieval:seed -- [--apply] [--reset] [--corpus <path>] [--queries <path>]",
+                "",
+                "Options:",
+                "  --apply   write fixture corpus + queries into MongoDB",
+                "  --reset   delete current dataset rows before writing",
+                "  --corpus  override fixture corpus path",
+                "  --queries override fixture queries path",
+                "  --reembed             regenerate chunk embeddings using provider abstraction (inputType=document)",
+                "  --reembed-provider    override embedding provider for all chunks (requires --reembed-model)",
+                "  --reembed-model       override embedding model for all chunks",
+                "  --reembed-dimensions  override embedding dimensions for all chunks",
+                "  --reembed-live        use live provider adapters for re-embedding",
+                "  --reembed-voyage-remote-batch                   use Voyage /files + /batches mode for document embeddings (live only)",
+                "  --reembed-voyage-remote-batch-min-texts <n>     minimum texts to trigger remote batch mode",
+                "  --reembed-voyage-remote-batch-no-wait           submit batch without waiting for completion",
+                "  --reembed-voyage-remote-batch-poll-ms <n>       poll interval for batch completion",
+                "  --reembed-voyage-remote-batch-timeout-ms <n>    timeout for batch completion",
+                "  --reembed-voyage-remote-batch-concurrency <n>   concurrent remote batch groups"
+            ].join("\n") + "\n");
+            process.exit(0);
+        }
+        throw new Error(`Unknown argument: ${token}`);
+    }
+    return options;
+}
+function toDate(value) {
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime())) {
+        throw new Error(`Invalid fixture datetime: '${value}'`);
+    }
+    return parsed;
+}
+function validateOptions(options) {
+    if (options.reembedProvider && !options.reembedModel) {
+        throw new Error("--reembed-provider requires --reembed-model so provider/model overrides stay explicit.");
+    }
+    const remoteBatchTuneFlagsUsed = typeof options.reembedVoyageRemoteBatchMinTexts === "number" ||
+        typeof options.reembedVoyageRemoteBatchPollMs === "number" ||
+        typeof options.reembedVoyageRemoteBatchTimeoutMs === "number" ||
+        typeof options.reembedVoyageRemoteBatchConcurrency === "number" ||
+        options.reembedVoyageRemoteBatchWait === false;
+    if (options.reembedVoyageRemoteBatch || remoteBatchTuneFlagsUsed) {
+        if (!options.reembed) {
+            throw new Error("Voyage remote-batch flags require --reembed because they only apply to re-embedding.");
+        }
+        if (!options.reembedLive) {
+            throw new Error("Voyage remote-batch requires --reembed-live because remote /files + /batches is a live-provider path.");
+        }
+        if (options.reembedProvider &&
+            options.reembedProvider.trim().toLowerCase() !== "voyage") {
+            throw new Error("Voyage remote-batch flags can only be used when re-embedding provider is voyage.");
+        }
+    }
+}
+async function run() {
+    const options = parseArgs(process.argv.slice(2));
+    validateOptions(options);
+    const config = loadRuntimeConfig();
+    const fixturePaths = {
+        corpusPath: options.corpusPath,
+        queriesPath: options.queriesPath
+    };
+    const bundle = await loadRetrievalFixtureBundle(fixturePaths);
+    const summary = summarizeRetrievalFixture(bundle);
+    let reembedSummary = null;
+    let corpusChunks = bundle.corpus.chunks;
+    if (options.reembed) {
+        const reembedded = await reembedFixtureChunks(bundle.corpus.chunks, {
+            provider: options.reembedProvider,
+            model: options.reembedModel,
+            dimensions: options.reembedDimensions,
+            live: options.reembedLive,
+            remoteBatch: options.reembedVoyageRemoteBatch,
+            remoteBatchMinTexts: options.reembedVoyageRemoteBatchMinTexts,
+            remoteBatchWait: options.reembedVoyageRemoteBatchWait,
+            remoteBatchPollIntervalMs: options.reembedVoyageRemoteBatchPollMs,
+            remoteBatchTimeoutMs: options.reembedVoyageRemoteBatchTimeoutMs,
+            remoteBatchConcurrency: options.reembedVoyageRemoteBatchConcurrency
+        });
+        corpusChunks = reembedded.chunks;
+        reembedSummary = reembedded.summary;
+    }
+    if (!options.apply) {
+        process.stdout.write(`${JSON.stringify({
+            status: "DRY_RUN",
+            apply: false,
+            reset: options.reset,
+            dataset: summary,
+            reembed: reembedSummary,
+            files: {
+                corpusPath: bundle.corpusPath,
+                queriesPath: bundle.queriesPath
+            }
+        }, null, 2)}\n`);
+        return;
+    }
+    if (!config.mongo.uri) {
+        throw new Error("CLAWMONGO_MONGODB_URI is required when --apply is set.");
+    }
+    const client = new MongoClient(config.mongo.uri, {
+        appName: "clawmongo-retrieval-seed",
+        serverSelectionTimeoutMS: config.mongo.connectTimeoutMs
+    });
+    await client.connect();
+    try {
+        const db = client.db(config.mongo.dbName);
+        const memoryChunks = db.collection("memory_chunks");
+        const retrievalQueries = db.collection("retrieval_eval_queries");
+        const resetResult = {
+            memoryChunksDeleted: 0,
+            retrievalQueriesDeleted: 0
+        };
+        if (options.reset) {
+            const [chunksDelete, queriesDelete] = await Promise.all([
+                memoryChunks.deleteMany({ fixture_dataset: summary.datasetId }),
+                retrievalQueries.deleteMany({ fixture_dataset: summary.datasetId })
+            ]);
+            resetResult.memoryChunksDeleted = chunksDelete.deletedCount;
+            resetResult.retrievalQueriesDeleted = queriesDelete.deletedCount;
+        }
+        const chunkWrites = await memoryChunks.bulkWrite(corpusChunks.map((chunk) => {
+            const eventTs = toDate(chunk.timestamp);
+            const payload = {
+                tenant_id: chunk.tenant_id,
+                workspace_id: chunk.workspace_id,
+                chunk_id: chunk.chunk_id,
+                text: chunk.text,
+                embedding: chunk.embedding,
+                embedding_provider: chunk.embedding_provider,
+                embedding_model: chunk.embedding_model,
+                event_ts: eventTs,
+                schema_version: chunk.schema_version,
+                updated_at: eventTs,
+                doc_id: chunk.doc_id,
+                source_type: chunk.source_type,
+                channel: chunk.channel,
+                thread_key: chunk.thread_key,
+                language: chunk.language,
+                fixture_dataset: summary.datasetId,
+                fixture_fingerprint: summary.fingerprint
+            };
+            return {
+                updateOne: {
+                    filter: {
+                        tenant_id: chunk.tenant_id,
+                        workspace_id: chunk.workspace_id,
+                        chunk_id: chunk.chunk_id
+                    },
+                    update: {
+                        $set: payload,
+                        $setOnInsert: {
+                            created_at: eventTs
+                        }
+                    },
+                    upsert: true
+                }
+            };
+        }), { ordered: false });
+        const queryTimestamp = toDate(bundle.corpus.generated_at);
+        const queryWrites = await retrievalQueries.bulkWrite(bundle.queries.queries.map((query) => {
+            const payload = {
+                fixture_dataset: summary.datasetId,
+                fixture_fingerprint: summary.fingerprint,
+                query_id: query.query_id,
+                query_class: query.query_class,
+                query: query.query,
+                tenant_id: query.tenant_id,
+                workspace_id: query.workspace_id,
+                channel: query.channel ?? null,
+                thread_key: query.thread_key ?? null,
+                time_range: query.time_range ?? null,
+                expected_chunk_ids: query.expected_chunk_ids,
+                critical_exact: query.critical_exact,
+                scope_valid: query.scope_valid,
+                updated_at: queryTimestamp
+            };
+            return {
+                updateOne: {
+                    filter: {
+                        fixture_dataset: summary.datasetId,
+                        query_id: query.query_id
+                    },
+                    update: {
+                        $set: payload,
+                        $setOnInsert: {
+                            created_at: queryTimestamp
+                        }
+                    },
+                    upsert: true
+                }
+            };
+        }), { ordered: false });
+        process.stdout.write(`${JSON.stringify({
+            status: "APPLIED",
+            apply: true,
+            reset: options.reset,
+            dataset: summary,
+            reembed: reembedSummary,
+            files: {
+                corpusPath: bundle.corpusPath,
+                queriesPath: bundle.queriesPath
+            },
+            resetResult,
+            writes: {
+                memory_chunks: {
+                    matchedCount: chunkWrites.matchedCount,
+                    modifiedCount: chunkWrites.modifiedCount,
+                    upsertedCount: chunkWrites.upsertedCount
+                },
+                retrieval_eval_queries: {
+                    matchedCount: queryWrites.matchedCount,
+                    modifiedCount: queryWrites.modifiedCount,
+                    upsertedCount: queryWrites.upsertedCount
+                }
+            }
+        }, null, 2)}\n`);
+    }
+    finally {
+        await client.close();
+    }
+}
+void run().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`retrieval-seed failed: ${message}\n`);
+    process.exitCode = 1;
+});