@resolveio/server-lib 20.15.6 → 20.15.8

package/methods/ai-terminal.js

@@ -145,6 +145,7 @@ 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_NAME_MATCH_FALLBACK_MAX_FIELDS = 12;
 var AI_ASSISTANT_PROGRESS_TICKS = [
     'Grabbing Data',
     'Drafting response'
@@ -246,6 +247,13 @@ var AI_ASSISTANT_COLLECTION_STOPWORDS = new Set([
     'missing',
     'overdue'
 ]);
+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']
+    }
+];
 var AI_ASSISTANT_SYSTEM_PROMPT = [
     'You are the ResolveIO in-app AI assistant running with read-only access to the codebase.',
     'Core rules:',
@@ -259,6 +267,7 @@ var AI_ASSISTANT_SYSTEM_PROMPT = [
     '- Step 1 (always): determine the target collections/models/modules/workflows using context, routes, and collection hints. Assume the user is non-technical and will not provide internal names.',
     '- Planning stage: regex/keyword scan the codebase for collectionName/model definitions, methods, publications, and Angular routes/modules to map user wording to internal names.',
     '- Map user wording to internal collections/fields yourself. Do not ask for property names unless required to run a query.',
+    '- Use term hints from context (synonym expansions) when mapping user language to collections.',
     '- Do not guess or invent collections/fields. If unsure, verify in the codebase or run a small Mongo read (limit 1-5) to learn the shape.',
     '- Prefer running a small Mongo read over asking multiple questions.',
     '- For any data request (counts, lists, breakdowns, recent/last items), you MUST run a MONGO_READ or MONGO_AGG before answering.',
@@ -275,6 +284,7 @@ var AI_ASSISTANT_SYSTEM_PROMPT = [
     '- When you reference database results, summarize first, then include a Markdown table.',
     '- When presenting record lists or aggregates, produce a Markdown table (pipes).',
     '- Never show raw JSON dumps.',
+    '- Do not invent placeholders like "Not available" or "N/A". If a value is missing in tool results, leave the cell blank or omit the column and note it briefly.',
     '- Do not include `_id` & `__v` & `id_<other collection _id property>` in tables by default.',
     '- If `_id` & `__v` & `id_<other collection _id property>` is needed, show it as `id` and shorten (e.g., first 6-8 chars) unless asked otherwise.',
     '- Rename `createdAt` to `Created At` and `updatedAt` to `Updated At` in tables.',
@@ -1039,11 +1049,21 @@ 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 progressTracker, streamProgress, assistantContent, toolResult, assistantDebug, directiveSource, dataQuestion, lastDirective, toolResponseDebug, toolError, collectionHints, dbName, db, hintText, _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, finalMetadata, finalAssistantDoc;
-                        var _f;
-                        return __generator(this, function (_g) {
-                            switch (_g.label) {
+                        var runStart, steps, recordStep, progressTracker, streamProgress, assistantContent, toolResult, assistantDebug, directiveSource, dataQuestion, lastDirective, toolResponseDebug, toolError, termHints, collectionHints, collectionTokenization, collectionRanking, collectionSelection, timingBreakdown, contextRoute, contextMode, hintSeed, termExpansion, hintText, baseTokens, expandedTokens, dbName, db, collectionNames, _a, assistantContext, prompt_1, workspaceRoot, codexConfig, runOptions, responseText, directiveText, directive, directivePrompt, directiveStart, forcedDirective, _b, initialStart, directivePrompt, forcedStart, forcedDirective, _c, cleanedResponseText, 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;
+                        return __generator(this, function (_s) {
+                            switch (_s.label) {
                                 case 0:
+                                    runStart = Date.now();
+                                    steps = [];
+                                    recordStep = function (step, details) {
+                                        steps.push({
+                                            step: step,
+                                            at: new Date().toISOString(),
+                                            ms: Date.now() - runStart,
+                                            details: details
+                                        });
+                                    };
                                     progressTracker = createAssistantProgressTracker(assistantMessageId, initialProgress);
                                     streamProgress = createAssistantStreamProgressHandler(progressTracker);
                                     assistantContent = '';
@@ -1054,38 +1074,75 @@ function executeAiAssistantCodexRun(payload, context) {
                                     lastDirective = null;
                                     toolResponseDebug = null;
                                     toolError = null;
-                                    _g.label = 1;
-                                case 1:
-                                    _g.trys.push([1, 30, 31, 32]);
+                                    termHints = [];
                                     collectionHints = [];
-                                    _g.label = 2;
+                                    collectionTokenization = null;
+                                    collectionRanking = null;
+                                    collectionSelection = 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 });
+                                    _s.label = 1;
+                                case 1:
+                                    _s.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);
+                                    collectionTokenization = {
+                                        baseText: hintSeed || undefined,
+                                        expandedText: hintText || undefined,
+                                        baseTokens: baseTokens.length ? baseTokens : undefined,
+                                        expandedTokens: expandedTokens.length ? expandedTokens : undefined
+                                    };
+                                    recordStep('Planning: term expansion', {
+                                        termMatches: termExpansion.matches.length ? termExpansion.matches : undefined
+                                    });
+                                    _s.label = 2;
                                 case 2:
-                                    _g.trys.push([2, 4, , 5]);
+                                    _s.trys.push([2, 4, , 5]);
                                     dbName = resolveAssistantDatabaseName(undefined, input.mongo);
                                     db = resolveio_server_app_1.ResolveIOServer.getMongoConnection().db(dbName);
-                                    hintText = [
-                                        message,
-                                        normalizeOptionalString((_f = input === null || input === void 0 ? void 0 : input.context) === null || _f === void 0 ? void 0 : _f.route)
-                                    ].filter(Boolean).join(' ');
-                                    return [4 /*yield*/, resolveAssistantCollectionHints(hintText, dbName, db)];
+                                    return [4 /*yield*/, listAssistantCollections(db, dbName)];
                                 case 3:
-                                    collectionHints = _g.sent();
+                                    collectionNames = _s.sent();
+                                    collectionHints = resolveCollectionHintsFromTokens(expandedTokens, collectionNames, 5);
+                                    collectionRanking = buildCollectionRankingDebugFromTokens(expandedTokens, collectionNames, 8);
                                     return [3 /*break*/, 5];
                                 case 4:
-                                    _a = _g.sent();
+                                    _a = _s.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', {
+                                        contextRoute: contextRoute || undefined,
+                                        contextMode: contextMode || undefined,
+                                        collectionHints: collectionHints.length ? collectionHints : undefined,
+                                        termHints: termHints.length ? termHints : undefined
+                                    });
                                     assistantContext = buildAssistantContext(input, {
                                         isSuperAdmin: isSuperAdmin,
                                         hasInvoiceAccess: hasInvoiceAccess,
                                         customerId: customerId,
-                                        collectionHints: collectionHints
+                                        collectionHints: collectionHints,
+                                        termHints: termHints
                                     });
                                     prompt_1 = buildAssistantCodexPrompt(message, attachmentData.promptText, historyLines.join('\n'), assistantContext);
                                     return [4 /*yield*/, resolveAssistantWorkspaceRoot()];
                                 case 6:
-                                    workspaceRoot = _g.sent();
+                                    workspaceRoot = _s.sent();
                                     codexConfig = resolveCodexSettings();
                                     runOptions = {
                                         timeoutMs: resolveCodexTimeoutMs(),
@@ -1104,52 +1161,82 @@ function executeAiAssistantCodexRun(payload, context) {
                                     directiveText = '';
                                     directive = null;
                                     if (!dataQuestion) return [3 /*break*/, 10];
+                                    recordStep('Directive: determine tool', { type: 'data-question' });
                                     directivePrompt = buildAssistantCodexDirectivePrompt(message, attachmentData.promptText, historyLines.join('\n'), assistantContext);
-                                    _g.label = 7;
+                                    _s.label = 7;
                                 case 7:
-                                    _g.trys.push([7, 9, , 10]);
+                                    _s.trys.push([7, 9, , 10]);
+                                    directiveStart = Date.now();
                                     return [4 /*yield*/, runCodexInWorkerThread(directivePrompt, runOptions, codexConfig, streamProgress)];
                                 case 8:
-                                    directiveText = _g.sent();
+                                    directiveText = _s.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((_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 = _g.sent();
+                                    _b = _s.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 = _g.sent();
+                                    responseText = _s.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((_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
+                                        });
                                     }
-                                    _g.label = 12;
+                                    _s.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);
-                                    _g.label = 13;
+                                    _s.label = 13;
                                 case 13:
-                                    _g.trys.push([13, 15, , 16]);
+                                    _s.trys.push([13, 15, , 16]);
+                                    forcedStart = Date.now();
                                     return [4 /*yield*/, runCodexInWorkerThread(directivePrompt, runOptions, codexConfig, streamProgress)];
                                 case 14:
-                                    directiveText = _g.sent();
+                                    directiveText = _s.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((_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 = _g.sent();
+                                    _c = _s.sent();
                                     return [3 /*break*/, 16];
                                 case 16:
                                     cleanedResponseText = (directive === null || directive === void 0 ? void 0 : directive.cleaned) || responseText;
@@ -1159,53 +1246,70 @@ function executeAiAssistantCodexRun(payload, context) {
                                     if (!((directive === null || directive === void 0 ? void 0 : directive.payload) && AI_ASSISTANT_TOOL_MAX_STEPS > 0)) return [3 /*break*/, 28];
                                     toolRequest = buildAssistantToolRequest(directive, input);
                                     progressTracker.push('Grabbing Data');
-                                    _g.label = 17;
+                                    recordStep('Grabbing Data: start', {
+                                        type: directive.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
+                                    });
+                                    _s.label = 17;
                                 case 17:
-                                    _g.trys.push([17, 26, , 27]);
+                                    _s.trys.push([17, 26, , 27]);
+                                    toolStart = Date.now();
                                     if (!(directive.type === 'aggregate')) return [3 /*break*/, 19];
                                     return [4 /*yield*/, executeAiAssistantMongoAggregate(toolRequest, context)];
                                 case 18:
-                                    _d = _g.sent();
+                                    _d = _s.sent();
                                     return [3 /*break*/, 21];
                                 case 19: return [4 /*yield*/, executeAiAssistantMongoRead(toolRequest, context)];
                                 case 20:
-                                    _d = _g.sent();
-                                    _g.label = 21;
+                                    _d = _s.sent();
+                                    _s.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);
                                     toolResult = toolPayload.result;
+                                    recordStep('Grabbing Data: complete', {
+                                        rowCount: toolPayload.result.output.rowCount,
+                                        total: toolPayload.result.output.total,
+                                        columns: toolPayload.result.output.columns
+                                    });
                                     progressTracker.push('Drafting response');
+                                    recordStep('Drafting response');
                                     followupPrompt = buildAssistantCodexToolFollowupPrompt(message, attachmentData.promptText, historyLines.join('\n'), assistantContext, toolPayload.prompt);
-                                    _g.label = 22;
+                                    _s.label = 22;
                                 case 22:
-                                    _g.trys.push([22, 24, , 25]);
+                                    _s.trys.push([22, 24, , 25]);
+                                    followupStart = Date.now();
                                     return [4 /*yield*/, runCodexInWorkerThread(followupPrompt, runOptions, codexConfig, streamProgress)];
                                 case 23:
-                                    followupText = _g.sent();
+                                    followupText = _s.sent();
+                                    timingBreakdown.followupMs = Date.now() - followupStart;
                                     assistantContent = sanitizeAssistantResponse(followupText);
                                     return [3 /*break*/, 25];
                                 case 24:
-                                    _e = _g.sent();
+                                    _e = _s.sent();
                                     assistantContent = buildAssistantToolFallbackResponse(toolPayload.result);
                                     return [3 /*break*/, 25];
                                 case 25: return [3 /*break*/, 27];
                                 case 26:
-                                    error_2 = _g.sent();
+                                    error_2 = _s.sent();
                                     assistantContent = buildAssistantToolErrorMessage(error_2, directive, toolRequest);
                                     toolError = error_2;
                                     return [3 /*break*/, 27];
                                 case 27: return [3 /*break*/, 29];
                                 case 28:
                                     progressTracker.push('Drafting response');
-                                    _g.label = 29;
+                                    recordStep('Drafting response');
+                                    _s.label = 29;
                                 case 29: return [3 /*break*/, 32];
                                 case 30:
-                                    error_3 = _g.sent();
+                                    error_3 = _s.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];
                                 case 31:
                                     progressTracker.stop();
@@ -1216,13 +1320,43 @@ 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,
                                             directiveSource: directiveSource,
                                             toolResult: toolResult,
                                             toolResponseDebug: toolResponseDebug,
-                                            toolError: toolError
+                                            toolError: toolError,
+                                            trace: {
+                                                steps: steps,
+                                                planning: {
+                                                    contextMode: contextMode || undefined,
+                                                    contextRoute: contextRoute || undefined,
+                                                    termHints: termHints.length ? termHints : undefined,
+                                                    collectionHints: collectionHints.length ? collectionHints : undefined,
+                                                    collectionTokenization: collectionTokenization || undefined,
+                                                    collectionRanking: collectionRanking || undefined,
+                                                    collectionSelection: collectionSelection || undefined
+                                                },
+                                                timings: {
+                                                    startedAt: new Date(runStart).toISOString(),
+                                                    finishedAt: new Date(finishedAt).toISOString(),
+                                                    totalMs: finishedAt - runStart,
+                                                    codexMs: codexMs,
+                                                    draftingMs: draftingMs,
+                                                    toolMs: timingBreakdown.toolMs,
+                                                    directiveMs: timingBreakdown.directiveMs,
+                                                    initialResponseMs: timingBreakdown.initialResponseMs,
+                                                    forcedDirectiveMs: timingBreakdown.forcedDirectiveMs,
+                                                    followupMs: timingBreakdown.followupMs
+                                                }
+                                            }
                                         });
                                     }
                                     finalMetadata = __assign(__assign(__assign({ model: resolveCodexModel() }, (requestId ? { request_id: requestId } : {})), (toolResult ? { tool_result: toolResult } : {})), (assistantDebug ? { debug: assistantDebug } : {}));
@@ -1236,16 +1370,16 @@ function executeAiAssistantCodexRun(payload, context) {
                                             }
                                         })];
                                 case 33:
-                                    _g.sent();
-                                    _g.label = 34;
+                                    _s.sent();
+                                    _s.label = 34;
                                 case 34: return [4 /*yield*/, touchConversation(conversation._id, finalNow, assistantMessageId ? String(assistantMessageId) : undefined)];
                                 case 35:
-                                    _g.sent();
+                                    _s.sent();
                                     if (!(input.delete_files_after_run !== false)) return [3 /*break*/, 37];
                                     return [4 /*yield*/, cleanupAttachments(attachmentData.attachments)];
                                 case 36:
-                                    _g.sent();
-                                    _g.label = 37;
+                                    _s.sent();
+                                    _s.label = 37;
                                 case 37: return [2 /*return*/, finalAssistantDoc];
                             }
                         });
@@ -1259,7 +1393,7 @@ 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, display;
+        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, expanded, fallbackDocs, total, sanitizedDocuments, includeIds, requestedFields, fieldAliases, displayDocs, priorityFields, display;
         var _c, _d;
         return __generator(this, function (_e) {
             switch (_e.label) {
@@ -1314,7 +1448,7 @@ function executeAiAssistantMongoRead(payload, context) {
                     documents = _e.sent();
                     executedQuery = scopedQuery;
                     fallbackMeta = {};
-                    if (!!documents.length) return [3 /*break*/, 8];
+                    if (!!documents.length) return [3 /*break*/, 10];
                     dateFallback = resolveQueryDateFieldFallback(scopedQuery);
                     if (!dateFallback) return [3 /*break*/, 8];
                     fallbackQuery = replaceQueryField(scopedQuery, dateFallback.from, dateFallback.to);
@@ -1329,25 +1463,55 @@ function executeAiAssistantMongoRead(payload, context) {
                     }
                     _e.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(scopedQuery);
+                    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();
+                    fallbackDocs = _e.sent();
+                    if (fallbackDocs.length) {
+                        documents = fallbackDocs;
+                        executedQuery = expanded.query;
+                        fallbackMeta.dateFieldsExpanded.used = true;
+                    }
                     _e.label = 10;
                 case 10:
+                    total = null;
+                    if (!normalized.includeTotal) return [3 /*break*/, 12];
+                    return [4 /*yield*/, db.collection(collection).countDocuments(executedQuery, { readPreference: AI_ASSISTANT_READ_PREFERENCE })];
+                case 11:
+                    total = _e.sent();
+                    _e.label = 12;
+                case 12:
                     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;
-                    display = buildDisplayTable(sanitizedDocuments, {
+                    requestedFields = resolveProjectionRequestedFields(normalized.findOptions.projection);
+                    fieldAliases = resolveFieldAliases(sanitizedDocuments, requestedFields);
+                    displayDocs = Object.keys(fieldAliases).length
+                        ? applyFieldAliasesForDisplay(sanitizedDocuments, fieldAliases)
+                        : sanitizedDocuments;
+                    priorityFields = requestedFields.length
+                        ? __spreadArray(__spreadArray([], __read(requestedFields), false), __read(AI_ASSISTANT_DISPLAY_PRIORITY_FIELDS), false) : AI_ASSISTANT_DISPLAY_PRIORITY_FIELDS;
+                    display = buildDisplayTable(displayDocs, {
                         includeIds: includeIds,
                         maxColumns: AI_ASSISTANT_DISPLAY_MAX_COLUMNS,
-                        maxRows: normalized.findOptions.limit
+                        maxRows: normalized.findOptions.limit,
+                        priorityFields: priorityFields,
+                        includeGroupFromId: false
                     });
                     if (total !== null) {
                         display.total = total;
                     }
+                    if (Object.keys(fieldAliases).length) {
+                        fallbackMeta.fieldAliases = fieldAliases;
+                    }
                     return [2 /*return*/, __assign({ documents: sanitizedDocuments, total: total, display: display }, (isSuperAdmin ? {
                             debug: {
                                 collection: collection,
@@ -1369,7 +1533,7 @@ 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 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, completionExprFallback, fallbackPipeline, fallbackDocs, unwindFallback, fallbackPipeline, fallbackDocs, nameFallback, fallbackPipeline, fallbackDocs, sanitizedDocuments, includeIds, display;
         var _c, _d;
         return __generator(this, function (_e) {
             switch (_e.label) {
@@ -1468,7 +1632,7 @@ function executeAiAssistantMongoAggregate(payload, context) {
                     }
                     _e.label = 10;
                 case 10:
-                    if (!!documents.length) return [3 /*break*/, 12];
+                    if (!!documents.length) return [3 /*break*/, 14];
                     completionFallback = resolveAggregateCompletionFallback(executedPipeline);
                     if (!completionFallback) return [3 /*break*/, 12];
                     fallbackMeta.completion = {
@@ -1476,7 +1640,8 @@ function executeAiAssistantMongoAggregate(payload, context) {
                         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];
@@ -1492,24 +1657,72 @@ function executeAiAssistantMongoAggregate(payload, context) {
                     }
                     _e.label = 12;
                 case 12:
-                    if (!(documents.length <= 1)) return [3 /*break*/, 14];
+                    if (!!documents.length) return [3 /*break*/, 14];
+                    completionExprFallback = resolveAggregateCompletionExprFallback(executedPipeline);
+                    if (!completionExprFallback) return [3 /*break*/, 14];
+                    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*/, 14];
+                    return [4 /*yield*/, db.collection(collection)
+                            .aggregate(fallbackPipeline, aggregateOptions)
+                            .toArray()];
+                case 13:
+                    fallbackDocs = _e.sent();
+                    if (fallbackDocs.length) {
+                        documents = fallbackDocs;
+                        executedPipeline = fallbackPipeline;
+                        fallbackMeta.completion.used = true;
+                    }
+                    _e.label = 14;
+                case 14:
+                    if (!(documents.length <= 1)) return [3 /*break*/, 16];
                     unwindFallback = resolveAggregateUnwindFallback(executedPipeline);
-                    if (!unwindFallback) return [3 /*break*/, 14];
+                    if (!unwindFallback) return [3 /*break*/, 16];
                     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*/, 16];
                     return [4 /*yield*/, db.collection(collection)
                             .aggregate(fallbackPipeline, aggregateOptions)
                             .toArray()];
-                case 13:
+                case 15:
                     fallbackDocs = _e.sent();
                     if (fallbackDocs.length > documents.length) {
                         documents = fallbackDocs;
                         executedPipeline = fallbackPipeline;
                         fallbackMeta.unwind.used = true;
                     }
-                    _e.label = 14;
-                case 14:
+                    _e.label = 16;
+                case 16:
+                    if (!!documents.length) return [3 /*break*/, 18];
+                    nameFallback = resolveAggregateNameMatchFallback(executedPipeline);
+                    if (!nameFallback) return [3 /*break*/, 18];
+                    fallbackMeta.nameMatch = {
+                        field: nameFallback.field,
+                        fields: nameFallback.fields,
+                        attempted: true,
+                        used: false
+                    };
+                    fallbackPipeline = buildAggregateNameMatchFallbackPipeline(executedPipeline, nameFallback);
+                    if (!(fallbackPipeline.length && !containsForbiddenMongoOperators(fallbackPipeline))) return [3 /*break*/, 18];
+                    return [4 /*yield*/, db.collection(collection)
+                            .aggregate(fallbackPipeline, aggregateOptions)
+                            .toArray()];
+                case 17:
+                    fallbackDocs = _e.sent();
+                    if (fallbackDocs.length) {
+                        documents = fallbackDocs;
+                        executedPipeline = fallbackPipeline;
+                        fallbackMeta.nameMatch.used = true;
+                    }
+                    _e.label = 18;
+                case 18:
                     sanitizedDocuments = isSuperAdmin
                         ? documents
                         : documents.map(function (doc) { return redactSensitiveFields((0, common_1.deepCopy)(doc)); });
@@ -1517,7 +1730,8 @@ function executeAiAssistantMongoAggregate(payload, context) {
                     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: {
@@ -1606,7 +1820,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,
@@ -1686,7 +1901,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;
     var notes = [];
     if (params.dataQuestion) {
         notes.push('Detected a data request; tool call required.');
@@ -1727,16 +1942,37 @@ function buildAssistantDebugPayload(params) {
     if ((_k = fallbackInfo === null || fallbackInfo === void 0 ? void 0 : fallbackInfo.dateFieldCreatedAt) === null || _k === void 0 ? void 0 : _k.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 ((_l = fallbackInfo === null || fallbackInfo === void 0 ? void 0 : fallbackInfo.completion) === null || _l === void 0 ? void 0 : _l.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 ((_m = fallbackInfo === null || fallbackInfo === void 0 ? void 0 : fallbackInfo.dateFieldsExpanded) === null || _m === void 0 ? void 0 : _m.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 ((_o = fallbackInfo === null || fallbackInfo === void 0 ? void 0 : fallbackInfo.unwind) === null || _o === void 0 ? void 0 : _o.used) {
         notes.push("Applied unwind fallback on ".concat(fallbackInfo.unwind.path, "."));
     }
+    if ((_p = fallbackInfo === null || fallbackInfo === void 0 ? void 0 : fallbackInfo.nameMatch) === null || _p === void 0 ? void 0 : _p.used) {
+        var fields = Array.isArray(fallbackInfo.nameMatch.fields)
+            ? fallbackInfo.nameMatch.fields.join(', ')
+            : fallbackInfo.nameMatch.field;
+        notes.push("Expanded name match fields: ".concat(fields, "."));
+    }
     if (params.toolError) {
-        var errorMessage = ((_m = params.toolError) === null || _m === void 0 ? void 0 : _m.message) || String(params.toolError || '');
+        var errorMessage = ((_q = params.toolError) === null || _q === void 0 ? void 0 : _q.message) || String(params.toolError || '');
         if (errorMessage) {
             notes.push("Tool error: ".concat(errorMessage));
         }
     }
-    return {
+    var payload = {
         decision: {
             dataQuestion: params.dataQuestion,
             directiveSource: params.directiveSource
@@ -1751,15 +1987,19 @@ function buildAssistantDebugPayload(params) {
         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 ((_r = params.toolResponseDebug) === null || _r === void 0 ? void 0 : _r.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: ((_s = params.toolResponseDebug) === null || _s === void 0 ? void 0 : _s.query) || undefined,
+        pipeline: ((_t = params.toolResponseDebug) === null || _t === void 0 ? void 0 : _t.executedPipeline) || ((_u = params.toolResponseDebug) === null || _u === void 0 ? void 0 : _u.originalPipeline) || undefined,
+        options: ((_v = params.toolResponseDebug) === null || _v === void 0 ? void 0 : _v.options) || undefined,
+        fallbacks: ((_w = params.toolResponseDebug) === null || _w === void 0 ? void 0 : _w.fallbacks) || undefined,
         notes: notes
     };
+    if (params.trace && typeof params.trace === 'object') {
+        payload.trace = params.trace;
+    }
+    return payload;
 }
 function buildAssistantToolErrorMessage(error, directive, request) {
     var _a, _b;
@@ -2009,6 +2249,219 @@ function normalizeColumnPriorityKey(column) {
     var base = trimmed.includes('.') ? trimmed.split('.').pop() || trimmed : trimmed;
     return base.toLowerCase();
 }
+function tokenizeFieldKey(value) {
+    var normalized = String(value || '')
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/[^a-zA-Z0-9]+/g, ' ')
+        .trim()
+        .toLowerCase();
+    return normalized ? normalized.split(/\s+/).filter(Boolean) : [];
+}
+function normalizeFieldMatchKey(value) {
+    return tokenizeFieldKey(value).join('');
+}
+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') {
+                return undefined;
+            }
+            current = current[part];
+        }
+    }
+    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);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return current;
+}
+function hasNonEmptyValue(docs, fieldPath, options) {
+    var e_2, _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;
+            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;
+            }
+            if (!isEmptyDisplayValue(value)) {
+                return true;
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (docs_1_1 && !docs_1_1.done && (_a = docs_1.return)) _a.call(docs_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return false;
+}
+function collectFieldCandidates(docs) {
+    var candidates = new Map();
+    if (!Array.isArray(docs)) {
+        return candidates;
+    }
+    var addCandidate = function (path, value) {
+        if (!path) {
+            return;
+        }
+        var entry = candidates.get(path) || {
+            nonEmpty: 0,
+            objectLike: 0,
+            normalized: normalizeFieldMatchKey(path)
+        };
+        if (!isEmptyDisplayValue(value)) {
+            entry.nonEmpty += 1;
+        }
+        if (isDisplayObjectLike(value)) {
+            entry.objectLike += 1;
+        }
+        candidates.set(path, entry);
+    };
+    docs.forEach(function (doc) {
+        if (!doc || typeof doc !== 'object') {
+            return;
+        }
+        Object.keys(doc).forEach(function (key) {
+            if (!key) {
+                return;
+            }
+            var value = doc[key];
+            addCandidate(key, value);
+            if (isPlainObject(value) && !isMongoObjectId(value) && !(value instanceof Date)) {
+                var nestedKeys = Object.keys(value).slice(0, 50);
+                nestedKeys.forEach(function (nestedKey) {
+                    if (!nestedKey) {
+                        return;
+                    }
+                    addCandidate("".concat(key, ".").concat(nestedKey), value[nestedKey]);
+                });
+            }
+        });
+    });
+    return candidates;
+}
+function resolveFieldAliases(docs, requestedFields) {
+    var aliases = {};
+    if (!Array.isArray(docs) || !requestedFields.length) {
+        return aliases;
+    }
+    var missing = requestedFields.filter(function (field) { return field && !hasNonEmptyValue(docs, field, { treatObjectLikeAsEmpty: true }); });
+    if (!missing.length) {
+        return aliases;
+    }
+    var candidates = collectFieldCandidates(docs);
+    missing.forEach(function (field) {
+        var normalizedRequested = normalizeFieldMatchKey(field);
+        if (!normalizedRequested) {
+            return;
+        }
+        var bestPath = '';
+        var bestScore = 0;
+        candidates.forEach(function (stats, path) {
+            if (!path || stats.nonEmpty === 0) {
+                return;
+            }
+            if (isAssistantIdField(path)) {
+                return;
+            }
+            var normalizedCandidate = stats.normalized || normalizeFieldMatchKey(path);
+            if (!normalizedCandidate) {
+                return;
+            }
+            var score = 0;
+            if (normalizedCandidate === normalizedRequested) {
+                score = 100;
+            }
+            else if (normalizedCandidate.includes(normalizedRequested) || normalizedRequested.includes(normalizedCandidate)) {
+                score = 70;
+            }
+            else {
+                var candidateTokens_1 = tokenizeFieldKey(path);
+                var requestedTokens = tokenizeFieldKey(field);
+                var overlap = requestedTokens.filter(function (token) { return candidateTokens_1.includes(token); }).length;
+                if (overlap > 0) {
+                    score = 40 + overlap * 5;
+                }
+            }
+            var objectRatio = stats.objectLike / Math.max(stats.nonEmpty, 1);
+            if (objectRatio > 0.5) {
+                score -= 50;
+            }
+            if (score > bestScore) {
+                bestScore = score;
+                bestPath = path;
+            }
+        });
+        if (bestPath && bestScore >= 60) {
+            aliases[field] = bestPath;
+        }
+    });
+    return aliases;
+}
+function applyFieldAliasesForDisplay(docs, aliases) {
+    if (!Array.isArray(docs) || !aliases || !Object.keys(aliases).length) {
+        return docs;
+    }
+    return docs.map(function (doc) {
+        var next = __assign({}, doc);
+        Object.keys(aliases).forEach(function (targetField) {
+            var sourcePath = aliases[targetField];
+            if (!sourcePath) {
+                return;
+            }
+            var existing = targetField.includes('.') ? getValueAtPath(doc, targetField) : doc === null || doc === void 0 ? void 0 : doc[targetField];
+            if (!isEmptyDisplayValue(existing)) {
+                return;
+            }
+            var value = getValueAtPath(doc, sourcePath);
+            if (value !== undefined) {
+                next[targetField] = value;
+            }
+        });
+        return next;
+    });
+}
+function resolveProjectionRequestedFields(projection) {
+    if (!projection || typeof projection !== 'object') {
+        return [];
+    }
+    var keys = Object.keys(projection);
+    if (!keys.length) {
+        return [];
+    }
+    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;
+        }
+    });
+    if (!hasInclude || hasExclude) {
+        return [];
+    }
+    return keys.filter(function (key) { return !isAssistantIdField(key); });
+}
 function formatDisplayColumnName(column) {
     var trimmed = String(column || '').trim();
     if (!trimmed) {
@@ -2027,7 +2480,22 @@ function formatDisplayColumnName(column) {
     if (normalized === 'updatedat') {
         return 'Updated At';
     }
-    return trimmed;
+    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
+        .replace(/[_-]+/g, ' ')
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .replace(/\b\w/g, function (char) { return char.toUpperCase(); });
 }
 function truncateDisplayText(value, maxLength) {
     if (maxLength === void 0) { maxLength = AI_ASSISTANT_DISPLAY_STRING_LIMIT; }
@@ -2090,14 +2558,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)) {
@@ -2140,7 +2611,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) {
@@ -2496,7 +2972,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();
@@ -2523,7 +3000,7 @@ function matchContainsField(value, field) {
     });
 }
 function resolveAggregateCompletionFallback(pipeline) {
-    var e_1, _a;
+    var e_3, _a;
     if (!Array.isArray(pipeline)) {
         return null;
     }
@@ -2536,7 +3013,7 @@ function resolveAggregateCompletionFallback(pipeline) {
         }
         var addFields = stage.$addFields;
         try {
-            for (var _b = (e_1 = void 0, __values(Object.keys(addFields))), _c = _b.next(); !_c.done; _c = _b.next()) {
+            for (var _b = (e_3 = void 0, __values(Object.keys(addFields))), _c = _b.next(); !_c.done; _c = _b.next()) {
                 var key = _c.value;
                 if (!isCompletionFieldName(key)) {
                     continue;
@@ -2550,12 +3027,12 @@ function resolveAggregateCompletionFallback(pipeline) {
                 }
             }
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_1) throw e_1.error; }
+            finally { if (e_3) throw e_3.error; }
         }
         if (candidateField) {
             break;
@@ -2601,18 +3078,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;
@@ -2645,6 +3122,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_4, _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_4 = 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_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_4) throw e_4.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) {
@@ -2751,14 +3385,261 @@ 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') {
-            return;
-        }
-        if (stage.$match && typeof stage.$match === 'object') {
-            collectDateFieldsFromMatch(stage.$match, fields);
+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_5, _a, e_6, _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_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (match_1_1 && !match_1_1.done && (_a = match_1.return)) _a.call(match_1);
+            }
+            finally { if (e_5) throw e_5.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_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (keys_1_1 && !keys_1_1.done && (_b = keys_1.return)) _b.call(keys_1);
+        }
+        finally { if (e_6) throw e_6.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 (seen.has(value)) {
+            return;
+        }
+        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 (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;
+    }
+    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 isEmptyMatchValue(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 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('$')) {
+            var stripped = stripMatchField(value, field);
+            if (isEmptyMatchValue(stripped) && (key === '$and' || key === '$or')) {
+                return;
+            }
+            result[key] = stripped;
+            return;
+        }
+        if (value && typeof value === 'object') {
+            var stripped = stripMatchField(value, field);
+            if (!isEmptyMatchValue(stripped)) {
+                result[key] = stripped;
+            }
+            return;
+        }
+        result[key] = value;
+    });
+    return result;
+}
+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) {
@@ -2922,6 +3803,27 @@ function tokenizeCollectionText(value) {
     });
     return Array.from(new Set(tokens));
 }
+function expandAssistantTermSynonyms(text) {
+    var base = normalizeOptionalString(text);
+    if (!base) {
+        return { expanded: '', matches: [] };
+    }
+    var expanded = base;
+    var matches = [];
+    AI_ASSISTANT_TERM_SYNONYMS.forEach(function (entry) {
+        if (!entry.pattern.test(base)) {
+            return;
+        }
+        var existing = expanded.toLowerCase();
+        entry.expansions.forEach(function (expansion) {
+            if (expansion && !existing.includes(expansion.toLowerCase())) {
+                expanded = "".concat(expanded, " ").concat(expansion);
+            }
+        });
+        matches.push({ term: entry.label, expansions: entry.expansions });
+    });
+    return { expanded: expanded, matches: matches };
+}
 function listAssistantCollections(db, dbName) {
     return __awaiter(this, void 0, void 0, function () {
         var cacheKey, cached, now, collections, names, _a;
@@ -2977,6 +3879,75 @@ function scoreCollectionMatch(requestedTokens, candidateName) {
     }
     return score;
 }
+function scoreCollectionMatchDetailed(requestedTokens, candidateName) {
+    var candidateTokens = tokenizeCollectionText(candidateName);
+    var tokenMatches = requestedTokens.filter(function (token) { return candidateTokens.includes(token); });
+    var score = tokenMatches.length * 10;
+    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
+    };
+}
+function resolveCollectionHintsFromTokens(tokens, collectionNames, max) {
+    if (max === void 0) { max = 5; }
+    if (!tokens.length || !collectionNames.length) {
+        return [];
+    }
+    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, 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('-'));
+    if (!tokens.length || !collectionNames.length) {
+        return {
+            tokens: tokens,
+            requestedKey: requestedKey,
+            ranked: []
+        };
+    }
+    var ranked = collectionNames
+        .map(function (name) { return (__assign({ name: name }, scoreCollectionMatchDetailed(tokens, name))); })
+        .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,
+        ranked: ranked
+    };
+}
+function buildCollectionSelectionDetail(tokens, collection) {
+    var trimmed = normalizeOptionalString(collection);
+    if (!trimmed) {
+        return null;
+    }
+    var detail = scoreCollectionMatchDetailed(tokens, trimmed);
+    return {
+        collection: trimmed,
+        score: detail.score,
+        tokenMatches: detail.tokenMatches,
+        keyMatch: detail.keyMatch,
+        candidateTokens: detail.candidateTokens
+    };
+}
 function findBestCollectionMatch(requested, collectionNames) {
     var requestedTokens = tokenizeCollectionText(requested);
     if (!requestedTokens.length || !collectionNames.length) {
@@ -3022,38 +3993,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_2, _a, e_3, _b;
+    var e_7, _a, e_8, _b;
     if (!query || typeof query !== 'object') {
         return null;
     }
@@ -3067,12 +4008,12 @@ function findQueryDateField(query) {
                 }
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
         finally {
             try {
                 if (query_1_1 && !query_1_1.done && (_a = query_1.return)) _a.call(query_1);
             }
-            finally { if (e_2) throw e_2.error; }
+            finally { if (e_7) throw e_7.error; }
         }
         return null;
     }
@@ -3091,12 +4032,12 @@ function findQueryDateField(query) {
             }
         }
     }
-    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
     finally {
         try {
             if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
         }
-        finally { if (e_3) throw e_3.error; }
+        finally { if (e_8) throw e_8.error; }
     }
     return null;
 }
@@ -3114,6 +4055,117 @@ 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_1 = false;
+            var nextArray = value.map(function (entry) {
+                var visited = visit(entry);
+                if (visited.changed) {
+                    changed_1 = true;
+                }
+                return visited.value;
+            });
+            return { value: changed_1 ? nextArray : value, changed: changed_1 };
+        }
+        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 resolveQueryDateFieldFallback(query) {
     var dateField = findQueryDateField(query);
     if (!dateField) {
@@ -3126,7 +4178,7 @@ function resolveQueryDateFieldFallback(query) {
     return { from: dateField, to: fallback };
 }
 function containsForbiddenMongoOperators(value) {
-    var e_4, _a;
+    var e_9, _a;
     if (!value || typeof value !== 'object') {
         return false;
     }
@@ -3145,12 +4197,12 @@ function containsForbiddenMongoOperators(value) {
             }
         }
     }
-    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
     finally {
         try {
             if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
         }
-        finally { if (e_4) throw e_4.error; }
+        finally { if (e_9) throw e_9.error; }
     }
     return false;
 }
@@ -3384,8 +4436,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_5_1;
-        var _e, e_5, _f, _g;
+        var _a, _b, _c, _d, message, payload, status_1, e_10_1;
+        var _e, e_10, _f, _g;
         return __generator(this, function (_h) {
             switch (_h.label) {
                 case 0:
@@ -3412,8 +4464,8 @@ function waitForCodexWorkerMessage(worker, streamStatusHandler) {
                     return [3 /*break*/, 1];
                 case 4: return [3 /*break*/, 11];
                 case 5:
-                    e_5_1 = _h.sent();
-                    e_5 = { error: e_5_1 };
+                    e_10_1 = _h.sent();
+                    e_10 = { error: e_10_1 };
                     return [3 /*break*/, 11];
                 case 6:
                     _h.trys.push([6, , 9, 10]);
@@ -3424,7 +4476,7 @@ function waitForCodexWorkerMessage(worker, streamStatusHandler) {
                     _h.label = 8;
                 case 8: return [3 /*break*/, 10];
                 case 9:
-                    if (e_5) throw e_5.error;
+                    if (e_10) throw e_10.error;
                     return [7 /*endfinally*/];
                 case 10: return [7 /*endfinally*/];
                 case 11: throw new CodexWorkerBootstrapError('Codex worker exited before completing.');
@@ -3776,6 +4828,12 @@ function buildAssistantContext(input, userContext) {
     if (collectionHints.length) {
         lines.push("Collection hints: ".concat(collectionHints.join(', ')));
     }
+    var termHints = Array.isArray(userContext === null || userContext === void 0 ? void 0 : userContext.termHints)
+        ? userContext === null || userContext === void 0 ? void 0 : userContext.termHints.filter(Boolean)
+        : [];
+    if (termHints.length) {
+        lines.push("Term hints: ".concat(termHints.join('; ')));
+    }
     var mongoDb = normalizeOptionalString((_c = input === null || input === void 0 ? void 0 : input.mongo) === null || _c === void 0 ? void 0 : _c.database);
     var mongoDbs = Array.isArray((_d = input === null || input === void 0 ? void 0 : input.mongo) === null || _d === void 0 ? void 0 : _d.databases)
         ? input.mongo.databases.map(function (value) { return normalizeOptionalString(value); }).filter(Boolean)
@@ -3806,7 +4864,7 @@ function normalizeRouteMatchKey(value) {
     return normalizeRouteKey(value).toLowerCase();
 }
 function buildClientRouteIndex() {
-    var e_6, _a;
+    var e_11, _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();
@@ -3825,12 +4883,12 @@ function buildClientRouteIndex() {
             }
         }
     }
-    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
     finally {
         try {
             if (routes_1_1 && !routes_1_1.done && (_a = routes_1.return)) _a.call(routes_1);
         }
-        finally { if (e_6) throw e_6.error; }
+        finally { if (e_11) throw e_11.error; }
     }
     return { set: set, map: map, size: routes.length };
 }
@@ -3956,7 +5014,7 @@ function sanitizeAssistantResponse(value) {
     return normalizeAssistantRoutes(normalizedCurrency);
 }
 function evaluateAssistantGuardrails(message) {
-    var e_7, _a;
+    var e_12, _a;
     var normalized = String(message || '').toLowerCase();
     var patterns = [
         {
@@ -4002,12 +5060,12 @@ function evaluateAssistantGuardrails(message) {
             }
         }
     }
-    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    catch (e_12_1) { e_12 = { error: e_12_1 }; }
     finally {
         try {
             if (patterns_1_1 && !patterns_1_1.done && (_a = patterns_1.return)) _a.call(patterns_1);
         }
-        finally { if (e_7) throw e_7.error; }
+        finally { if (e_12) throw e_12.error; }
     }
     return null;
 }
@@ -4094,20 +5152,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_13, _a, e_14, _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_13_1) { e_13 = { error: e_13_1 }; }
+    finally {
+        try {
+            if (tokens_1_1 && !tokens_1_1.done && (_a = tokens_1.return)) _a.call(tokens_1);
+        }
+        finally { if (e_13) throw e_13.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_14_1) { e_14 = { error: e_14_1 }; }
+    finally {
+        try {
+            if (output_1_1 && !output_1_1.done && (_b = output_1.return)) _b.call(output_1);
+        }
+        finally { if (e_14) throw e_14.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;
@@ -4171,8 +5471,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_8_1;
-        var e_8, _b;
+        var limits, totalBytes, totalChars, chunks, cleaned, attachments_1, attachments_1_1, attachment, localPath, safe, stat, ext, name_1, type, readable, content, _a, e_15_1;
+        var e_15, _b;
         return __generator(this, function (_c) {
             switch (_c.label) {
                 case 0:
@@ -4251,14 +5551,14 @@ function readAttachmentContents(attachments) {
                     return [3 /*break*/, 2];
                 case 10: return [3 /*break*/, 13];
                 case 11:
-                    e_8_1 = _c.sent();
-                    e_8 = { error: e_8_1 };
+                    e_15_1 = _c.sent();
+                    e_15 = { error: e_15_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_8) throw e_8.error; }
+                    finally { if (e_15) throw e_15.error; }
                     return [7 /*endfinally*/];
                 case 13: return [2 /*return*/, {
                         promptText: chunks.length ? "\n\nAttachments:\n".concat(chunks.join('\n\n')) : '',
@@ -4435,7 +5735,7 @@ function estimateUsage(messages, responseText, model) {
     };
 }
 function evaluateGuardrails(message) {
-    var e_9, _a;
+    var e_16, _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.' },
@@ -4457,12 +5757,12 @@ function evaluateGuardrails(message) {
             }
         }
     }
-    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    catch (e_16_1) { e_16 = { error: e_16_1 }; }
     finally {
         try {
             if (patterns_2_1 && !patterns_2_1.done && (_a = patterns_2.return)) _a.call(patterns_2);
         }
-        finally { if (e_9) throw e_9.error; }
+        finally { if (e_16) throw e_16.error; }
     }
     return null;
 }