@resolveio/server-lib 22.1.9 → 22.1.10

package/methods/ai-terminal.js

@@ -352,8 +352,59 @@ var AI_ASSISTANT_COLLECTION_DOMAIN_TOKENS = new Set([
     'orders',
     'delivery',
     'deliveries',
+    'asset',
+    'assets',
+    'treatment',
+    'treatments',
+    'treatmentplan',
+    'treatmentplans',
+    'dispatch',
+    'driver',
+    'drivers',
+    'treater',
+    'specialty',
+    'specialtyjob',
+    'specialtyjobs',
+    'bol',
+    'bols',
+    'lading',
+    'pso',
+    'psos',
+    'po',
+    'pos',
+    'ats',
+    'automated',
+    'automation',
+    'continuous',
+    'isotank',
+    'isotanks',
+    'trailer',
+    'trailers',
+    'chemicaltrailer',
+    'chemicaltrailers',
+    'vac',
+    'vactruck',
+    'vactrucks',
+    'purchase',
+    'purchasing',
+    'purchaseorder',
+    'purchaseorders',
+    'batchjob',
+    'batchjobs',
+    'production',
+    'salesorder',
+    'salesorders',
     'truck',
+    'trucktreat',
+    'trucktreating',
+    'product',
+    'products',
+    'item',
+    'items',
+    'inventory',
     'treating',
+    'batchtreat',
+    'batchtreating',
     'route',
     'routes',
     'well',
@@ -403,6 +454,21 @@ var AI_ASSISTANT_TERM_SYNONYMS = [
         label: 'support tickets',
         pattern: /\bsupport[\s-]*tickets?\b/i,
         expansions: ['support-tickets', 'support ticket', 'ticket hours', 'billable hours']
+    },
+    {
+        label: 'delivery aliases',
+        pattern: /\b(bols?|bills?\s+of\s+lading|pso(?:s)?|production\s+sales\s+orders?|sales\s+orders?|truck[\s_-]+treat(?:ing)?|treater[\s_-]+truck|batch[\s_-]+(?:treat(?:ing)?|jobs?)|specialty[\s_-]+jobs?|continuous|ats|automated[\s_-]+treatment[\s_-]+system|isotanks?|chemical[\s_-]+trailers?|vac[\s_-]+trucks?|assets?|treatment[\s_-]+plans?|treatments?)\b/i,
+        expansions: ['delivery', 'deliveries', 'dispatch', 'route', 'work-order-dynamics', 'work order dynamics', 'work-orders', 'jobs', 'treatments', 'treatment-plans', 'assets']
+    },
+    {
+        label: 'purchase order aliases',
+        pattern: /\b(po(?:s)?|purchase[\s_-]+orders?)\b/i,
+        expansions: ['orders', 'purchase-orders', 'purchase orders', 'purchase order']
+    },
+    {
+        label: 'chemical catalog aliases',
+        pattern: /\b(chemicals?|products?|items?)\b/i,
+        expansions: ['chemical', 'chemicals', 'product', 'products', 'item', 'items', 'inventory']
     }
 ];
 var AI_ASSISTANT_REPORT_BUILDER_EXPERT_PLAYBOOK = [
@@ -2243,6 +2309,7 @@ function executeAiAssistantCodexRun(payload, context) {
                                 case 45:
                                     _j = _13.sent();
                                     assistantContent = buildAssistantToolFallbackResponse(toolPayload.result);
+                                    assistantContent = applyAssistantDisplayTableToResponse(assistantContent, toolPayload.result.output.display);
                                     return [3 /*break*/, 46];
                                 case 46: return [3 /*break*/, 48];
                                 case 47:
@@ -2549,7 +2616,7 @@ function executeAiAssistantReportIssue(payload, context) {
 }
 function executeAiAssistantMongoRead(payload, context) {
     return __awaiter(this, void 0, void 0, function () {
-        var input, rawCollection, retryState, triedCollections, crossCollectionRetryEnabled, dbName, db, collectionResolution, collection, bridgeCollection, retryRootCollection, schemaFields, effectivePermissionView, _a, user, isSuperAdmin, customerId, fallbackMeta, baseQuery, stripped, userId, normalizedClient, shouldScopeByClient, _b, strippedClient, clientScopedQuery, scopedQuery, normalized, findOptions, runFindWithRepair, initialRead, documents, executedQuery, probeDocs, dateFallback, fallbackQuery, fallbackRead, fallbackDocs, expanded, fallbackRead, fallbackDocs, nameFallback, fallbackRead, fallbackDocs, _c, chemicalLookup, fallbackRead, fallbackDocs, queryFields, _d, aliases, rewrittenQuery, fallbackRead, fallbackDocs, _e, activeFallback, fallbackRead, fallbackDocs, _f, idLookup, fallbackRead, fallbackDocs, baseCollection, fallbackPayload, fallbackResult, existingFallbacks, crossCollectionCandidates, crossCollectionCandidates_1, crossCollectionCandidates_1_1, candidateCollection, fallbackPayload, fallbackResult, fallbackDocs, existingFallbacks, rejectedQuality, e_1_1, nameFields, dateFields, diagnostics, queryNoName, _g, queryNoDate, _h, _j, _k, _l, allCollections, base, alt, altCount, _m, total, sanitizedDocuments, requestedFields, missingFields, _o, projectionAliases, expandedProjection, refreshedDocs, includeIds, fieldAliases, displayDocs, idLookupDisplay, priorityFields, displayMaxRows, display;
+        var input, rawCollection, retryState, triedCollections, crossCollectionRetryEnabled, dbName, db, collectionResolution, collection, bridgeCollection, retryRootCollection, schemaFields, effectivePermissionView, _a, user, isSuperAdmin, customerId, fallbackMeta, baseQuery, stripped, userId, normalizedClient, shouldScopeByClient, _b, strippedClient, clientScopedQuery, scopedQuery, normalized, findOptions, runFindWithRepair, initialRead, documents, executedQuery, probeDocs, dateFallback, fallbackQuery, fallbackRead, fallbackDocs, expanded, fallbackRead, fallbackDocs, nameFallback, fallbackRead, fallbackDocs, _c, chemicalLookup, fallbackRead, fallbackDocs, queryFields, _d, aliases, rewrittenQuery, fallbackRead, fallbackDocs, _e, activeFallback, fallbackRead, fallbackDocs, _f, idLookup, fallbackRead, fallbackDocs, baseCollection, fallbackPayload, fallbackResult, existingFallbacks, hasActiveStatusFilters, crossCollectionCandidates, crossCollectionCandidates_1, crossCollectionCandidates_1_1, candidateCollection, fallbackPayload, fallbackResult, fallbackDocs, existingFallbacks, rejectedQuality, e_1_1, nameFields, dateFields, diagnostics, queryNoName, _g, queryNoDate, _h, _j, _k, _l, allCollections, base, alt, altCount, _m, total, sanitizedDocuments, requestedFields, missingFields, _o, projectionAliases, expandedProjection, refreshedDocs, includeIds, fieldAliases, displayDocs, idLookupDisplay, priorityFields, displayMaxRows, display;
         var e_1, _p;
         var _this = this;
         var _q, _r;
@@ -2845,7 +2912,7 @@ function executeAiAssistantMongoRead(payload, context) {
                     _s.label = 24;
                 case 24:
                     probeDocs = _e;
-                    activeFallback = resolveReadActiveStatusFallback(executedQuery, probeDocs || []);
+                    activeFallback = resolveReadActiveStatusFallback(executedQuery, probeDocs || [], schemaFields);
                     if (!activeFallback) return [3 /*break*/, 26];
                     fallbackMeta.activeStatus = {
                         fields: activeFallback.fields,
@@ -2934,7 +3001,8 @@ function executeAiAssistantMongoRead(payload, context) {
                     }
                     _s.label = 34;
                 case 34:
-                    if (!(!documents.length && crossCollectionRetryEnabled)) return [3 /*break*/, 43];
+                    hasActiveStatusFilters = collectAssistantActiveMatchFields(executedQuery).length > 0;
+                    if (!(!documents.length && crossCollectionRetryEnabled && !hasActiveStatusFilters)) return [3 /*break*/, 44];
                     return [4 /*yield*/, resolveAssistantAvailableCrossCollectionFallbacks(db, dbName, collection, triedCollections)];
                 case 35:
                     crossCollectionCandidates = _s.sent();
@@ -3003,8 +3071,20 @@ function executeAiAssistantMongoRead(payload, context) {
                     }
                     finally { if (e_1) throw e_1.error; }
                     return [7 /*endfinally*/];
-                case 43:
-                    if (!(!documents.length && isSuperAdmin)) return [3 /*break*/, 60];
+                case 43: return [3 /*break*/, 45];
+                case 44:
+                    if (!documents.length && crossCollectionRetryEnabled && hasActiveStatusFilters && isSuperAdmin) {
+                        fallbackMeta.collectionRetry = {
+                            from: collection,
+                            root: retryRootCollection,
+                            attempted: false,
+                            skipped: true,
+                            reason: 'active_status_query_preserved'
+                        };
+                    }
+                    _s.label = 45;
+                case 45:
+                    if (!(!documents.length && isSuperAdmin)) return [3 /*break*/, 62];
                     nameFields = collectMatchFieldsByCondition(executedQuery, function (field, condition) { return isRegexMatchCondition(condition)
                         || (typeof condition === 'string' && shouldApplyAssistantNameRegex(field)); });
                     dateFields = collectMatchFieldsByCondition(executedQuery, function (_field, condition) { return isDateCondition(condition); });
@@ -3012,36 +3092,36 @@ function executeAiAssistantMongoRead(payload, context) {
                         nameFields: nameFields.length ? nameFields : undefined,
                         dateFields: dateFields.length ? dateFields : undefined
                     };
-                    _s.label = 44;
-                case 44:
-                    _s.trys.push([44, 49, , 50]);
-                    if (!nameFields.length) return [3 /*break*/, 46];
+                    _s.label = 46;
+                case 46:
+                    _s.trys.push([46, 51, , 52]);
+                    if (!nameFields.length) return [3 /*break*/, 48];
                     queryNoName = stripMatchFields(executedQuery, nameFields);
                     _g = diagnostics;
                     return [4 /*yield*/, db.collection(collection).countDocuments(queryNoName, {
                             readPreference: AI_ASSISTANT_READ_PREFERENCE
                         })];
-                case 45:
+                case 47:
                     _g.recentCount = _s.sent();
-                    _s.label = 46;
-                case 46:
-                    if (!dateFields.length) return [3 /*break*/, 48];
+                    _s.label = 48;
+                case 48:
+                    if (!dateFields.length) return [3 /*break*/, 50];
                     queryNoDate = stripMatchFields(executedQuery, dateFields);
                     _h = diagnostics;
                     return [4 /*yield*/, db.collection(collection).countDocuments(queryNoDate, {
                             readPreference: AI_ASSISTANT_READ_PREFERENCE
                         })];
-                case 47:
-                    _h.nameMatchCount = _s.sent();
-                    _s.label = 48;
-                case 48: return [3 /*break*/, 50];
                 case 49:
+                    _h.nameMatchCount = _s.sent();
+                    _s.label = 50;
+                case 50: return [3 /*break*/, 52];
+                case 51:
                     _j = _s.sent();
-                    return [3 /*break*/, 50];
-                case 50:
-                    _s.trys.push([50, 53, , 54]);
+                    return [3 /*break*/, 52];
+                case 52:
+                    _s.trys.push([52, 55, , 56]);
                     _k = probeDocs;
-                    if (_k) return [3 /*break*/, 52];
+                    if (_k) return [3 /*break*/, 54];
                     return [4 /*yield*/, fetchAssistantProbeDocs({
                             db: db,
                             collection: collection,
@@ -3050,56 +3130,56 @@ function executeAiAssistantMongoRead(payload, context) {
                             isSuperAdmin: isSuperAdmin,
                             includeClientScope: shouldScopeByClient
                         })];
-                case 51:
+                case 53:
                     _k = (_s.sent());
-                    _s.label = 52;
-                case 52:
+                    _s.label = 54;
+                case 54:
                     probeDocs = _k;
                     if (probeDocs.length && nameFields.length) {
                         diagnostics.chemicalIdDetected = detectChemicalIdFromProbe(probeDocs, nameFields);
                     }
-                    return [3 /*break*/, 54];
-                case 53:
+                    return [3 /*break*/, 56];
+                case 55:
                     _l = _s.sent();
-                    return [3 /*break*/, 54];
-                case 54:
-                    _s.trys.push([54, 58, , 59]);
+                    return [3 /*break*/, 56];
+                case 56:
+                    _s.trys.push([56, 60, , 61]);
                     return [4 /*yield*/, listAssistantCollections(db, dbName)];
-                case 55:
+                case 57:
                     allCollections = _s.sent();
                     base = stripVersionSuffix(collection.startsWith('report-') ? collection.slice('report-'.length) : collection);
                     alt = collection.startsWith('report-') ? base : "report-".concat(base);
-                    if (!(alt && alt !== collection && allCollections.includes(alt))) return [3 /*break*/, 57];
+                    if (!(alt && alt !== collection && allCollections.includes(alt))) return [3 /*break*/, 59];
                     return [4 /*yield*/, db.collection(alt).countDocuments({}, { readPreference: AI_ASSISTANT_READ_PREFERENCE })];
-                case 56:
+                case 58:
                     altCount = _s.sent();
                     diagnostics.alternateCollection = alt;
                     diagnostics.alternateCollectionCount = altCount;
-                    _s.label = 57;
-                case 57: return [3 /*break*/, 59];
-                case 58:
+                    _s.label = 59;
+                case 59: return [3 /*break*/, 61];
+                case 60:
                     _m = _s.sent();
-                    return [3 /*break*/, 59];
-                case 59:
+                    return [3 /*break*/, 61];
+                case 61:
                     fallbackMeta.zeroDiagnostics = diagnostics;
-                    _s.label = 60;
-                case 60:
+                    _s.label = 62;
+                case 62:
                     total = null;
-                    if (!normalized.includeTotal) return [3 /*break*/, 62];
+                    if (!normalized.includeTotal) return [3 /*break*/, 64];
                     return [4 /*yield*/, db.collection(collection).countDocuments(executedQuery, { readPreference: AI_ASSISTANT_READ_PREFERENCE })];
-                case 61:
+                case 63:
                     total = _s.sent();
-                    _s.label = 62;
-                case 62:
+                    _s.label = 64;
+                case 64:
                     sanitizedDocuments = isSuperAdmin
                         ? documents
                         : documents.map(function (doc) { return redactSensitiveFields((0, common_1.deepCopy)(doc)); });
                     requestedFields = resolveProjectionRequestedFields(findOptions.projection);
-                    if (!(sanitizedDocuments.length && requestedFields.length)) return [3 /*break*/, 66];
+                    if (!(sanitizedDocuments.length && requestedFields.length)) return [3 /*break*/, 68];
                     missingFields = requestedFields.filter(function (field) { return !hasNonEmptyValue(sanitizedDocuments, field, { treatObjectLikeAsEmpty: true }); });
-                    if (!missingFields.length) return [3 /*break*/, 66];
+                    if (!missingFields.length) return [3 /*break*/, 68];
                     _o = probeDocs;
-                    if (_o) return [3 /*break*/, 64];
+                    if (_o) return [3 /*break*/, 66];
                     return [4 /*yield*/, fetchAssistantProbeDocs({
                             db: db,
                             collection: collection,
@@ -3108,25 +3188,25 @@ function executeAiAssistantMongoRead(payload, context) {
                             isSuperAdmin: isSuperAdmin,
                             includeClientScope: shouldScopeByClient
                         })];
-                case 63:
+                case 65:
                     _o = (_s.sent());
-                    _s.label = 64;
-                case 64:
+                    _s.label = 66;
+                case 66:
                     probeDocs = _o;
-                    if (!probeDocs.length) return [3 /*break*/, 66];
+                    if (!probeDocs.length) return [3 /*break*/, 68];
                     projectionAliases = resolveFieldAliases(probeDocs, missingFields, schemaFields);
-                    if (!Object.keys(projectionAliases).length) return [3 /*break*/, 66];
+                    if (!Object.keys(projectionAliases).length) return [3 /*break*/, 68];
                     fallbackMeta.projectionAliases = {
                         aliases: projectionAliases,
                         attempted: true,
                         used: false
                     };
                     expandedProjection = expandProjectionWithAliases(findOptions.projection, projectionAliases);
-                    if (!(expandedProjection && expandedProjection !== findOptions.projection)) return [3 /*break*/, 66];
+                    if (!(expandedProjection && expandedProjection !== findOptions.projection)) return [3 /*break*/, 68];
                     findOptions = __assign(__assign({}, findOptions), { projection: expandedProjection });
                     normalized.findOptions.projection = expandedProjection;
                     return [4 /*yield*/, db.collection(collection).find(executedQuery, findOptions).toArray()];
-                case 65:
+                case 67:
                     refreshedDocs = _s.sent();
                     if (refreshedDocs.length) {
                         documents = refreshedDocs;
@@ -3135,8 +3215,8 @@ function executeAiAssistantMongoRead(payload, context) {
                             : refreshedDocs.map(function (doc) { return redactSensitiveFields((0, common_1.deepCopy)(doc)); });
                         fallbackMeta.projectionAliases.used = true;
                     }
-                    _s.label = 66;
-                case 66:
+                    _s.label = 68;
+                case 68:
                     includeIds = ((_r = input.options) === null || _r === void 0 ? void 0 : _r.includeIds) === true;
                     fieldAliases = resolveFieldAliases(sanitizedDocuments, requestedFields, schemaFields);
                     displayDocs = Object.keys(fieldAliases).length
@@ -3151,7 +3231,7 @@ function executeAiAssistantMongoRead(payload, context) {
                             idCustomer: customerId,
                             isSuperAdmin: isSuperAdmin
                         })];
-                case 67:
+                case 69:
                     idLookupDisplay = _s.sent();
                     if (idLookupDisplay === null || idLookupDisplay === void 0 ? void 0 : idLookupDisplay.docs) {
                         displayDocs = idLookupDisplay.docs;
@@ -3308,7 +3388,7 @@ function executeAiAssistantMongoAggregate(payload, context) {
                     }
                     aggregateOptions = __assign(__assign({}, normalizedOptions.aggregateOptions), { readPreference: AI_ASSISTANT_READ_PREFERENCE });
                     runAggregateWithRepair = function (pipeline, stage) { return __awaiter(_this, void 0, void 0, function () {
-                        var docs, error_7, isDateRepair, isRankSortByRepair, repaired, docs;
+                        var docs, error_7, isDateRepair, isRankSortByRepair, isDottedOutputFieldRepair, repaired, docs;
                         return __generator(this, function (_a) {
                             switch (_a.label) {
                                 case 0:
@@ -3323,12 +3403,15 @@ function executeAiAssistantMongoAggregate(payload, context) {
                                     error_7 = _a.sent();
                                     isDateRepair = isAssistantDateArithmeticArgumentError(error_7);
                                     isRankSortByRepair = isAssistantRankSortByError(error_7);
-                                    if (!isDateRepair && !isRankSortByRepair) {
+                                    isDottedOutputFieldRepair = isAssistantDottedOutputFieldError(error_7);
+                                    if (!isDateRepair && !isRankSortByRepair && !isDottedOutputFieldRepair) {
                                         throw error_7;
                                     }
                                     repaired = isDateRepair
                                         ? repairAssistantDateArithmeticInPipeline(pipeline)
-                                        : repairAssistantRankSortByInPipeline(pipeline);
+                                        : isRankSortByRepair
+                                            ? repairAssistantRankSortByInPipeline(pipeline)
+                                            : repairAssistantDottedOutputFieldNamesInPipeline(pipeline);
                                     if (!repaired.changed || containsForbiddenMongoOperators(repaired.pipeline)) {
                                         throw error_7;
                                     }
@@ -3353,6 +3436,14 @@ function executeAiAssistantMongoAggregate(payload, context) {
                                             reason: 'normalized_rank_sortby_single_key'
                                         };
                                     }
+                                    if (isDottedOutputFieldRepair) {
+                                        fallbackMeta.outputFieldPath = {
+                                            attempted: true,
+                                            used: true,
+                                            stage: stage,
+                                            reason: 'normalized_dotted_output_field_names'
+                                        };
+                                    }
                                     return [2 /*return*/, { documents: docs, pipeline: repaired.pipeline }];
                                 case 4: return [2 /*return*/];
                             }
@@ -8427,31 +8518,127 @@ function ensureAssistantMinimumDisplayColumns(display) {
         : rows.length;
     return __assign(__assign({}, display), { columns: [primary, 'Count'], rows: [(_a = {}, _a[primary] = uniqueLabels[0], _a.Count = totalCount, _a)], rowCount: 1, truncated: false });
 }
+function resolveAssistantDisplayTemporalLabelHint(value) {
+    var text = normalizeOptionalString(value).toLowerCase();
+    if (!text) {
+        return '';
+    }
+    var explicitCustomerGrouping = /\b(?:by|per)\s+(?:each\s+)?customer\b/.test(text)
+        || /\bcustomer\s+breakdown\b/.test(text)
+        || /\brevenue\s+by\s+customer\b/.test(text);
+    if (explicitCustomerGrouping) {
+        return 'Customer';
+    }
+    if (/\b(year|yearly|per year|by year)\b/.test(text)) {
+        return 'Year';
+    }
+    if (/\b(quarter|quarterly|per quarter|by quarter)\b/.test(text)) {
+        return 'Quarter';
+    }
+    if (/\b(month|monthly|per month|by month)\b/.test(text)) {
+        return 'Month';
+    }
+    if (/\b(week|weekly|per week|by week)\b/.test(text)) {
+        return 'Week';
+    }
+    if (/\b(day|daily|per day|by day|date)\b/.test(text)) {
+        return 'Day';
+    }
+    if (/\b(customer|client)\b/.test(text)) {
+        return 'Customer';
+    }
+    return '';
+}
+function renameAssistantDisplayColumn(display, fromColumn, toColumn) {
+    var from = normalizeOptionalString(fromColumn);
+    var to = normalizeOptionalString(toColumn);
+    if (!from || !to || from === to || !Array.isArray(display === null || display === void 0 ? void 0 : display.columns)) {
+        return display;
+    }
+    var index = display.columns.findIndex(function (column) { return normalizeOptionalString(column).toLowerCase() === from.toLowerCase(); });
+    if (index === -1) {
+        return display;
+    }
+    var sourceColumn = display.columns[index];
+    var columns = __spreadArray([], __read(display.columns), false);
+    columns[index] = to;
+    var rows = Array.isArray(display.rows)
+        ? display.rows.map(function (row) {
+            var next = __assign({}, (row || {}));
+            if (Object.prototype.hasOwnProperty.call(next, sourceColumn) && !Object.prototype.hasOwnProperty.call(next, to)) {
+                next[to] = next[sourceColumn];
+                delete next[sourceColumn];
+            }
+            return next;
+        })
+        : [];
+    return __assign(__assign({}, display), { columns: columns, rows: rows });
+}
+function applyAssistantDisplayColumnHints(value, display) {
+    if (!display || !Array.isArray(display.columns) || !display.columns.length) {
+        return display;
+    }
+    var firstColumn = normalizeOptionalString(display.columns[0]).toLowerCase();
+    if (firstColumn !== 'group' && firstColumn !== 'result') {
+        return display;
+    }
+    var labelHint = resolveAssistantDisplayTemporalLabelHint(value);
+    if (!labelHint) {
+        return display;
+    }
+    return renameAssistantDisplayColumn(display, display.columns[0], labelHint);
+}
+function resolveAssistantEmptyDisplayColumns(value) {
+    var labelHint = resolveAssistantDisplayTemporalLabelHint(value);
+    if (labelHint) {
+        if (labelHint === 'Customer') {
+            var requestedMonths = resolveAssistantRequestedMonthBucketsFromMessage(value);
+            if (requestedMonths.length >= 3) {
+                return __spreadArray([labelHint], __read(requestedMonths), false);
+            }
+            var looseMonthMatch = value.match(/\b(?:last|past|previous|over\s+the\s+last)\s+(\d+)\s+(?:full\s+calendar\s+|calendar\s+|full\s+)?months?\b/i);
+            var looseMonthCount = (looseMonthMatch === null || looseMonthMatch === void 0 ? void 0 : looseMonthMatch[1]) ? Number(looseMonthMatch[1]) : Number.NaN;
+            if (Number.isFinite(looseMonthCount) && looseMonthCount > 0) {
+                var inferred = buildAssistantExpectedMonthBuckets((0, common_1.round)(looseMonthCount), 'full_month');
+                if (inferred.length >= 3) {
+                    return __spreadArray([labelHint], __read(inferred), false);
+                }
+            }
+            return [labelHint, 'Details'];
+        }
+        return [labelHint, 'Total Revenue'];
+    }
+    if (hasAssistantDeliveryAliasTerms(value)) {
+        return ['Delivery', 'Details'];
+    }
+    return ['Result', 'Details'];
+}
 function applyAssistantDisplayTableToResponse(value, display) {
+    var _a;
     if (!display || !Array.isArray(display.rows)) {
         return value;
     }
-    var normalizedDisplay = ensureAssistantMinimumDisplayColumns(display);
+    var normalizedDisplay = applyAssistantDisplayColumnHints(value, ensureAssistantMinimumDisplayColumns(display));
     if (!display.rows.length) {
         var cleaned_1 = stripAssistantMarkdownTables(value);
         var rowCount = typeof normalizedDisplay.rowCount === 'number' && normalizedDisplay.rowCount > 0
             ? normalizedDisplay.rowCount
             : 0;
-        var tableDisplay = rowCount > 0
-            ? {
-                columns: ['Metric', 'Value'],
-                rows: [{ Metric: 'Rows matched', Value: rowCount }],
-                rowCount: 1,
-                truncated: false,
-                includeIds: false
-            }
-            : {
-                columns: ['Result', 'Details'],
-                rows: [{ Result: 'No matching rows', Details: '' }],
-                rowCount: 0,
-                truncated: false,
-                includeIds: false
-            };
+        var fallbackColumns = Array.isArray(normalizedDisplay.columns) && normalizedDisplay.columns.length
+            ? normalizedDisplay.columns
+            : resolveAssistantEmptyDisplayColumns(cleaned_1 || value);
+        var normalizedColumns = fallbackColumns.length === 1
+            ? __spreadArray(__spreadArray([], __read(fallbackColumns), false), ['Value'], false) : fallbackColumns;
+        var rowSummary = rowCount > 0
+            ? [(_a = {}, _a[normalizedColumns[0]] = 'Rows matched', _a[normalizedColumns[1]] = rowCount, _a)]
+            : [];
+        var tableDisplay = {
+            columns: normalizedColumns,
+            rows: rowSummary,
+            rowCount: rowCount,
+            truncated: false,
+            includeIds: false
+        };
         var emptyTable = formatDisplayTableMarkdown(tableDisplay);
         if (!emptyTable) {
             return cleaned_1 || value;
@@ -9226,10 +9413,63 @@ function normalizeAssistantDateArithmeticArgs(expression) {
         }
         expression.$let = nextArgs;
     };
+    var normalizeDatePartArgs = function () {
+        var operators = ['$year', '$month', '$week', '$isoWeek', '$isoWeekYear', '$dayOfMonth', '$dayOfYear'];
+        var looksLikeDateOperand = function (candidate) {
+            if (candidate instanceof Date) {
+                return true;
+            }
+            if (typeof candidate === 'string') {
+                return candidate.startsWith('$$') || candidate.startsWith('$');
+            }
+            if (candidate && typeof candidate === 'object' && !Array.isArray(candidate)) {
+                return Object.keys(candidate).some(function (op) { return op.startsWith('$'); });
+            }
+            return false;
+        };
+        operators.forEach(function (operator) {
+            if (!Object.prototype.hasOwnProperty.call(expression, operator)) {
+                return;
+            }
+            var rawArgs = expression[operator];
+            if (!rawArgs || typeof rawArgs !== 'object' || Array.isArray(rawArgs)) {
+                return;
+            }
+            if (rawArgs instanceof Date || rawArgs instanceof RegExp || isMongoObjectId(rawArgs)) {
+                return;
+            }
+            var nextArgs = __assign({}, rawArgs);
+            if (!Object.prototype.hasOwnProperty.call(nextArgs, 'date')) {
+                var dateCandidateKey = Object.keys(nextArgs).find(function (key) {
+                    if (key === 'timezone') {
+                        return false;
+                    }
+                    return looksLikeDateOperand(nextArgs[key]);
+                });
+                if (dateCandidateKey) {
+                    nextArgs.date = nextArgs[dateCandidateKey];
+                    delete nextArgs[dateCandidateKey];
+                }
+            }
+            if (!Object.prototype.hasOwnProperty.call(nextArgs, 'date')) {
+                return;
+            }
+            var allowedKeys = new Set(['date', 'timezone']);
+            Object.keys(nextArgs).forEach(function (key) {
+                if (!allowedKeys.has(key)) {
+                    delete nextArgs[key];
+                }
+            });
+            expression[operator] = Object.prototype.hasOwnProperty.call(nextArgs, 'timezone')
+                ? nextArgs
+                : nextArgs.date;
+        });
+    };
     normalizeOperatorArgs('$dateAdd');
     normalizeOperatorArgs('$dateSubtract');
     normalizeDateTruncArgs();
     normalizeLetArgs();
+    normalizeDatePartArgs();
     return expression;
 }
 function normalizeAssistantNowExprPlaceholdersDeep(value) {
@@ -9262,6 +9502,13 @@ function isAssistantDateArithmeticArgumentError(error) {
     return message.includes('unrecognized argument to $datesubtract:')
         || message.includes('unrecognized argument to $dateadd:')
         || message.includes('unrecognized argument to $datetrunc:')
+        || message.includes('unrecognized option to $year:')
+        || message.includes('unrecognized option to $month:')
+        || message.includes('unrecognized option to $week:')
+        || message.includes('unrecognized option to $isoweek:')
+        || message.includes('unrecognized option to $isoweekyear:')
+        || message.includes('unrecognized option to $dayofmonth:')
+        || message.includes('unrecognized option to $dayofyear:')
         || message.includes('unrecognized parameter to $let:')
         || message.includes("missing 'in' parameter to $let")
         || message.includes("missing 'unit' parameter to $datetrunc")
@@ -9295,6 +9542,13 @@ function isAssistantRankSortByError(error) {
     return message.includes('$rank must be specified with a top level sortby expression with exactly one element')
         || message.includes('$denserank must be specified with a top level sortby expression with exactly one element');
 }
+function isAssistantDottedOutputFieldError(error) {
+    var message = normalizeOptionalString(error === null || error === void 0 ? void 0 : error.message).toLowerCase();
+    if (!message) {
+        return false;
+    }
+    return message.includes("fieldpath field names may not contain '.'");
+}
 function didAssistantValueChange(before, after) {
     try {
         return JSON.stringify(before) !== JSON.stringify(after);
@@ -9340,6 +9594,49 @@ function repairAssistantRankSortByInPipeline(pipeline) {
         changed: didAssistantValueChange(pipeline, repaired)
     };
 }
+function repairAssistantDottedOutputFieldNamesInPipeline(pipeline) {
+    var rewriteStageOutputFields = function (value) {
+        if (Array.isArray(value)) {
+            return value.map(function (entry) { return rewriteStageOutputFields(entry); });
+        }
+        if (!value || typeof value !== 'object' || value instanceof Date || value instanceof RegExp || isMongoObjectId(value)) {
+            return value;
+        }
+        var next = {};
+        Object.keys(value).forEach(function (field) {
+            var safeField = field.startsWith('$') || field === '_id'
+                ? field
+                : field.replace(/\./g, '_');
+            next[safeField] = rewriteStageOutputFields(value[field]);
+        });
+        return next;
+    };
+    var repaired = Array.isArray(pipeline)
+        ? pipeline.map(function (stage) {
+            if (!stage || typeof stage !== 'object' || Array.isArray(stage)) {
+                return stage;
+            }
+            var next = __assign({}, stage);
+            if (stage.$project && typeof stage.$project === 'object' && !Array.isArray(stage.$project)) {
+                next.$project = rewriteStageOutputFields(stage.$project);
+            }
+            if (stage.$addFields && typeof stage.$addFields === 'object' && !Array.isArray(stage.$addFields)) {
+                next.$addFields = rewriteStageOutputFields(stage.$addFields);
+            }
+            if (stage.$set && typeof stage.$set === 'object' && !Array.isArray(stage.$set)) {
+                next.$set = rewriteStageOutputFields(stage.$set);
+            }
+            if (stage.$group && typeof stage.$group === 'object' && !Array.isArray(stage.$group)) {
+                next.$group = rewriteStageOutputFields(stage.$group);
+            }
+            return next;
+        })
+        : pipeline;
+    return {
+        pipeline: repaired,
+        changed: didAssistantValueChange(pipeline, repaired)
+    };
+}
 function isMatchExpressionOperand(value) {
     if (typeof value === 'string') {
         return value.startsWith('$$');
@@ -10964,12 +11261,22 @@ function collectAssistantActiveMatchFields(query) {
     var fields = collectMatchFieldsByCondition(query, function (field, condition) { return isAssistantActiveFieldPath(field) && isAssistantActiveCondition(condition); });
     return Array.from(new Set(fields));
 }
-function resolveReadActiveStatusFallback(query, probeDocs) {
+function resolveReadActiveStatusFallback(query, probeDocs, schemaFields) {
+    var _a;
     var fields = collectAssistantActiveMatchFields(query);
-    if (!fields.length || !Array.isArray(probeDocs) || !probeDocs.length) {
+    var hasProbeDocs = Array.isArray(probeDocs) && probeDocs.length > 0;
+    var normalizedSchemaFields = Array.isArray(schemaFields)
+        ? new Set(schemaFields
+            .map(function (field) { return normalizeOptionalString(field).toLowerCase(); })
+            .filter(Boolean)
+            .map(function (field) { return field.split('.').pop() || field; }))
+        : new Set();
+    if (!fields.length || (!hasProbeDocs && !normalizedSchemaFields.size)) {
         return null;
     }
-    var hasAnyFieldData = fields.some(function (field) { return hasNonEmptyValue(probeDocs, field, { treatObjectLikeAsEmpty: true }); });
+    var hasAnyFieldData = hasProbeDocs
+        ? fields.some(function (field) { return hasNonEmptyValue(probeDocs, field, { treatObjectLikeAsEmpty: true }); })
+        : false;
     if (hasAnyFieldData) {
         return null;
     }
@@ -10977,6 +11284,38 @@ function resolveReadActiveStatusFallback(query, probeDocs) {
     if (!stripped.changed || !stripped.value || typeof stripped.value !== 'object') {
         return null;
     }
+    var fallbackActiveCandidates = [
+        { field: 'status', condition: { $regex: '^active$', $options: 'i' } },
+        { field: 'state', condition: { $regex: '^active$', $options: 'i' } },
+        { field: 'active', condition: true },
+        { field: 'is_active', condition: true },
+        { field: 'isactive', condition: true },
+        { field: 'enabled', condition: true },
+        { field: 'is_enabled', condition: true },
+        { field: 'isenabled', condition: true }
+    ].filter(function (entry) {
+        if (!entry.field || fields.includes(entry.field)) {
+            return false;
+        }
+        var hasProbeData = hasProbeDocs
+            ? hasNonEmptyValue(probeDocs, entry.field, { treatObjectLikeAsEmpty: true })
+            : false;
+        return hasProbeData || normalizedSchemaFields.has(entry.field);
+    });
+    if (fallbackActiveCandidates.length) {
+        var activeMatch = fallbackActiveCandidates.length === 1
+            ? (_a = {}, _a[fallbackActiveCandidates[0].field] = fallbackActiveCandidates[0].condition, _a) : { $or: fallbackActiveCandidates.map(function (entry) {
+                var _a;
+                return (_a = {}, _a[entry.field] = entry.condition, _a);
+            }) };
+        var baseQuery = stripped.value;
+        return {
+            query: Object.keys(baseQuery).length
+                ? { $and: [baseQuery, activeMatch] }
+                : activeMatch,
+            fields: __spreadArray(__spreadArray([], __read(fields), false), __read(fallbackActiveCandidates.map(function (entry) { return entry.field; })), false)
+        };
+    }
     return {
         query: stripped.value,
         fields: fields
@@ -12185,6 +12524,62 @@ function mergeAssistantHintValues() {
     });
     return result;
 }
+function hasAssistantDeliveryAliasTerms(value) {
+    var normalized = normalizeOptionalString(value).toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    return /\b(deliver(?:y|ies)|dispatch|driver|bols?|bills?\s+of\s+lading|pso(?:s)?|production\s+sales\s+orders?|sales\s+orders?|truck[\s_-]+treat(?:ing)?|treater[\s_-]+truck|batch[\s_-]+(?:treat(?:ing)?|jobs?)|specialty[\s_-]+jobs?|continuous|ats|automated[\s_-]+treatment[\s_-]+system|isotanks?|chemical[\s_-]+trailers?|vac[\s_-]+trucks?|assets?|treatment[\s_-]+plans?|treatments?)\b/i.test(normalized);
+}
+function hasAssistantDeliveryAliasPathTerms(value) {
+    var normalized = normalizeOptionalString(value).toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    return /\b(deliver(?:y|ies)?|route|dispatch|driver|bols?|bills?[-_/ ]?of[-_/ ]?lading|pso(?:s)?|production[-_/ ]?sales[-_/ ]?orders?|sales[-_/ ]?orders?|truck[-_/ ]?treat(?:ing)?|treater[-_/ ]?truck|batch[-_/ ]?(?:treat(?:ing)?|jobs?)|specialty[-_/ ]?jobs?|continuous|ats|automated[-_/ ]?treatment[-_/ ]?system|isotanks?|chemical[-_/ ]?trailers?|vac[-_/ ]?trucks?|assets?|treatment[-_/ ]?plans?|treatments?)\b/i.test(normalized);
+}
+function hasAssistantPurchaseOrderAliasTerms(value) {
+    var normalized = normalizeOptionalString(value).toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    return /\b(po(?:s)?|purchase[\s_-]+orders?)\b/i.test(normalized);
+}
+function hasAssistantPurchaseOrderAliasPathTerms(value) {
+    var normalized = normalizeOptionalString(value).toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    return /\b(po(?:s)?|purchase[-_/ ]?orders?)\b/i.test(normalized);
+}
+function hasAssistantChemicalCatalogAliasTerms(value) {
+    var normalized = normalizeOptionalString(value).toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    return /\b(chemicals?|products?|items?)\b/i.test(normalized);
+}
+var AI_ASSISTANT_DELIVERY_HINT_CANDIDATES = [
+    'work-order-dynamics',
+    'work-orders',
+    'deliveries',
+    'jobs',
+    'treatments',
+    'treatment-plans',
+    'assets',
+    'orders'
+];
+var AI_ASSISTANT_PURCHASE_HINT_CANDIDATES = [
+    'orders',
+    'purchase-orders'
+];
+var AI_ASSISTANT_CHEMICAL_HINT_CANDIDATES = [
+    'chemicals',
+    'products',
+    'items',
+    'inventory',
+    'blends'
+];
 function resolveCollectionHintsFromRoute(route, collectionNames) {
     var normalizedRoute = normalizeOptionalString(route);
     if (!normalizedRoute || !collectionNames.length) {
@@ -12233,6 +12628,15 @@ function resolveAssistantDefaultCollectionHints(message) {
     if (/\busers?\b/.test(text)) {
         push('users');
     }
+    if (hasAssistantDeliveryAliasTerms(text)) {
+        AI_ASSISTANT_DELIVERY_HINT_CANDIDATES.forEach(push);
+    }
+    if (hasAssistantPurchaseOrderAliasTerms(text)) {
+        AI_ASSISTANT_PURCHASE_HINT_CANDIDATES.forEach(push);
+    }
+    if (hasAssistantChemicalCatalogAliasTerms(text)) {
+        AI_ASSISTANT_CHEMICAL_HINT_CANDIDATES.forEach(push);
+    }
     return hints;
 }
 function buildCollectionRankingDebugFromTokens(tokens, collectionNames, max) {
@@ -12495,7 +12899,7 @@ function findBestCollectionMatch(requested, collectionNames) {
 }
 function resolveAssistantCollectionName(db, dbName, requested) {
     return __awaiter(this, void 0, void 0, function () {
-        var trimmed, collectionNames, best, candidates;
+        var trimmed, collectionNames, aliasCandidates, matchedAlias, best, candidates;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -12509,6 +12913,11 @@ function resolveAssistantCollectionName(db, dbName, requested) {
                     if (collectionNames.includes(trimmed)) {
                         return [2 /*return*/, { name: trimmed, matched: true, candidates: [], score: 100 }];
                     }
+                    aliasCandidates = resolveAssistantBridgeCollectionAliasCandidates(trimmed);
+                    matchedAlias = aliasCandidates.find(function (candidate) { return collectionNames.includes(candidate); });
+                    if (matchedAlias) {
+                        return [2 /*return*/, { name: matchedAlias, matched: true, candidates: [], score: 95 }];
+                    }
                     best = findBestCollectionMatch(trimmed, collectionNames);
                     if (best && best.score >= 20) {
                         return [2 /*return*/, { name: best.name, matched: true, candidates: [], score: best.score }];
@@ -12526,11 +12935,150 @@ function resolveAssistantCollectionName(db, dbName, requested) {
 }
 var AI_ASSISTANT_BRIDGE_COLLECTION_ALIASES = {
     user: 'users',
+    client: 'customers',
+    clients: 'customers',
+    customer: 'customers',
+    delivery: 'work-order-dynamics',
+    deliveries: 'work-order-dynamics',
+    bol: 'work-order-dynamics',
+    bols: 'work-order-dynamics',
+    billoflading: 'work-order-dynamics',
+    billsoflading: 'work-order-dynamics',
+    pso: 'work-order-dynamics',
+    psos: 'work-order-dynamics',
+    productionsalesorder: 'work-order-dynamics',
+    productionsalesorders: 'work-order-dynamics',
+    salesorder: 'work-order-dynamics',
+    salesorders: 'work-order-dynamics',
+    batchjob: 'jobs',
+    batchjobs: 'jobs',
+    continuous: 'work-order-dynamics',
+    ats: 'work-order-dynamics',
+    automatedtreatmentsystem: 'work-order-dynamics',
+    trucktreat: 'work-order-dynamics',
+    trucktreating: 'work-order-dynamics',
+    treatertruck: 'work-order-dynamics',
+    batchtreat: 'work-order-dynamics',
+    batchtreating: 'work-order-dynamics',
+    specialtyjob: 'work-order-dynamics',
+    specialtyjobs: 'work-order-dynamics',
+    isotank: 'assets',
+    isotanks: 'assets',
+    chemicaltrailer: 'assets',
+    chemicaltrailers: 'assets',
+    vactruck: 'assets',
+    vactrucks: 'assets',
+    asset: 'assets',
+    assets: 'assets',
+    treatmentplan: 'treatment-plans',
+    treatmentplans: 'treatment-plans',
+    treatment: 'treatments',
+    treatments: 'treatments',
+    chemical: 'chemicals',
+    chemicals: 'chemicals',
+    product: 'products',
+    products: 'products',
+    item: 'items',
+    items: 'items',
+    po: 'orders',
+    pos: 'orders',
+    purchaseorder: 'orders',
+    purchaseorders: 'orders',
     supportticket: 'support-tickets',
     supporttickets: 'support-tickets',
     ticket: 'support-tickets',
     tickets: 'support-tickets'
 };
+var AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES = [
+    'work-order-dynamics',
+    'work-orders',
+    'deliveries',
+    'jobs',
+    'treatments',
+    'treatment-plans',
+    'assets',
+    'orders'
+];
+var AI_ASSISTANT_TREATMENT_COLLECTION_ALIAS_CANDIDATES = [
+    'treatments',
+    'treatment-plans',
+    'work-order-dynamics',
+    'work-orders',
+    'jobs',
+    'assets',
+    'orders'
+];
+var AI_ASSISTANT_ASSET_COLLECTION_ALIAS_CANDIDATES = [
+    'assets',
+    'equipment',
+    'trailers',
+    'trucks',
+    'isotanks',
+    'tanks',
+    'work-order-dynamics',
+    'work-orders',
+    'jobs'
+];
+var AI_ASSISTANT_CHEMICAL_COLLECTION_ALIAS_CANDIDATES = [
+    'chemicals',
+    'products',
+    'items',
+    'inventory',
+    'blends',
+    'orders'
+];
+var AI_ASSISTANT_PURCHASE_COLLECTION_ALIAS_CANDIDATES = [
+    'orders',
+    'purchase-orders'
+];
+var AI_ASSISTANT_BRIDGE_COLLECTION_ALIAS_OPTIONS = {
+    delivery: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    deliveries: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    bol: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    bols: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    billoflading: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    billsoflading: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    pso: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    psos: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    productionsalesorder: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    productionsalesorders: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    salesorder: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    salesorders: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    trucktreat: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    trucktreating: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    treatertruck: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    batchtreat: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    batchtreating: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    batchjob: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    batchjobs: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    specialtyjob: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    specialtyjobs: AI_ASSISTANT_DELIVERY_COLLECTION_ALIAS_CANDIDATES,
+    continuous: AI_ASSISTANT_TREATMENT_COLLECTION_ALIAS_CANDIDATES,
+    ats: AI_ASSISTANT_TREATMENT_COLLECTION_ALIAS_CANDIDATES,
+    automatedtreatmentsystem: AI_ASSISTANT_TREATMENT_COLLECTION_ALIAS_CANDIDATES,
+    treatmentplan: AI_ASSISTANT_TREATMENT_COLLECTION_ALIAS_CANDIDATES,
+    treatmentplans: AI_ASSISTANT_TREATMENT_COLLECTION_ALIAS_CANDIDATES,
+    treatment: AI_ASSISTANT_TREATMENT_COLLECTION_ALIAS_CANDIDATES,
+    treatments: AI_ASSISTANT_TREATMENT_COLLECTION_ALIAS_CANDIDATES,
+    asset: AI_ASSISTANT_ASSET_COLLECTION_ALIAS_CANDIDATES,
+    assets: AI_ASSISTANT_ASSET_COLLECTION_ALIAS_CANDIDATES,
+    isotank: AI_ASSISTANT_ASSET_COLLECTION_ALIAS_CANDIDATES,
+    isotanks: AI_ASSISTANT_ASSET_COLLECTION_ALIAS_CANDIDATES,
+    chemicaltrailer: AI_ASSISTANT_ASSET_COLLECTION_ALIAS_CANDIDATES,
+    chemicaltrailers: AI_ASSISTANT_ASSET_COLLECTION_ALIAS_CANDIDATES,
+    vactruck: AI_ASSISTANT_ASSET_COLLECTION_ALIAS_CANDIDATES,
+    vactrucks: AI_ASSISTANT_ASSET_COLLECTION_ALIAS_CANDIDATES,
+    chemical: AI_ASSISTANT_CHEMICAL_COLLECTION_ALIAS_CANDIDATES,
+    chemicals: AI_ASSISTANT_CHEMICAL_COLLECTION_ALIAS_CANDIDATES,
+    product: AI_ASSISTANT_CHEMICAL_COLLECTION_ALIAS_CANDIDATES,
+    products: AI_ASSISTANT_CHEMICAL_COLLECTION_ALIAS_CANDIDATES,
+    item: AI_ASSISTANT_CHEMICAL_COLLECTION_ALIAS_CANDIDATES,
+    items: AI_ASSISTANT_CHEMICAL_COLLECTION_ALIAS_CANDIDATES,
+    po: AI_ASSISTANT_PURCHASE_COLLECTION_ALIAS_CANDIDATES,
+    pos: AI_ASSISTANT_PURCHASE_COLLECTION_ALIAS_CANDIDATES,
+    purchaseorder: AI_ASSISTANT_PURCHASE_COLLECTION_ALIAS_CANDIDATES,
+    purchaseorders: AI_ASSISTANT_PURCHASE_COLLECTION_ALIAS_CANDIDATES
+};
 var AI_ASSISTANT_DIRECT_COLLECTION_FALLBACK_ALLOWLIST = new Set([]);
 var AI_ASSISTANT_SUPPORT_COLLECTION_FALLBACKS = [
     'support-tickets',
@@ -12597,9 +13145,8 @@ function resolveAssistantCrossCollectionFallbackCandidates(collection) {
         }
         candidates.add(candidate);
     };
-    var alias = resolveAssistantBridgeCollectionAlias(normalized)
-        || resolveAssistantBridgeCollectionAlias(normalizeCollectionKey(normalized));
-    addCandidate(alias);
+    var aliasCandidates = mergeAssistantHintValues(resolveAssistantBridgeCollectionAliasCandidates(normalized), resolveAssistantBridgeCollectionAliasCandidates(normalizeCollectionKey(normalized)));
+    aliasCandidates.forEach(addCandidate);
     if (AI_ASSISTANT_SUPPORT_COLLECTION_FALLBACKS.includes(normalized)
         || normalized.includes('ticket')
         || normalized.includes('support')) {
@@ -12916,10 +13463,7 @@ function resolveAssistantNestedPrefixCollectionCandidates(params) {
         }
         candidates.push(preferred);
     };
-    var alias = resolveAssistantBridgeCollectionAlias(normalizedPrefix);
-    if (alias) {
-        push(alias);
-    }
+    resolveAssistantBridgeCollectionAliasCandidates(normalizedPrefix).forEach(push);
     push(normalizedPrefix);
     resolveAssistantAvailableCrossCollectionFallbacksFromNames(normalizedPrefix, params.triedCollections, params.collectionNames).forEach(push);
     var tokenizedPrefix = tokenizeCollectionText(normalizedPrefix);
@@ -13007,9 +13551,25 @@ function resolveAssistantNestedAggregateFallbacks(params) {
         });
     });
 }
-function resolveAssistantBridgeCollectionAlias(value) {
+function resolveAssistantBridgeCollectionAliasCandidates(value) {
     var key = normalizeCollectionKey(value);
-    return AI_ASSISTANT_BRIDGE_COLLECTION_ALIASES[key] || '';
+    if (!key) {
+        return [];
+    }
+    var candidates = [];
+    var push = function (candidate) {
+        var normalized = normalizeOptionalString(candidate);
+        if (!normalized || candidates.includes(normalized)) {
+            return;
+        }
+        candidates.push(normalized);
+    };
+    var aliasOptions = AI_ASSISTANT_BRIDGE_COLLECTION_ALIAS_OPTIONS[key];
+    if (Array.isArray(aliasOptions)) {
+        aliasOptions.forEach(push);
+    }
+    push(AI_ASSISTANT_BRIDGE_COLLECTION_ALIASES[key]);
+    return candidates;
 }
 function isAssistantDirectCollectionFallbackAllowed(collection) {
     var normalized = normalizeOptionalString(collection);
@@ -13046,7 +13606,7 @@ function doesAssistantCollectionExistInDb(db, collection) {
 }
 function resolveAssistantReportBuilderBridgeCollection(collection_1, db_1) {
     return __awaiter(this, arguments, void 0, function (collection, db, dbName) {
-        var normalized, alias, manager, hasManager, candidates, pushCandidate, base, reportCandidate, candidates_5, candidates_5_1, candidate, model, resolved, resolvedName, resolvedModel, _a, candidates_6, candidates_6_1, candidate, e_34_1, candidates_7, candidates_7_1, candidate;
+        var normalized, aliasCandidates, alias, manager, hasManager, candidates, pushCandidate, base, reportCandidate, candidates_5, candidates_5_1, candidate, model, resolved, resolvedName, resolvedModel, _a, candidates_6, candidates_6_1, candidate, e_34_1, candidates_7, candidates_7_1, candidate;
         var e_35, _b, e_34, _c, e_36, _d;
         var _e;
         if (dbName === void 0) { dbName = ''; }
@@ -13057,7 +13617,8 @@ function resolveAssistantReportBuilderBridgeCollection(collection_1, db_1) {
                     if (!normalized) {
                         throw new Error('AI assistant report builder bridge: Collection is required.');
                     }
-                    alias = resolveAssistantBridgeCollectionAlias(normalized);
+                    aliasCandidates = resolveAssistantBridgeCollectionAliasCandidates(normalized);
+                    alias = aliasCandidates[0] || '';
                     manager = (_e = resolveio_server_app_1.ResolveIOServer.getMongoManager) === null || _e === void 0 ? void 0 : _e.call(resolveio_server_app_1.ResolveIOServer);
                     hasManager = !!(manager && typeof manager.collection === 'function');
                     candidates = [];
@@ -13069,9 +13630,7 @@ function resolveAssistantReportBuilderBridgeCollection(collection_1, db_1) {
                         candidates.push(value);
                     };
                     pushCandidate(normalized);
-                    if (alias) {
-                        pushCandidate(alias);
-                    }
+                    aliasCandidates.forEach(pushCandidate);
                     base = stripVersionSuffix(normalized.startsWith('report-') ? normalized.slice('report-'.length) : normalized);
                     if (base && base !== normalized) {
                         pushCandidate(base);
@@ -14214,6 +14773,8 @@ function buildAssistantWorkspaceRootCandidates(params) {
     var pathCandidates = [
         serverConfig['AI_ASSISTANT_WORKSPACE_ROOT'],
         env['AI_ASSISTANT_WORKSPACE_ROOT'],
+        serverConfig['AI_ASSISTANT_ROOT_WORKSPACE'],
+        env['AI_ASSISTANT_ROOT_WORKSPACE'],
         serverConfig['AI_TERMINAL_WORKSPACE_ROOT'],
         env['AI_TERMINAL_WORKSPACE_ROOT'],
         serverConfig['AI_DASHBOARD_WORKSPACE_ROOT'],
@@ -15764,16 +16325,16 @@ function resolveAssistantChangeModulesFromText(message) {
     if (/\b(invoice|invoices|invoicing|revenue|billing|payment|payments|paid)\b/i.test(text)) {
         push('invoice');
     }
-    if (/\b(work[\s-]*order|wo)\b/i.test(text)) {
+    if (/\b(work[\s-]*order|wo)\b/i.test(text) || hasAssistantPurchaseOrderAliasTerms(text)) {
         push('work_order');
     }
-    if (/\b(deliver(?:y|ies)|route|dispatch|driver)\b/i.test(text)) {
+    if (/\broute\b/i.test(text) || hasAssistantDeliveryAliasTerms(text)) {
         push('delivery');
     }
     if (/\b(blend|blending)\b/i.test(text)) {
         push('blend');
     }
-    if (/\b(chemical|chemicals)\b/i.test(text)) {
+    if (hasAssistantChemicalCatalogAliasTerms(text)) {
         push('chemical');
     }
     if (/\b(job|jobs)\b/i.test(text)) {
@@ -15801,16 +16362,16 @@ function resolveAssistantChangeModulesFromPath(filePath) {
     if (/\binvoices?\b/.test(normalized)) {
         push('invoice');
     }
-    if (/\bwork[-_/ ]?order|wo[-_/ ]|orders?\b/.test(normalized)) {
+    if (/\bwork[-_/ ]?order|wo[-_/ ]|orders?\b/.test(normalized) || hasAssistantPurchaseOrderAliasPathTerms(normalized)) {
         push('work_order');
     }
-    if (/\bdeliver|route|dispatch|driver\b/.test(normalized)) {
+    if (hasAssistantDeliveryAliasPathTerms(normalized)) {
         push('delivery');
     }
     if (/\bblend\b/.test(normalized)) {
         push('blend');
     }
-    if (/\bchemical\b/.test(normalized)) {
+    if (/\b(chemical|product|item)\b/.test(normalized)) {
         push('chemical');
     }
     if (/\bjobs?\b/.test(normalized)) {
@@ -15842,13 +16403,13 @@ function userHasAssistantChangeModuleAccess(user, module) {
         case 'invoice':
             return userHasInvoiceAccess(user);
         case 'work_order':
-            return userHasViewTokenPermission(user, /work[-_/ ]?order|dispatch|operations|field|delivery|route/i);
+            return userHasViewTokenPermission(user, /work[-_/ ]?order|dispatch|operations|field|delivery|route|bol|pso|sales[-_/ ]?order|purchase[-_/ ]?order|\bpo\b|\bpos\b|continuous|ats|treat(?:ment|ing)|asset/i);
         case 'delivery':
-            return userHasViewTokenPermission(user, /delivery|route|dispatch|work[-_/ ]?order/i);
+            return userHasViewTokenPermission(user, /delivery|route|dispatch|work[-_/ ]?order|bol|pso|sales[-_/ ]?order|truck[-_/ ]?treat(?:ing)?|treater|specialty|batch[-_/ ]?(?:treat(?:ing)?|job)|continuous|ats|automated[-_/ ]?treatment[-_/ ]?system|isotank|chemical[-_/ ]?trailer|vac[-_/ ]?truck|asset|treatment[-_/ ]?plan|treatments?/i);
         case 'blend':
             return userHasViewTokenPermission(user, /blend|chemical|mix/i);
         case 'chemical':
-            return userHasViewTokenPermission(user, /chemical|blend/i);
+            return userHasViewTokenPermission(user, /chemical|blend|product|item|inventory/i);
         case 'job':
             return userHasViewTokenPermission(user, /job|work[-_/ ]?order/i);
         case 'portal':