@murphai/murph 1.3.0 → 1.3.2

package/node_modules/@murphai/assistant-engine/dist/assistant/outbox/store.js

@@ -1,9 +1,14 @@
-import { readdir, readFile, rename, rm } from 'node:fs/promises';
+import { createHash, randomUUID } from 'node:crypto';
+import { access, readdir, readFile, rename, rm } from 'node:fs/promises';
 import path from 'node:path';
-import { assistantOutboxIntentSchema, } from '@murphai/operator-config/assistant-cli-contracts';
+import { assistantOutboxIntentIdSchema, assistantOutboxIntentSchema, assistantResponseMediaSchema, } from '@murphai/operator-config/assistant-cli-contracts';
+import * as z from '@murphai/contracts/zod-runtime';
 import { parseHostedEmailThreadTarget } from '@murphai/runtime-state';
+import { VaultCliError } from '@murphai/operator-config/vault-cli-errors';
+import { adoptAssistantStateFile, openSqliteRuntimeDatabase, readSqliteRuntimeUserVersion, withImmediateTransaction, writeSqliteRuntimeUserVersion, } from '@murphai/runtime-state/node';
 import { recordAssistantDiagnosticEvent } from '../diagnostics.js';
 import { withAssistantRuntimeWriteLock } from '../runtime-write-lock.js';
+import { hasAssistantOutboxDeliveryEvidence } from '../response-media.js';
 import { ensureAssistantState } from '../store/persistence.js';
 import { resolveAssistantStatePaths } from '../store.js';
 import { compareAssistantTimestampsAscending, ensureAssistantStateDirectory, isMissingFileError, normalizeNullableString, writeJsonFileAtomic, } from '../shared.js';
@@ -14,6 +19,21 @@ import { compareAssistantOutboxDeliverySequenceOrder } from './ordering.js';
 import { readAssistantCronCanonicalRuntimeStore } from '../cron/runtime-state.js';
 const ASSISTANT_TERMINAL_OUTBOX_RETENTION_LIMIT = 100;
 const ASSISTANT_TERMINAL_OUTBOX_RETENTION_MS = 14 * 24 * 60 * 60 * 1000;
+const ASSISTANT_OUTBOX_INVENTORY_READ_CONCURRENCY = 4;
+const ASSISTANT_OUTBOX_DEDUPE_DATABASE_NAME = 'outbox-dedupe.sqlite';
+const ASSISTANT_OUTBOX_DEDUPE_DATABASE_VERSION = 1;
+const ASSISTANT_OUTBOX_LEGACY_DEDUPE_FALLBACK_LIMIT = 100;
+const ASSISTANT_OUTBOX_FOREGROUND_ROUTE_LIMIT = 100;
+const ASSISTANT_OUTBOX_FOREGROUND_PROVIDER_MESSAGE_LIMIT = 50;
+class AssistantOutboxDedupeDatabaseValidationError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'AssistantOutboxDedupeDatabaseValidationError';
+    }
+}
+const assistantOutboxDedupeMediaListSchema = z
+    .array(assistantResponseMediaSchema)
+    .max(40);
 export async function readAssistantOutboxIntent(vault, intentId) {
     const paths = resolveAssistantStatePaths(vault);
     await ensureAssistantState(paths);
@@ -23,27 +43,49 @@ export async function saveAssistantOutboxIntent(vault, intent) {
     return withAssistantRuntimeWriteLock(vault, async (paths) => {
         await ensureAssistantState(paths);
         const parsed = assistantOutboxIntentSchema.parse(sanitizeAssistantOutboxIntentForPersistence(intent));
-        const persisted = sanitizeAssistantOutboxIntentForPersistence(parsed);
-        await writeJsonFileAtomic(resolveAssistantOutboxIntentPath(paths.outboxDirectory, parsed.intentId), persisted);
-        return parsed;
+        return await persistAssistantOutboxIntentAtPath({
+            intent: parsed,
+            intentPath: resolveAssistantOutboxIntentPath(paths.outboxDirectory, parsed.intentId),
+            paths,
+        });
     });
 }
-export async function listAssistantOutboxIntentsLocal(vault) {
+export async function persistAssistantOutboxIntentAtPath(input) {
+    const parsed = assistantOutboxIntentSchema.parse(sanitizeAssistantOutboxIntentForPersistence(input.intent));
+    const persisted = sanitizeAssistantOutboxIntentForPersistence(parsed);
+    if (isActiveAssistantOutboxIntent(parsed)) {
+        await synchronizeAssistantOutboxDedupeProjection(input.paths, parsed, input.dedupeIdentityOrigin ?? 'unknown');
+        await writeJsonFileAtomic(input.intentPath, persisted);
+    }
+    else {
+        await writeJsonFileAtomic(input.intentPath, persisted);
+        await synchronizeAssistantOutboxDedupeProjection(input.paths, parsed, input.dedupeIdentityOrigin ?? 'unknown');
+    }
+    return parsed;
+}
+export async function listAssistantOutboxIntentsLocal(vault, onScan) {
     const paths = resolveAssistantStatePaths(vault);
     await ensureAssistantState(paths);
     const entries = await readdir(paths.outboxDirectory, {
         withFileTypes: true,
     });
+    const inventoryEntries = entries.filter((entry) => entry.isFile() && entry.name.endsWith('.json'));
     const intents = [];
-    for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith('.json')) {
-            continue;
-        }
-        const intent = await readAssistantOutboxIntentInventoryEntry(vault, path.join(paths.outboxDirectory, entry.name));
-        if (intent) {
-            intents.push(intent);
+    let bytesRead = 0;
+    let filesRead = 0;
+    for (let index = 0; index < inventoryEntries.length; index += ASSISTANT_OUTBOX_INVENTORY_READ_CONCURRENCY) {
+        const batch = inventoryEntries.slice(index, index + ASSISTANT_OUTBOX_INVENTORY_READ_CONCURRENCY);
+        const batchIntents = await Promise.all(batch.map((entry) => readAssistantOutboxIntentInventoryEntry(vault, path.join(paths.outboxDirectory, entry.name), (bytes) => {
+            bytesRead += bytes;
+            filesRead += 1;
+        })));
+        for (const intent of batchIntents) {
+            if (intent) {
+                intents.push(intent);
+            }
         }
     }
+    onScan?.({ bytesRead, filesRead });
     return intents.sort((left, right) => compareAssistantTimestampsAscending(left.createdAt, right.createdAt) ||
         compareAssistantOutboxDeliverySequenceOrder(left, right));
 }
@@ -54,7 +96,7 @@ export async function pruneAssistantTerminalOutboxIntents(input) {
     });
     const cutoffMs = input.now.getTime() - ASSISTANT_TERMINAL_OUTBOX_RETENTION_MS;
     const terminalIntents = [];
-    const protectedNewsletterOccurrencePrefixes = await readProtectedNewsletterOccurrencePrefixes(input.paths);
+    const protectedGroupEmailOccurrencePrefixes = await readProtectedGroupEmailOccurrencePrefixes(input.paths);
     for (const entry of entries) {
         if (!entry.isFile() || !entry.name.endsWith('.json')) {
             continue;
@@ -63,7 +105,7 @@ export async function pruneAssistantTerminalOutboxIntents(input) {
         const intent = await readAssistantOutboxIntentInventoryEntry(input.vault, intentPath);
         if (!intent
             || !isTerminalAssistantOutboxIntent(intent)
-            || isPruneProtectedAssistantOutboxIntent(intent, protectedNewsletterOccurrencePrefixes)) {
+            || isPruneProtectedAssistantOutboxIntent(intent, protectedGroupEmailOccurrencePrefixes)) {
             continue;
         }
         terminalIntents.push({
@@ -80,8 +122,14 @@ export async function pruneAssistantTerminalOutboxIntents(input) {
         return compareAssistantTimestampsAscending(right.intent.createdAt, left.intent.createdAt);
     });
     let pruned = 0;
-    for (const [index, entry] of terminalIntents.entries()) {
-        const pruneByCount = index >= ASSISTANT_TERMINAL_OUTBOX_RETENTION_LIMIT;
+    let countPrunableIntentCount = 0;
+    for (const entry of terminalIntents) {
+        const preserveUntilAgeCutoff = isGeneratedImageDeliveryEvidenceIntent(entry.intent);
+        const pruneByCount = !preserveUntilAgeCutoff
+            && countPrunableIntentCount >= ASSISTANT_TERMINAL_OUTBOX_RETENTION_LIMIT;
+        if (!preserveUntilAgeCutoff) {
+            countPrunableIntentCount += 1;
+        }
         const pruneByAge = Number.isFinite(entry.terminalAtMs) && entry.terminalAtMs < cutoffMs;
         if (!pruneByCount && !pruneByAge) {
             continue;
@@ -89,37 +137,159 @@ export async function pruneAssistantTerminalOutboxIntents(input) {
         await rm(entry.intentPath, {
             force: true,
         });
+        await removeAssistantOutboxDedupeProjectionIntent(input.paths, entry.intent.intentId);
         pruned += 1;
     }
     return pruned;
 }
 export async function findAssistantOutboxIntentByDedupeIdentity(input) {
-    const intents = await listAssistantOutboxIntentsLocal(input.vault);
-    const activeIntents = intents.filter(isActiveAssistantOutboxIntent);
-    const exactMatch = activeIntents.find((intent) => intent.dedupeKey === input.dedupeKey);
-    if (exactMatch) {
-        return exactMatch;
-    }
+    const paths = resolveAssistantStatePaths(input.vault);
+    await ensureAssistantState(paths);
     const dedupeToken = normalizeNullableString(input.dedupeToken);
     const deliveryIdempotencyKey = normalizeNullableString(input.deliveryIdempotencyKey);
-    if (dedupeToken && dedupeToken === deliveryIdempotencyKey) {
-        const transportKeyMatch = activeIntents.find((intent) => normalizeNullableString(intent.deliveryIdempotencyKey) ===
-            deliveryIdempotencyKey);
-        if (transportKeyMatch) {
-            return transportKeyMatch;
-        }
+    const dedupeKey = normalizeNullableString(input.dedupeKey);
+    const routes = [
+        ...(dedupeKey
+            ? [{
+                    kind: 'dedupe-key',
+                    key: dedupeKey,
+                    matches: (intent) => intent.dedupeKey === dedupeKey,
+                }]
+            : []),
+        ...(deliveryIdempotencyKey
+            ? [{
+                    kind: 'delivery-idempotency-key',
+                    key: deliveryIdempotencyKey,
+                    matches: (intent) => normalizeNullableString(intent.deliveryIdempotencyKey) ===
+                        deliveryIdempotencyKey,
+                }]
+            : []),
+        ...(normalizeNullableString(input.legacyDedupeKey)
+            ? [{
+                    kind: 'dedupe-key',
+                    key: normalizeNullableString(input.legacyDedupeKey),
+                    matches: (intent) => intent.dedupeKey === normalizeNullableString(input.legacyDedupeKey),
+                }]
+            : []),
+    ];
+    const projectedMatch = await findAssistantOutboxIntentByProjectedRoutes({
+        paths,
+        rebuildOnStale: true,
+        routes,
+        vault: input.vault,
+    });
+    if (projectedMatch) {
+        return projectedMatch;
     }
-    return (activeIntents.find((intent) => {
-        const legacyDedupeKey = hashAssistantOutboxLegacyMediaDedupeIdentity({
-            dedupeToken,
-            media: intent.media,
+    if (deliveryIdempotencyKey || input.skipLegacyMediaFallback) {
+        // A rebuilt exact transport route owns hosted retry identity. Once that
+        // route misses, or a caller has a stable shared transport identity,
+        // media-sensitive pre-migration recovery cannot legitimately match and
+        // must not turn unrelated retained media into an admission cap.
+        return null;
+    }
+    return await findAssistantOutboxIntentByLegacyMediaIdentity({
+        dedupeToken,
+        paths,
+        vault: input.vault,
+    });
+}
+export async function listAssistantOutboxIntentsForAutoReplyRoute(input) {
+    const paths = resolveAssistantStatePaths(input.vault);
+    await ensureAssistantState(paths);
+    const routeTags = resolveAssistantOutboxAutoReplyQueryTags(input);
+    const providerTags = [...new Set((input.providerMessageIds ?? [])
+            .map(normalizeNullableString)
+            .filter((value) => value !== null))]
+        .slice(0, ASSISTANT_OUTBOX_FOREGROUND_PROVIDER_MESSAGE_LIMIT)
+        .map((providerMessageId) => resolveAssistantOutboxForegroundTagDigest('auto-provider-message', { providerMessageId }));
+    const providerIntentIds = [];
+    for (const providerTag of providerTags) {
+        providerIntentIds.push(...await readAssistantOutboxForegroundProviderIntentIds({
+            // One route-local match resolves an exact native-reply anchor; two
+            // prove ambiguity for that provider message id.
+            limit: 2,
+            paths,
+            providerTag,
+            routeTags,
+        }));
+    }
+    const routeIntentIds = await readAssistantOutboxForegroundTagIntentIds({
+        limit: ASSISTANT_OUTBOX_FOREGROUND_ROUTE_LIMIT,
+        newestFirst: true,
+        paths,
+        tagDigests: routeTags,
+    });
+    const intentIds = [...new Set([
+            ...providerIntentIds,
+            ...routeIntentIds,
+        ])].slice(0, ASSISTANT_OUTBOX_FOREGROUND_ROUTE_LIMIT);
+    return await readAssistantOutboxProjectedIntents({
+        intentIds,
+        paths,
+        vault: input.vault,
+    });
+}
+export async function listAssistantOutboxIntentsForPrivateCompletionRoute(input) {
+    const paths = resolveAssistantStatePaths(input.vault);
+    await ensureAssistantState(paths);
+    const tagDigest = resolveAssistantOutboxForegroundTagDigest('private-completion-route', {
+        actorId: input.actorId,
+        bindingDeliveryKind: input.bindingDeliveryKind,
+        bindingDeliveryTarget: input.bindingDeliveryTarget,
+        channel: input.channel,
+        identityId: input.identityId,
+        threadId: input.threadId,
+    });
+    const intentIds = await readAssistantOutboxForegroundTagIntentIds({
+        limit: ASSISTANT_OUTBOX_FOREGROUND_ROUTE_LIMIT + 1,
+        newestFirst: false,
+        paths,
+        tagDigests: [tagDigest],
+    });
+    if (intentIds.length > ASSISTANT_OUTBOX_FOREGROUND_ROUTE_LIMIT) {
+        throw new VaultCliError('ASSISTANT_PRIVATE_COMPLETION_ROUTE_BOUND_EXCEEDED', `Assistant private completion recovery exceeded its fixed ${ASSISTANT_OUTBOX_FOREGROUND_ROUTE_LIMIT}-intent route bound.`);
+    }
+    return await readAssistantOutboxProjectedIntents({
+        intentIds,
+        paths,
+        vault: input.vault,
+    });
+}
+async function findAssistantOutboxIntentByProjectedRoutes(input) {
+    const intentIds = await readAssistantOutboxDedupeRoutes(input.paths, input.routes);
+    for (const [index, route] of input.routes.entries()) {
+        const intentId = intentIds[index];
+        if (!intentId) {
+            continue;
+        }
+        const intent = await readAssistantOutboxIntentAtPath(resolveAssistantOutboxIntentPath(input.paths.outboxDirectory, intentId), { vault: input.vault });
+        if (intent &&
+            isActiveAssistantOutboxIntent(intent) &&
+            route.matches(intent)) {
+            return intent;
+        }
+        if (input.rebuildOnStale) {
+            await rebuildAssistantOutboxDedupeDatabaseWithWriteLock(input.paths);
+            return await findAssistantOutboxIntentByProjectedRoutes({
+                ...input,
+                rebuildOnStale: false,
+            });
+        }
+        await removeAssistantOutboxDedupeProjectionRouteIfOwned({
+            intentId,
+            kind: route.kind,
+            key: route.key,
+            paths: input.paths,
         });
-        return legacyDedupeKey !== null && intent.dedupeKey === legacyDedupeKey;
-    }) ?? null);
+    }
+    return null;
 }
 export async function readAssistantOutboxIntentAtPath(intentPath, options) {
     try {
-        return assistantOutboxIntentSchema.parse(JSON.parse(await readFile(intentPath, 'utf8')));
+        const raw = await readFile(intentPath, 'utf8');
+        options?.onBytesRead?.(Buffer.byteLength(raw, 'utf8'));
+        return assistantOutboxIntentSchema.parse(JSON.parse(raw));
     }
     catch (error) {
         if (isMissingFileError(error)) {
@@ -136,8 +306,11 @@ export async function readAssistantOutboxIntentAtPath(intentPath, options) {
         throw error;
     }
 }
-export async function readAssistantOutboxIntentInventoryEntry(vault, intentPath) {
-    return readAssistantOutboxIntentAtPath(intentPath, { vault });
+export async function readAssistantOutboxIntentInventoryEntry(vault, intentPath, onBytesRead) {
+    return readAssistantOutboxIntentAtPath(intentPath, {
+        ...(onBytesRead ? { onBytesRead } : {}),
+        vault,
+    });
 }
 export async function quarantineAssistantOutboxIntentFile(input) {
     const paths = resolveAssistantStatePaths(input.vault);
@@ -154,6 +327,9 @@ export async function quarantineAssistantOutboxIntentFile(input) {
         }
         throw error;
     }
+    if (input.skipDedupeProjectionUpdate !== true) {
+        await removeAssistantOutboxDedupeProjectionIntent(paths, basename);
+    }
     try {
         const deliveryError = normalizeAssistantDeliveryError(input.error);
         await recordAssistantDiagnosticEvent({
@@ -167,26 +343,843 @@ export async function quarantineAssistantOutboxIntentFile(input) {
     }
     catch { }
 }
+async function readAssistantOutboxDedupeRoutes(paths, routes) {
+    const read = async () => await withAssistantOutboxDedupeDatabase(paths, (database) => {
+        const readRoute = database.prepare(`
+        SELECT intent_id AS intentId
+        FROM assistant_outbox_dedupe_routes
+        WHERE kind = ? AND key_digest = ?
+        ORDER BY created_at_ms ASC, intent_id ASC
+        LIMIT 1
+      `);
+        return routes.map((route) => {
+            const row = readRoute.get(route.kind, resolveAssistantOutboxDedupeKeyDigest(route.kind, route.key));
+            if (!row) {
+                return null;
+            }
+            try {
+                return assistantOutboxIntentIdSchema.parse(row.intentId);
+            }
+            catch (error) {
+                throw new AssistantOutboxDedupeDatabaseValidationError('Assistant outbox dedupe database contains an invalid intent id.', { cause: error });
+            }
+        });
+    });
+    try {
+        return await read();
+    }
+    catch (error) {
+        if (!(error instanceof AssistantOutboxDedupeDatabaseValidationError)) {
+            throw error;
+        }
+        await rebuildAssistantOutboxDedupeDatabaseWithWriteLock(paths);
+        return await read();
+    }
+}
+async function readAssistantOutboxForegroundTagIntentIds(input) {
+    const tagDigests = [...new Set(input.tagDigests)];
+    if (tagDigests.length === 0) {
+        return [];
+    }
+    return await withAssistantOutboxDedupeDatabase(input.paths, (database) => {
+        const placeholders = tagDigests.map(() => '?').join(', ');
+        const rows = database.prepare(`
+      SELECT intent_id AS intentId
+      FROM assistant_outbox_foreground_tags
+      WHERE tag_digest IN (${placeholders})
+      GROUP BY intent_id
+      ORDER BY
+        ${input.newestFirst ? 'max' : 'min'}(created_at_ms)
+          ${input.newestFirst ? 'DESC' : 'ASC'},
+        intent_id ${input.newestFirst ? 'DESC' : 'ASC'}
+      LIMIT ?
+    `).all(...tagDigests, input.limit);
+        return rows.map((row) => {
+            try {
+                return assistantOutboxIntentIdSchema.parse(row.intentId);
+            }
+            catch (error) {
+                throw new AssistantOutboxDedupeDatabaseValidationError('Assistant outbox dedupe database contains an invalid foreground route intent id.', { cause: error });
+            }
+        });
+    });
+}
+async function readAssistantOutboxForegroundProviderIntentIds(input) {
+    const routeTags = [...new Set(input.routeTags)];
+    if (routeTags.length === 0) {
+        return [];
+    }
+    return await withAssistantOutboxDedupeDatabase(input.paths, (database) => {
+        const routePlaceholders = routeTags.map(() => '?').join(', ');
+        const rows = database.prepare(`
+      SELECT provider.intent_id AS intentId
+      FROM assistant_outbox_foreground_tags AS provider
+      WHERE provider.tag_digest = ?
+        AND EXISTS (
+          SELECT 1
+          FROM assistant_outbox_foreground_tags AS route
+          WHERE route.intent_id = provider.intent_id
+            AND route.tag_digest IN (${routePlaceholders})
+        )
+      ORDER BY provider.created_at_ms DESC, provider.intent_id DESC
+      LIMIT ?
+    `).all(input.providerTag, ...routeTags, input.limit);
+        return rows.map((row) => {
+            try {
+                return assistantOutboxIntentIdSchema.parse(row.intentId);
+            }
+            catch (error) {
+                throw new AssistantOutboxDedupeDatabaseValidationError('Assistant outbox dedupe database contains an invalid provider route intent id.', { cause: error });
+            }
+        });
+    });
+}
+async function readAssistantOutboxProjectedIntents(input) {
+    const intents = [];
+    for (const intentId of input.intentIds) {
+        const intent = await readAssistantOutboxIntentAtPath(resolveAssistantOutboxIntentPath(input.paths.outboxDirectory, intentId), { vault: input.vault });
+        if (intent) {
+            intents.push(intent);
+            continue;
+        }
+        await removeAssistantOutboxDedupeProjectionIntent(input.paths, intentId);
+    }
+    return intents.sort((left, right) => compareAssistantTimestampsAscending(left.createdAt, right.createdAt) ||
+        compareAssistantOutboxDeliverySequenceOrder(left, right));
+}
+async function findAssistantOutboxIntentByLegacyMediaIdentity(input) {
+    const dedupeToken = normalizeNullableString(input.dedupeToken);
+    if (!dedupeToken) {
+        return null;
+    }
+    const candidates = await readAssistantOutboxLegacyDedupeCandidates(input.paths);
+    if (candidates === null) {
+        return null;
+    }
+    const boundedCandidates = candidates.slice(0, ASSISTANT_OUTBOX_LEGACY_DEDUPE_FALLBACK_LIMIT);
+    const routes = boundedCandidates.map((candidate) => {
+        const legacyDedupeKey = hashAssistantOutboxLegacyMediaDedupeIdentity({
+            dedupeToken,
+            media: candidate.media,
+        });
+        if (!legacyDedupeKey) {
+            throw new Error('Expected a normalized legacy dedupe key.');
+        }
+        return {
+            kind: 'dedupe-key',
+            key: legacyDedupeKey,
+            matches: (intent) => intent.dedupeKey === legacyDedupeKey,
+        };
+    });
+    const projectedMatch = await findAssistantOutboxIntentByProjectedRoutes({
+        paths: input.paths,
+        rebuildOnStale: true,
+        routes,
+        vault: input.vault,
+    });
+    if (projectedMatch) {
+        return projectedMatch;
+    }
+    if (candidates.length > ASSISTANT_OUTBOX_LEGACY_DEDUPE_FALLBACK_LIMIT) {
+        throw new VaultCliError('ASSISTANT_OUTBOX_LEGACY_DEDUPE_BOUND_EXCEEDED', `Assistant outbox legacy dedupe recovery exceeded its fixed ${ASSISTANT_OUTBOX_LEGACY_DEDUPE_FALLBACK_LIMIT}-media-identity bound.`);
+    }
+    return null;
+}
+async function readAssistantOutboxLegacyDedupeCandidates(paths) {
+    const read = async () => await withAssistantOutboxDedupeDatabase(paths, (database) => {
+        const metadata = database.prepare(`
+        SELECT legacy_fallback_required AS legacyFallbackRequired
+        FROM assistant_outbox_dedupe_metadata
+        WHERE singleton = 1
+      `).get();
+        if (metadata?.legacyFallbackRequired === 0) {
+            return null;
+        }
+        if (metadata?.legacyFallbackRequired !== 1) {
+            throw new AssistantOutboxDedupeDatabaseValidationError('Assistant outbox dedupe database has invalid fallback metadata.');
+        }
+        const rows = database.prepare(`
+        SELECT
+          media_json AS mediaJson
+        FROM assistant_outbox_legacy_candidates
+        WHERE media_json IS NOT NULL
+        GROUP BY media_json
+        ORDER BY min(created_at_ms) ASC, min(intent_id) ASC
+        LIMIT ?
+      `).all(ASSISTANT_OUTBOX_LEGACY_DEDUPE_FALLBACK_LIMIT + 1);
+        return rows.map((row) => {
+            try {
+                const mediaValue = JSON.parse(String(row.mediaJson));
+                assistantOutboxDedupeMediaListSchema.parse(mediaValue);
+                return {
+                    media: mediaValue,
+                };
+            }
+            catch (error) {
+                throw new AssistantOutboxDedupeDatabaseValidationError('Assistant outbox dedupe database contains an invalid legacy candidate.', { cause: error });
+            }
+        });
+    });
+    try {
+        return await read();
+    }
+    catch (error) {
+        if (!(error instanceof AssistantOutboxDedupeDatabaseValidationError)) {
+            throw error;
+        }
+        await rebuildAssistantOutboxDedupeDatabaseWithWriteLock(paths);
+        return await read();
+    }
+}
+async function synchronizeAssistantOutboxDedupeProjection(paths, intent, dedupeIdentityOrigin) {
+    await withAssistantOutboxDedupeDatabase(paths, (database) => {
+        withImmediateTransaction(database, () => {
+            const previousCandidate = database.prepare(`
+        SELECT
+          dedupe_key AS dedupeKey,
+          media_json AS mediaJson
+        FROM assistant_outbox_legacy_candidates
+        WHERE intent_id = ?
+      `).get(intent.intentId);
+            const legacyIdentityPossible = typeof previousCandidate?.dedupeKey === 'string'
+                ? previousCandidate.dedupeKey !== intent.dedupeKey
+                : dedupeIdentityOrigin === 'unknown' &&
+                    /^[a-f0-9]{40}$/u.test(intent.dedupeKey);
+            database.prepare(`
+        DELETE FROM assistant_outbox_dedupe_routes
+        WHERE intent_id = ?
+      `).run(intent.intentId);
+            database.prepare(`
+        DELETE FROM assistant_outbox_legacy_candidates
+        WHERE intent_id = ?
+      `).run(intent.intentId);
+            database.prepare(`
+        DELETE FROM assistant_outbox_foreground_tags
+        WHERE intent_id = ?
+      `).run(intent.intentId);
+            const insertForegroundTag = database.prepare(`
+        INSERT INTO assistant_outbox_foreground_tags (
+          tag_digest,
+          intent_id,
+          created_at_ms
+        ) VALUES (?, ?, ?)
+      `);
+            for (const tagDigest of resolveAssistantOutboxForegroundTagDigests(intent)) {
+                insertForegroundTag.run(tagDigest, intent.intentId, Date.parse(intent.createdAt));
+            }
+            if (!isActiveAssistantOutboxIntent(intent)) {
+                return;
+            }
+            const insertRoute = database.prepare(`
+        INSERT INTO assistant_outbox_dedupe_routes (
+          kind,
+          key_digest,
+          intent_id,
+          created_at_ms
+        ) VALUES (?, ?, ?, ?)
+      `);
+            for (const route of resolveAssistantOutboxDedupeRoutes(intent)) {
+                insertRoute.run(route.kind, resolveAssistantOutboxDedupeKeyDigest(route.kind, route.key), intent.intentId, Date.parse(intent.createdAt));
+            }
+            database.prepare(`
+        INSERT INTO assistant_outbox_legacy_candidates (
+          intent_id,
+          dedupe_key,
+          media_json,
+          created_at_ms
+        ) VALUES (?, ?, ?, ?)
+      `).run(intent.intentId, intent.dedupeKey, legacyIdentityPossible || typeof previousCandidate?.mediaJson === 'string'
+                ? JSON.stringify(intent.media)
+                : null, Date.parse(intent.createdAt));
+            if (legacyIdentityPossible) {
+                database.prepare(`
+          UPDATE assistant_outbox_dedupe_metadata
+          SET legacy_fallback_required = 1
+          WHERE singleton = 1
+        `).run();
+            }
+        });
+    });
+}
+async function removeAssistantOutboxDedupeProjectionIntent(paths, intentId) {
+    await withAssistantOutboxDedupeDatabase(paths, (database) => {
+        withImmediateTransaction(database, () => {
+            database.prepare(`
+        DELETE FROM assistant_outbox_dedupe_routes
+        WHERE intent_id = ?
+      `).run(intentId);
+            database.prepare(`
+        DELETE FROM assistant_outbox_legacy_candidates
+        WHERE intent_id = ?
+      `).run(intentId);
+            database.prepare(`
+        DELETE FROM assistant_outbox_foreground_tags
+        WHERE intent_id = ?
+      `).run(intentId);
+        });
+    });
+}
+async function removeAssistantOutboxDedupeProjectionRouteIfOwned(input) {
+    await withAssistantOutboxDedupeDatabase(input.paths, (database) => {
+        database.prepare(`
+      DELETE FROM assistant_outbox_dedupe_routes
+      WHERE kind = ? AND key_digest = ? AND intent_id = ?
+    `).run(input.kind, resolveAssistantOutboxDedupeKeyDigest(input.kind, input.key), input.intentId);
+    });
+}
+function resolveAssistantOutboxDedupeRoutes(intent) {
+    const deliveryIdempotencyKey = normalizeNullableString(intent.deliveryIdempotencyKey);
+    return [
+        {
+            kind: 'dedupe-key',
+            key: intent.dedupeKey,
+        },
+        ...(deliveryIdempotencyKey
+            ? [{
+                    kind: 'delivery-idempotency-key',
+                    key: deliveryIdempotencyKey,
+                }]
+            : []),
+    ];
+}
+function resolveAssistantOutboxForegroundTagDigests(intent) {
+    const tags = new Set();
+    const bindingDelivery = intent.bindingDelivery;
+    if (isActiveAssistantOutboxIntent(intent) &&
+        bindingDelivery
+        && intent.threadIsDirect === true
+        && intent.privateCompletionContinuitySessionId !== undefined
+        && intent.privateCompletionContinuity?.status !== 'applied') {
+        tags.add(resolveAssistantOutboxForegroundTagDigest('private-completion-route', {
+            actorId: intent.actorId,
+            bindingDeliveryKind: bindingDelivery.kind,
+            bindingDeliveryTarget: bindingDelivery.target,
+            channel: intent.channel,
+            identityId: intent.identityId,
+            threadId: intent.threadId,
+        }));
+    }
+    if (!hasAssistantOutboxDeliveryEvidence(intent, true)) {
+        return [...tags];
+    }
+    const delivery = intent.delivery;
+    if (!delivery || delivery.kind === 'message-reaction') {
+        return [...tags];
+    }
+    const channel = normalizeNullableString(delivery.channel);
+    if (!channel) {
+        return [...tags];
+    }
+    const targets = [...new Set([
+            normalizeNullableString(delivery.target),
+            normalizeNullableString(delivery.providerThreadId),
+        ].filter((value) => value !== null))];
+    const constraintVariants = resolveAssistantOutboxAutoReplyConstraintVariants({
+        actorId: intent.actorId,
+        identityId: intent.identityId,
+        threadId: intent.threadId,
+    });
+    for (const constraints of constraintVariants) {
+        for (const deliveryTarget of targets) {
+            tags.add(resolveAssistantOutboxForegroundTagDigest('auto-conversation-target', { channel, deliveryTarget, ...constraints }));
+        }
+        const threadId = normalizeNullableString(intent.threadId);
+        if (channel === 'email' && threadId) {
+            tags.add(resolveAssistantOutboxForegroundTagDigest('auto-email-thread', { channel, threadId, ...constraints }));
+        }
+    }
+    if (channel === 'linq') {
+        for (const deliveryTarget of targets) {
+            tags.add(resolveAssistantOutboxForegroundTagDigest('auto-linq-target', { channel, deliveryTarget }));
+        }
+    }
+    for (const providerMessageId of resolveAssistantOutboxProviderMessageIds(delivery)) {
+        tags.add(resolveAssistantOutboxForegroundTagDigest('auto-provider-message', { providerMessageId }));
+    }
+    return [...tags];
+}
+function resolveAssistantOutboxAutoReplyQueryTags(input) {
+    const channel = normalizeNullableString(input.channel);
+    const deliveryTarget = normalizeNullableString(input.deliveryTarget);
+    if (!channel || !deliveryTarget) {
+        return [];
+    }
+    const constraints = resolveAssistantOutboxAutoReplyQueryConstraints(input);
+    const tags = [resolveAssistantOutboxForegroundTagDigest('auto-conversation-target', { channel, deliveryTarget, ...constraints })];
+    const threadId = normalizeNullableString(input.threadId);
+    if (channel === 'email' && threadId) {
+        tags.push(resolveAssistantOutboxForegroundTagDigest('auto-email-thread', { channel, threadId, ...constraints }));
+    }
+    if (channel === 'linq') {
+        tags.push(resolveAssistantOutboxForegroundTagDigest('auto-linq-target', { channel, deliveryTarget }));
+    }
+    return [...new Set(tags)];
+}
+function resolveAssistantOutboxAutoReplyQueryConstraints(input) {
+    const constraints = {};
+    const actorId = normalizeNullableString(input.actorId);
+    const identityId = normalizeNullableString(input.identityId);
+    const threadId = normalizeNullableString(input.threadId);
+    if (actorId) {
+        constraints.actorId = actorId;
+    }
+    if (identityId) {
+        constraints.identityId = identityId;
+    }
+    if (threadId) {
+        constraints.threadId = threadId;
+    }
+    return constraints;
+}
+function resolveAssistantOutboxAutoReplyConstraintVariants(input) {
+    let variants = [{}];
+    for (const [key, value] of Object.entries(resolveAssistantOutboxAutoReplyQueryConstraints(input))) {
+        variants = variants.flatMap((variant) => [
+            variant,
+            { ...variant, [key]: value },
+        ]);
+    }
+    return variants;
+}
+function resolveAssistantOutboxProviderMessageIds(delivery) {
+    if (delivery.kind === 'message-reaction') {
+        return [];
+    }
+    return [...new Set([
+            ...(Array.isArray(delivery.providerMessageIds)
+                ? delivery.providerMessageIds
+                : []),
+            delivery.providerMessageId,
+        ].map(normalizeNullableString)
+            .filter((value) => value !== null))];
+}
+function resolveAssistantOutboxForegroundTagDigest(kind, value) {
+    return createHash('sha256')
+        .update(JSON.stringify({ kind, value }))
+        .digest('hex');
+}
+function resolveAssistantOutboxDedupeKeyDigest(kind, key) {
+    return createHash('sha256')
+        .update(JSON.stringify({ kind, key }))
+        .digest('hex');
+}
+async function withAssistantOutboxDedupeDatabase(paths, operation) {
+    const database = await openOrRebuildAssistantOutboxDedupeDatabase(paths);
+    try {
+        const result = operation(database);
+        database.close();
+        return result;
+    }
+    catch (error) {
+        try {
+            database.close();
+        }
+        catch {
+            // Preserve the operation or close error for the shared recovery policy.
+        }
+        if (isAssistantOutboxDedupeProjectionRecoveryError(error)) {
+            // Never replay a callback that may have reached a write with an ambiguous
+            // commit outcome. The next ordinary attempt rebuilds before its operation.
+            await withAssistantOutboxDedupeRecoveryWriteLock(paths, async (lockedPaths) => {
+                if (await assistantOutboxDedupePathExists(resolveAssistantOutboxDedupeDatabasePath(lockedPaths))) {
+                    await quarantineAssistantOutboxDedupeDatabase(lockedPaths, error);
+                }
+            });
+        }
+        throw error;
+    }
+}
+async function openOrRebuildAssistantOutboxDedupeDatabase(paths) {
+    const databasePath = resolveAssistantOutboxDedupeDatabasePath(paths);
+    if (await assistantOutboxDedupePathExists(databasePath)) {
+        try {
+            return openAssistantOutboxDedupeDatabase(paths);
+        }
+        catch (error) {
+            if (!isAssistantOutboxDedupeProjectionRecoveryError(error)) {
+                throw error;
+            }
+        }
+    }
+    return await withAssistantOutboxDedupeRecoveryWriteLock(paths, async (lockedPaths) => {
+        const lockedDatabasePath = resolveAssistantOutboxDedupeDatabasePath(lockedPaths);
+        if (await assistantOutboxDedupePathExists(lockedDatabasePath)) {
+            try {
+                return openAssistantOutboxDedupeDatabase(lockedPaths);
+            }
+            catch (error) {
+                if (!isAssistantOutboxDedupeProjectionRecoveryError(error)) {
+                    throw error;
+                }
+                await quarantineAssistantOutboxDedupeDatabase(lockedPaths, error);
+            }
+        }
+        return await rebuildAssistantOutboxDedupeDatabase(lockedPaths);
+    });
+}
+async function withAssistantOutboxDedupeRecoveryWriteLock(paths, operation) {
+    return await withAssistantRuntimeWriteLock(paths.absoluteVaultRoot, operation);
+}
+async function rebuildAssistantOutboxDedupeDatabaseWithWriteLock(paths) {
+    await withAssistantOutboxDedupeRecoveryWriteLock(paths, async (lockedPaths) => {
+        const rebuilt = await rebuildAssistantOutboxDedupeDatabase(lockedPaths);
+        rebuilt.close();
+    });
+}
+function openAssistantOutboxDedupeDatabase(paths) {
+    const database = openSqliteRuntimeDatabase(resolveAssistantOutboxDedupeDatabasePath(paths), {
+        journalMode: 'DELETE',
+        synchronous: 'FULL',
+    });
+    try {
+        const version = readSqliteRuntimeUserVersion(database);
+        if (version !== ASSISTANT_OUTBOX_DEDUPE_DATABASE_VERSION) {
+            throw new AssistantOutboxDedupeDatabaseValidationError(`Unsupported assistant outbox dedupe database version: ${version}.`);
+        }
+        assertAssistantOutboxDedupeDatabaseShape(database);
+        return database;
+    }
+    catch (error) {
+        try {
+            database.close();
+        }
+        catch {
+            // Preserve the validation or SQLite error for the recovery boundary.
+        }
+        throw error;
+    }
+}
+function assertAssistantOutboxDedupeDatabaseShape(database) {
+    try {
+        database.prepare(`
+      SELECT kind, key_digest, intent_id, created_at_ms
+      FROM assistant_outbox_dedupe_routes
+      LIMIT 0
+    `).all();
+        database.prepare(`
+      SELECT intent_id, dedupe_key, media_json, created_at_ms
+      FROM assistant_outbox_legacy_candidates
+      LIMIT 0
+    `).all();
+        database.prepare(`
+      SELECT tag_digest, intent_id, created_at_ms
+      FROM assistant_outbox_foreground_tags
+      LIMIT 0
+    `).all();
+        const metadata = database.prepare(`
+      SELECT legacy_fallback_required
+      FROM assistant_outbox_dedupe_metadata
+      WHERE singleton = 1
+    `).get();
+        if (metadata?.legacy_fallback_required !== 0 &&
+            metadata?.legacy_fallback_required !== 1) {
+            throw new AssistantOutboxDedupeDatabaseValidationError('Assistant outbox dedupe database has invalid fallback metadata.');
+        }
+        const legacyOrderIndex = database.prepare(`
+      SELECT name
+      FROM sqlite_master
+      WHERE type = 'index'
+        AND name = 'assistant_outbox_legacy_candidates_order'
+    `).get();
+        if (legacyOrderIndex?.name !== 'assistant_outbox_legacy_candidates_order') {
+            throw new AssistantOutboxDedupeDatabaseValidationError('Assistant outbox dedupe database is missing its legacy candidate order index.');
+        }
+        const routeLookupIndex = database.prepare(`
+      SELECT name
+      FROM sqlite_master
+      WHERE type = 'index'
+        AND name = 'assistant_outbox_dedupe_routes_lookup'
+    `).get();
+        if (routeLookupIndex?.name !== 'assistant_outbox_dedupe_routes_lookup') {
+            throw new AssistantOutboxDedupeDatabaseValidationError('Assistant outbox dedupe database is missing its route lookup index.');
+        }
+        const foregroundTagIndex = database.prepare(`
+      SELECT name
+      FROM sqlite_master
+      WHERE type = 'index'
+        AND name = 'assistant_outbox_foreground_tags_lookup'
+    `).get();
+        if (foregroundTagIndex?.name !== 'assistant_outbox_foreground_tags_lookup') {
+            throw new AssistantOutboxDedupeDatabaseValidationError('Assistant outbox dedupe database is missing its foreground tag index.');
+        }
+    }
+    catch (error) {
+        if (error instanceof AssistantOutboxDedupeDatabaseValidationError) {
+            throw error;
+        }
+        if (!isAssistantOutboxDedupeDatabaseShapeError(error)) {
+            throw error;
+        }
+        throw new AssistantOutboxDedupeDatabaseValidationError('Assistant outbox dedupe database has an invalid schema.', { cause: error });
+    }
+}
+function isAssistantOutboxDedupeDatabaseShapeError(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const candidate = error;
+    return (candidate.code === 'ERR_SQLITE_ERROR' &&
+        candidate.errcode === 1 &&
+        typeof candidate.message === 'string' &&
+        /^(?:no such (?:column|table)|table .* has no column named)/u.test(candidate.message));
+}
+// This is the single destructive classification for both opening and using the
+// projection. All unlisted SQLite failures preserve the active database.
+function isAssistantOutboxDedupeProjectionRecoveryError(error) {
+    if (error instanceof AssistantOutboxDedupeDatabaseValidationError) {
+        return true;
+    }
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const candidate = error;
+    if (candidate.code !== 'ERR_SQLITE_ERROR' ||
+        typeof candidate.errcode !== 'number') {
+        return false;
+    }
+    const primaryCode = candidate.errcode & 0xff;
+    return primaryCode === 11 || primaryCode === 26;
+}
+async function rebuildAssistantOutboxDedupeDatabase(paths) {
+    const intents = await collectAssistantOutboxIntentsForDedupeRebuild(paths);
+    const databasePath = resolveAssistantOutboxDedupeDatabasePath(paths);
+    const rebuildDirectory = path.join(path.dirname(databasePath), '.tmp');
+    const rebuildPath = path.join(rebuildDirectory, `${path.basename(databasePath)}.rebuild`);
+    await rm(rebuildDirectory, { force: true, recursive: true });
+    let rebuilt = null;
+    try {
+        rebuilt = openSqliteRuntimeDatabase(rebuildPath, {
+            journalMode: 'DELETE',
+            synchronous: 'FULL',
+        });
+        await adoptAssistantStateFile(rebuildPath);
+        initializeAssistantOutboxDedupeDatabase(rebuilt, intents);
+        rebuilt.close();
+        rebuilt = null;
+        await removeAssistantOutboxDedupeDatabaseSidecars(databasePath);
+        await rename(rebuildPath, databasePath);
+        await rm(rebuildDirectory, { force: true, recursive: true });
+    }
+    catch (error) {
+        rebuilt?.close();
+        await rm(rebuildDirectory, { force: true, recursive: true }).catch(() => undefined);
+        throw error;
+    }
+    return openAssistantOutboxDedupeDatabase(paths);
+}
+async function collectAssistantOutboxIntentsForDedupeRebuild(paths) {
+    const entries = await readdir(paths.outboxDirectory, {
+        withFileTypes: true,
+    });
+    const intents = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.json')) {
+            continue;
+        }
+        const intentPath = path.join(paths.outboxDirectory, entry.name);
+        let raw;
+        try {
+            raw = await readFile(intentPath, 'utf8');
+        }
+        catch (error) {
+            if (isMissingFileError(error)) {
+                continue;
+            }
+            throw error;
+        }
+        try {
+            intents.push(assistantOutboxIntentSchema.parse(JSON.parse(raw)));
+        }
+        catch (error) {
+            await quarantineAssistantOutboxIntentFile({
+                error,
+                intentPath,
+                skipDedupeProjectionUpdate: true,
+                vault: paths.absoluteVaultRoot,
+            });
+        }
+    }
+    return intents.sort((left, right) => compareAssistantTimestampsAscending(left.createdAt, right.createdAt) ||
+        compareAssistantOutboxDeliverySequenceOrder(left, right));
+}
+function initializeAssistantOutboxDedupeDatabase(database, intents) {
+    withImmediateTransaction(database, () => {
+        database.exec(`
+      CREATE TABLE assistant_outbox_dedupe_routes (
+        kind TEXT NOT NULL CHECK (
+          kind IN ('dedupe-key', 'delivery-idempotency-key')
+        ),
+        key_digest TEXT NOT NULL CHECK (length(key_digest) = 64),
+        intent_id TEXT NOT NULL,
+        created_at_ms INTEGER NOT NULL,
+        PRIMARY KEY (kind, key_digest, intent_id)
+      ) STRICT;
+      CREATE INDEX assistant_outbox_dedupe_routes_lookup
+      ON assistant_outbox_dedupe_routes (
+        kind,
+        key_digest,
+        created_at_ms,
+        intent_id
+      );
+      CREATE TABLE assistant_outbox_foreground_tags (
+        tag_digest TEXT NOT NULL CHECK (length(tag_digest) = 64),
+        intent_id TEXT NOT NULL,
+        created_at_ms INTEGER NOT NULL,
+        PRIMARY KEY (tag_digest, intent_id)
+      ) STRICT;
+      CREATE INDEX assistant_outbox_foreground_tags_lookup
+      ON assistant_outbox_foreground_tags (
+        tag_digest,
+        created_at_ms,
+        intent_id
+      );
+      CREATE TABLE assistant_outbox_legacy_candidates (
+        intent_id TEXT PRIMARY KEY,
+        dedupe_key TEXT NOT NULL,
+        media_json TEXT,
+        created_at_ms INTEGER NOT NULL
+      ) STRICT;
+      CREATE INDEX assistant_outbox_legacy_candidates_order
+      ON assistant_outbox_legacy_candidates (created_at_ms, intent_id)
+      WHERE media_json IS NOT NULL;
+      CREATE TABLE assistant_outbox_dedupe_metadata (
+        singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+        legacy_fallback_required INTEGER NOT NULL CHECK (
+          legacy_fallback_required IN (0, 1)
+        )
+      ) STRICT;
+    `);
+        database.prepare(`
+      INSERT INTO assistant_outbox_dedupe_metadata (
+        singleton,
+        legacy_fallback_required
+      ) VALUES (1, ?)
+    `).run(intents.length > 0 ? 1 : 0);
+        const insertRoute = database.prepare(`
+      INSERT INTO assistant_outbox_dedupe_routes (
+        kind,
+        key_digest,
+        intent_id,
+        created_at_ms
+      ) VALUES (?, ?, ?, ?)
+    `);
+        const insertForegroundTag = database.prepare(`
+      INSERT INTO assistant_outbox_foreground_tags (
+        tag_digest,
+        intent_id,
+        created_at_ms
+      ) VALUES (?, ?, ?)
+    `);
+        for (const intent of intents) {
+            for (const tagDigest of resolveAssistantOutboxForegroundTagDigests(intent)) {
+                insertForegroundTag.run(tagDigest, intent.intentId, Date.parse(intent.createdAt));
+            }
+            if (!isActiveAssistantOutboxIntent(intent)) {
+                continue;
+            }
+            for (const route of resolveAssistantOutboxDedupeRoutes(intent)) {
+                insertRoute.run(route.kind, resolveAssistantOutboxDedupeKeyDigest(route.kind, route.key), intent.intentId, Date.parse(intent.createdAt));
+            }
+            database.prepare(`
+        INSERT INTO assistant_outbox_legacy_candidates (
+          intent_id,
+          dedupe_key,
+          media_json,
+          created_at_ms
+        ) VALUES (?, ?, ?, ?)
+      `).run(intent.intentId, intent.dedupeKey, JSON.stringify(intent.media), Date.parse(intent.createdAt));
+        }
+        writeSqliteRuntimeUserVersion(database, ASSISTANT_OUTBOX_DEDUPE_DATABASE_VERSION);
+    });
+}
+async function quarantineAssistantOutboxDedupeDatabase(paths, _error) {
+    const databasePath = resolveAssistantOutboxDedupeDatabasePath(paths);
+    const quarantinePath = path.join(paths.outboxQuarantineDirectory, `${ASSISTANT_OUTBOX_DEDUPE_DATABASE_NAME}.${Date.now()}.${randomUUID()}.invalid.sqlite`);
+    await ensureAssistantStateDirectory(paths.outboxQuarantineDirectory);
+    try {
+        await rename(databasePath, quarantinePath);
+    }
+    catch (renameError) {
+        if (isMissingFileError(renameError)) {
+            return;
+        }
+        throw renameError;
+    }
+    finally {
+        await removeAssistantOutboxDedupeDatabaseSidecars(databasePath);
+    }
+    await recordAssistantDiagnosticEvent({
+        code: 'ASSISTANT_OUTBOX_DEDUPE_PROJECTION_INVALID',
+        component: 'outbox',
+        kind: 'outbox.dedupe-projection.quarantined',
+        level: 'warn',
+        message: 'Assistant outbox dedupe projection was invalid and rebuilt.',
+        vault: paths.absoluteVaultRoot,
+    }).catch(() => undefined);
+}
+function resolveAssistantOutboxDedupeDatabasePath(paths) {
+    return path.join(paths.stateDirectory, ASSISTANT_OUTBOX_DEDUPE_DATABASE_NAME);
+}
+async function assistantOutboxDedupePathExists(candidatePath) {
+    try {
+        await access(candidatePath);
+        return true;
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+async function removeAssistantOutboxDedupeDatabaseSidecars(databasePath) {
+    await Promise.all([
+        rm(`${databasePath}-journal`, { force: true }),
+        rm(`${databasePath}-shm`, { force: true }),
+        rm(`${databasePath}-wal`, { force: true }),
+    ]);
+}
 function isTerminalAssistantOutboxIntent(intent) {
     return (intent.status === 'sent' ||
         intent.status === 'failed' ||
         intent.status === 'abandoned');
 }
-function isPruneProtectedAssistantOutboxIntent(intent, protectedNewsletterOccurrencePrefixes) {
+function isGeneratedImageDeliveryEvidenceIntent(intent) {
+    if (intent.media.length !== 1) {
+        return false;
+    }
+    const media = intent.media[0];
+    return (media?.kind === 'vault_image'
+        && media.source === 'gpt-image-2'
+        && media.ref.startsWith('raw/captures/'));
+}
+function isPruneProtectedAssistantOutboxIntent(intent, protectedGroupEmailOccurrencePrefixes) {
+    if (intent.messageVolumeReceiptRecordedAt === null) {
+        return true;
+    }
+    if (intent.status === 'sent'
+        && intent.privateCompletionContinuitySessionId !== undefined
+        && intent.delivery !== null
+        && intent.privateCompletionContinuity?.status !== 'applied') {
+        return true;
+    }
     const deliveryIdempotencyKey = intent.deliveryIdempotencyKey;
     if (!deliveryIdempotencyKey
-        || !protectedNewsletterOccurrencePrefixes.some((prefix) => deliveryIdempotencyKey.startsWith(prefix))) {
+        || !protectedGroupEmailOccurrencePrefixes.some((prefix) => deliveryIdempotencyKey.startsWith(prefix))) {
         return false;
     }
     const target = parseHostedEmailThreadTarget(intent.explicitTarget);
     return target?.targetKind === 'group';
 }
-async function readProtectedNewsletterOccurrencePrefixes(paths) {
+async function readProtectedGroupEmailOccurrencePrefixes(paths) {
     const store = await readAssistantCronCanonicalRuntimeStore(paths, {
         reclaimStaleRunningClaims: false,
     });
     return store.jobs.flatMap((record) => record.state.pendingOccurrenceAt
         ? [
+            `group-email-effect:${record.jobId}:${record.state.pendingOccurrenceAt}:`,
+            // Read-only migration support for effects accepted before the
+            // generic group-email idempotency key shipped.
             `group-newsletter:${record.jobId}:${record.state.pendingOccurrenceAt}:`,
         ]
         : []);