@resolveio/server-lib 20.15.7 → 20.15.9

package/methods/ai-terminal.js

@@ -109,16 +109,21 @@ exports.loadAiTerminalMethods = loadAiTerminalMethods;
 exports.executeAiAssistantMongoRead = executeAiAssistantMongoRead;
 exports.executeAiAssistantMongoAggregate = executeAiAssistantMongoAggregate;
 exports.extractAssistantMongoDirective = extractAssistantMongoDirective;
+exports.normalizeIdsForTargetField = normalizeIdsForTargetField;
 exports.serializeMongoValue = serializeMongoValue;
 exports.flattenForTable = flattenForTable;
 exports.buildDisplayTable = buildDisplayTable;
 exports.formatDisplayTableMarkdown = formatDisplayTableMarkdown;
+exports.stripQueryFieldPathsDeep = stripQueryFieldPathsDeep;
+exports.stripScopedFieldsFromPipeline = stripScopedFieldsFromPipeline;
+exports.rewriteEmbeddedMatchObjects = rewriteEmbeddedMatchObjects;
 var fs_1 = require("fs");
 var events_1 = require("events");
 var os = require("os");
 var path = require("path");
 var promises_1 = require("timers/promises");
 var worker_threads_1 = require("worker_threads");
+var mongodb_1 = require("mongodb");
 var simpl_schema_1 = require("simpl-schema");
 var resolveio_server_app_1 = require("../resolveio-server-app");
 var user_collection_1 = require("../collections/user.collection");
@@ -145,6 +150,12 @@ var AI_ASSISTANT_DISPLAY_STRING_LIMIT = 160;
 var AI_ASSISTANT_PROGRESS_PLACEHOLDER = 'Planning...';
 var AI_ASSISTANT_PROGRESS_TICK_MS = 5000;
 var AI_ASSISTANT_READ_PREFERENCE = 'secondary';
+var AI_ASSISTANT_PROBE_LIMIT = 3;
+var AI_ASSISTANT_COLLECTION_OVERRIDE_SCORE_GAP = 20;
+var AI_ASSISTANT_COLLECTION_OVERRIDE_MIN_SCORE = 20;
+var AI_ASSISTANT_ID_LOOKUP_MAX_RESULTS = 20;
+var AI_ASSISTANT_ID_LOOKUP_CANDIDATE_LIMIT = 4;
+var AI_ASSISTANT_NAME_MATCH_FALLBACK_MAX_FIELDS = 12;
 var AI_ASSISTANT_PROGRESS_TICKS = [
     'Grabbing Data',
     'Drafting response'
@@ -175,6 +186,15 @@ var AI_ASSISTANT_DATE_FALLBACKS = {
     date_invoice: 'date_invoiced',
     date_invoiced: 'date_invoice'
 };
+var AI_ASSISTANT_DATE_EXPANSION_FIELDS = [
+    'date',
+    'date_start',
+    'date_end',
+    'date_original',
+    'date_created',
+    'createdAt',
+    'updatedAt'
+];
 var AI_ASSISTANT_BLOCKED_COLLECTIONS = new Set([
     'user-groups',
     'logged-in-users',
@@ -201,6 +221,7 @@ var AI_ASSISTANT_SENSITIVE_FIELDS = [
     'roles'
 ];
 var AI_ASSISTANT_CLIENT_SCOPE_CACHE = new Map();
+var AI_ASSISTANT_FIELD_INDEX_CACHE = new Map();
 var AI_ASSISTANT_COLLECTION_CACHE = new Map();
 var AI_ASSISTANT_COLLECTION_CACHE_TTL_MS = 5 * 60 * 1000;
 var AI_ASSISTANT_COLLECTION_STOPWORDS = new Set([
@@ -246,11 +267,72 @@ var AI_ASSISTANT_COLLECTION_STOPWORDS = new Set([
     'missing',
     'overdue'
 ]);
+var AI_ASSISTANT_COLLECTION_DOMAIN_TOKENS = new Set([
+    'blend',
+    'blends',
+    'chemical',
+    'chemicals',
+    'invoice',
+    'invoices',
+    'work',
+    'order',
+    'orders',
+    'delivery',
+    'deliveries',
+    'truck',
+    'treating',
+    'route',
+    'routes',
+    'well',
+    'wells',
+    'sample',
+    'samples',
+    'customer',
+    'customers'
+]);
+var AI_ASSISTANT_COLLECTION_GENERIC_TOKENS = new Set([
+    'ticket',
+    'tickets',
+    'report',
+    'reports',
+    'summary',
+    'summarize',
+    'recent',
+    'last',
+    'new',
+    'created',
+    'date',
+    'list',
+    'show'
+]);
+var AI_ASSISTANT_FIELD_TOKEN_SYNONYMS = {
+    volume: ['quantity', 'qty', 'amount', 'gallons', 'gallon', 'liters', 'liter', 'litre'],
+    quantity: ['volume', 'qty', 'amount', 'gallons', 'gallon'],
+    product: ['item', 'chemical', 'material', 'blend', 'name', 'title', 'label'],
+    customer: ['client', 'account', 'company'],
+    well: ['location', 'site', 'pad', 'api'],
+    batch: ['lot'],
+    lot: ['batch'],
+    date: ['created', 'createdat', 'created_at', 'date_created', 'updated', 'updatedat', 'updated_at', 'date_updated'],
+    total: ['sum', 'amount', 'total_amount', 'total_quantity']
+};
+var AI_ASSISTANT_ID_LOOKUP_HINTS = {
+    customer: ['customers', 'customer-versions'],
+    chemical: ['chemicals', 'chemical-versions'],
+    well: ['wells', 'well-groups', 'production-locations', 'locations'],
+    location: ['locations', 'production-locations'],
+    invoice: ['invoices']
+};
 var AI_ASSISTANT_TERM_SYNONYMS = [
     {
         label: 'truck treating jobs',
         pattern: /\btruck\s+treating\s+jobs?\b/i,
         expansions: ['truck treating deliveries', 'truck-treating-deliveries', 'truck treating route events']
+    },
+    {
+        label: 'blend tickets',
+        pattern: /\bblend(?:ing)?\s+tickets?\b/i,
+        expansions: ['chemical blends', 'chemical-blends', 'report-chemical-blends', 'blend batches']
     }
 ];
 var AI_ASSISTANT_SYSTEM_PROMPT = [
@@ -277,6 +359,7 @@ var AI_ASSISTANT_SYSTEM_PROMPT = [
     '- Process (fast path): Queue -> Planning -> Grabbing Data -> Drafting response. Use regex/keyword matching to identify collections/models, draft a minimal query, run the tool, then format a table. This should be fast; avoid extra narration.',
     '- Assume a relevant collection exists; if verification reads return zero data, report no data found instead of interrogating the user.',
     '- Never claim "no data exists" unless you resolved a collection and executed a legitimate query (with fallback date fields when needed) that returned zero rows.',
+    '- If a query returns zero rows, run a tiny probe read (limit 1-3) to validate fields and adjust filters/projection before concluding.',
     '- For direct questions, answer first. Ask a single follow-up only if required to proceed.',
     'Data Presentation:',
     '- Output plain Markdown (NO triple backticks).',
@@ -1048,10 +1131,10 @@ function executeAiAssistantCodexRun(payload, context) {
                     insertResult = _d.sent();
                     assistantMessageId = (insertResult === null || insertResult === void 0 ? void 0 : insertResult._id) || (insertResult === null || insertResult === void 0 ? void 0 : insertResult.insertedId);
                     enqueueAssistantCodexRun(function () { return __awaiter(_this, void 0, void 0, function () {
-                        var runStart, steps, recordStep, progressTracker, streamProgress, assistantContent, toolResult, assistantDebug, directiveSource, dataQuestion, lastDirective, toolResponseDebug, toolError, termHints, collectionHints, contextRoute, contextMode, hintSeed, termExpansion, hintText, dbName, db, _a, assistantContext, prompt_1, workspaceRoot, codexConfig, runOptions, responseText, directiveText, directive, directivePrompt, forcedDirective, _b, directivePrompt, forcedDirective, _c, cleanedResponseText, toolRequest, toolResponse, _d, toolPayload, followupPrompt, followupText, _e, error_2, error_3, finalNow, finishedAt, finalMetadata, finalAssistantDoc;
-                        var _f, _g, _h, _j, _k, _l, _m, _o;
-                        return __generator(this, function (_p) {
-                            switch (_p.label) {
+                        var runStart, steps, recordStep, progressTracker, streamProgress, assistantContent, toolResult, assistantDebug, directiveSource, dataQuestion, lastDirective, toolResponseDebug, toolError, termHints, collectionHints, collectionTokenization, collectionRanking, collectionSelection, collectionOverride, timingBreakdown, contextRoute, contextMode, hintSeed, termExpansion, hintText, baseTokens, expandedTokens, baseWeights, expandedWeights, dbName, db, collectionNames, _a, assistantContext, prompt_1, workspaceRoot, codexConfig, runOptions, responseText, directiveText, directive, directivePrompt, directiveStart, forcedDirective, _b, initialStart, directivePrompt, forcedStart, forcedDirective, _c, requestedCollection, cleanedResponseText, effectiveDirective, toolRequest, toolStart, toolResponse, _d, toolPayload, followupPrompt, followupStart, followupText, _e, error_2, error_3, finalNow, finishedAt, codexMs, draftingMs, finalMetadata, finalAssistantDoc;
+                        var _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+                        return __generator(this, function (_t) {
+                            switch (_t.label) {
                                 case 0:
                                     runStart = Date.now();
                                     steps = [];
@@ -1075,31 +1158,60 @@ function executeAiAssistantCodexRun(payload, context) {
                                     toolError = null;
                                     termHints = [];
                                     collectionHints = [];
+                                    collectionTokenization = null;
+                                    collectionRanking = null;
+                                    collectionSelection = null;
+                                    collectionOverride = null;
+                                    timingBreakdown = {
+                                        directiveMs: 0,
+                                        initialResponseMs: 0,
+                                        forcedDirectiveMs: 0,
+                                        toolMs: 0,
+                                        followupMs: 0
+                                    };
                                     contextRoute = normalizeOptionalString((_f = input === null || input === void 0 ? void 0 : input.context) === null || _f === void 0 ? void 0 : _f.route);
                                     contextMode = normalizeOptionalString((_g = input === null || input === void 0 ? void 0 : input.context) === null || _g === void 0 ? void 0 : _g.mode);
                                     recordStep('Queued', { requestId: requestId || undefined });
-                                    _p.label = 1;
+                                    _t.label = 1;
                                 case 1:
-                                    _p.trys.push([1, 30, 31, 32]);
+                                    _t.trys.push([1, 30, 31, 32]);
                                     hintSeed = [message, contextRoute].filter(Boolean).join(' ');
                                     termExpansion = expandAssistantTermSynonyms(hintSeed);
                                     hintText = termExpansion.expanded || hintSeed;
                                     termHints = termExpansion.matches.map(function (match) { return "".concat(match.term, " -> ").concat(match.expansions.join(', ')); });
+                                    baseTokens = tokenizeCollectionText(hintSeed);
+                                    expandedTokens = tokenizeCollectionText(hintText);
+                                    baseWeights = computeCollectionTokenWeights(baseTokens);
+                                    expandedWeights = computeCollectionTokenWeights(expandedTokens);
+                                    collectionTokenization = {
+                                        baseText: hintSeed || undefined,
+                                        expandedText: hintText || undefined,
+                                        baseTokens: baseTokens.length ? baseTokens : undefined,
+                                        expandedTokens: expandedTokens.length ? expandedTokens : undefined,
+                                        baseTokenWeights: baseTokens.length ? baseWeights.weights : undefined,
+                                        expandedTokenWeights: expandedTokens.length ? expandedWeights.weights : undefined,
+                                        hasDomainTokens: expandedTokens.length ? expandedWeights.hasDomain : undefined
+                                    };
                                     recordStep('Planning: term expansion', {
                                         termMatches: termExpansion.matches.length ? termExpansion.matches : undefined
                                     });
-                                    _p.label = 2;
+                                    _t.label = 2;
                                 case 2:
-                                    _p.trys.push([2, 4, , 5]);
+                                    _t.trys.push([2, 4, , 5]);
                                     dbName = resolveAssistantDatabaseName(undefined, input.mongo);
                                     db = resolveio_server_app_1.ResolveIOServer.getMongoConnection().db(dbName);
-                                    return [4 /*yield*/, resolveAssistantCollectionHints(hintText, dbName, db)];
+                                    return [4 /*yield*/, listAssistantCollections(db, dbName)];
                                 case 3:
-                                    collectionHints = _p.sent();
+                                    collectionNames = _t.sent();
+                                    collectionHints = resolveCollectionHintsFromTokens(expandedTokens, collectionNames, 5);
+                                    collectionRanking = buildCollectionRankingDebugFromTokens(expandedTokens, collectionNames, 8);
                                     return [3 /*break*/, 5];
                                 case 4:
-                                    _a = _p.sent();
+                                    _a = _t.sent();
                                     collectionHints = [];
+                                    collectionRanking = collectionRanking || ((collectionTokenization === null || collectionTokenization === void 0 ? void 0 : collectionTokenization.expandedTokens)
+                                        ? buildCollectionRankingDebugFromTokens(collectionTokenization.expandedTokens || [], [], 0)
+                                        : null);
                                     return [3 /*break*/, 5];
                                 case 5:
                                     recordStep('Planning: collection hints', {
@@ -1118,7 +1230,7 @@ function executeAiAssistantCodexRun(payload, context) {
                                     prompt_1 = buildAssistantCodexPrompt(message, attachmentData.promptText, historyLines.join('\n'), assistantContext);
                                     return [4 /*yield*/, resolveAssistantWorkspaceRoot()];
                                 case 6:
-                                    workspaceRoot = _p.sent();
+                                    workspaceRoot = _t.sent();
                                     codexConfig = resolveCodexSettings();
                                     runOptions = {
                                         timeoutMs: resolveCodexTimeoutMs(),
@@ -1139,103 +1251,128 @@ function executeAiAssistantCodexRun(payload, context) {
                                     if (!dataQuestion) return [3 /*break*/, 10];
                                     recordStep('Directive: determine tool', { type: 'data-question' });
                                     directivePrompt = buildAssistantCodexDirectivePrompt(message, attachmentData.promptText, historyLines.join('\n'), assistantContext);
-                                    _p.label = 7;
+                                    _t.label = 7;
                                 case 7:
-                                    _p.trys.push([7, 9, , 10]);
+                                    _t.trys.push([7, 9, , 10]);
+                                    directiveStart = Date.now();
                                     return [4 /*yield*/, runCodexInWorkerThread(directivePrompt, runOptions, codexConfig, streamProgress)];
                                 case 8:
-                                    directiveText = _p.sent();
+                                    directiveText = _t.sent();
+                                    timingBreakdown.directiveMs = Date.now() - directiveStart;
                                     forcedDirective = extractAssistantMongoDirective(directiveText);
                                     if (forcedDirective) {
                                         directive = forcedDirective;
                                         directiveSource = 'model';
                                         lastDirective = forcedDirective;
+                                        collectionSelection = buildCollectionSelectionDetail((collectionTokenization === null || collectionTokenization === void 0 ? void 0 : collectionTokenization.expandedTokens) || [], normalizeOptionalString((_h = directive.payload) === null || _h === void 0 ? void 0 : _h.collection) || '');
                                         recordStep('Directive resolved', {
                                             source: directiveSource,
                                             type: directive.type,
-                                            collection: normalizeOptionalString((_h = directive.payload) === null || _h === void 0 ? void 0 : _h.collection) || undefined,
-                                            permissionView: normalizeOptionalString((_j = directive.payload) === null || _j === void 0 ? void 0 : _j.permissionView) || undefined
+                                            collection: normalizeOptionalString((_j = directive.payload) === null || _j === void 0 ? void 0 : _j.collection) || undefined,
+                                            permissionView: normalizeOptionalString((_k = directive.payload) === null || _k === void 0 ? void 0 : _k.permissionView) || undefined
                                         });
                                     }
                                     return [3 /*break*/, 10];
                                 case 9:
-                                    _b = _p.sent();
+                                    _b = _t.sent();
                                     return [3 /*break*/, 10];
                                 case 10:
                                     if (!!directive) return [3 /*break*/, 12];
                                     recordStep('Response: draft initial answer', { mode: 'full' });
+                                    initialStart = Date.now();
                                     return [4 /*yield*/, runCodexInWorkerThread(prompt_1, runOptions, codexConfig, streamProgress)];
                                 case 11:
-                                    responseText = _p.sent();
+                                    responseText = _t.sent();
+                                    timingBreakdown.initialResponseMs = Date.now() - initialStart;
                                     directive = extractAssistantMongoDirective(responseText);
                                     if (directive) {
                                         directiveSource = 'model';
                                         lastDirective = directive;
+                                        collectionSelection = buildCollectionSelectionDetail((collectionTokenization === null || collectionTokenization === void 0 ? void 0 : collectionTokenization.expandedTokens) || [], normalizeOptionalString((_l = directive.payload) === null || _l === void 0 ? void 0 : _l.collection) || '');
                                         recordStep('Directive resolved', {
                                             source: directiveSource,
                                             type: directive.type,
-                                            collection: normalizeOptionalString((_k = directive.payload) === null || _k === void 0 ? void 0 : _k.collection) || undefined,
-                                            permissionView: normalizeOptionalString((_l = directive.payload) === null || _l === void 0 ? void 0 : _l.permissionView) || undefined
+                                            collection: normalizeOptionalString((_m = directive.payload) === null || _m === void 0 ? void 0 : _m.collection) || undefined,
+                                            permissionView: normalizeOptionalString((_o = directive.payload) === null || _o === void 0 ? void 0 : _o.permissionView) || undefined
                                         });
                                     }
-                                    _p.label = 12;
+                                    _t.label = 12;
                                 case 12:
                                     if (!(!directive && dataQuestion)) return [3 /*break*/, 16];
                                     recordStep('Directive: forced retry', { mode: 'directive-only' });
                                     directivePrompt = buildAssistantCodexDirectivePrompt(message, attachmentData.promptText, historyLines.join('\n'), assistantContext);
-                                    _p.label = 13;
+                                    _t.label = 13;
                                 case 13:
-                                    _p.trys.push([13, 15, , 16]);
+                                    _t.trys.push([13, 15, , 16]);
+                                    forcedStart = Date.now();
                                     return [4 /*yield*/, runCodexInWorkerThread(directivePrompt, runOptions, codexConfig, streamProgress)];
                                 case 14:
-                                    directiveText = _p.sent();
+                                    directiveText = _t.sent();
+                                    timingBreakdown.forcedDirectiveMs = Date.now() - forcedStart;
                                     forcedDirective = extractAssistantMongoDirective(directiveText);
                                     if (forcedDirective) {
                                         directive = forcedDirective;
                                         directiveSource = 'forced';
                                         lastDirective = forcedDirective;
+                                        collectionSelection = buildCollectionSelectionDetail((collectionTokenization === null || collectionTokenization === void 0 ? void 0 : collectionTokenization.expandedTokens) || [], normalizeOptionalString((_p = directive.payload) === null || _p === void 0 ? void 0 : _p.collection) || '');
                                         recordStep('Directive resolved', {
                                             source: directiveSource,
                                             type: directive.type,
-                                            collection: normalizeOptionalString((_m = directive.payload) === null || _m === void 0 ? void 0 : _m.collection) || undefined,
-                                            permissionView: normalizeOptionalString((_o = directive.payload) === null || _o === void 0 ? void 0 : _o.permissionView) || undefined
+                                            collection: normalizeOptionalString((_q = directive.payload) === null || _q === void 0 ? void 0 : _q.collection) || undefined,
+                                            permissionView: normalizeOptionalString((_r = directive.payload) === null || _r === void 0 ? void 0 : _r.permissionView) || undefined
                                         });
                                     }
                                     return [3 /*break*/, 16];
                                 case 15:
-                                    _c = _p.sent();
+                                    _c = _t.sent();
                                     return [3 /*break*/, 16];
                                 case 16:
+                                    if (directive) {
+                                        requestedCollection = normalizeOptionalString((_s = directive.payload) === null || _s === void 0 ? void 0 : _s.collection);
+                                        collectionOverride = resolveAssistantCollectionOverride(collectionRanking, requestedCollection);
+                                        if (collectionOverride) {
+                                            recordStep('Planning: collection override', {
+                                                from: collectionOverride.from || undefined,
+                                                to: collectionOverride.to,
+                                                reason: collectionOverride.reason,
+                                                scoreGap: collectionOverride.toScore - collectionOverride.fromScore
+                                            });
+                                        }
+                                    }
                                     cleanedResponseText = (directive === null || directive === void 0 ? void 0 : directive.cleaned) || responseText;
                                     if (cleanedResponseText) {
                                         assistantContent = sanitizeAssistantResponse(cleanedResponseText);
                                     }
                                     if (!((directive === null || directive === void 0 ? void 0 : directive.payload) && AI_ASSISTANT_TOOL_MAX_STEPS > 0)) return [3 /*break*/, 28];
-                                    toolRequest = buildAssistantToolRequest(directive, input);
+                                    effectiveDirective = collectionOverride
+                                        ? __assign(__assign({}, directive), { payload: __assign(__assign({}, (directive.payload || {})), { collection: collectionOverride.to }) }) : directive;
+                                    toolRequest = buildAssistantToolRequest(effectiveDirective, input);
                                     progressTracker.push('Grabbing Data');
                                     recordStep('Grabbing Data: start', {
-                                        type: directive.type,
+                                        type: effectiveDirective.type,
                                         collection: normalizeOptionalString(toolRequest === null || toolRequest === void 0 ? void 0 : toolRequest.collection) || undefined,
                                         permissionView: normalizeOptionalString(toolRequest === null || toolRequest === void 0 ? void 0 : toolRequest.permissionView) || undefined
                                     });
-                                    _p.label = 17;
+                                    _t.label = 17;
                                 case 17:
-                                    _p.trys.push([17, 26, , 27]);
-                                    if (!(directive.type === 'aggregate')) return [3 /*break*/, 19];
+                                    _t.trys.push([17, 26, , 27]);
+                                    toolStart = Date.now();
+                                    if (!(effectiveDirective.type === 'aggregate')) return [3 /*break*/, 19];
                                     return [4 /*yield*/, executeAiAssistantMongoAggregate(toolRequest, context)];
                                 case 18:
-                                    _d = _p.sent();
+                                    _d = _t.sent();
                                     return [3 /*break*/, 21];
                                 case 19: return [4 /*yield*/, executeAiAssistantMongoRead(toolRequest, context)];
                                 case 20:
-                                    _d = _p.sent();
-                                    _p.label = 21;
+                                    _d = _t.sent();
+                                    _t.label = 21;
                                 case 21:
                                     toolResponse = _d;
+                                    timingBreakdown.toolMs = Date.now() - toolStart;
                                     toolResponseDebug = (toolResponse === null || toolResponse === void 0 ? void 0 : toolResponse.debug) && typeof toolResponse.debug === 'object'
                                         ? toolResponse.debug
                                         : null;
-                                    toolPayload = buildAssistantToolResultPayload(directive, toolResponse);
+                                    toolPayload = buildAssistantToolResultPayload(effectiveDirective, toolResponse);
                                     toolResult = toolPayload.result;
                                     recordStep('Grabbing Data: complete', {
                                         rowCount: toolPayload.result.output.rowCount,
@@ -1245,21 +1382,23 @@ function executeAiAssistantCodexRun(payload, context) {
                                     progressTracker.push('Drafting response');
                                     recordStep('Drafting response');
                                     followupPrompt = buildAssistantCodexToolFollowupPrompt(message, attachmentData.promptText, historyLines.join('\n'), assistantContext, toolPayload.prompt);
-                                    _p.label = 22;
+                                    _t.label = 22;
                                 case 22:
-                                    _p.trys.push([22, 24, , 25]);
+                                    _t.trys.push([22, 24, , 25]);
+                                    followupStart = Date.now();
                                     return [4 /*yield*/, runCodexInWorkerThread(followupPrompt, runOptions, codexConfig, streamProgress)];
                                 case 23:
-                                    followupText = _p.sent();
+                                    followupText = _t.sent();
+                                    timingBreakdown.followupMs = Date.now() - followupStart;
                                     assistantContent = sanitizeAssistantResponse(followupText);
                                     return [3 /*break*/, 25];
                                 case 24:
-                                    _e = _p.sent();
+                                    _e = _t.sent();
                                     assistantContent = buildAssistantToolFallbackResponse(toolPayload.result);
                                     return [3 /*break*/, 25];
                                 case 25: return [3 /*break*/, 27];
                                 case 26:
-                                    error_2 = _p.sent();
+                                    error_2 = _t.sent();
                                     assistantContent = buildAssistantToolErrorMessage(error_2, directive, toolRequest);
                                     toolError = error_2;
                                     return [3 /*break*/, 27];
@@ -1267,10 +1406,10 @@ function executeAiAssistantCodexRun(payload, context) {
                                 case 28:
                                     progressTracker.push('Drafting response');
                                     recordStep('Drafting response');
-                                    _p.label = 29;
+                                    _t.label = 29;
                                 case 29: return [3 /*break*/, 32];
                                 case 30:
-                                    error_3 = _p.sent();
+                                    error_3 = _t.sent();
                                     assistantContent = buildAssistantCodexErrorMessage(error_3);
                                     recordStep('Error', { message: normalizeOptionalString(error_3 === null || error_3 === void 0 ? void 0 : error_3.message) || 'Unknown error' });
                                     return [3 /*break*/, 32];
@@ -1284,6 +1423,11 @@ function executeAiAssistantCodexRun(payload, context) {
                                     finalNow = new Date();
                                     if (isSuperAdmin) {
                                         finishedAt = Date.now();
+                                        codexMs = timingBreakdown.directiveMs
+                                            + timingBreakdown.initialResponseMs
+                                            + timingBreakdown.forcedDirectiveMs
+                                            + timingBreakdown.followupMs;
+                                        draftingMs = timingBreakdown.followupMs || timingBreakdown.initialResponseMs;
                                         assistantDebug = buildAssistantDebugPayload({
                                             dataQuestion: dataQuestion,
                                             directive: lastDirective,
@@ -1291,18 +1435,30 @@ function executeAiAssistantCodexRun(payload, context) {
                                             toolResult: toolResult,
                                             toolResponseDebug: toolResponseDebug,
                                             toolError: toolError,
+                                            collectionOverride: collectionOverride,
                                             trace: {
                                                 steps: steps,
                                                 planning: {
                                                     contextMode: contextMode || undefined,
                                                     contextRoute: contextRoute || undefined,
                                                     termHints: termHints.length ? termHints : undefined,
-                                                    collectionHints: collectionHints.length ? collectionHints : undefined
+                                                    collectionHints: collectionHints.length ? collectionHints : undefined,
+                                                    collectionTokenization: collectionTokenization || undefined,
+                                                    collectionRanking: collectionRanking || undefined,
+                                                    collectionSelection: collectionSelection || undefined,
+                                                    collectionOverride: collectionOverride || undefined
                                                 },
                                                 timings: {
                                                     startedAt: new Date(runStart).toISOString(),
                                                     finishedAt: new Date(finishedAt).toISOString(),
-                                                    totalMs: finishedAt - runStart
+                                                    totalMs: finishedAt - runStart,
+                                                    codexMs: codexMs,
+                                                    draftingMs: draftingMs,
+                                                    toolMs: timingBreakdown.toolMs,
+                                                    directiveMs: timingBreakdown.directiveMs,
+                                                    initialResponseMs: timingBreakdown.initialResponseMs,
+                                                    forcedDirectiveMs: timingBreakdown.forcedDirectiveMs,
+                                                    followupMs: timingBreakdown.followupMs
                                                 }
                                             }
                                         });
@@ -1318,16 +1474,16 @@ function executeAiAssistantCodexRun(payload, context) {
                                             }
                                         })];
                                 case 33:
-                                    _p.sent();
-                                    _p.label = 34;
+                                    _t.sent();
+                                    _t.label = 34;
                                 case 34: return [4 /*yield*/, touchConversation(conversation._id, finalNow, assistantMessageId ? String(assistantMessageId) : undefined)];
                                 case 35:
-                                    _p.sent();
+                                    _t.sent();
                                     if (!(input.delete_files_after_run !== false)) return [3 /*break*/, 37];
                                     return [4 /*yield*/, cleanupAttachments(attachmentData.attachments)];
                                 case 36:
-                                    _p.sent();
-                                    _p.label = 37;
+                                    _t.sent();
+                                    _t.label = 37;
                                 case 37: return [2 /*return*/, finalAssistantDoc];
                             }
                         });
@@ -1341,10 +1497,10 @@ function executeAiAssistantCodexRun(payload, context) {
 }
 function executeAiAssistantMongoRead(payload, context) {
     return __awaiter(this, void 0, void 0, function () {
-        var input, rawCollection, dbName, db, collectionResolution, collection, _a, user, isSuperAdmin, customerId, baseQuery, userId, normalizedClient, shouldScopeByClient, _b, clientScopedQuery, scopedQuery, normalized, findOptions, documents, executedQuery, fallbackMeta, dateFallback, fallbackQuery, fallbackDocs, total, sanitizedDocuments, includeIds, requestedFields, fieldAliases, displayDocs, priorityFields, display;
-        var _c, _d;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
+        var input, rawCollection, dbName, db, collectionResolution, collection, _a, user, isSuperAdmin, customerId, fallbackMeta, baseQuery, stripped, userId, normalizedClient, shouldScopeByClient, _b, strippedClient, clientScopedQuery, scopedQuery, normalized, findOptions, documents, executedQuery, probeDocs, dateFallback, fallbackQuery, fallbackDocs, expanded, fallbackDocs, nameFallback, fallbackDocs, queryFields, _c, aliases, rewrittenQuery, fallbackDocs, _d, idLookup, fallbackDocs, total, sanitizedDocuments, requestedFields, missingFields, _e, projectionAliases, expandedProjection, refreshedDocs, includeIds, fieldAliases, displayDocs, priorityFields, display;
+        var _f, _g;
+        return __generator(this, function (_h) {
+            switch (_h.label) {
                 case 0:
                     input = payload || {};
                     rawCollection = normalizeOptionalString(input.collection);
@@ -1355,16 +1511,26 @@ function executeAiAssistantMongoRead(payload, context) {
                     db = resolveio_server_app_1.ResolveIOServer.getMongoConnection().db(dbName);
                     return [4 /*yield*/, resolveAssistantCollectionName(db, dbName, rawCollection)];
                 case 1:
-                    collectionResolution = _e.sent();
+                    collectionResolution = _h.sent();
                     collection = collectionResolution.name || rawCollection;
                     return [4 /*yield*/, ensureAssistantReadAccess(context, input.permissionView, collection)];
                 case 2:
-                    _a = _e.sent(), user = _a.user, isSuperAdmin = _a.isSuperAdmin;
+                    _a = _h.sent(), user = _a.user, isSuperAdmin = _a.isSuperAdmin;
                     if (!isSuperAdmin && AI_ASSISTANT_BLOCKED_COLLECTIONS.has(collection)) {
                         throw new Error('AI assistant mongo read: Access denied.');
                     }
-                    customerId = normalizeOptionalString((_c = user === null || user === void 0 ? void 0 : user.other) === null || _c === void 0 ? void 0 : _c.id_customer);
+                    customerId = normalizeOptionalString((_f = user === null || user === void 0 ? void 0 : user.other) === null || _f === void 0 ? void 0 : _f.id_customer);
+                    fallbackMeta = {};
                     baseQuery = normalizeMongoQuery(input.query);
+                    if (!isSuperAdmin && customerId) {
+                        stripped = stripQueryFieldPathsDeepWithMeta(baseQuery, ['id_customer', 'other.id_customer']);
+                        baseQuery = stripped.value;
+                        fallbackMeta.scopeStrip = {
+                            attempted: true,
+                            fields: ['id_customer', 'other.id_customer'],
+                            used: stripped.changed
+                        };
+                    }
                     if (!isSuperAdmin && (collection === 'users' || collection === 'user-versions')) {
                         userId = normalizeOptionalString(user === null || user === void 0 ? void 0 : user._id);
                         if (!userId) {
@@ -1378,13 +1544,22 @@ function executeAiAssistantMongoRead(payload, context) {
                     if (!(!isSuperAdmin && normalizedClient)) return [3 /*break*/, 4];
                     return [4 /*yield*/, collectionHasClientIndex(db, dbName, collection)];
                 case 3:
-                    _b = _e.sent();
+                    _b = _h.sent();
                     return [3 /*break*/, 5];
                 case 4:
                     _b = false;
-                    _e.label = 5;
+                    _h.label = 5;
                 case 5:
                     shouldScopeByClient = _b;
+                    if (!isSuperAdmin && shouldScopeByClient) {
+                        strippedClient = stripQueryFieldPathsDeepWithMeta(baseQuery, ['id_client']);
+                        baseQuery = strippedClient.value;
+                        fallbackMeta.scopeStripClient = {
+                            attempted: true,
+                            fields: ['id_client'],
+                            used: strippedClient.changed
+                        };
+                    }
                     clientScopedQuery = shouldScopeByClient
                         ? applyClientScopeFilter(baseQuery, normalizedClient, isSuperAdmin)
                         : baseQuery;
@@ -1393,9 +1568,9 @@ function executeAiAssistantMongoRead(payload, context) {
                     findOptions = __assign(__assign({}, normalized.findOptions), { readPreference: AI_ASSISTANT_READ_PREFERENCE });
                     return [4 /*yield*/, db.collection(collection).find(scopedQuery, findOptions).toArray()];
                 case 6:
-                    documents = _e.sent();
+                    documents = _h.sent();
                     executedQuery = scopedQuery;
-                    fallbackMeta = {};
+                    probeDocs = null;
                     if (!!documents.length) return [3 /*break*/, 8];
                     dateFallback = resolveQueryDateFieldFallback(scopedQuery);
                     if (!dateFallback) return [3 /*break*/, 8];
@@ -1403,26 +1578,185 @@ function executeAiAssistantMongoRead(payload, context) {
                     fallbackMeta.dateField = __assign(__assign({}, dateFallback), { attempted: true, used: false });
                     return [4 /*yield*/, db.collection(collection).find(fallbackQuery, findOptions).toArray()];
                 case 7:
-                    fallbackDocs = _e.sent();
+                    fallbackDocs = _h.sent();
                     if (fallbackDocs.length) {
                         documents = fallbackDocs;
                         executedQuery = fallbackQuery;
                         fallbackMeta.dateField.used = true;
                     }
-                    _e.label = 8;
+                    _h.label = 8;
                 case 8:
-                    total = null;
-                    if (!normalized.includeTotal) return [3 /*break*/, 10];
-                    return [4 /*yield*/, db.collection(collection).countDocuments(executedQuery, { readPreference: AI_ASSISTANT_READ_PREFERENCE })];
+                    if (!!documents.length) return [3 /*break*/, 10];
+                    expanded = expandQueryDateFallbacks(executedQuery);
+                    if (!expanded) return [3 /*break*/, 10];
+                    fallbackMeta.dateFieldsExpanded = {
+                        fields: expanded.fields,
+                        attempted: true,
+                        used: false
+                    };
+                    return [4 /*yield*/, db.collection(collection).find(expanded.query, findOptions).toArray()];
                 case 9:
-                    total = _e.sent();
-                    _e.label = 10;
+                    fallbackDocs = _h.sent();
+                    if (fallbackDocs.length) {
+                        documents = fallbackDocs;
+                        executedQuery = expanded.query;
+                        fallbackMeta.dateFieldsExpanded.used = true;
+                    }
+                    _h.label = 10;
                 case 10:
+                    if (!!documents.length) return [3 /*break*/, 12];
+                    nameFallback = resolveReadNameMatchFallback(executedQuery);
+                    if (!nameFallback) return [3 /*break*/, 12];
+                    fallbackMeta.nameMatch = {
+                        field: nameFallback.field,
+                        fields: nameFallback.fields,
+                        attempted: true,
+                        used: false
+                    };
+                    return [4 /*yield*/, db.collection(collection).find(nameFallback.query, findOptions).toArray()];
+                case 11:
+                    fallbackDocs = _h.sent();
+                    if (fallbackDocs.length) {
+                        documents = fallbackDocs;
+                        executedQuery = nameFallback.query;
+                        fallbackMeta.nameMatch.used = true;
+                    }
+                    _h.label = 12;
+                case 12:
+                    if (!!documents.length) return [3 /*break*/, 16];
+                    queryFields = extractQueryFieldPaths(executedQuery).filter(function (field) { return !isAssistantIdField(field); });
+                    if (!queryFields.length) return [3 /*break*/, 16];
+                    _c = probeDocs;
+                    if (_c) return [3 /*break*/, 14];
+                    return [4 /*yield*/, fetchAssistantProbeDocs({
+                            db: db,
+                            collection: collection,
+                            idClient: normalizedClient,
+                            idCustomer: customerId,
+                            isSuperAdmin: isSuperAdmin,
+                            includeClientScope: shouldScopeByClient
+                        })];
+                case 13:
+                    _c = (_h.sent());
+                    _h.label = 14;
+                case 14:
+                    probeDocs = _c;
+                    if (!probeDocs.length) return [3 /*break*/, 16];
+                    aliases = resolveFieldAliases(probeDocs, queryFields);
+                    if (!Object.keys(aliases).length) return [3 /*break*/, 16];
+                    fallbackMeta.queryFieldAliases = {
+                        aliases: aliases,
+                        attempted: true,
+                        used: false
+                    };
+                    rewrittenQuery = Object.entries(aliases)
+                        .reduce(function (acc, _a) {
+                        var _b = __read(_a, 2), from = _b[0], to = _b[1];
+                        return replaceFieldPathDeep(acc, from, to);
+                    }, executedQuery);
+                    return [4 /*yield*/, db.collection(collection).find(rewrittenQuery, findOptions).toArray()];
+                case 15:
+                    fallbackDocs = _h.sent();
+                    if (fallbackDocs.length) {
+                        documents = fallbackDocs;
+                        executedQuery = rewrittenQuery;
+                        fallbackMeta.queryFieldAliases.used = true;
+                    }
+                    _h.label = 16;
+                case 16:
+                    if (!!documents.length) return [3 /*break*/, 21];
+                    _d = probeDocs;
+                    if (_d) return [3 /*break*/, 18];
+                    return [4 /*yield*/, fetchAssistantProbeDocs({
+                            db: db,
+                            collection: collection,
+                            idClient: normalizedClient,
+                            idCustomer: customerId,
+                            isSuperAdmin: isSuperAdmin,
+                            includeClientScope: shouldScopeByClient
+                        })];
+                case 17:
+                    _d = (_h.sent());
+                    _h.label = 18;
+                case 18:
+                    probeDocs = _d;
+                    return [4 /*yield*/, applyIdLookupFallbackToQuery({
+                            query: executedQuery,
+                            db: db,
+                            dbName: dbName,
+                            idClient: normalizedClient,
+                            idCustomer: customerId,
+                            isSuperAdmin: isSuperAdmin,
+                            probeDocs: probeDocs || undefined
+                        })];
+                case 19:
+                    idLookup = _h.sent();
+                    if (!idLookup) return [3 /*break*/, 21];
+                    fallbackMeta.idLookup = __assign(__assign({}, idLookup.meta), { attempted: true, used: false });
+                    return [4 /*yield*/, db.collection(collection).find(idLookup.query, findOptions).toArray()];
+                case 20:
+                    fallbackDocs = _h.sent();
+                    if (fallbackDocs.length) {
+                        documents = fallbackDocs;
+                        executedQuery = idLookup.query;
+                        fallbackMeta.idLookup.used = true;
+                    }
+                    _h.label = 21;
+                case 21:
+                    total = null;
+                    if (!normalized.includeTotal) return [3 /*break*/, 23];
+                    return [4 /*yield*/, db.collection(collection).countDocuments(executedQuery, { readPreference: AI_ASSISTANT_READ_PREFERENCE })];
+                case 22:
+                    total = _h.sent();
+                    _h.label = 23;
+                case 23:
                     sanitizedDocuments = isSuperAdmin
                         ? documents
                         : documents.map(function (doc) { return redactSensitiveFields((0, common_1.deepCopy)(doc)); });
-                    includeIds = ((_d = input.options) === null || _d === void 0 ? void 0 : _d.includeIds) === true;
-                    requestedFields = resolveProjectionRequestedFields(normalized.findOptions.projection);
+                    requestedFields = resolveProjectionRequestedFields(findOptions.projection);
+                    if (!(sanitizedDocuments.length && requestedFields.length)) return [3 /*break*/, 27];
+                    missingFields = requestedFields.filter(function (field) { return !hasNonEmptyValue(sanitizedDocuments, field, { treatObjectLikeAsEmpty: true }); });
+                    if (!missingFields.length) return [3 /*break*/, 27];
+                    _e = probeDocs;
+                    if (_e) return [3 /*break*/, 25];
+                    return [4 /*yield*/, fetchAssistantProbeDocs({
+                            db: db,
+                            collection: collection,
+                            idClient: normalizedClient,
+                            idCustomer: customerId,
+                            isSuperAdmin: isSuperAdmin,
+                            includeClientScope: shouldScopeByClient
+                        })];
+                case 24:
+                    _e = (_h.sent());
+                    _h.label = 25;
+                case 25:
+                    probeDocs = _e;
+                    if (!probeDocs.length) return [3 /*break*/, 27];
+                    projectionAliases = resolveFieldAliases(probeDocs, missingFields);
+                    if (!Object.keys(projectionAliases).length) return [3 /*break*/, 27];
+                    fallbackMeta.projectionAliases = {
+                        aliases: projectionAliases,
+                        attempted: true,
+                        used: false
+                    };
+                    expandedProjection = expandProjectionWithAliases(findOptions.projection, projectionAliases);
+                    if (!(expandedProjection && expandedProjection !== findOptions.projection)) return [3 /*break*/, 27];
+                    findOptions = __assign(__assign({}, findOptions), { projection: expandedProjection });
+                    normalized.findOptions.projection = expandedProjection;
+                    return [4 /*yield*/, db.collection(collection).find(executedQuery, findOptions).toArray()];
+                case 26:
+                    refreshedDocs = _h.sent();
+                    if (refreshedDocs.length) {
+                        documents = refreshedDocs;
+                        sanitizedDocuments = isSuperAdmin
+                            ? refreshedDocs
+                            : refreshedDocs.map(function (doc) { return redactSensitiveFields((0, common_1.deepCopy)(doc)); });
+                        fallbackMeta.projectionAliases.used = true;
+                    }
+                    _h.label = 27;
+                case 27:
+                    includeIds = ((_g = input.options) === null || _g === void 0 ? void 0 : _g.includeIds) === true;
                     fieldAliases = resolveFieldAliases(sanitizedDocuments, requestedFields);
                     displayDocs = Object.keys(fieldAliases).length
                         ? applyFieldAliasesForDisplay(sanitizedDocuments, fieldAliases)
@@ -1433,7 +1767,8 @@ function executeAiAssistantMongoRead(payload, context) {
                         includeIds: includeIds,
                         maxColumns: AI_ASSISTANT_DISPLAY_MAX_COLUMNS,
                         maxRows: normalized.findOptions.limit,
-                        priorityFields: priorityFields
+                        priorityFields: priorityFields,
+                        includeGroupFromId: false
                     });
                     if (total !== null) {
                         display.total = total;
@@ -1462,10 +1797,10 @@ function executeAiAssistantMongoRead(payload, context) {
 }
 function executeAiAssistantMongoAggregate(payload, context) {
     return __awaiter(this, void 0, void 0, function () {
-        var input, rawCollection, dbName, db, collectionResolution, collection, _a, user, isSuperAdmin, customerId, baseQuery, userId, normalizedClient, shouldScopeByClient, _b, clientScopedQuery, scopedQuery, normalizedPipeline, pipelineWithScope, normalizedOptions, limitedPipeline, dateField, aggregateOptions, documents, executedPipeline, fallbackMeta, fallback, fallbackPipeline, fallbackDocs, createdFallback, createdPipeline, createdDocs, completionFallback, fallbackPipeline, fallbackDocs, unwindFallback, fallbackPipeline, fallbackDocs, sanitizedDocuments, includeIds, display;
-        var _c, _d;
-        return __generator(this, function (_e) {
-            switch (_e.label) {
+        var input, rawCollection, dbName, db, collectionResolution, collection, _a, user, isSuperAdmin, customerId, fallbackMeta, baseQuery, stripped, userId, normalizedClient, shouldScopeByClient, _b, clientScopedQuery, scopedQuery, normalizedPipeline, sanitizedPipeline, strippedPipeline, pipelineWithScope, normalizedOptions, limitedPipeline, dateField, aggregateOptions, documents, executedPipeline, probeDocs, fallback, fallbackPipeline, fallbackDocs, createdFallback, createdPipeline, createdDocs, expanded, expandedDocs, completionFallback, fallbackPipeline, fallbackDocs, completionExprFallback, fallbackPipeline, fallbackDocs, unwindFallback, fallbackPipeline, fallbackDocs, nameFallback, fallbackPipeline, fallbackDocs, matchFields_1, _c, aliases, rewrittenPipeline, fallbackDocs, _loop_1, i, state_1, sanitizedDocuments, includeIds, display;
+        var _d, _e;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
                 case 0:
                     input = payload || {};
                     rawCollection = normalizeOptionalString(input.collection);
@@ -1476,16 +1811,26 @@ function executeAiAssistantMongoAggregate(payload, context) {
                     db = resolveio_server_app_1.ResolveIOServer.getMongoConnection().db(dbName);
                     return [4 /*yield*/, resolveAssistantCollectionName(db, dbName, rawCollection)];
                 case 1:
-                    collectionResolution = _e.sent();
+                    collectionResolution = _f.sent();
                     collection = collectionResolution.name || rawCollection;
                     return [4 /*yield*/, ensureAssistantReadAccess(context, input.permissionView, collection)];
                 case 2:
-                    _a = _e.sent(), user = _a.user, isSuperAdmin = _a.isSuperAdmin;
+                    _a = _f.sent(), user = _a.user, isSuperAdmin = _a.isSuperAdmin;
                     if (!isSuperAdmin && AI_ASSISTANT_BLOCKED_COLLECTIONS.has(collection)) {
                         throw new Error('AI assistant mongo aggregate: Access denied.');
                     }
-                    customerId = normalizeOptionalString((_c = user === null || user === void 0 ? void 0 : user.other) === null || _c === void 0 ? void 0 : _c.id_customer);
+                    customerId = normalizeOptionalString((_d = user === null || user === void 0 ? void 0 : user.other) === null || _d === void 0 ? void 0 : _d.id_customer);
+                    fallbackMeta = {};
                     baseQuery = normalizeMongoQuery(input.query);
+                    if (!isSuperAdmin && customerId) {
+                        stripped = stripQueryFieldPathsDeepWithMeta(baseQuery, ['id_customer', 'other.id_customer']);
+                        baseQuery = stripped.value;
+                        fallbackMeta.scopeStrip = {
+                            attempted: true,
+                            fields: ['id_customer', 'other.id_customer'],
+                            used: stripped.changed
+                        };
+                    }
                     if (!isSuperAdmin && (collection === 'users' || collection === 'user-versions')) {
                         userId = normalizeOptionalString(user === null || user === void 0 ? void 0 : user._id);
                         if (!userId) {
@@ -1499,11 +1844,11 @@ function executeAiAssistantMongoAggregate(payload, context) {
                     if (!(!isSuperAdmin && normalizedClient)) return [3 /*break*/, 4];
                     return [4 /*yield*/, collectionHasClientIndex(db, dbName, collection)];
                 case 3:
-                    _b = _e.sent();
+                    _b = _f.sent();
                     return [3 /*break*/, 5];
                 case 4:
                     _b = false;
-                    _e.label = 5;
+                    _f.label = 5;
                 case 5:
                     shouldScopeByClient = _b;
                     clientScopedQuery = shouldScopeByClient
@@ -1511,7 +1856,17 @@ function executeAiAssistantMongoAggregate(payload, context) {
                         : baseQuery;
                     scopedQuery = applyCustomerScopeFilter(clientScopedQuery, collection, customerId, isSuperAdmin);
                     normalizedPipeline = normalizeAssistantAggregatePipeline(input.pipeline);
-                    pipelineWithScope = buildAssistantAggregatePipeline(scopedQuery, normalizedPipeline);
+                    sanitizedPipeline = normalizedPipeline;
+                    if (!isSuperAdmin && customerId) {
+                        strippedPipeline = stripScopedFieldsFromPipelineWithMeta(normalizedPipeline, ['id_customer', 'other.id_customer']);
+                        sanitizedPipeline = strippedPipeline.pipeline;
+                        fallbackMeta.scopeStripPipeline = {
+                            attempted: true,
+                            fields: ['id_customer', 'other.id_customer'],
+                            used: strippedPipeline.changed
+                        };
+                    }
+                    pipelineWithScope = buildAssistantAggregatePipeline(scopedQuery, sanitizedPipeline);
                     normalizedOptions = normalizeAssistantAggregateOptions(input.options);
                     limitedPipeline = applyAssistantAggregateLimit(pipelineWithScope, normalizedOptions.limit, normalizedOptions.maxLimit, normalizedOptions.defaultLimit);
                     dateField = findAggregateDateField(limitedPipeline);
@@ -1523,9 +1878,9 @@ function executeAiAssistantMongoAggregate(payload, context) {
                             .aggregate(limitedPipeline, aggregateOptions)
                             .toArray()];
                 case 6:
-                    documents = _e.sent();
+                    documents = _f.sent();
                     executedPipeline = limitedPipeline;
-                    fallbackMeta = {};
+                    probeDocs = null;
                     if (!(!documents.length && dateField)) return [3 /*break*/, 10];
                     fallback = resolveAggregateDateFieldFallback(limitedPipeline);
                     if (!fallback) return [3 /*break*/, 8];
@@ -1536,13 +1891,13 @@ function executeAiAssistantMongoAggregate(payload, context) {
                             .aggregate(fallbackPipeline, aggregateOptions)
                             .toArray()];
                 case 7:
-                    fallbackDocs = _e.sent();
+                    fallbackDocs = _f.sent();
                     if (fallbackDocs.length) {
                         documents = fallbackDocs;
                         executedPipeline = fallbackPipeline;
                         fallbackMeta.dateField.used = true;
                     }
-                    _e.label = 8;
+                    _f.label = 8;
                 case 8:
                     if (!(!documents.length && dateField !== 'createdAt')) return [3 /*break*/, 10];
                     createdFallback = { from: dateField, to: 'createdAt', attempted: true, used: false };
@@ -1553,64 +1908,258 @@ function executeAiAssistantMongoAggregate(payload, context) {
                             .aggregate(createdPipeline, aggregateOptions)
                             .toArray()];
                 case 9:
-                    createdDocs = _e.sent();
+                    createdDocs = _f.sent();
                     if (createdDocs.length) {
                         documents = createdDocs;
                         executedPipeline = createdPipeline;
                         fallbackMeta.dateFieldCreatedAt.used = true;
                     }
-                    _e.label = 10;
+                    _f.label = 10;
                 case 10:
                     if (!!documents.length) return [3 /*break*/, 12];
+                    expanded = expandAggregateDateMatchFallback(executedPipeline);
+                    if (!expanded) return [3 /*break*/, 12];
+                    fallbackMeta.dateFieldsExpanded = {
+                        fields: expanded.fields,
+                        attempted: true,
+                        used: false
+                    };
+                    if (!!containsForbiddenMongoOperators(expanded.pipeline)) return [3 /*break*/, 12];
+                    return [4 /*yield*/, db.collection(collection)
+                            .aggregate(expanded.pipeline, aggregateOptions)
+                            .toArray()];
+                case 11:
+                    expandedDocs = _f.sent();
+                    if (expandedDocs.length) {
+                        documents = expandedDocs;
+                        executedPipeline = expanded.pipeline;
+                        fallbackMeta.dateFieldsExpanded.used = true;
+                    }
+                    _f.label = 12;
+                case 12:
+                    if (!!documents.length) return [3 /*break*/, 16];
                     completionFallback = resolveAggregateCompletionFallback(executedPipeline);
-                    if (!completionFallback) return [3 /*break*/, 12];
+                    if (!completionFallback) return [3 /*break*/, 14];
                     fallbackMeta.completion = {
                         field: completionFallback.field,
                         sources: completionFallback.sources,
                         attempted: true,
                         used: false,
-                        statusFilter: !!completionFallback.statusFilter
+                        statusFilter: !!completionFallback.statusFilter,
+                        strategy: 'addFields'
                     };
                     fallbackPipeline = buildAggregateCompletionFallbackPipeline(executedPipeline, completionFallback);
-                    if (!(fallbackPipeline.length && !containsForbiddenMongoOperators(fallbackPipeline))) return [3 /*break*/, 12];
+                    if (!(fallbackPipeline.length && !containsForbiddenMongoOperators(fallbackPipeline))) return [3 /*break*/, 14];
                     return [4 /*yield*/, db.collection(collection)
                             .aggregate(fallbackPipeline, aggregateOptions)
                             .toArray()];
-                case 11:
-                    fallbackDocs = _e.sent();
+                case 13:
+                    fallbackDocs = _f.sent();
                     if (fallbackDocs.length) {
                         documents = fallbackDocs;
                         executedPipeline = fallbackPipeline;
                         fallbackMeta.completion.used = true;
                     }
-                    _e.label = 12;
-                case 12:
-                    if (!(documents.length <= 1)) return [3 /*break*/, 14];
+                    _f.label = 14;
+                case 14:
+                    if (!!documents.length) return [3 /*break*/, 16];
+                    completionExprFallback = resolveAggregateCompletionExprFallback(executedPipeline);
+                    if (!completionExprFallback) return [3 /*break*/, 16];
+                    fallbackMeta.completion = {
+                        field: completionExprFallback.field,
+                        sources: completionExprFallback.sources,
+                        attempted: true,
+                        used: false,
+                        statusFilter: !!completionExprFallback.statusFilter,
+                        strategy: 'expr'
+                    };
+                    fallbackPipeline = buildAggregateCompletionExprFallbackPipeline(executedPipeline, completionExprFallback);
+                    if (!(fallbackPipeline.length && !containsForbiddenMongoOperators(fallbackPipeline))) return [3 /*break*/, 16];
+                    return [4 /*yield*/, db.collection(collection)
+                            .aggregate(fallbackPipeline, aggregateOptions)
+                            .toArray()];
+                case 15:
+                    fallbackDocs = _f.sent();
+                    if (fallbackDocs.length) {
+                        documents = fallbackDocs;
+                        executedPipeline = fallbackPipeline;
+                        fallbackMeta.completion.used = true;
+                    }
+                    _f.label = 16;
+                case 16:
+                    if (!(documents.length <= 1)) return [3 /*break*/, 18];
                     unwindFallback = resolveAggregateUnwindFallback(executedPipeline);
-                    if (!unwindFallback) return [3 /*break*/, 14];
+                    if (!unwindFallback) return [3 /*break*/, 18];
                     fallbackMeta.unwind = { path: unwindFallback.path, attempted: true, used: false };
                     fallbackPipeline = buildAggregateUnwindFallbackPipeline(executedPipeline, unwindFallback);
-                    if (!!containsForbiddenMongoOperators(fallbackPipeline)) return [3 /*break*/, 14];
+                    if (!!containsForbiddenMongoOperators(fallbackPipeline)) return [3 /*break*/, 18];
                     return [4 /*yield*/, db.collection(collection)
                             .aggregate(fallbackPipeline, aggregateOptions)
                             .toArray()];
-                case 13:
-                    fallbackDocs = _e.sent();
+                case 17:
+                    fallbackDocs = _f.sent();
                     if (fallbackDocs.length > documents.length) {
                         documents = fallbackDocs;
                         executedPipeline = fallbackPipeline;
                         fallbackMeta.unwind.used = true;
                     }
-                    _e.label = 14;
-                case 14:
+                    _f.label = 18;
+                case 18:
+                    if (!!documents.length) return [3 /*break*/, 20];
+                    nameFallback = resolveAggregateNameMatchFallback(executedPipeline);
+                    if (!nameFallback) return [3 /*break*/, 20];
+                    fallbackMeta.nameMatch = {
+                        field: nameFallback.field,
+                        fields: nameFallback.fields,
+                        attempted: true,
+                        used: false
+                    };
+                    fallbackPipeline = buildAggregateNameMatchFallbackPipeline(executedPipeline, nameFallback);
+                    if (!(fallbackPipeline.length && !containsForbiddenMongoOperators(fallbackPipeline))) return [3 /*break*/, 20];
+                    return [4 /*yield*/, db.collection(collection)
+                            .aggregate(fallbackPipeline, aggregateOptions)
+                            .toArray()];
+                case 19:
+                    fallbackDocs = _f.sent();
+                    if (fallbackDocs.length) {
+                        documents = fallbackDocs;
+                        executedPipeline = fallbackPipeline;
+                        fallbackMeta.nameMatch.used = true;
+                    }
+                    _f.label = 20;
+                case 20:
+                    if (!!documents.length) return [3 /*break*/, 24];
+                    matchFields_1 = new Set();
+                    (executedPipeline || []).forEach(function (stage) {
+                        if (stage && typeof stage === 'object' && stage.$match && typeof stage.$match === 'object') {
+                            extractQueryFieldPaths(stage.$match)
+                                .filter(function (field) { return !isAssistantIdField(field); })
+                                .forEach(function (field) { return matchFields_1.add(field); });
+                        }
+                    });
+                    if (!matchFields_1.size) return [3 /*break*/, 24];
+                    _c = probeDocs;
+                    if (_c) return [3 /*break*/, 22];
+                    return [4 /*yield*/, fetchAssistantProbeDocs({
+                            db: db,
+                            collection: collection,
+                            idClient: normalizedClient,
+                            idCustomer: customerId,
+                            isSuperAdmin: isSuperAdmin,
+                            includeClientScope: shouldScopeByClient
+                        })];
+                case 21:
+                    _c = (_f.sent());
+                    _f.label = 22;
+                case 22:
+                    probeDocs = _c;
+                    if (!probeDocs.length) return [3 /*break*/, 24];
+                    aliases = resolveFieldAliases(probeDocs, Array.from(matchFields_1));
+                    if (!Object.keys(aliases).length) return [3 /*break*/, 24];
+                    fallbackMeta.queryFieldAliases = {
+                        aliases: aliases,
+                        attempted: true,
+                        used: false
+                    };
+                    rewrittenPipeline = Object.entries(aliases)
+                        .reduce(function (acc, _a) {
+                        var _b = __read(_a, 2), from = _b[0], to = _b[1];
+                        return replaceFieldPathDeep(acc, from, to);
+                    }, executedPipeline);
+                    if (!!containsForbiddenMongoOperators(rewrittenPipeline)) return [3 /*break*/, 24];
+                    return [4 /*yield*/, db.collection(collection)
+                            .aggregate(rewrittenPipeline, aggregateOptions)
+                            .toArray()];
+                case 23:
+                    fallbackDocs = _f.sent();
+                    if (fallbackDocs.length) {
+                        documents = fallbackDocs;
+                        executedPipeline = rewrittenPipeline;
+                        fallbackMeta.queryFieldAliases.used = true;
+                    }
+                    _f.label = 24;
+                case 24:
+                    if (!!documents.length) return [3 /*break*/, 28];
+                    _loop_1 = function (i) {
+                        var stage, _g, idLookup, rewrittenPipeline, fallbackDocs;
+                        return __generator(this, function (_h) {
+                            switch (_h.label) {
+                                case 0:
+                                    stage = executedPipeline[i];
+                                    if (!stage || typeof stage !== 'object' || !stage.$match || typeof stage.$match !== 'object') {
+                                        return [2 /*return*/, "continue"];
+                                    }
+                                    _g = probeDocs;
+                                    if (_g) return [3 /*break*/, 2];
+                                    return [4 /*yield*/, fetchAssistantProbeDocs({
+                                            db: db,
+                                            collection: collection,
+                                            idClient: normalizedClient,
+                                            idCustomer: customerId,
+                                            isSuperAdmin: isSuperAdmin,
+                                            includeClientScope: shouldScopeByClient
+                                        })];
+                                case 1:
+                                    _g = (_h.sent());
+                                    _h.label = 2;
+                                case 2:
+                                    probeDocs = _g;
+                                    return [4 /*yield*/, applyIdLookupFallbackToQuery({
+                                            query: stage.$match,
+                                            db: db,
+                                            dbName: dbName,
+                                            idClient: normalizedClient,
+                                            idCustomer: customerId,
+                                            isSuperAdmin: isSuperAdmin,
+                                            probeDocs: probeDocs || undefined
+                                        })];
+                                case 3:
+                                    idLookup = _h.sent();
+                                    if (!idLookup) {
+                                        return [2 /*return*/, "continue"];
+                                    }
+                                    fallbackMeta.idLookup = __assign(__assign({}, idLookup.meta), { attempted: true, used: false, stage: i });
+                                    rewrittenPipeline = executedPipeline.map(function (current, index) { return (index === i ? { $match: idLookup.query } : current); });
+                                    if (!!containsForbiddenMongoOperators(rewrittenPipeline)) return [3 /*break*/, 5];
+                                    return [4 /*yield*/, db.collection(collection)
+                                            .aggregate(rewrittenPipeline, aggregateOptions)
+                                            .toArray()];
+                                case 4:
+                                    fallbackDocs = _h.sent();
+                                    if (fallbackDocs.length) {
+                                        documents = fallbackDocs;
+                                        executedPipeline = rewrittenPipeline;
+                                        fallbackMeta.idLookup.used = true;
+                                        return [2 /*return*/, "break"];
+                                    }
+                                    _h.label = 5;
+                                case 5: return [2 /*return*/];
+                            }
+                        });
+                    };
+                    i = 0;
+                    _f.label = 25;
+                case 25:
+                    if (!(i < (executedPipeline || []).length)) return [3 /*break*/, 28];
+                    return [5 /*yield**/, _loop_1(i)];
+                case 26:
+                    state_1 = _f.sent();
+                    if (state_1 === "break")
+                        return [3 /*break*/, 28];
+                    _f.label = 27;
+                case 27:
+                    i += 1;
+                    return [3 /*break*/, 25];
+                case 28:
                     sanitizedDocuments = isSuperAdmin
                         ? documents
                         : documents.map(function (doc) { return redactSensitiveFields((0, common_1.deepCopy)(doc)); });
-                    includeIds = ((_d = input.options) === null || _d === void 0 ? void 0 : _d.includeIds) === true;
+                    includeIds = ((_e = input.options) === null || _e === void 0 ? void 0 : _e.includeIds) === true;
                     display = buildDisplayTable(sanitizedDocuments, {
                         includeIds: includeIds,
                         maxColumns: AI_ASSISTANT_DISPLAY_MAX_COLUMNS,
-                        maxRows: normalizedOptions.limit || sanitizedDocuments.length
+                        maxRows: normalizedOptions.limit || sanitizedDocuments.length,
+                        includeGroupFromId: true
                     });
                     return [2 /*return*/, __assign({ documents: sanitizedDocuments, display: display }, (isSuperAdmin ? {
                             debug: {
@@ -1699,7 +2248,8 @@ function buildAssistantToolResultPayload(directive, toolResponse) {
         : buildDisplayTable(documents, {
             includeIds: includeIds,
             maxColumns: AI_ASSISTANT_DISPLAY_MAX_COLUMNS,
-            maxRows: AI_ASSISTANT_DISPLAY_PREVIEW_MAX_ROWS
+            maxRows: AI_ASSISTANT_DISPLAY_PREVIEW_MAX_ROWS,
+            includeGroupFromId: directive.type === 'aggregate'
         });
     var trimmedDisplay = trimDisplayTable(display, {
         maxColumns: AI_ASSISTANT_DISPLAY_MAX_COLUMNS,
@@ -1779,7 +2329,7 @@ function buildAssistantToolFallbackResponse(result) {
     return lines.join('\n').trim();
 }
 function buildAssistantDebugPayload(params) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
     var notes = [];
     if (params.dataQuestion) {
         notes.push('Detected a data request; tool call required.');
@@ -1787,18 +2337,24 @@ function buildAssistantDebugPayload(params) {
     if (params.directiveSource === 'forced') {
         notes.push('Assistant response omitted a MONGO_* directive; ran a directive-only pass.');
     }
+    if ((_a = params.collectionOverride) === null || _a === void 0 ? void 0 : _a.to) {
+        var from = params.collectionOverride.from ? "\"".concat(params.collectionOverride.from, "\"") : '(none)';
+        var to = "\"".concat(params.collectionOverride.to, "\"");
+        var reason = params.collectionOverride.reason ? " (".concat(params.collectionOverride.reason, ")") : '';
+        notes.push("Collection override: ".concat(from, " -> ").concat(to).concat(reason, "."));
+    }
     var directive = params.directive;
     var directivePayload = (directive === null || directive === void 0 ? void 0 : directive.payload) || {};
     var rawCollection = normalizeOptionalString(directivePayload === null || directivePayload === void 0 ? void 0 : directivePayload.collection);
-    var debugCollectionRequested = normalizeOptionalString((_a = params.toolResponseDebug) === null || _a === void 0 ? void 0 : _a.collectionRequested);
-    var debugCollectionResolved = normalizeOptionalString((_b = params.toolResponseDebug) === null || _b === void 0 ? void 0 : _b.collectionResolved);
-    var debugCollection = normalizeOptionalString((_c = params.toolResponseDebug) === null || _c === void 0 ? void 0 : _c.collection);
+    var debugCollectionRequested = normalizeOptionalString((_b = params.toolResponseDebug) === null || _b === void 0 ? void 0 : _b.collectionRequested);
+    var debugCollectionResolved = normalizeOptionalString((_c = params.toolResponseDebug) === null || _c === void 0 ? void 0 : _c.collectionResolved);
+    var debugCollection = normalizeOptionalString((_d = params.toolResponseDebug) === null || _d === void 0 ? void 0 : _d.collection);
     var requestedCollection = debugCollectionRequested || rawCollection;
     var resolvedCollection = debugCollectionResolved || debugCollection || requestedCollection;
-    var matchedCollection = typeof ((_d = params.toolResponseDebug) === null || _d === void 0 ? void 0 : _d.collectionMatched) === 'boolean'
+    var matchedCollection = typeof ((_e = params.toolResponseDebug) === null || _e === void 0 ? void 0 : _e.collectionMatched) === 'boolean'
         ? params.toolResponseDebug.collectionMatched
         : undefined;
-    var candidateCollections = Array.isArray((_e = params.toolResponseDebug) === null || _e === void 0 ? void 0 : _e.collectionCandidates)
+    var candidateCollections = Array.isArray((_f = params.toolResponseDebug) === null || _f === void 0 ? void 0 : _f.collectionCandidates)
         ? params.toolResponseDebug.collectionCandidates.filter(Boolean)
         : [];
     if (requestedCollection && resolvedCollection && requestedCollection !== resolvedCollection) {
@@ -1807,24 +2363,78 @@ function buildAssistantDebugPayload(params) {
     else if (matchedCollection === false && candidateCollections.length) {
         notes.push("No direct collection match; candidates: ".concat(candidateCollections.join(', '), "."));
     }
-    if (((_f = params.toolResult) === null || _f === void 0 ? void 0 : _f.type) === 'mongo_agg') {
+    if (((_g = params.toolResult) === null || _g === void 0 ? void 0 : _g.type) === 'mongo_agg') {
         notes.push('Used aggregation for grouped/breakdown request.');
     }
-    else if (((_g = params.toolResult) === null || _g === void 0 ? void 0 : _g.type) === 'mongo_read') {
+    else if (((_h = params.toolResult) === null || _h === void 0 ? void 0 : _h.type) === 'mongo_read') {
         notes.push('Used read query for list/count request.');
     }
-    var fallbackInfo = (_h = params.toolResponseDebug) === null || _h === void 0 ? void 0 : _h.fallbacks;
-    if ((_j = fallbackInfo === null || fallbackInfo === void 0 ? void 0 : fallbackInfo.dateField) === null || _j === void 0 ? void 0 : _j.used) {
+    var fallbackInfo = (_j = params.toolResponseDebug) === null || _j === void 0 ? void 0 : _j.fallbacks;
+    if ((_k = fallbackInfo === null || fallbackInfo === void 0 ? void 0 : fallbackInfo.dateField) === null || _k === void 0 ? void 0 : _k.used) {
         notes.push("Retried with date field fallback ".concat(fallbackInfo.dateField.from, " -> ").concat(fallbackInfo.dateField.to, "."));
     }
-    if ((_k = fallbackInfo === null || fallbackInfo === void 0 ? void 0 : fallbackInfo.dateFieldCreatedAt) === null || _k === void 0 ? void 0 : _k.used) {
+    if ((_l = fallbackInfo === null || fallbackInfo === void 0 ? void 0 : fallbackInfo.dateFieldCreatedAt) === null || _l === void 0 ? void 0 : _l.used) {
         notes.push("Retried with date field fallback ".concat(fallbackInfo.dateFieldCreatedAt.from, " -> ").concat(fallbackInfo.dateFieldCreatedAt.to, "."));
     }
-    if ((_l = fallbackInfo === null || fallbackInfo === void 0 ? void 0 : fallbackInfo.unwind) === null || _l === void 0 ? void 0 : _l.used) {
+    if ((_m = fallbackInfo === null || fallbackInfo === void 0 ? void 0 : fallbackInfo.completion) === null || _m === void 0 ? void 0 : _m.used) {
+        var sources = Array.isArray(fallbackInfo.completion.sources)
+            ? fallbackInfo.completion.sources.join(', ')
+            : fallbackInfo.completion.field;
+        var strategy = fallbackInfo.completion.strategy ? " (".concat(fallbackInfo.completion.strategy, ")") : '';
+        notes.push("Applied completion fallback".concat(strategy, ": ").concat(sources, "."));
+    }
+    if ((_o = fallbackInfo === null || fallbackInfo === void 0 ? void 0 : fallbackInfo.dateFieldsExpanded) === null || _o === void 0 ? void 0 : _o.used) {
+        var fields = Array.isArray(fallbackInfo.dateFieldsExpanded.fields)
+            ? fallbackInfo.dateFieldsExpanded.fields.join(', ')
+            : String(fallbackInfo.dateFieldsExpanded.fields || '');
+        if (fields) {
+            notes.push("Expanded date fields: ".concat(fields, "."));
+        }
+    }
+    if ((_p = fallbackInfo === null || fallbackInfo === void 0 ? void 0 : fallbackInfo.queryFieldAliases) === null || _p === void 0 ? void 0 : _p.used) {
+        var entries = fallbackInfo.queryFieldAliases.aliases
+            ? Object.entries(fallbackInfo.queryFieldAliases.aliases)
+                .map(function (_a) {
+                var _b = __read(_a, 2), from = _b[0], to = _b[1];
+                return "".concat(from, " -> ").concat(to);
+            })
+                .join(', ')
+            : '';
+        if (entries) {
+            notes.push("Rewrote query fields: ".concat(entries, "."));
+        }
+    }
+    if ((_q = fallbackInfo === null || fallbackInfo === void 0 ? void 0 : fallbackInfo.projectionAliases) === null || _q === void 0 ? void 0 : _q.used) {
+        var entries = fallbackInfo.projectionAliases.aliases
+            ? Object.entries(fallbackInfo.projectionAliases.aliases)
+                .map(function (_a) {
+                var _b = __read(_a, 2), from = _b[0], to = _b[1];
+                return "".concat(from, " -> ").concat(to);
+            })
+                .join(', ')
+            : '';
+        if (entries) {
+            notes.push("Expanded projection fields: ".concat(entries, "."));
+        }
+    }
+    if ((_r = fallbackInfo === null || fallbackInfo === void 0 ? void 0 : fallbackInfo.unwind) === null || _r === void 0 ? void 0 : _r.used) {
         notes.push("Applied unwind fallback on ".concat(fallbackInfo.unwind.path, "."));
     }
+    if ((_s = fallbackInfo === null || fallbackInfo === void 0 ? void 0 : fallbackInfo.nameMatch) === null || _s === void 0 ? void 0 : _s.used) {
+        var fields = Array.isArray(fallbackInfo.nameMatch.fields)
+            ? fallbackInfo.nameMatch.fields.join(', ')
+            : fallbackInfo.nameMatch.field;
+        notes.push("Expanded name match fields: ".concat(fields, "."));
+    }
+    if ((_t = fallbackInfo === null || fallbackInfo === void 0 ? void 0 : fallbackInfo.idLookup) === null || _t === void 0 ? void 0 : _t.used) {
+        var field = fallbackInfo.idLookup.field || 'id';
+        var strategy = fallbackInfo.idLookup.strategy || 'lookup';
+        var collection = fallbackInfo.idLookup.collection ? " in ".concat(fallbackInfo.idLookup.collection) : '';
+        var detail = fallbackInfo.idLookup.nameField ? " via ".concat(fallbackInfo.idLookup.nameField) : '';
+        notes.push("Resolved ".concat(field, " by ").concat(strategy).concat(collection).concat(detail, "."));
+    }
     if (params.toolError) {
-        var errorMessage = ((_m = params.toolError) === null || _m === void 0 ? void 0 : _m.message) || String(params.toolError || '');
+        var errorMessage = ((_u = params.toolError) === null || _u === void 0 ? void 0 : _u.message) || String(params.toolError || '');
         if (errorMessage) {
             notes.push("Tool error: ".concat(errorMessage));
         }
@@ -1839,18 +2449,19 @@ function buildAssistantDebugPayload(params) {
             payload: directivePayload,
             rawLine: directive.rawLine
         } : null,
+        collectionOverride: params.collectionOverride || undefined,
         collection: resolvedCollection || requestedCollection || undefined,
         collectionRequested: requestedCollection || undefined,
         collectionResolved: resolvedCollection || undefined,
         collectionMatched: matchedCollection,
         collectionCandidates: candidateCollections.length ? candidateCollections : undefined,
-        collectionScore: typeof ((_o = params.toolResponseDebug) === null || _o === void 0 ? void 0 : _o.collectionScore) === 'number'
+        collectionScore: typeof ((_v = params.toolResponseDebug) === null || _v === void 0 ? void 0 : _v.collectionScore) === 'number'
             ? params.toolResponseDebug.collectionScore
             : undefined,
-        query: ((_p = params.toolResponseDebug) === null || _p === void 0 ? void 0 : _p.query) || undefined,
-        pipeline: ((_q = params.toolResponseDebug) === null || _q === void 0 ? void 0 : _q.executedPipeline) || ((_r = params.toolResponseDebug) === null || _r === void 0 ? void 0 : _r.originalPipeline) || undefined,
-        options: ((_s = params.toolResponseDebug) === null || _s === void 0 ? void 0 : _s.options) || undefined,
-        fallbacks: ((_t = params.toolResponseDebug) === null || _t === void 0 ? void 0 : _t.fallbacks) || undefined,
+        query: ((_w = params.toolResponseDebug) === null || _w === void 0 ? void 0 : _w.query) || undefined,
+        pipeline: ((_x = params.toolResponseDebug) === null || _x === void 0 ? void 0 : _x.executedPipeline) || ((_y = params.toolResponseDebug) === null || _y === void 0 ? void 0 : _y.originalPipeline) || undefined,
+        options: ((_z = params.toolResponseDebug) === null || _z === void 0 ? void 0 : _z.options) || undefined,
+        fallbacks: ((_0 = params.toolResponseDebug) === null || _0 === void 0 ? void 0 : _0.fallbacks) || undefined,
         notes: notes
     };
     if (params.trace && typeof params.trace === 'object') {
@@ -2117,40 +2728,184 @@ function tokenizeFieldKey(value) {
 function normalizeFieldMatchKey(value) {
     return tokenizeFieldKey(value).join('');
 }
+function expandFieldTokens(tokens) {
+    var expanded = new Set();
+    tokens.forEach(function (token) {
+        if (!token) {
+            return;
+        }
+        expanded.add(token);
+        var synonyms = AI_ASSISTANT_FIELD_TOKEN_SYNONYMS[token];
+        if (Array.isArray(synonyms)) {
+            synonyms.forEach(function (synonym) {
+                if (synonym) {
+                    expanded.add(synonym);
+                }
+            });
+        }
+    });
+    return Array.from(expanded);
+}
 function getValueAtPath(obj, path) {
-    var e_1, _a;
     if (!obj || typeof obj !== 'object') {
         return undefined;
     }
     var parts = String(path || '').split('.').filter(Boolean);
-    var current = obj;
-    try {
-        for (var parts_1 = __values(parts), parts_1_1 = parts_1.next(); !parts_1_1.done; parts_1_1 = parts_1.next()) {
-            var part = parts_1_1.value;
-            if (!current || typeof current !== 'object') {
+    var walk = function (current, index) {
+        if (index >= parts.length) {
+            return current;
+        }
+        var part = parts[index];
+        if (Array.isArray(current)) {
+            var numeric = Number(part);
+            if (!Number.isNaN(numeric) && current[numeric] !== undefined) {
+                return walk(current[numeric], index + 1);
+            }
+            var values = current.map(function (entry) { return walk(entry, index); }).filter(function (value) { return value !== undefined; });
+            if (!values.length) {
                 return undefined;
             }
-            current = current[part];
+            return values.length === 1 ? values[0] : values;
+        }
+        if (!current || typeof current !== 'object') {
+            return undefined;
+        }
+        return walk(current[part], index + 1);
+    };
+    return walk(obj, 0);
+}
+function inferIdFieldStorageTypeFromDocs(docs, fieldPath) {
+    var e_1, _a, e_2, _b;
+    if (!Array.isArray(docs) || !fieldPath) {
+        return 'unknown';
+    }
+    var sawString = false;
+    try {
+        for (var docs_1 = __values(docs), docs_1_1 = docs_1.next(); !docs_1_1.done; docs_1_1 = docs_1.next()) {
+            var doc = docs_1_1.value;
+            var value = fieldPath.includes('.')
+                ? getValueAtPath(doc, fieldPath)
+                : doc === null || doc === void 0 ? void 0 : doc[fieldPath];
+            var queue = Array.isArray(value) ? value : [value];
+            try {
+                for (var queue_1 = (e_2 = void 0, __values(queue)), queue_1_1 = queue_1.next(); !queue_1_1.done; queue_1_1 = queue_1.next()) {
+                    var entry = queue_1_1.value;
+                    if (entry === null || entry === undefined) {
+                        continue;
+                    }
+                    if (isMongoObjectId(entry)) {
+                        return 'objectId';
+                    }
+                    if (typeof entry === 'string' && entry.trim()) {
+                        sawString = true;
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (queue_1_1 && !queue_1_1.done && (_b = queue_1.return)) _b.call(queue_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
         }
     }
     catch (e_1_1) { e_1 = { error: e_1_1 }; }
     finally {
         try {
-            if (parts_1_1 && !parts_1_1.done && (_a = parts_1.return)) _a.call(parts_1);
+            if (docs_1_1 && !docs_1_1.done && (_a = docs_1.return)) _a.call(docs_1);
         }
         finally { if (e_1) throw e_1.error; }
     }
-    return current;
+    return sawString ? 'string' : 'unknown';
+}
+function normalizeIdsForTargetField(ids, targetDocs, targetFieldPath, targetFieldTypeOverride) {
+    if (!Array.isArray(ids) || !ids.length) {
+        return [];
+    }
+    var targetType = targetFieldTypeOverride
+        || inferIdFieldStorageTypeFromDocs(targetDocs || [], targetFieldPath);
+    var normalized = [];
+    var seenStrings = new Set();
+    var seenObjectIds = new Set();
+    var pushString = function (value) {
+        var text = String(value || '').trim();
+        if (!text || seenStrings.has(text)) {
+            return;
+        }
+        seenStrings.add(text);
+        normalized.push(text);
+    };
+    var pushObjectId = function (value) {
+        if (!isMongoObjectId(value)) {
+            return;
+        }
+        var hex = typeof value.toHexString === 'function' ? value.toHexString() : String(value || '');
+        if (!hex || seenObjectIds.has(hex)) {
+            return;
+        }
+        seenObjectIds.add(hex);
+        normalized.push(value);
+    };
+    ids.forEach(function (value) {
+        if (value === null || value === undefined) {
+            return;
+        }
+        if (targetType === 'string') {
+            if (isMongoObjectId(value)) {
+                var hex = typeof value.toHexString === 'function' ? value.toHexString() : String(value || '');
+                pushString(hex);
+                return;
+            }
+            pushString(value);
+            return;
+        }
+        if (targetType === 'objectId') {
+            if (isMongoObjectId(value)) {
+                pushObjectId(value);
+                return;
+            }
+            if (typeof value === 'string' && isObjectIdString(value)) {
+                try {
+                    pushObjectId(new mongodb_1.ObjectId(value));
+                }
+                catch (_a) {
+                    return;
+                }
+            }
+            return;
+        }
+        if (isMongoObjectId(value)) {
+            pushObjectId(value);
+            var hex = typeof value.toHexString === 'function' ? value.toHexString() : String(value || '');
+            if (hex) {
+                pushString(hex);
+            }
+            return;
+        }
+        if (typeof value === 'string' && isObjectIdString(value)) {
+            try {
+                pushObjectId(new mongodb_1.ObjectId(value));
+            }
+            catch (_b) {
+                // Ignore invalid object id conversions.
+            }
+            pushString(value);
+            return;
+        }
+        pushString(value);
+    });
+    return normalized;
 }
 function hasNonEmptyValue(docs, fieldPath, options) {
-    var e_2, _a;
+    var e_3, _a;
     if (!Array.isArray(docs) || !fieldPath) {
         return false;
     }
     var usePath = fieldPath.includes('.');
     try {
-        for (var docs_1 = __values(docs), docs_1_1 = docs_1.next(); !docs_1_1.done; docs_1_1 = docs_1.next()) {
-            var doc = docs_1_1.value;
+        for (var docs_2 = __values(docs), docs_2_1 = docs_2.next(); !docs_2_1.done; docs_2_1 = docs_2.next()) {
+            var doc = docs_2_1.value;
             var value = usePath ? getValueAtPath(doc, fieldPath) : doc === null || doc === void 0 ? void 0 : doc[fieldPath];
             if ((options === null || options === void 0 ? void 0 : options.treatObjectLikeAsEmpty) && isDisplayObjectLike(value)) {
                 continue;
@@ -2160,12 +2915,12 @@ function hasNonEmptyValue(docs, fieldPath, options) {
             }
         }
     }
-    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
     finally {
         try {
-            if (docs_1_1 && !docs_1_1.done && (_a = docs_1.return)) _a.call(docs_1);
+            if (docs_2_1 && !docs_2_1.done && (_a = docs_2.return)) _a.call(docs_2);
         }
-        finally { if (e_2) throw e_2.error; }
+        finally { if (e_3) throw e_3.error; }
     }
     return false;
 }
@@ -2201,6 +2956,17 @@ function collectFieldCandidates(docs) {
             }
             var value = doc[key];
             addCandidate(key, value);
+            if (Array.isArray(value)) {
+                var nestedSamples = value.filter(function (entry) { return isPlainObject(entry); }).slice(0, 3);
+                nestedSamples.forEach(function (entry) {
+                    Object.keys(entry).slice(0, 50).forEach(function (nestedKey) {
+                        if (!nestedKey) {
+                            return;
+                        }
+                        addCandidate("".concat(key, ".").concat(nestedKey), entry[nestedKey]);
+                    });
+                });
+            }
             if (isPlainObject(value) && !isMongoObjectId(value) && !(value instanceof Date)) {
                 var nestedKeys = Object.keys(value).slice(0, 50);
                 nestedKeys.forEach(function (nestedKey) {
@@ -2251,10 +3017,18 @@ function resolveFieldAliases(docs, requestedFields) {
             }
             else {
                 var candidateTokens_1 = tokenizeFieldKey(path);
-                var requestedTokens = tokenizeFieldKey(field);
+                var requestedBaseTokens = tokenizeFieldKey(field);
+                var requestedTokens = expandFieldTokens(requestedBaseTokens);
                 var overlap = requestedTokens.filter(function (token) { return candidateTokens_1.includes(token); }).length;
+                var baseOverlap = requestedBaseTokens.filter(function (token) { return candidateTokens_1.includes(token); }).length;
                 if (overlap > 0) {
-                    score = 40 + overlap * 5;
+                    score = 40 + overlap * 10;
+                    if (baseOverlap === 0) {
+                        score += 10;
+                    }
+                    if (requestedBaseTokens.length <= 2) {
+                        score += 10;
+                    }
                 }
             }
             var objectRatio = stats.objectLike / Math.max(stats.nonEmpty, 1);
@@ -2319,32 +3093,143 @@ function resolveProjectionRequestedFields(projection) {
     }
     return keys.filter(function (key) { return !isAssistantIdField(key); });
 }
-function formatDisplayColumnName(column) {
-    var trimmed = String(column || '').trim();
-    if (!trimmed) {
-        return '';
+function isInclusiveProjection(projection) {
+    if (!projection || typeof projection !== 'object') {
+        return false;
     }
-    if (trimmed === '_id') {
-        return 'id';
+    var keys = Object.keys(projection);
+    if (!keys.length) {
+        return false;
     }
-    if (trimmed === '_group') {
-        return 'Group';
+    var hasInclude = false;
+    var hasExclude = false;
+    keys.forEach(function (key) {
+        var value = projection[key];
+        if (value === 0 || value === false) {
+            hasExclude = true;
+        }
+        else if (value === 1 || value === true) {
+            hasInclude = true;
+        }
+    });
+    return hasInclude && !hasExclude;
+}
+function expandProjectionWithAliases(projection, aliases) {
+    if (!projection || !isInclusiveProjection(projection) || !aliases || !Object.keys(aliases).length) {
+        return projection;
     }
-    var normalized = trimmed.replace(/[\s_]+/g, '').toLowerCase();
-    if (normalized === 'createdat') {
-        return 'Created At';
+    var next = __assign({}, projection);
+    Object.keys(aliases).forEach(function (target) {
+        var source = aliases[target];
+        if (!source) {
+            return;
+        }
+        if (!Object.prototype.hasOwnProperty.call(next, source)) {
+            next[source] = 1;
+        }
+    });
+    return next;
+}
+function collectQueryFieldPaths(value, fields) {
+    if (!value || typeof value !== 'object' || value instanceof Date || value instanceof RegExp || isMongoObjectId(value)) {
+        return;
     }
-    if (normalized === 'updatedat') {
-        return 'Updated At';
+    if (Array.isArray(value)) {
+        value.forEach(function (entry) { return collectQueryFieldPaths(entry, fields); });
+        return;
     }
-    var parts = trimmed.split('.');
-    var base = parts[parts.length - 1] || trimmed;
-    if ((base === 'name' || base === 'title' || base === 'label') && parts.length > 1) {
-        return parts[parts.length - 2]
-            .replace(/[_-]+/g, ' ')
-            .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
-            .replace(/\s+/g, ' ')
-            .trim()
+    Object.keys(value).forEach(function (key) {
+        var entry = value[key];
+        if (key.startsWith('$')) {
+            collectQueryFieldPaths(entry, fields);
+            return;
+        }
+        fields.add(key);
+        if (entry && typeof entry === 'object' && !Array.isArray(entry) && !isMongoObjectId(entry) && !(entry instanceof Date)) {
+            var nestedKeys = Object.keys(entry).filter(function (nested) { return !nested.startsWith('$'); });
+            nestedKeys.forEach(function (nested) {
+                fields.add("".concat(key, ".").concat(nested));
+            });
+        }
+    });
+}
+function extractQueryFieldPaths(query) {
+    var fields = new Set();
+    collectQueryFieldPaths(query, fields);
+    return Array.from(fields).filter(Boolean);
+}
+function replaceFieldPathDeep(value, fromField, toField) {
+    if (Array.isArray(value)) {
+        return value.map(function (entry) { return replaceFieldPathDeep(entry, fromField, toField); });
+    }
+    if (value instanceof Date || isMongoObjectId(value)) {
+        return value;
+    }
+    if (value && typeof value === 'object') {
+        var next_1 = {};
+        Object.keys(value).forEach(function (key) {
+            var nextKey = key === fromField ? toField : key;
+            next_1[nextKey] = replaceFieldPathDeep(value[key], fromField, toField);
+        });
+        return next_1;
+    }
+    if (typeof value === 'string') {
+        if (value.startsWith("$".concat(fromField))) {
+            return "$".concat(toField).concat(value.slice(fromField.length + 1));
+        }
+        return value;
+    }
+    return value;
+}
+function replaceQueryFieldCondition(query, field, condition) {
+    if (Array.isArray(query)) {
+        return query.map(function (entry) { return replaceQueryFieldCondition(entry, field, condition); });
+    }
+    if (!query || typeof query !== 'object') {
+        return query;
+    }
+    var next = __assign({}, query);
+    Object.keys(next).forEach(function (key) {
+        if (key === field) {
+            next[key] = condition;
+            return;
+        }
+        if (key.startsWith('$')) {
+            next[key] = replaceQueryFieldCondition(next[key], field, condition);
+            return;
+        }
+        if (next[key] && typeof next[key] === 'object') {
+            next[key] = replaceQueryFieldCondition(next[key], field, condition);
+        }
+    });
+    return next;
+}
+function formatDisplayColumnName(column) {
+    var trimmed = String(column || '').trim();
+    if (!trimmed) {
+        return '';
+    }
+    if (trimmed === '_id') {
+        return 'id';
+    }
+    if (trimmed === '_group') {
+        return 'Group';
+    }
+    var normalized = trimmed.replace(/[\s_]+/g, '').toLowerCase();
+    if (normalized === 'createdat') {
+        return 'Created At';
+    }
+    if (normalized === 'updatedat') {
+        return 'Updated At';
+    }
+    var parts = trimmed.split('.');
+    var base = parts[parts.length - 1] || trimmed;
+    if ((base === 'name' || base === 'title' || base === 'label') && parts.length > 1) {
+        return parts[parts.length - 2]
+            .replace(/[_-]+/g, ' ')
+            .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+            .replace(/\s+/g, ' ')
+            .trim()
             .replace(/\b\w/g, function (char) { return char.toUpperCase(); });
     }
     return base
@@ -2415,14 +3300,17 @@ function serializeMongoValue(value, maxLength) {
     }
     return truncateDisplayText(String(value), maxLength);
 }
-function flattenForTable(doc) {
+function flattenForTable(doc, options) {
     var result = {};
     if (!doc || typeof doc !== 'object') {
         return result;
     }
     if (Object.prototype.hasOwnProperty.call(doc, '_id')) {
         var idValue_1 = doc._id;
-        if (idValue_1 !== null && idValue_1 !== undefined) {
+        if (options === null || options === void 0 ? void 0 : options.includeIds) {
+            result._id = idValue_1;
+        }
+        if ((options === null || options === void 0 ? void 0 : options.includeGroupFromId) && idValue_1 !== null && idValue_1 !== undefined) {
             if (isPlainObject(idValue_1) && !isMongoObjectId(idValue_1) && !(idValue_1 instanceof Date)) {
                 Object.keys(idValue_1).forEach(function (key) {
                     if (!key || Object.prototype.hasOwnProperty.call(result, key)) {
@@ -2465,7 +3353,12 @@ function flattenForTable(doc) {
     return result;
 }
 function buildDisplayTable(docs, options) {
-    var rowsRaw = Array.isArray(docs) ? docs.map(function (doc) { return flattenForTable(doc); }) : [];
+    var rowsRaw = Array.isArray(docs)
+        ? docs.map(function (doc) { return flattenForTable(doc, {
+            includeIds: (options === null || options === void 0 ? void 0 : options.includeIds) === true,
+            includeGroupFromId: (options === null || options === void 0 ? void 0 : options.includeGroupFromId) === true
+        }); })
+        : [];
     var stats = new Map();
     rowsRaw.forEach(function (row) {
         Object.keys(row).forEach(function (key) {
@@ -2715,10 +3608,12 @@ function normalizeAssistantAggregatePipeline(pipeline) {
         .map(function (stage) {
         var next = __assign({}, stage);
         if (next.$match && typeof next.$match === 'object') {
-            next.$match = applyAssistantNameRegexToQuery(next.$match);
+            var rewritten = rewriteEmbeddedMatchObjects(next.$match);
+            next.$match = applyAssistantNameRegexToQuery(rewritten);
         }
         if (next.$geoNear && typeof next.$geoNear === 'object' && next.$geoNear.query) {
-            next.$geoNear = __assign(__assign({}, next.$geoNear), { query: applyAssistantNameRegexToQuery(next.$geoNear.query) });
+            var rewritten = rewriteEmbeddedMatchObjects(next.$geoNear.query);
+            next.$geoNear = __assign(__assign({}, next.$geoNear), { query: applyAssistantNameRegexToQuery(rewritten) });
         }
         return next;
     });
@@ -2821,7 +3716,8 @@ function normalizeAggregateFieldList(values) {
     return result;
 }
 function isCompletionFieldName(value) {
-    return String(value || '').toLowerCase().includes('complete');
+    var normalized = String(value || '').toLowerCase();
+    return normalized.includes('complete') || normalized.includes('close');
 }
 function isDateLikeFieldName(value) {
     var normalized = String(value || '').toLowerCase();
@@ -2848,7 +3744,7 @@ function matchContainsField(value, field) {
     });
 }
 function resolveAggregateCompletionFallback(pipeline) {
-    var e_3, _a;
+    var e_4, _a;
     if (!Array.isArray(pipeline)) {
         return null;
     }
@@ -2861,7 +3757,7 @@ function resolveAggregateCompletionFallback(pipeline) {
         }
         var addFields = stage.$addFields;
         try {
-            for (var _b = (e_3 = void 0, __values(Object.keys(addFields))), _c = _b.next(); !_c.done; _c = _b.next()) {
+            for (var _b = (e_4 = void 0, __values(Object.keys(addFields))), _c = _b.next(); !_c.done; _c = _b.next()) {
                 var key = _c.value;
                 if (!isCompletionFieldName(key)) {
                     continue;
@@ -2875,12 +3771,12 @@ function resolveAggregateCompletionFallback(pipeline) {
                 }
             }
         }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_3) throw e_3.error; }
+            finally { if (e_4) throw e_4.error; }
         }
         if (candidateField) {
             break;
@@ -2926,18 +3822,18 @@ function resolveAggregateCompletionFallback(pipeline) {
         statusFilter: statusFilter
     };
 }
+function buildIfNullChain(fields) {
+    if (!fields.length) {
+        return null;
+    }
+    var expr = "$".concat(fields[fields.length - 1]);
+    for (var i = fields.length - 2; i >= 0; i -= 1) {
+        expr = { $ifNull: ["$".concat(fields[i]), expr] };
+    }
+    return expr;
+}
 function buildAggregateCompletionFallbackPipeline(pipeline, fallback) {
     var _a;
-    var buildIfNullChain = function (fields) {
-        if (!fields.length) {
-            return null;
-        }
-        var expr = "$".concat(fields[fields.length - 1]);
-        for (var i = fields.length - 2; i >= 0; i -= 1) {
-            expr = { $ifNull: ["$".concat(fields[i]), expr] };
-        }
-        return expr;
-    };
     var matchStage = (_a = pipeline[fallback.matchIndex]) === null || _a === void 0 ? void 0 : _a.$match;
     if (!matchStage || typeof matchStage !== 'object') {
         return pipeline;
@@ -2970,6 +3866,163 @@ function buildAggregateCompletionFallbackPipeline(pipeline, fallback) {
         return stage;
     });
 }
+function normalizeCompletionStatusValue(value) {
+    var normalized = String(value || '').toLowerCase();
+    if (!normalized) {
+        return null;
+    }
+    if (normalized.includes('complete')) {
+        return 'complete';
+    }
+    if (normalized.includes('close')) {
+        return 'close';
+    }
+    return null;
+}
+function applyCompletionStatusRegexFallback(match) {
+    if (Array.isArray(match)) {
+        return match.map(function (entry) { return applyCompletionStatusRegexFallback(entry); });
+    }
+    if (!match || typeof match !== 'object') {
+        return match;
+    }
+    var result = {};
+    Object.keys(match).forEach(function (key) {
+        var value = match[key];
+        if (key === 'status' || key === 'state') {
+            if (typeof value === 'string') {
+                var token = normalizeCompletionStatusValue(value);
+                if (token) {
+                    result[key] = { $regex: token, $options: 'i' };
+                    return;
+                }
+            }
+            result[key] = value;
+            return;
+        }
+        if (key.startsWith('$')) {
+            result[key] = applyCompletionStatusRegexFallback(value);
+            return;
+        }
+        if (value && typeof value === 'object') {
+            result[key] = applyCompletionStatusRegexFallback(value);
+            return;
+        }
+        result[key] = value;
+    });
+    return result;
+}
+function buildCompletionFallbackSources(field) {
+    return normalizeAggregateFieldList([
+        field,
+        'date_completed',
+        'date_closed',
+        'completedAt',
+        'closedAt',
+        'completed_at',
+        'closed_at',
+        'date_completed_at',
+        'date_closed_at',
+        'completion_date',
+        'completed_date',
+        'date_finished',
+        'finished_at',
+        'createdAt',
+        'date_created'
+    ]);
+}
+function resolveAggregateCompletionExprFallback(pipeline) {
+    var e_5, _a;
+    if (!Array.isArray(pipeline)) {
+        return null;
+    }
+    for (var i = 0; i < pipeline.length; i += 1) {
+        var stage = pipeline[i];
+        if (!stage || typeof stage !== 'object' || !stage.$match || typeof stage.$match !== 'object') {
+            continue;
+        }
+        var matchStage = stage.$match;
+        var candidateField = '';
+        if (matchStage.$expr) {
+            var exprFields = extractExpressionFieldPaths(matchStage.$expr)
+                .filter(function (field) { return isCompletionFieldName(field); });
+            if (exprFields.length) {
+                candidateField = exprFields[0];
+            }
+        }
+        if (!candidateField) {
+            try {
+                for (var _b = (e_5 = void 0, __values(Object.keys(matchStage))), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var key = _c.value;
+                    if (key.startsWith('$')) {
+                        continue;
+                    }
+                    if (!isCompletionFieldName(key)) {
+                        continue;
+                    }
+                    var entry = matchStage[key];
+                    if (hasDateRangeOperators(entry) || entry instanceof Date) {
+                        candidateField = key;
+                        break;
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        }
+        if (!candidateField) {
+            continue;
+        }
+        var sources = buildCompletionFallbackSources(candidateField);
+        if (!sources.length) {
+            return null;
+        }
+        var hasStatus = matchContainsField(matchStage, 'status') || matchContainsField(matchStage, 'state');
+        var statusFilter = !hasStatus
+            ? { $or: [{ status: { $regex: 'complete', $options: 'i' } }, { state: { $regex: 'complete', $options: 'i' } }] }
+            : null;
+        return {
+            matchIndex: i,
+            field: candidateField,
+            sources: sources,
+            statusFilter: statusFilter
+        };
+    }
+    return null;
+}
+function buildAggregateCompletionExprFallbackPipeline(pipeline, fallback) {
+    var _a;
+    var _b;
+    var targetField = 'completed_at_effective';
+    var replacedPipeline = replaceAggregateDateField(pipeline, fallback.field, targetField);
+    var matchStage = (_b = replacedPipeline[fallback.matchIndex]) === null || _b === void 0 ? void 0 : _b.$match;
+    if (!matchStage || typeof matchStage !== 'object') {
+        return replacedPipeline;
+    }
+    var baseMatch = applyCompletionStatusRegexFallback(matchStage);
+    var nextMatch = fallback.statusFilter ? { $and: [baseMatch, fallback.statusFilter] } : baseMatch;
+    var addFieldsStage = { $addFields: (_a = {}, _a[targetField] = buildIfNullChain(fallback.sources), _a) };
+    var alreadyHasField = replacedPipeline
+        .slice(0, fallback.matchIndex)
+        .some(function (stage) { return stage && typeof stage === 'object' && stage.$addFields && Object.prototype.hasOwnProperty.call(stage.$addFields, targetField); });
+    var output = [];
+    replacedPipeline.forEach(function (stage, index) {
+        if (index === fallback.matchIndex) {
+            if (!alreadyHasField) {
+                output.push(addFieldsStage);
+            }
+            output.push({ $match: nextMatch });
+            return;
+        }
+        output.push(stage);
+    });
+    return output;
+}
 function resolveAggregateUnwindFallback(pipeline) {
     var groupIndex = findAggregateGroupIndex(pipeline);
     if (groupIndex === -1) {
@@ -3076,47 +4129,771 @@ function buildAggregateUnwindFallbackPipeline(pipeline, fallback) {
     };
     return __spreadArray(__spreadArray(__spreadArray([], __read(before), false), [unwindStage], false), __read(after), false);
 }
-function findAggregateDateField(pipeline) {
-    var fields = new Set();
-    (pipeline || []).forEach(function (stage) {
-        if (!stage || typeof stage !== 'object') {
+function isRegexMatchCondition(value) {
+    if (!value) {
+        return false;
+    }
+    if (value instanceof RegExp) {
+        return true;
+    }
+    if (typeof value === 'object' && !Array.isArray(value)) {
+        return Object.prototype.hasOwnProperty.call(value, '$regex');
+    }
+    return false;
+}
+function findRegexMatchInMatchObject(match, prefix) {
+    var e_6, _a, e_7, _b;
+    if (prefix === void 0) { prefix = ''; }
+    if (Array.isArray(match)) {
+        try {
+            for (var match_1 = __values(match), match_1_1 = match_1.next(); !match_1_1.done; match_1_1 = match_1.next()) {
+                var entry = match_1_1.value;
+                var found = findRegexMatchInMatchObject(entry, prefix);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (match_1_1 && !match_1_1.done && (_a = match_1.return)) _a.call(match_1);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        return null;
+    }
+    if (!match || typeof match !== 'object') {
+        return null;
+    }
+    var keys = Object.keys(match);
+    try {
+        for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+            var key = keys_1_1.value;
+            var value = match[key];
+            if (key.startsWith('$')) {
+                var found = findRegexMatchInMatchObject(value, prefix);
+                if (found) {
+                    return found;
+                }
+                continue;
+            }
+            var currentPath = prefix ? "".concat(prefix, ".").concat(key) : key;
+            if (isRegexMatchCondition(value)) {
+                return { field: currentPath, condition: value };
+            }
+            if (value && typeof value === 'object') {
+                var found = findRegexMatchInMatchObject(value, currentPath);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (keys_1_1 && !keys_1_1.done && (_b = keys_1.return)) _b.call(keys_1);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    return null;
+}
+function expandNameFieldCandidates(field) {
+    var normalized = normalizeOptionalString(field);
+    if (!normalized) {
+        return [];
+    }
+    var parts = normalized.split('.').filter(Boolean);
+    var leaf = parts[parts.length - 1] || normalized;
+    var prefix = parts.length > 1 ? parts.slice(0, -1).join('.') : '';
+    var withPrefix = function (value) { return (prefix ? "".concat(prefix, ".").concat(value) : value); };
+    var candidates = [];
+    var seen = new Set();
+    var push = function (value) {
+        if (!value) {
             return;
         }
-        if (stage.$match && typeof stage.$match === 'object') {
-            collectDateFieldsFromMatch(stage.$match, fields);
+        if (seen.has(value)) {
+            return;
         }
-    });
-    if (fields.size !== 1) {
+        seen.add(value);
+        candidates.push(value);
+    };
+    push(normalized);
+    var leafLower = leaf.toLowerCase();
+    var genericVariants = ['name', 'title', 'label', 'display_name', 'displayName', 'description'];
+    genericVariants.forEach(function (variant) { return push(withPrefix(variant)); });
+    if (!leafLower.endsWith('name')) {
+        push(withPrefix("".concat(leaf, "_name")));
+        push(withPrefix("".concat(leaf, "Name")));
+    }
+    if (leafLower.includes('chemical')) {
+        [
+            'chemical',
+            'chemical_name',
+            'chemicalName',
+            'chem_name',
+            'chemName',
+            'product',
+            'product_name',
+            'productName',
+            'material',
+            'blend_name'
+        ].forEach(function (variant) { return push(withPrefix(variant)); });
+        push(withPrefix("".concat(leaf, ".name")));
+        push(withPrefix("".concat(leaf, ".label")));
+        push(withPrefix("".concat(leaf, ".product")));
+        if (normalized.includes('blend_chemicals')) {
+            ['chemical', 'chemical_name', 'chemicalName', 'product', 'product_name', 'productName'].forEach(push);
+        }
+    }
+    if (leafLower.includes('customer')) {
+        [
+            'customer',
+            'customer_name',
+            'customerName',
+            'company',
+            'company_name',
+            'companyName',
+            'account',
+            'account_name',
+            'accountName',
+            'name'
+        ].forEach(function (variant) { return push(withPrefix(variant)); });
+        push(withPrefix("".concat(leaf, ".name")));
+    }
+    if (leafLower.includes('well')) {
+        [
+            'well',
+            'well_name',
+            'wellName',
+            'name',
+            'site',
+            'site_name',
+            'siteName',
+            'pad',
+            'pad_name',
+            'padName',
+            'api',
+            'api_number',
+            'apiNumber',
+            'well_number',
+            'wellNumber'
+        ].forEach(function (variant) { return push(withPrefix(variant)); });
+        push(withPrefix("".concat(leaf, ".name")));
+    }
+    return candidates.slice(0, AI_ASSISTANT_NAME_MATCH_FALLBACK_MAX_FIELDS);
+}
+function resolveAggregateNameMatchFallback(pipeline) {
+    if (!Array.isArray(pipeline)) {
         return null;
     }
-    return Array.from(fields)[0];
+    for (var i = 0; i < pipeline.length; i += 1) {
+        var stage = pipeline[i];
+        if (!stage || typeof stage !== 'object' || !stage.$match || typeof stage.$match !== 'object') {
+            continue;
+        }
+        var found = findRegexMatchInMatchObject(stage.$match);
+        if (!found || !shouldApplyAssistantNameRegex(found.field)) {
+            continue;
+        }
+        var fields = expandNameFieldCandidates(found.field);
+        if (fields.length <= 1) {
+            continue;
+        }
+        return {
+            matchIndex: i,
+            field: found.field,
+            condition: found.condition,
+            fields: fields
+        };
+    }
+    return null;
 }
-function collectDateFieldsFromMatch(value, fields) {
-    if (!value || typeof value !== 'object') {
-        return;
+function resolveReadNameMatchFallback(query) {
+    if (!query || typeof query !== 'object') {
+        return null;
+    }
+    var found = findRegexMatchInMatchObject(query);
+    if (!found || !shouldApplyAssistantNameRegex(found.field) || isAssistantIdField(found.field)) {
+        return null;
+    }
+    var fields = expandNameFieldCandidates(found.field);
+    if (fields.length <= 1) {
+        return null;
+    }
+    var baseMatch = stripMatchField(query, found.field);
+    var orConditions = fields.map(function (field) {
+        var _a;
+        return (_a = {}, _a[field] = found.condition, _a);
+    });
+    var nextMatch = isEmptyMatchValue(baseMatch)
+        ? { $or: orConditions }
+        : { $and: [baseMatch, { $or: orConditions }] };
+    return {
+        query: nextMatch,
+        field: found.field,
+        fields: fields
+    };
+}
+function isEmptyMatchValue(value) {
+    if (value === null || value === undefined) {
+        return true;
     }
     if (Array.isArray(value)) {
-        value.forEach(function (entry) { return collectDateFieldsFromMatch(entry, fields); });
-        return;
+        return value.length === 0;
     }
-    Object.keys(value).forEach(function (key) {
-        var entry = value[key];
-        if (Object.prototype.hasOwnProperty.call(AI_ASSISTANT_DATE_FALLBACKS, key)) {
-            if (hasDateRangeOperators(entry) || entry instanceof Date) {
-                fields.add(key);
-            }
+    if (typeof value === 'object') {
+        return Object.keys(value).length === 0;
+    }
+    return false;
+}
+function stripMatchField(match, field) {
+    if (Array.isArray(match)) {
+        var strippedArray = match
+            .map(function (entry) { return stripMatchField(entry, field); })
+            .filter(function (entry) { return !isEmptyMatchValue(entry); });
+        return strippedArray;
+    }
+    if (!match || typeof match !== 'object') {
+        return match;
+    }
+    var result = {};
+    Object.keys(match).forEach(function (key) {
+        if (key === field) {
             return;
         }
+        var value = match[key];
         if (key.startsWith('$')) {
-            collectDateFieldsFromMatch(entry, fields);
+            var stripped = stripMatchField(value, field);
+            if (isEmptyMatchValue(stripped) && (key === '$and' || key === '$or')) {
+                return;
+            }
+            result[key] = stripped;
             return;
         }
-        if (entry && typeof entry === 'object') {
-            collectDateFieldsFromMatch(entry, fields);
+        if (value && typeof value === 'object') {
+            var stripped = stripMatchField(value, field);
+            if (!isEmptyMatchValue(stripped)) {
+                result[key] = stripped;
+            }
+            return;
         }
+        result[key] = value;
     });
+    return result;
 }
-function hasDateRangeOperators(value) {
+function isEmptyQueryValue(value) {
+    if (value === null || value === undefined) {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.length === 0;
+    }
+    if (typeof value === 'object') {
+        return Object.keys(value).length === 0;
+    }
+    return false;
+}
+function stripQueryFieldPathsDeepWithMeta(query, fieldsToStrip) {
+    var fieldSet = new Set((fieldsToStrip || []).filter(Boolean));
+    var stripValue = function (value, prefix) {
+        if (Array.isArray(value)) {
+            var changed_1 = false;
+            var nextArray = value
+                .map(function (entry) {
+                var stripped = stripValue(entry, prefix);
+                if (stripped.changed) {
+                    changed_1 = true;
+                }
+                return stripped.value;
+            })
+                .filter(function (entry) { return !isEmptyQueryValue(entry); });
+            if (nextArray.length !== value.length) {
+                changed_1 = true;
+            }
+            return { value: nextArray, changed: changed_1 };
+        }
+        if (!value || typeof value !== 'object' || value instanceof Date || value instanceof RegExp || isMongoObjectId(value)) {
+            return { value: value, changed: false };
+        }
+        var result = {};
+        var changed = false;
+        var keys = Object.keys(value);
+        keys.forEach(function (key) {
+            var entry = value[key];
+            if (key.startsWith('$')) {
+                if (Array.isArray(entry) && (key === '$and' || key === '$or' || key === '$nor')) {
+                    var stripped = stripValue(entry, prefix);
+                    var arrayValue = Array.isArray(stripped.value) ? stripped.value : [];
+                    if (arrayValue.length === 0) {
+                        changed = true;
+                        return;
+                    }
+                    if (arrayValue.length !== entry.length || stripped.changed) {
+                        changed = true;
+                    }
+                    result[key] = arrayValue;
+                    return;
+                }
+                if (entry && typeof entry === 'object') {
+                    var stripped = stripValue(entry, prefix);
+                    if (stripped.changed) {
+                        changed = true;
+                    }
+                    result[key] = stripped.value;
+                    return;
+                }
+                result[key] = entry;
+                return;
+            }
+            var currentPath = prefix ? "".concat(prefix, ".").concat(key) : key;
+            if (fieldSet.has(currentPath)) {
+                changed = true;
+                return;
+            }
+            if (entry && typeof entry === 'object') {
+                var stripped = stripValue(entry, currentPath);
+                if (stripped.changed) {
+                    changed = true;
+                }
+                if (!isEmptyQueryValue(stripped.value)) {
+                    result[key] = stripped.value;
+                }
+                else {
+                    changed = true;
+                }
+                return;
+            }
+            result[key] = entry;
+        });
+        var resultKeys = Object.keys(result);
+        if (resultKeys.length === 1 && (resultKeys[0] === '$and' || resultKeys[0] === '$or')) {
+            var only = result[resultKeys[0]];
+            if (Array.isArray(only) && only.length === 1) {
+                return { value: only[0], changed: true };
+            }
+        }
+        return { value: result, changed: changed };
+    };
+    return stripValue(query, '');
+}
+function stripQueryFieldPathsDeep(query, fieldsToStrip) {
+    return stripQueryFieldPathsDeepWithMeta(query, fieldsToStrip).value;
+}
+function stripScopedFieldsFromPipelineWithMeta(pipeline, fieldsToStrip) {
+    if (!Array.isArray(pipeline)) {
+        return { pipeline: [], changed: false };
+    }
+    var changed = false;
+    var nextPipeline = pipeline.map(function (stage) {
+        if (!stage || typeof stage !== 'object') {
+            return stage;
+        }
+        var nextStage = stage;
+        if (stage.$match && typeof stage.$match === 'object') {
+            var stripped = stripQueryFieldPathsDeepWithMeta(stage.$match, fieldsToStrip);
+            if (stripped.changed) {
+                changed = true;
+            }
+            nextStage = __assign(__assign({}, nextStage), { $match: stripped.value });
+        }
+        if (stage.$geoNear && typeof stage.$geoNear === 'object' && stage.$geoNear.query) {
+            var stripped = stripQueryFieldPathsDeepWithMeta(stage.$geoNear.query, fieldsToStrip);
+            if (stripped.changed) {
+                changed = true;
+            }
+            nextStage = __assign(__assign({}, nextStage), { $geoNear: __assign(__assign({}, stage.$geoNear), { query: stripped.value }) });
+        }
+        return nextStage;
+    });
+    return { pipeline: nextPipeline, changed: changed };
+}
+function stripScopedFieldsFromPipeline(pipeline, fieldsToStrip) {
+    return stripScopedFieldsFromPipelineWithMeta(pipeline, fieldsToStrip).pipeline;
+}
+function isIdLookupCondition(value) {
+    if (!value) {
+        return false;
+    }
+    if (value instanceof RegExp) {
+        return true;
+    }
+    if (typeof value === 'string') {
+        return !isObjectIdString(value.trim());
+    }
+    if (typeof value === 'object') {
+        return Object.prototype.hasOwnProperty.call(value, '$regex');
+    }
+    return false;
+}
+function collectIdFieldConditions(match) {
+    var results = [];
+    var visit = function (value) {
+        if (Array.isArray(value)) {
+            value.forEach(function (entry) { return visit(entry); });
+            return;
+        }
+        if (!value || typeof value !== 'object') {
+            return;
+        }
+        Object.keys(value).forEach(function (key) {
+            var entry = value[key];
+            if (key.startsWith('$')) {
+                visit(entry);
+                return;
+            }
+            if (isAssistantIdField(key) && isIdLookupCondition(entry)) {
+                results.push({ field: key, condition: entry });
+                return;
+            }
+            if (entry && typeof entry === 'object') {
+                visit(entry);
+            }
+        });
+    };
+    visit(match);
+    return results;
+}
+function resolveLocalNameFieldFromDocs(docs, baseToken) {
+    var normalizedBase = normalizeOptionalString(baseToken);
+    if (!normalizedBase || !Array.isArray(docs) || !docs.length) {
+        return null;
+    }
+    if (hasNonEmptyValue(docs, normalizedBase, { treatObjectLikeAsEmpty: true })) {
+        return normalizedBase;
+    }
+    var aliases = resolveFieldAliases(docs, [normalizedBase]);
+    return aliases[normalizedBase] || null;
+}
+function buildIdFieldNameFallbackQuery(query, idField, nameField, condition) {
+    var _a, _b;
+    var baseMatch = stripMatchField(query, idField);
+    var orConditions = [
+        (_a = {}, _a[idField] = condition, _a),
+        (_b = {}, _b[nameField] = condition, _b)
+    ];
+    var nextMatch = isEmptyMatchValue(baseMatch)
+        ? { $or: orConditions }
+        : { $and: [baseMatch, { $or: orConditions }] };
+    return nextMatch;
+}
+function resolveIdLookupCandidates(baseToken, collectionNames) {
+    var normalizedBase = normalizeOptionalString(baseToken).toLowerCase();
+    if (!normalizedBase || !Array.isArray(collectionNames) || !collectionNames.length) {
+        return [];
+    }
+    var candidates = new Set();
+    var hints = AI_ASSISTANT_ID_LOOKUP_HINTS[normalizedBase] || [];
+    hints.forEach(function (hint) {
+        if (collectionNames.includes(hint)) {
+            candidates.add(hint);
+        }
+    });
+    var tokens = tokenizeCollectionText(normalizedBase);
+    var ranked = collectionNames
+        .map(function (name) { return ({ name: name, score: scoreCollectionMatch(tokens, name) }); })
+        .filter(function (entry) { return entry.score > 0; })
+        .sort(function (a, b) { return b.score - a.score; })
+        .slice(0, AI_ASSISTANT_ID_LOOKUP_CANDIDATE_LIMIT);
+    ranked.forEach(function (entry) { return candidates.add(entry.name); });
+    return Array.from(candidates);
+}
+function buildNameLookupFields(baseToken, docs) {
+    var normalizedBase = normalizeOptionalString(baseToken);
+    var candidates = expandNameFieldCandidates(normalizedBase);
+    if (!Array.isArray(docs) || !docs.length) {
+        return candidates;
+    }
+    var available = collectFieldCandidates(docs);
+    var filtered = candidates.filter(function (field) {
+        var stats = available.get(field);
+        return !!stats && stats.nonEmpty > 0;
+    });
+    return filtered.length ? filtered : candidates;
+}
+function lookupIdsForNameMatch(params) {
+    return __awaiter(this, void 0, void 0, function () {
+        var db, dbName, collection, baseToken, regex, idClient, idCustomer, isSuperAdmin, probeDocs, fields, query, hasClient, normalizedCustomer, hasCustomer, projection, docs, ids;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    db = params.db, dbName = params.dbName, collection = params.collection, baseToken = params.baseToken, regex = params.regex, idClient = params.idClient, idCustomer = params.idCustomer, isSuperAdmin = params.isSuperAdmin, probeDocs = params.probeDocs;
+                    fields = buildNameLookupFields(baseToken, probeDocs);
+                    if (!fields.length) {
+                        return [2 /*return*/, null];
+                    }
+                    query = { $or: fields.map(function (field) {
+                            var _a;
+                            return (_a = {}, _a[field] = regex, _a);
+                        }) };
+                    if (!!isSuperAdmin) return [3 /*break*/, 3];
+                    return [4 /*yield*/, collectionHasClientIndex(db, dbName, collection)];
+                case 1:
+                    hasClient = _a.sent();
+                    if (hasClient) {
+                        query = applyClientScopeFilter(query, idClient, isSuperAdmin);
+                    }
+                    normalizedCustomer = normalizeOptionalString(idCustomer);
+                    if (!(normalizedCustomer && collection !== 'customers')) return [3 /*break*/, 3];
+                    return [4 /*yield*/, collectionHasFieldIndex(db, dbName, collection, 'id_customer')];
+                case 2:
+                    hasCustomer = _a.sent();
+                    if (hasCustomer) {
+                        query = applyCustomerScopeFilter(query, collection, normalizedCustomer, isSuperAdmin);
+                    }
+                    _a.label = 3;
+                case 3:
+                    projection = { _id: 1 };
+                    fields.forEach(function (field) {
+                        projection[field] = 1;
+                    });
+                    return [4 /*yield*/, db.collection(collection)
+                            .find(query, {
+                            projection: projection,
+                            limit: AI_ASSISTANT_ID_LOOKUP_MAX_RESULTS,
+                            readPreference: AI_ASSISTANT_READ_PREFERENCE
+                        })
+                            .toArray()];
+                case 4:
+                    docs = _a.sent();
+                    ids = docs.map(function (doc) { return doc === null || doc === void 0 ? void 0 : doc._id; }).filter(Boolean);
+                    return [2 /*return*/, ids.length ? { ids: ids, fields: fields } : null];
+            }
+        });
+    });
+}
+function applyIdLookupFallbackToQuery(params) {
+    return __awaiter(this, void 0, void 0, function () {
+        var query, db, dbName, idClient, idCustomer, isSuperAdmin, probeDocs, conditions, collectionNames, _a, conditions_1, conditions_1_1, condition, regex, baseToken, targetFieldType, nextValue, localNameField, candidates, candidates_1, candidates_1_1, candidate, candidateHasClientScope, _b, candidateProbe, lookup, targetFieldType, normalizedIds, idsForQuery, e_8_1, e_9_1;
+        var e_9, _c, e_8, _d;
+        var _e;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    query = params.query, db = params.db, dbName = params.dbName, idClient = params.idClient, idCustomer = params.idCustomer, isSuperAdmin = params.isSuperAdmin, probeDocs = params.probeDocs;
+                    conditions = collectIdFieldConditions(query);
+                    if (!conditions.length) {
+                        return [2 /*return*/, null];
+                    }
+                    _a = params.collectionNames;
+                    if (_a) return [3 /*break*/, 2];
+                    return [4 /*yield*/, listAssistantCollections(db, dbName)];
+                case 1:
+                    _a = (_f.sent());
+                    _f.label = 2;
+                case 2:
+                    collectionNames = _a;
+                    _f.label = 3;
+                case 3:
+                    _f.trys.push([3, 18, 19, 20]);
+                    conditions_1 = __values(conditions), conditions_1_1 = conditions_1.next();
+                    _f.label = 4;
+                case 4:
+                    if (!!conditions_1_1.done) return [3 /*break*/, 17];
+                    condition = conditions_1_1.value;
+                    regex = buildRegexFromCondition(condition.condition);
+                    if (!regex) {
+                        return [3 /*break*/, 16];
+                    }
+                    baseToken = normalizeIdFieldBase(condition.field);
+                    if (!baseToken) {
+                        return [3 /*break*/, 16];
+                    }
+                    if (baseToken === 'customer' && idCustomer) {
+                        targetFieldType = inferIdFieldStorageTypeFromDocs(probeDocs || [], condition.field);
+                        nextValue = idCustomer;
+                        if (targetFieldType === 'objectId' && isObjectIdString(idCustomer)) {
+                            try {
+                                nextValue = new mongodb_1.ObjectId(idCustomer);
+                            }
+                            catch (_g) {
+                                nextValue = idCustomer;
+                            }
+                        }
+                        return [2 /*return*/, {
+                                query: replaceQueryFieldCondition(query, condition.field, nextValue),
+                                meta: {
+                                    field: condition.field,
+                                    strategy: 'customer_scope',
+                                    value: idCustomer,
+                                    targetFieldType: targetFieldType
+                                }
+                            }];
+                    }
+                    localNameField = resolveLocalNameFieldFromDocs(probeDocs || [], baseToken);
+                    if (localNameField) {
+                        return [2 /*return*/, {
+                                query: buildIdFieldNameFallbackQuery(query, condition.field, localNameField, regex),
+                                meta: {
+                                    field: condition.field,
+                                    strategy: 'local_name',
+                                    nameField: localNameField
+                                }
+                            }];
+                    }
+                    candidates = resolveIdLookupCandidates(baseToken, collectionNames);
+                    _f.label = 5;
+                case 5:
+                    _f.trys.push([5, 14, 15, 16]);
+                    candidates_1 = (e_8 = void 0, __values(candidates)), candidates_1_1 = candidates_1.next();
+                    _f.label = 6;
+                case 6:
+                    if (!!candidates_1_1.done) return [3 /*break*/, 13];
+                    candidate = candidates_1_1.value;
+                    if (!candidate) {
+                        return [3 /*break*/, 12];
+                    }
+                    if (!isSuperAdmin && AI_ASSISTANT_BLOCKED_COLLECTIONS.has(candidate)) {
+                        return [3 /*break*/, 12];
+                    }
+                    if (!idClient) return [3 /*break*/, 8];
+                    return [4 /*yield*/, collectionHasClientIndex(db, dbName, candidate)];
+                case 7:
+                    _b = _f.sent();
+                    return [3 /*break*/, 9];
+                case 8:
+                    _b = false;
+                    _f.label = 9;
+                case 9:
+                    candidateHasClientScope = _b;
+                    return [4 /*yield*/, fetchAssistantProbeDocs({
+                            db: db,
+                            collection: candidate,
+                            idClient: idClient,
+                            idCustomer: idCustomer,
+                            isSuperAdmin: isSuperAdmin,
+                            includeClientScope: candidateHasClientScope
+                        })];
+                case 10:
+                    candidateProbe = _f.sent();
+                    return [4 /*yield*/, lookupIdsForNameMatch({
+                            db: db,
+                            dbName: dbName,
+                            collection: candidate,
+                            baseToken: baseToken,
+                            regex: regex,
+                            idClient: idClient,
+                            idCustomer: idCustomer,
+                            isSuperAdmin: isSuperAdmin,
+                            probeDocs: candidateProbe
+                        })];
+                case 11:
+                    lookup = _f.sent();
+                    if ((_e = lookup === null || lookup === void 0 ? void 0 : lookup.ids) === null || _e === void 0 ? void 0 : _e.length) {
+                        targetFieldType = inferIdFieldStorageTypeFromDocs(probeDocs || [], condition.field);
+                        normalizedIds = normalizeIdsForTargetField(lookup.ids, probeDocs || [], condition.field, targetFieldType);
+                        idsForQuery = normalizedIds.length ? normalizedIds : lookup.ids;
+                        return [2 /*return*/, {
+                                query: replaceQueryFieldCondition(query, condition.field, { $in: idsForQuery }),
+                                meta: {
+                                    field: condition.field,
+                                    strategy: 'lookup',
+                                    collection: candidate,
+                                    ids: lookup.ids.length,
+                                    idsNormalized: normalizedIds.length,
+                                    targetFieldType: targetFieldType,
+                                    fields: lookup.fields
+                                }
+                            }];
+                    }
+                    _f.label = 12;
+                case 12:
+                    candidates_1_1 = candidates_1.next();
+                    return [3 /*break*/, 6];
+                case 13: return [3 /*break*/, 16];
+                case 14:
+                    e_8_1 = _f.sent();
+                    e_8 = { error: e_8_1 };
+                    return [3 /*break*/, 16];
+                case 15:
+                    try {
+                        if (candidates_1_1 && !candidates_1_1.done && (_d = candidates_1.return)) _d.call(candidates_1);
+                    }
+                    finally { if (e_8) throw e_8.error; }
+                    return [7 /*endfinally*/];
+                case 16:
+                    conditions_1_1 = conditions_1.next();
+                    return [3 /*break*/, 4];
+                case 17: return [3 /*break*/, 20];
+                case 18:
+                    e_9_1 = _f.sent();
+                    e_9 = { error: e_9_1 };
+                    return [3 /*break*/, 20];
+                case 19:
+                    try {
+                        if (conditions_1_1 && !conditions_1_1.done && (_c = conditions_1.return)) _c.call(conditions_1);
+                    }
+                    finally { if (e_9) throw e_9.error; }
+                    return [7 /*endfinally*/];
+                case 20: return [2 /*return*/, null];
+            }
+        });
+    });
+}
+function buildAggregateNameMatchFallbackPipeline(pipeline, fallback) {
+    var _a;
+    var matchStage = (_a = pipeline[fallback.matchIndex]) === null || _a === void 0 ? void 0 : _a.$match;
+    if (!matchStage || typeof matchStage !== 'object') {
+        return pipeline;
+    }
+    var baseMatch = stripMatchField(matchStage, fallback.field);
+    var orConditions = fallback.fields.map(function (field) {
+        var _a;
+        return (_a = {}, _a[field] = fallback.condition, _a);
+    });
+    var nextMatch = isEmptyMatchValue(baseMatch)
+        ? { $or: orConditions }
+        : { $and: [baseMatch, { $or: orConditions }] };
+    return pipeline.map(function (stage, index) {
+        if (index === fallback.matchIndex) {
+            return { $match: nextMatch };
+        }
+        return stage;
+    });
+}
+function findAggregateDateField(pipeline) {
+    var fields = new Set();
+    (pipeline || []).forEach(function (stage) {
+        if (!stage || typeof stage !== 'object') {
+            return;
+        }
+        if (stage.$match && typeof stage.$match === 'object') {
+            collectDateFieldsFromMatch(stage.$match, fields);
+        }
+    });
+    if (fields.size !== 1) {
+        return null;
+    }
+    return Array.from(fields)[0];
+}
+function collectDateFieldsFromMatch(value, fields) {
+    if (!value || typeof value !== 'object') {
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach(function (entry) { return collectDateFieldsFromMatch(entry, fields); });
+        return;
+    }
+    Object.keys(value).forEach(function (key) {
+        var entry = value[key];
+        if (Object.prototype.hasOwnProperty.call(AI_ASSISTANT_DATE_FALLBACKS, key)) {
+            if (hasDateRangeOperators(entry) || entry instanceof Date) {
+                fields.add(key);
+            }
+            return;
+        }
+        if (key.startsWith('$')) {
+            collectDateFieldsFromMatch(entry, fields);
+            return;
+        }
+        if (entry && typeof entry === 'object') {
+            collectDateFieldsFromMatch(entry, fields);
+        }
+    });
+}
+function hasDateRangeOperators(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         return false;
     }
@@ -3134,12 +4911,12 @@ function replaceAggregateDateField(pipeline, fromField, toField) {
             return value;
         }
         if (value && typeof value === 'object') {
-            var next_1 = {};
+            var next_2 = {};
             Object.keys(value).forEach(function (key) {
                 var nextKey = key === fromField ? toField : key;
-                next_1[nextKey] = replacer(value[key]);
+                next_2[nextKey] = replacer(value[key]);
             });
-            return next_1;
+            return next_2;
         }
         if (typeof value === 'string') {
             if (value.startsWith("$".concat(fromField))) {
@@ -3156,7 +4933,8 @@ function normalizeMongoQuery(query) {
     if (containsForbiddenMongoOperators(normalized)) {
         throw new Error('AI assistant mongo read: Query contains restricted operators.');
     }
-    return applyAssistantNameRegexToQuery(normalized);
+    var rewritten = rewriteEmbeddedMatchObjects(normalized);
+    return applyAssistantNameRegexToQuery(rewritten);
 }
 function shouldApplyAssistantNameRegex(field) {
     var normalized = String(field || '').toLowerCase().trim();
@@ -3213,6 +4991,126 @@ function applyAssistantNameRegexToQuery(query) {
     });
     return result;
 }
+function isObjectIdString(value) {
+    return /^[a-f0-9]{24}$/i.test(value);
+}
+function isPlainMatchObject(value) {
+    return isPlainObject(value)
+        && !isMongoObjectId(value)
+        && !(value instanceof Date)
+        && !(value instanceof RegExp);
+}
+function hasOperatorKeys(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    return Object.keys(value).some(function (key) { return key.startsWith('$'); });
+}
+function rewriteEmbeddedMatchObjects(query) {
+    var rewriteValue = function (value, allowArrayRewrite) {
+        if (Array.isArray(value)) {
+            if (!allowArrayRewrite) {
+                return value;
+            }
+            return value.map(function (entry) { return rewriteValue(entry, true); });
+        }
+        if (!value || typeof value !== 'object' || value instanceof Date || value instanceof RegExp || isMongoObjectId(value)) {
+            return value;
+        }
+        var result = {};
+        Object.keys(value).forEach(function (key) {
+            var entry = value[key];
+            if (key.startsWith('$')) {
+                result[key] = rewriteValue(entry, true);
+                return;
+            }
+            if (isPlainMatchObject(entry) && !Array.isArray(entry) && !hasOperatorKeys(entry)) {
+                var flattened = flattenMatchObject(entry, key);
+                Object.assign(result, flattened);
+                return;
+            }
+            if (isPlainMatchObject(entry) && !Array.isArray(entry)) {
+                result[key] = rewriteValue(entry, true);
+                return;
+            }
+            if (Array.isArray(entry)) {
+                result[key] = allowArrayRewrite ? entry.map(function (item) { return rewriteValue(item, true); }) : entry;
+                return;
+            }
+            result[key] = entry;
+        });
+        return result;
+    };
+    var flattenMatchObject = function (value, prefix) {
+        var result = {};
+        Object.keys(value || {}).forEach(function (key) {
+            var entry = value[key];
+            var currentPath = "".concat(prefix, ".").concat(key);
+            if (isPlainMatchObject(entry) && !Array.isArray(entry) && !hasOperatorKeys(entry)) {
+                var flattened = flattenMatchObject(entry, currentPath);
+                Object.assign(result, flattened);
+                return;
+            }
+            if (isPlainMatchObject(entry) && !Array.isArray(entry)) {
+                result[currentPath] = rewriteValue(entry, true);
+                return;
+            }
+            if (Array.isArray(entry)) {
+                result[currentPath] = entry;
+                return;
+            }
+            result[currentPath] = entry;
+        });
+        return result;
+    };
+    return rewriteValue(query, true);
+}
+function buildRegexFromCondition(condition) {
+    if (!condition) {
+        return null;
+    }
+    if (condition instanceof RegExp) {
+        return condition;
+    }
+    if (typeof condition === 'string') {
+        var trimmed = condition.trim();
+        if (!trimmed || isObjectIdString(trimmed)) {
+            return null;
+        }
+        return new RegExp(escapeRegexValue(trimmed), 'i');
+    }
+    if (typeof condition === 'object') {
+        var raw = condition.$regex;
+        if (raw !== undefined) {
+            var source = String(raw);
+            var options = typeof condition.$options === 'string'
+                ? condition.$options
+                : 'i';
+            try {
+                return new RegExp(source, options);
+            }
+            catch (_a) {
+                return new RegExp(escapeRegexValue(source), 'i');
+            }
+        }
+    }
+    return null;
+}
+function normalizeIdFieldBase(field) {
+    var normalized = normalizeOptionalString(field).toLowerCase();
+    if (!normalized) {
+        return '';
+    }
+    var parts = normalized.split('.').filter(Boolean);
+    var last = parts[parts.length - 1] || normalized;
+    if (last.startsWith('id_')) {
+        return last.slice(3);
+    }
+    if (normalized.startsWith('id_')) {
+        return normalized.slice(3);
+    }
+    return last;
+}
 function normalizeCollectionKey(value) {
     return String(value || '').toLowerCase().replace(/[^a-z0-9]/g, '');
 }
@@ -3247,6 +5145,19 @@ function tokenizeCollectionText(value) {
     });
     return Array.from(new Set(tokens));
 }
+function computeCollectionTokenWeights(tokens) {
+    var unique = Array.from(new Set(tokens));
+    var hasDomain = unique.some(function (token) { return AI_ASSISTANT_COLLECTION_DOMAIN_TOKENS.has(token); });
+    var weights = {};
+    unique.forEach(function (token) {
+        if (hasDomain && AI_ASSISTANT_COLLECTION_GENERIC_TOKENS.has(token)) {
+            weights[token] = 0.4;
+            return;
+        }
+        weights[token] = 1;
+    });
+    return { weights: weights, hasDomain: hasDomain };
+}
 function expandAssistantTermSynonyms(text) {
     var base = normalizeOptionalString(text);
     if (!base) {
@@ -3299,29 +5210,179 @@ function listAssistantCollections(db, dbName) {
         });
     });
 }
-function scoreCollectionMatch(requestedTokens, candidateName) {
+function scoreCollectionMatch(requestedTokens, candidateName, tokenWeights) {
     if (!requestedTokens.length) {
         return 0;
     }
-    var candidateTokens = tokenizeCollectionText(candidateName);
-    if (!candidateTokens.length) {
-        return 0;
+    var candidateTokens = tokenizeCollectionText(candidateName);
+    if (!candidateTokens.length) {
+        return 0;
+    }
+    var score = 0;
+    requestedTokens.forEach(function (token) {
+        var _a;
+        if (candidateTokens.includes(token)) {
+            var weight = (_a = tokenWeights === null || tokenWeights === void 0 ? void 0 : tokenWeights[token]) !== null && _a !== void 0 ? _a : 1;
+            score += 10 * weight;
+        }
+    });
+    var requestedKey = normalizeCollectionKey(requestedTokens.join('-'));
+    var candidateKey = normalizeCollectionKey(candidateName);
+    if (candidateKey === requestedKey && requestedKey) {
+        score += 50;
+    }
+    else if (requestedKey && (candidateKey.includes(requestedKey) || requestedKey.includes(candidateKey))) {
+        score += 20;
+    }
+    return score;
+}
+function scoreCollectionMatchDetailed(requestedTokens, candidateName, tokenWeights) {
+    var candidateTokens = tokenizeCollectionText(candidateName);
+    var tokenMatches = requestedTokens.filter(function (token) { return candidateTokens.includes(token); });
+    var weights = tokenWeights || {};
+    var tokenScore = tokenMatches.reduce(function (sum, token) { var _a; return sum + 10 * ((_a = weights[token]) !== null && _a !== void 0 ? _a : 1); }, 0);
+    var score = tokenScore;
+    var requestedKey = normalizeCollectionKey(requestedTokens.join('-'));
+    var candidateKey = normalizeCollectionKey(candidateName);
+    var keyMatch = null;
+    if (candidateKey === requestedKey && requestedKey) {
+        score += 50;
+        keyMatch = 'exact';
+    }
+    else if (requestedKey && (candidateKey.includes(requestedKey) || requestedKey.includes(candidateKey))) {
+        score += 20;
+        keyMatch = 'partial';
+    }
+    return {
+        score: score,
+        tokenMatches: tokenMatches,
+        keyMatch: keyMatch,
+        candidateTokens: candidateTokens,
+        tokenScore: tokenScore,
+        tokenWeights: tokenMatches.reduce(function (acc, token) {
+            var _a;
+            acc[token] = (_a = weights[token]) !== null && _a !== void 0 ? _a : 1;
+            return acc;
+        }, {})
+    };
+}
+function resolveCollectionHintsFromTokens(tokens, collectionNames, max) {
+    if (max === void 0) { max = 5; }
+    if (!tokens.length || !collectionNames.length) {
+        return [];
+    }
+    var weights = computeCollectionTokenWeights(tokens).weights;
+    return collectionNames
+        .map(function (name) { return ({ name: name, score: scoreCollectionMatch(tokens, name, weights) }); })
+        .filter(function (entry) { return entry.score > 0; })
+        .sort(function (a, b) { return b.score - a.score; })
+        .slice(0, Math.max(max, 0))
+        .map(function (entry) { return entry.name; });
+}
+function buildCollectionRankingDebugFromTokens(tokens, collectionNames, max) {
+    if (max === void 0) { max = 8; }
+    var requestedKey = normalizeCollectionKey(tokens.join('-'));
+    var _a = computeCollectionTokenWeights(tokens), weights = _a.weights, hasDomain = _a.hasDomain;
+    if (!tokens.length || !collectionNames.length) {
+        return {
+            tokens: tokens,
+            requestedKey: requestedKey,
+            hasDomain: hasDomain,
+            tokenWeights: weights,
+            ranked: []
+        };
+    }
+    var ranked = collectionNames
+        .map(function (name) { return (__assign({ name: name }, scoreCollectionMatchDetailed(tokens, name, weights))); })
+        .filter(function (entry) { return entry.score > 0; })
+        .sort(function (a, b) { return b.score - a.score; })
+        .slice(0, Math.max(max, 0));
+    return {
+        tokens: tokens,
+        requestedKey: requestedKey,
+        hasDomain: hasDomain,
+        tokenWeights: weights,
+        ranked: ranked
+    };
+}
+function buildCollectionSelectionDetail(tokens, collection) {
+    var trimmed = normalizeOptionalString(collection);
+    if (!trimmed) {
+        return null;
+    }
+    var weights = computeCollectionTokenWeights(tokens).weights;
+    var detail = scoreCollectionMatchDetailed(tokens, trimmed, weights);
+    return {
+        collection: trimmed,
+        score: detail.score,
+        tokenMatches: detail.tokenMatches,
+        keyMatch: detail.keyMatch,
+        candidateTokens: detail.candidateTokens,
+        tokenScore: detail.tokenScore,
+        tokenWeights: detail.tokenWeights
+    };
+}
+function isVersionCollectionName(value) {
+    var normalized = normalizeOptionalString(value).toLowerCase();
+    return normalized.endsWith('.versions') || normalized.endsWith('-versions') || normalized.includes('.versions.');
+}
+function pickPreferredCollectionCandidate(ranked) {
+    if (!Array.isArray(ranked) || !ranked.length) {
+        return null;
+    }
+    var top = ranked[0];
+    if (!top) {
+        return null;
+    }
+    if (!isVersionCollectionName(top.name)) {
+        return top;
+    }
+    var nonVersion = ranked.find(function (entry) { return entry && !isVersionCollectionName(entry.name); });
+    if (nonVersion && nonVersion.score >= top.score - 5) {
+        return nonVersion;
+    }
+    return top;
+}
+function resolveAssistantCollectionOverride(collectionRanking, currentCollection) {
+    var _a, _b;
+    var ranked = Array.isArray(collectionRanking === null || collectionRanking === void 0 ? void 0 : collectionRanking.ranked) ? collectionRanking === null || collectionRanking === void 0 ? void 0 : collectionRanking.ranked : [];
+    if (!ranked.length) {
+        return null;
+    }
+    var top = pickPreferredCollectionCandidate(ranked);
+    if (!top || top.score < AI_ASSISTANT_COLLECTION_OVERRIDE_MIN_SCORE) {
+        return null;
     }
-    var score = 0;
-    requestedTokens.forEach(function (token) {
-        if (candidateTokens.includes(token)) {
-            score += 10;
-        }
-    });
-    var requestedKey = normalizeCollectionKey(requestedTokens.join('-'));
-    var candidateKey = normalizeCollectionKey(candidateName);
-    if (candidateKey === requestedKey && requestedKey) {
-        score += 50;
+    var current = normalizeOptionalString(currentCollection);
+    if (!current) {
+        return {
+            from: '',
+            to: top.name,
+            fromScore: 0,
+            toScore: top.score,
+            reason: 'no collection specified'
+        };
     }
-    else if (requestedKey && (candidateKey.includes(requestedKey) || requestedKey.includes(candidateKey))) {
-        score += 20;
+    if (current === top.name) {
+        return null;
     }
-    return score;
+    var currentScore = (_b = (_a = ranked.find(function (entry) { return entry.name === current; })) === null || _a === void 0 ? void 0 : _a.score) !== null && _b !== void 0 ? _b : 0;
+    var scoreGap = top.score - currentScore;
+    var currentIsVersion = isVersionCollectionName(current);
+    var topIsVersion = isVersionCollectionName(top.name);
+    if (scoreGap < AI_ASSISTANT_COLLECTION_OVERRIDE_SCORE_GAP && !(currentIsVersion && !topIsVersion)) {
+        return null;
+    }
+    var reason = currentIsVersion && !topIsVersion
+        ? 'preferred non-version collection'
+        : "higher score (".concat(top.score, " vs ").concat(currentScore, ")");
+    return {
+        from: current,
+        to: top.name,
+        fromScore: currentScore,
+        toScore: top.score,
+        reason: reason
+    };
 }
 function findBestCollectionMatch(requested, collectionNames) {
     var requestedTokens = tokenizeCollectionText(requested);
@@ -3368,38 +5429,8 @@ function resolveAssistantCollectionName(db, dbName, requested) {
         });
     });
 }
-function resolveAssistantCollectionHints(message, dbName, db) {
-    return __awaiter(this, void 0, void 0, function () {
-        var text, collectionNames, tokens;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    text = normalizeOptionalString(message);
-                    if (!text) {
-                        return [2 /*return*/, []];
-                    }
-                    return [4 /*yield*/, listAssistantCollections(db, dbName)];
-                case 1:
-                    collectionNames = _a.sent();
-                    if (!collectionNames.length) {
-                        return [2 /*return*/, []];
-                    }
-                    tokens = tokenizeCollectionText(text);
-                    if (!tokens.length) {
-                        return [2 /*return*/, []];
-                    }
-                    return [2 /*return*/, collectionNames
-                            .map(function (name) { return ({ name: name, score: scoreCollectionMatch(tokens, name) }); })
-                            .filter(function (entry) { return entry.score > 0; })
-                            .sort(function (a, b) { return b.score - a.score; })
-                            .slice(0, 5)
-                            .map(function (entry) { return entry.name; })];
-            }
-        });
-    });
-}
 function findQueryDateField(query) {
-    var e_4, _a, e_5, _b;
+    var e_10, _a, e_11, _b;
     if (!query || typeof query !== 'object') {
         return null;
     }
@@ -3413,12 +5444,12 @@ function findQueryDateField(query) {
                 }
             }
         }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
         finally {
             try {
                 if (query_1_1 && !query_1_1.done && (_a = query_1.return)) _a.call(query_1);
             }
-            finally { if (e_4) throw e_4.error; }
+            finally { if (e_10) throw e_10.error; }
         }
         return null;
     }
@@ -3437,12 +5468,12 @@ function findQueryDateField(query) {
             }
         }
     }
-    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
     finally {
         try {
             if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
         }
-        finally { if (e_5) throw e_5.error; }
+        finally { if (e_11) throw e_11.error; }
     }
     return null;
 }
@@ -3460,6 +5491,198 @@ function replaceQueryField(query, fromField, toField) {
     });
     return result;
 }
+function extractDateRangeConditions(query) {
+    if (!query || typeof query !== 'object' || query instanceof Date) {
+        return [];
+    }
+    var results = [];
+    Object.keys(query).forEach(function (key) {
+        if (key.startsWith('$')) {
+            return;
+        }
+        var value = query[key];
+        if (value instanceof Date) {
+            results.push({ field: key, condition: value });
+            return;
+        }
+        if (value && typeof value === 'object' && hasDateRangeOperators(value)) {
+            results.push({ field: key, condition: value });
+        }
+    });
+    return results;
+}
+function expandQueryDateFallbacks(query) {
+    if (!query || typeof query !== 'object') {
+        return null;
+    }
+    var addedFields = [];
+    var pushField = function (field) {
+        if (!field) {
+            return;
+        }
+        if (addedFields.includes(field)) {
+            return;
+        }
+        addedFields.push(field);
+    };
+    var expandOrArray = function (orArray) {
+        var existingFields = new Set();
+        orArray.forEach(function (entry) {
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+                return;
+            }
+            Object.keys(entry).forEach(function (key) {
+                if (!key.startsWith('$')) {
+                    existingFields.add(key);
+                }
+            });
+        });
+        var extended = __spreadArray([], __read(orArray), false);
+        orArray.forEach(function (entry) {
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+                return;
+            }
+            var dateConditions = extractDateRangeConditions(entry);
+            dateConditions.forEach(function (condition) {
+                var fallback = AI_ASSISTANT_DATE_FALLBACKS[condition.field];
+                if (fallback && !existingFields.has(fallback)) {
+                    extended = __spreadArray(__spreadArray([], __read(extended), false), [replaceQueryField(entry, condition.field, fallback)], false);
+                    existingFields.add(fallback);
+                    pushField(fallback);
+                }
+            });
+            if (!existingFields.has('date_original')) {
+                var candidate = dateConditions.find(function (condition) { return condition.field.startsWith('date_') && condition.field !== 'date_original'; });
+                if (candidate) {
+                    extended = __spreadArray(__spreadArray([], __read(extended), false), [replaceQueryField(entry, candidate.field, 'date_original')], false);
+                    existingFields.add('date_original');
+                    pushField('date_original');
+                }
+            }
+        });
+        return extended;
+    };
+    var visit = function (value) {
+        if (Array.isArray(value)) {
+            var changed_2 = false;
+            var nextArray = value.map(function (entry) {
+                var visited = visit(entry);
+                if (visited.changed) {
+                    changed_2 = true;
+                }
+                return visited.value;
+            });
+            return { value: changed_2 ? nextArray : value, changed: changed_2 };
+        }
+        if (!value || typeof value !== 'object') {
+            return { value: value, changed: false };
+        }
+        var changed = false;
+        var next = __assign({}, value);
+        Object.keys(value).forEach(function (key) {
+            if (key === '$or' && Array.isArray(value.$or)) {
+                var expanded = expandOrArray(value.$or);
+                if (expanded.length !== value.$or.length) {
+                    next.$or = expanded;
+                    changed = true;
+                }
+                return;
+            }
+            var visited = visit(value[key]);
+            if (visited.changed) {
+                next[key] = visited.value;
+                changed = true;
+            }
+        });
+        return { value: changed ? next : value, changed: changed };
+    };
+    var result = visit(query);
+    if (!result.changed || !addedFields.length) {
+        return null;
+    }
+    return { query: result.value, fields: addedFields };
+}
+function buildDateFieldExpansionList(field) {
+    var normalized = normalizeOptionalString(field);
+    if (!normalized) {
+        return [];
+    }
+    var expansions = new Set();
+    var add = function (value) {
+        if (value && value !== normalized) {
+            expansions.add(value);
+        }
+    };
+    var fallback = AI_ASSISTANT_DATE_FALLBACKS[normalized];
+    if (fallback) {
+        add(fallback);
+    }
+    if (normalized.startsWith('date_') || normalized === 'date' || normalized.endsWith('_date')) {
+        AI_ASSISTANT_DATE_EXPANSION_FIELDS.forEach(add);
+    }
+    if (normalized === 'createdAt' || normalized === 'updatedAt') {
+        AI_ASSISTANT_DATE_EXPANSION_FIELDS.forEach(add);
+    }
+    return Array.from(expansions);
+}
+function expandAggregateDateMatchFallback(pipeline) {
+    if (!Array.isArray(pipeline)) {
+        return null;
+    }
+    var _loop_2 = function (i) {
+        var stage = pipeline[i];
+        if (!stage || typeof stage !== 'object' || !stage.$match || typeof stage.$match !== 'object') {
+            return "continue";
+        }
+        var matchStage = stage.$match;
+        var orArray = Array.isArray(matchStage.$or) ? matchStage.$or : null;
+        if (!orArray || !orArray.length) {
+            return "continue";
+        }
+        var existingFields = new Set();
+        orArray.forEach(function (entry) {
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+                return;
+            }
+            Object.keys(entry).forEach(function (key) {
+                if (!key.startsWith('$')) {
+                    existingFields.add(key);
+                }
+            });
+        });
+        var expandedOr = __spreadArray([], __read(orArray), false);
+        var addedFields = new Set();
+        orArray.forEach(function (entry) {
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+                return;
+            }
+            var conditions = extractDateRangeConditions(entry);
+            conditions.forEach(function (condition) {
+                var expansions = buildDateFieldExpansionList(condition.field);
+                expansions.forEach(function (field) {
+                    if (existingFields.has(field)) {
+                        return;
+                    }
+                    expandedOr = __spreadArray(__spreadArray([], __read(expandedOr), false), [replaceQueryField(entry, condition.field, field)], false);
+                    existingFields.add(field);
+                    addedFields.add(field);
+                });
+            });
+        });
+        if (!addedFields.size) {
+            return { value: null };
+        }
+        var nextMatch = __assign(__assign({}, matchStage), { $or: expandedOr });
+        var updated = pipeline.map(function (current, index) { return (index === i ? { $match: nextMatch } : current); });
+        return { value: { pipeline: updated, fields: Array.from(addedFields) } };
+    };
+    for (var i = 0; i < pipeline.length; i += 1) {
+        var state_2 = _loop_2(i);
+        if (typeof state_2 === "object")
+            return state_2.value;
+    }
+    return null;
+}
 function resolveQueryDateFieldFallback(query) {
     var dateField = findQueryDateField(query);
     if (!dateField) {
@@ -3472,7 +5695,7 @@ function resolveQueryDateFieldFallback(query) {
     return { from: dateField, to: fallback };
 }
 function containsForbiddenMongoOperators(value) {
-    var e_6, _a;
+    var e_12, _a;
     if (!value || typeof value !== 'object') {
         return false;
     }
@@ -3491,12 +5714,12 @@ function containsForbiddenMongoOperators(value) {
             }
         }
     }
-    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    catch (e_12_1) { e_12 = { error: e_12_1 }; }
     finally {
         try {
             if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
         }
-        finally { if (e_6) throw e_6.error; }
+        finally { if (e_12) throw e_12.error; }
     }
     return false;
 }
@@ -3505,9 +5728,49 @@ function buildClientScopeCacheKey(dbName, collection) {
     var normalizedCollection = normalizeOptionalString(collection).toLowerCase();
     return "".concat(normalizedDb || 'db', ":").concat(normalizedCollection);
 }
+function buildFieldIndexCacheKey(dbName, collection, field) {
+    var normalizedDb = normalizeOptionalString(dbName).toLowerCase();
+    var normalizedCollection = normalizeOptionalString(collection).toLowerCase();
+    var normalizedField = normalizeOptionalString(field).toLowerCase();
+    return "".concat(normalizedDb || 'db', ":").concat(normalizedCollection, ":").concat(normalizedField);
+}
+function collectionHasFieldIndex(db, dbName, collection, field) {
+    return __awaiter(this, void 0, void 0, function () {
+        var normalizedCollection, normalizedField, cacheKey, cached, indexes, hasIndex, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    normalizedCollection = normalizeOptionalString(collection);
+                    normalizedField = normalizeOptionalString(field);
+                    if (!normalizedCollection || !normalizedField) {
+                        return [2 /*return*/, false];
+                    }
+                    cacheKey = buildFieldIndexCacheKey(dbName, normalizedCollection, normalizedField);
+                    cached = AI_ASSISTANT_FIELD_INDEX_CACHE.get(cacheKey);
+                    if (typeof cached === 'boolean') {
+                        return [2 /*return*/, cached];
+                    }
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, db.collection(normalizedCollection).indexes()];
+                case 2:
+                    indexes = _b.sent();
+                    hasIndex = Array.isArray(indexes)
+                        && indexes.some(function (entry) { return (entry === null || entry === void 0 ? void 0 : entry.key) && Object.prototype.hasOwnProperty.call(entry.key, normalizedField); });
+                    AI_ASSISTANT_FIELD_INDEX_CACHE.set(cacheKey, hasIndex);
+                    return [2 /*return*/, hasIndex];
+                case 3:
+                    _a = _b.sent();
+                    return [2 /*return*/, false];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
 function collectionHasClientIndex(db, dbName, collection) {
     return __awaiter(this, void 0, void 0, function () {
-        var normalizedCollection, cacheKey, cached, indexes, hasIndex, _a;
+        var normalizedCollection, cacheKey, cached, hasIndex, _a;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
@@ -3523,11 +5786,9 @@ function collectionHasClientIndex(db, dbName, collection) {
                     _b.label = 1;
                 case 1:
                     _b.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, db.collection(normalizedCollection).indexes()];
+                    return [4 /*yield*/, collectionHasFieldIndex(db, dbName, normalizedCollection, 'id_client')];
                 case 2:
-                    indexes = _b.sent();
-                    hasIndex = Array.isArray(indexes)
-                        && indexes.some(function (entry) { return (entry === null || entry === void 0 ? void 0 : entry.key) && Object.prototype.hasOwnProperty.call(entry.key, 'id_client'); });
+                    hasIndex = _b.sent();
                     AI_ASSISTANT_CLIENT_SCOPE_CACHE.set(cacheKey, hasIndex);
                     return [2 /*return*/, hasIndex];
                 case 3:
@@ -3569,6 +5830,25 @@ function applyCustomerScopeFilter(query, collection, idCustomer, isSuperAdmin) {
         $and: [query, (_a = {}, _a[customerField] = normalizedCustomer, _a)]
     };
 }
+function buildAssistantProbeQuery(collection, idClient, idCustomer, isSuperAdmin, includeClientScope) {
+    if (isSuperAdmin === void 0) { isSuperAdmin = false; }
+    if (includeClientScope === void 0) { includeClientScope = false; }
+    var query = {};
+    if (includeClientScope) {
+        query = applyClientScopeFilter(query, idClient, isSuperAdmin);
+    }
+    return applyCustomerScopeFilter(query, collection, idCustomer, isSuperAdmin);
+}
+function fetchAssistantProbeDocs(params) {
+    var db = params.db, collection = params.collection, idClient = params.idClient, idCustomer = params.idCustomer, isSuperAdmin = params.isSuperAdmin, includeClientScope = params.includeClientScope;
+    var probeQuery = buildAssistantProbeQuery(collection, idClient, idCustomer, isSuperAdmin, includeClientScope);
+    return db.collection(collection)
+        .find(probeQuery, {
+        limit: AI_ASSISTANT_PROBE_LIMIT,
+        readPreference: AI_ASSISTANT_READ_PREFERENCE
+    })
+        .toArray();
+}
 function userHasViewPermission(user, view) {
     var _a, _b, _c;
     if (!user || !view) {
@@ -3730,8 +6010,8 @@ function applyCodexStreamStatusHandler(runOptions, streamStatusHandler) {
 }
 function waitForCodexWorkerMessage(worker, streamStatusHandler) {
     return __awaiter(this, void 0, void 0, function () {
-        var _a, _b, _c, _d, message, payload, status_1, e_7_1;
-        var _e, e_7, _f, _g;
+        var _a, _b, _c, _d, message, payload, status_1, e_13_1;
+        var _e, e_13, _f, _g;
         return __generator(this, function (_h) {
             switch (_h.label) {
                 case 0:
@@ -3758,8 +6038,8 @@ function waitForCodexWorkerMessage(worker, streamStatusHandler) {
                     return [3 /*break*/, 1];
                 case 4: return [3 /*break*/, 11];
                 case 5:
-                    e_7_1 = _h.sent();
-                    e_7 = { error: e_7_1 };
+                    e_13_1 = _h.sent();
+                    e_13 = { error: e_13_1 };
                     return [3 /*break*/, 11];
                 case 6:
                     _h.trys.push([6, , 9, 10]);
@@ -3770,7 +6050,7 @@ function waitForCodexWorkerMessage(worker, streamStatusHandler) {
                     _h.label = 8;
                 case 8: return [3 /*break*/, 10];
                 case 9:
-                    if (e_7) throw e_7.error;
+                    if (e_13) throw e_13.error;
                     return [7 /*endfinally*/];
                 case 10: return [7 /*endfinally*/];
                 case 11: throw new CodexWorkerBootstrapError('Codex worker exited before completing.');
@@ -4158,7 +6438,7 @@ function normalizeRouteMatchKey(value) {
     return normalizeRouteKey(value).toLowerCase();
 }
 function buildClientRouteIndex() {
-    var e_8, _a;
+    var e_14, _a;
     var _b;
     var routes = ((_b = resolveio_server_app_1.ResolveIOServer.getClientRoutes) === null || _b === void 0 ? void 0 : _b.call(resolveio_server_app_1.ResolveIOServer)) || [];
     var set = new Set();
@@ -4177,12 +6457,12 @@ function buildClientRouteIndex() {
             }
         }
     }
-    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    catch (e_14_1) { e_14 = { error: e_14_1 }; }
     finally {
         try {
             if (routes_1_1 && !routes_1_1.done && (_a = routes_1.return)) _a.call(routes_1);
         }
-        finally { if (e_8) throw e_8.error; }
+        finally { if (e_14) throw e_14.error; }
     }
     return { set: set, map: map, size: routes.length };
 }
@@ -4272,6 +6552,20 @@ function sanitizeAssistantResponse(value) {
         }
         return /^i\s+(can|will|['’]ll|am going to|['’]m going to)\s+(pull|run|query|get|fetch|look up|retrieve|grab)\b/i.test(normalized);
     };
+    var isInternalPlanLine = function (line) {
+        var trimmed = line.trim();
+        if (!trimmed || trimmed.length > 120) {
+            return false;
+        }
+        var normalized = trimmed.toLowerCase();
+        var hasPhrase = /schema[-\s]?probe|query rewrite|id[-\s]?lookup|collection override|probe read|tiny probe|fallback plan/i.test(normalized);
+        if (!hasPhrase) {
+            return false;
+        }
+        var isBulletish = /^[-*•]+\s+/.test(trimmed);
+        var isPlanish = /^(plan|planning|approach|strategy|steps?|todo|checklist)\b/i.test(trimmed);
+        return isBulletish || isPlanish;
+    };
     var cleanedLines = [];
     withoutBlocks.split('\n').forEach(function (line) {
         var trimmed = line.trim();
@@ -4282,6 +6576,9 @@ function sanitizeAssistantResponse(value) {
         if (isTentativeQueryLine(line)) {
             return;
         }
+        if (isInternalPlanLine(line)) {
+            return;
+        }
         if (/^work ticket summary:/i.test(trimmed)) {
             return;
         }
@@ -4308,7 +6605,7 @@ function sanitizeAssistantResponse(value) {
     return normalizeAssistantRoutes(normalizedCurrency);
 }
 function evaluateAssistantGuardrails(message) {
-    var e_9, _a;
+    var e_15, _a;
     var normalized = String(message || '').toLowerCase();
     var patterns = [
         {
@@ -4354,12 +6651,12 @@ function evaluateAssistantGuardrails(message) {
             }
         }
     }
-    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    catch (e_15_1) { e_15 = { error: e_15_1 }; }
     finally {
         try {
             if (patterns_1_1 && !patterns_1_1.done && (_a = patterns_1.return)) _a.call(patterns_1);
         }
-        finally { if (e_9) throw e_9.error; }
+        finally { if (e_15) throw e_15.error; }
     }
     return null;
 }
@@ -4446,20 +6743,262 @@ function normalizeAiFormFields(fields) {
     })
         .filter(function (field) { return !!field; });
 }
+function tokenizeArithmeticExpression(expression) {
+    var tokens = [];
+    var i = 0;
+    while (i < expression.length) {
+        var char = expression[i];
+        if (/\s/.test(char)) {
+            i += 1;
+            continue;
+        }
+        if (/[()+\-*/]/.test(char)) {
+            tokens.push(char);
+            i += 1;
+            continue;
+        }
+        if (/\d|\./.test(char)) {
+            var j = i + 1;
+            while (j < expression.length && /[\d.]/.test(expression[j])) {
+                j += 1;
+            }
+            tokens.push(expression.slice(i, j));
+            i = j;
+            continue;
+        }
+        return null;
+    }
+    return tokens;
+}
+function evaluateArithmeticExpression(expression) {
+    var e_16, _a, e_17, _b;
+    var tokens = tokenizeArithmeticExpression(expression);
+    if (!tokens || !tokens.length) {
+        return null;
+    }
+    var output = [];
+    var ops = [];
+    var precedence = { '+': 1, '-': 1, '*': 2, '/': 2 };
+    var prevToken = '';
+    var pushOperator = function (op) {
+        while (ops.length) {
+            var top_1 = ops[ops.length - 1];
+            if (top_1 === '(') {
+                break;
+            }
+            if ((precedence[top_1] || 0) >= (precedence[op] || 0)) {
+                output.push(ops.pop());
+                continue;
+            }
+            break;
+        }
+        ops.push(op);
+    };
+    try {
+        for (var tokens_1 = __values(tokens), tokens_1_1 = tokens_1.next(); !tokens_1_1.done; tokens_1_1 = tokens_1.next()) {
+            var token = tokens_1_1.value;
+            if (token === '(') {
+                ops.push(token);
+                prevToken = token;
+                continue;
+            }
+            if (token === ')') {
+                while (ops.length && ops[ops.length - 1] !== '(') {
+                    output.push(ops.pop());
+                }
+                if (!ops.length) {
+                    return null;
+                }
+                ops.pop();
+                prevToken = token;
+                continue;
+            }
+            if (precedence[token]) {
+                if (!prevToken || prevToken === '(' || precedence[prevToken]) {
+                    output.push('0');
+                }
+                pushOperator(token);
+                prevToken = token;
+                continue;
+            }
+            if (!/^\d+(\.\d+)?$/.test(token)) {
+                return null;
+            }
+            output.push(token);
+            prevToken = token;
+        }
+    }
+    catch (e_16_1) { e_16 = { error: e_16_1 }; }
+    finally {
+        try {
+            if (tokens_1_1 && !tokens_1_1.done && (_a = tokens_1.return)) _a.call(tokens_1);
+        }
+        finally { if (e_16) throw e_16.error; }
+    }
+    while (ops.length) {
+        var op = ops.pop();
+        if (op === '(' || op === ')') {
+            return null;
+        }
+        output.push(op);
+    }
+    var stack = [];
+    try {
+        for (var output_1 = __values(output), output_1_1 = output_1.next(); !output_1_1.done; output_1_1 = output_1.next()) {
+            var token = output_1_1.value;
+            if (precedence[token]) {
+                if (stack.length < 2) {
+                    return null;
+                }
+                var b = stack.pop();
+                var a = stack.pop();
+                switch (token) {
+                    case '+':
+                        stack.push(a + b);
+                        break;
+                    case '-':
+                        stack.push(a - b);
+                        break;
+                    case '*':
+                        stack.push(a * b);
+                        break;
+                    case '/':
+                        stack.push(a / b);
+                        break;
+                    default:
+                        return null;
+                }
+                continue;
+            }
+            stack.push(Number(token));
+        }
+    }
+    catch (e_17_1) { e_17 = { error: e_17_1 }; }
+    finally {
+        try {
+            if (output_1_1 && !output_1_1.done && (_b = output_1.return)) _b.call(output_1);
+        }
+        finally { if (e_17) throw e_17.error; }
+    }
+    if (stack.length !== 1 || Number.isNaN(stack[0])) {
+        return null;
+    }
+    return stack[0];
+}
+function resolveDateExpression(expression) {
+    var trimmed = String(expression || '').trim();
+    if (!trimmed) {
+        return null;
+    }
+    var quotedMatch = trimmed.match(/^['"](.+?)['"]$/);
+    if (quotedMatch) {
+        var date = new Date(quotedMatch[1]);
+        return Number.isNaN(date.getTime()) ? null : date.toISOString();
+    }
+    if (trimmed === 'Date.now()') {
+        return new Date(Date.now()).toISOString();
+    }
+    var nowMatch = trimmed.match(/^Date\.now\(\)\s*([+-])\s*(.+)$/);
+    if (nowMatch) {
+        var delta = evaluateArithmeticExpression(nowMatch[2]);
+        if (delta === null) {
+            return null;
+        }
+        var base = Date.now();
+        var computed = nowMatch[1] === '-' ? base - delta : base + delta;
+        return new Date(computed).toISOString();
+    }
+    var numeric = evaluateArithmeticExpression(trimmed);
+    if (numeric !== null) {
+        var date = new Date(numeric);
+        return Number.isNaN(date.getTime()) ? null : date.toISOString();
+    }
+    return null;
+}
+function replaceNewDateExpressions(input) {
+    var output = '';
+    var index = 0;
+    while (index < input.length) {
+        var start = input.indexOf('new Date(', index);
+        if (start === -1) {
+            output += input.slice(index);
+            break;
+        }
+        output += input.slice(index, start);
+        var cursor = start + 'new Date('.length;
+        var depth = 1;
+        while (cursor < input.length && depth > 0) {
+            var char = input[cursor];
+            if (char === '(') {
+                depth += 1;
+            }
+            else if (char === ')') {
+                depth -= 1;
+            }
+            cursor += 1;
+        }
+        if (depth !== 0) {
+            output += input.slice(start);
+            break;
+        }
+        var inner = input.slice(start + 'new Date('.length, cursor - 1);
+        var iso = resolveDateExpression(inner);
+        if (iso) {
+            output += "{\"$date\":\"".concat(iso, "\"}");
+        }
+        else {
+            output += input.slice(start, cursor);
+        }
+        index = cursor;
+    }
+    return output;
+}
+function replaceIsoDateExpressions(input) {
+    return input.replace(/ISODate\(([^)]+)\)/g, function (_match, inner) {
+        var iso = resolveDateExpression(inner);
+        return iso ? "{\"$date\":\"".concat(iso, "\"}") : _match;
+    });
+}
+function preprocessJsonLike(content) {
+    var normalized = content;
+    normalized = replaceNewDateExpressions(normalized);
+    normalized = replaceIsoDateExpressions(normalized);
+    return normalized;
+}
+function convertExtendedDates(value) {
+    if (Array.isArray(value)) {
+        return value.map(function (entry) { return convertExtendedDates(entry); });
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    var keys = Object.keys(value);
+    if (keys.length === 1 && keys[0] === '$date') {
+        var raw = value.$date;
+        var date = new Date(raw);
+        return Number.isNaN(date.getTime()) ? value : date;
+    }
+    var output = {};
+    keys.forEach(function (key) {
+        output[key] = convertExtendedDates(value[key]);
+    });
+    return output;
+}
 function parseJsonObject(content) {
     if (!content || typeof content !== 'string') {
         return null;
     }
+    var normalized = preprocessJsonLike(content);
     try {
-        return JSON.parse(content);
+        return convertExtendedDates(JSON.parse(normalized));
     }
     catch (_a) {
-        var match = content.match(/\{[\s\S]*\}/);
+        var match = normalized.match(/\{[\s\S]*\}/);
         if (!match) {
             return null;
         }
         try {
-            return JSON.parse(match[0]);
+            return convertExtendedDates(JSON.parse(match[0]));
         }
         catch (_b) {
             return null;
@@ -4523,8 +7062,8 @@ function handleCodexUpload(id_conversation, file_name, content_base64, size, con
 }
 function readAttachmentContents(attachments) {
     return __awaiter(this, void 0, void 0, function () {
-        var limits, totalBytes, totalChars, chunks, cleaned, attachments_1, attachments_1_1, attachment, localPath, safe, stat, ext, name_1, type, readable, content, _a, e_10_1;
-        var e_10, _b;
+        var limits, totalBytes, totalChars, chunks, cleaned, attachments_1, attachments_1_1, attachment, localPath, safe, stat, ext, name_1, type, readable, content, _a, e_18_1;
+        var e_18, _b;
         return __generator(this, function (_c) {
             switch (_c.label) {
                 case 0:
@@ -4603,14 +7142,14 @@ function readAttachmentContents(attachments) {
                     return [3 /*break*/, 2];
                 case 10: return [3 /*break*/, 13];
                 case 11:
-                    e_10_1 = _c.sent();
-                    e_10 = { error: e_10_1 };
+                    e_18_1 = _c.sent();
+                    e_18 = { error: e_18_1 };
                     return [3 /*break*/, 13];
                 case 12:
                     try {
                         if (attachments_1_1 && !attachments_1_1.done && (_b = attachments_1.return)) _b.call(attachments_1);
                     }
-                    finally { if (e_10) throw e_10.error; }
+                    finally { if (e_18) throw e_18.error; }
                     return [7 /*endfinally*/];
                 case 13: return [2 /*return*/, {
                         promptText: chunks.length ? "\n\nAttachments:\n".concat(chunks.join('\n\n')) : '',
@@ -4787,7 +7326,7 @@ function estimateUsage(messages, responseText, model) {
     };
 }
 function evaluateGuardrails(message) {
-    var e_11, _a;
+    var e_19, _a;
     var normalized = String(message || '').toLowerCase();
     var patterns = [
         { pattern: /\b(source\s*code|full\s*code|entire\s*code|repo\s*dump|repository|git\s*clone)\b/i, reason: 'Code access is restricted.' },
@@ -4809,12 +7348,12 @@ function evaluateGuardrails(message) {
             }
         }
     }
-    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    catch (e_19_1) { e_19 = { error: e_19_1 }; }
     finally {
         try {
             if (patterns_2_1 && !patterns_2_1.done && (_a = patterns_2.return)) _a.call(patterns_2);
         }
-        finally { if (e_11) throw e_11.error; }
+        finally { if (e_19) throw e_19.error; }
     }
     return null;
 }