@resolveio/server-lib 22.0.4 → 22.0.5

package/methods/ai-terminal.js

@@ -159,6 +159,10 @@ var AI_ASSISTANT_COLLECTION_OVERRIDE_MIN_SCORE = 20;
 var AI_ASSISTANT_ID_LOOKUP_MAX_RESULTS = 20;
 var AI_ASSISTANT_ID_LOOKUP_CANDIDATE_LIMIT = 4;
 var AI_ASSISTANT_NAME_MATCH_FALLBACK_MAX_FIELDS = 12;
+var AI_ASSISTANT_CONTEXT_MAX_COLLECTIONS = 3;
+var AI_ASSISTANT_CONTEXT_MAX_FIELDS_PER_COLLECTION = 24;
+var AI_ASSISTANT_LOCALE = 'en-US';
+var AI_ASSISTANT_CURRENCY_CODE = 'USD';
 var AI_ASSISTANT_PROGRESS_TICKS = [
     'Grabbing Data',
     'Drafting response'
@@ -277,6 +281,18 @@ var AI_ASSISTANT_COLLECTION_DOMAIN_TOKENS = new Set([
     'chemicals',
     'invoice',
     'invoices',
+    'revenue',
+    'revenues',
+    'sales',
+    'sale',
+    'billing',
+    'billings',
+    'payment',
+    'payments',
+    'paid',
+    'income',
+    'finance',
+    'financial',
     'work',
     'order',
     'orders',
@@ -317,7 +333,11 @@ var AI_ASSISTANT_FIELD_TOKEN_SYNONYMS = {
     batch: ['lot'],
     lot: ['batch'],
     date: ['created', 'createdat', 'created_at', 'date_created', 'updated', 'updatedat', 'updated_at', 'date_updated'],
-    total: ['sum', 'amount', 'total_amount', 'total_quantity']
+    total: ['sum', 'amount', 'total_amount', 'total_quantity'],
+    revenue: ['sales', 'billing', 'paid', 'payment', 'total', 'amount', 'grand', 'subtotal', 'sub_total', 'paid_total', 'grand_total'],
+    sales: ['revenue', 'billing', 'paid', 'payment', 'total', 'amount', 'grand', 'subtotal', 'sub_total'],
+    billing: ['revenue', 'sales', 'paid', 'payment', 'total', 'amount', 'grand', 'subtotal', 'sub_total'],
+    payment: ['paid', 'revenue', 'sales', 'billing', 'total', 'amount']
 };
 var AI_ASSISTANT_ID_LOOKUP_HINTS = {
     customer: ['customers', 'customer-versions'],
@@ -336,6 +356,11 @@ var AI_ASSISTANT_TERM_SYNONYMS = [
         label: 'blend tickets',
         pattern: /\bblend(?:ing)?\s+tickets?\b/i,
         expansions: ['chemical blends', 'chemical-blends', 'report-chemical-blends', 'blend batches']
+    },
+    {
+        label: 'revenue',
+        pattern: /\b(revenue|sales|billing)\b/i,
+        expansions: ['invoice', 'invoices', 'paid invoices', 'invoice payments', 'billing', 'sales']
     }
 ];
 var AI_ASSISTANT_SYSTEM_PROMPT = [
@@ -372,6 +397,7 @@ var AI_ASSISTANT_SYSTEM_PROMPT = [
     '- Output plain Markdown (NO triple backticks).',
     '- When you reference database results, summarize first, then include a Markdown table.',
     '- When presenting record lists or aggregates, produce a Markdown table (pipes).',
+    '- Format currency as $1,234.56 (no USD prefix) with two decimals.',
     '- 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.',
@@ -406,6 +432,8 @@ var AI_ASSISTANT_SYSTEM_PROMPT = [
     '- If you need grouped/aggregated data (totals by user, rankings, trends), end your response with a single line exactly in this format:',
     '- MONGO_AGG: {"collection":"<name>","pipeline":[...],"options":{"allowDiskUse":true,"limit":20},"permissionView":"</route>"}',
     '- For invoice data, set permissionView to an invoice route (ex: /invoice/list or /report/invoice).',
+    '- For revenue/sales/billing questions, use invoices and sum paid_total (fallback to grand_total) with date_paid and Paid/Closed status when available.',
+    '- For relative date ranges (last/past/recent), include an upper bound <= $$NOW unless the user specifies a future end date.',
     '- Keep queries minimal, read-only, and avoid user/credential data unless the user is a super admin.',
     '- Assume you are not a super admin unless explicitly told otherwise.',
     '- Only request data when the user has permission for that module; invoice data requires invoice view access.',
@@ -1168,7 +1196,7 @@ function executeAiAssistantCodexRun(payload, context) {
                     insertResult = _d.sent();
                     assistantMessageId = (insertResult === null || insertResult === void 0 ? void 0 : insertResult._id) || (insertResult === null || insertResult === void 0 ? void 0 : insertResult.insertedId);
                     enqueueAssistantCodexRun(function () { return __awaiter(_this, void 0, void 0, function () {
-                        var runStart, steps, recordStep, progressTracker, streamProgress, assistantContent, toolResult, assistantDebug, directiveSource, dataQuestion, lastDirective, toolResponseDebug, toolError, termHints, collectionHints, collectionTokenization, collectionRanking, collectionSelection, collectionOverride, collectionNames, timingBreakdown, contextRoute, contextMode, hintSeed, termExpansion, hintText, baseTokens, expandedTokens, baseWeights, expandedWeights, dbName, db, _a, assistantContext, prompt_1, workspaceRoot, codexConfig, runOptions, responseText, directiveText, directive, directivePrompt, directiveStart, forcedDirective, _b, initialStart, directivePrompt, forcedStart, forcedDirective, _c, requestedCollection, cleanedResponseText, effectiveDirective, toolRequest, toolStart, toolResponse, _d, toolPayload, followupPrompt, followupStart, followupText, _e, error_2, error_3, finishedAt, finalNow, finishedAt, codexMs, draftingMs, finalMetadata, finalAssistantDoc;
+                        var runStart, steps, recordStep, progressTracker, streamProgress, assistantContent, toolResult, assistantDebug, directiveSource, dataQuestion, lastDirective, toolResponseDebug, toolError, termHints, collectionHints, fieldHints, collectionTokenization, collectionRanking, collectionSelection, collectionOverride, collectionNames, timingBreakdown, contextRoute, contextMode, hintSeed, termExpansion, hintText, baseTokens, expandedTokens, baseWeights, expandedWeights, dbName, db, _a, routeHints, rankedCollections, hintCollections, assistantContext, prompt_1, workspaceRoot, codexConfig, runOptions, responseText, directiveText, directive, directivePrompt, directiveStart, forcedDirective, _b, initialStart, directivePrompt, forcedStart, forcedDirective, _c, requestedCollection, cleanedResponseText, effectiveDirective, toolRequest, toolStart, toolResponse, _d, toolPayload, followupPrompt, followupStart, followupText, _e, error_2, error_3, finishedAt, finalNow, finishedAt, codexMs, draftingMs, finalMetadata, finalAssistantDoc;
                         var _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
                         return __generator(this, function (_u) {
                             switch (_u.label) {
@@ -1206,6 +1234,7 @@ function executeAiAssistantCodexRun(payload, context) {
                                     toolError = null;
                                     termHints = [];
                                     collectionHints = [];
+                                    fieldHints = [];
                                     collectionTokenization = null;
                                     collectionRanking = null;
                                     collectionSelection = null;
@@ -1263,18 +1292,30 @@ function executeAiAssistantCodexRun(payload, context) {
                                         : null);
                                     return [3 /*break*/, 5];
                                 case 5:
+                                    routeHints = resolveCollectionHintsFromRoute(contextRoute, collectionNames);
+                                    if (routeHints.length) {
+                                        collectionHints = mergeAssistantHintValues(routeHints, collectionHints);
+                                    }
+                                    rankedCollections = Array.isArray(collectionRanking === null || collectionRanking === void 0 ? void 0 : collectionRanking.ranked)
+                                        ? collectionRanking === null || collectionRanking === void 0 ? void 0 : collectionRanking.ranked.map(function (entry) { return entry.name; })
+                                        : [];
+                                    hintCollections = mergeAssistantHintValues(collectionHints, rankedCollections)
+                                        .slice(0, AI_ASSISTANT_CONTEXT_MAX_COLLECTIONS);
+                                    fieldHints = buildAssistantFieldHints(message, hintCollections);
                                     recordStep('Planning: collection hints', {
                                         contextRoute: contextRoute || undefined,
                                         contextMode: contextMode || undefined,
                                         collectionHints: collectionHints.length ? collectionHints : undefined,
-                                        termHints: termHints.length ? termHints : undefined
+                                        termHints: termHints.length ? termHints : undefined,
+                                        fieldHints: fieldHints.length ? fieldHints : undefined
                                     });
                                     assistantContext = buildAssistantContext(input, {
                                         isSuperAdmin: isSuperAdmin,
                                         hasInvoiceAccess: hasInvoiceAccess,
                                         customerId: customerId,
                                         collectionHints: collectionHints,
-                                        termHints: termHints
+                                        termHints: termHints,
+                                        fieldHints: fieldHints
                                     });
                                     prompt_1 = buildAssistantCodexPrompt(message, attachmentData.promptText, historyLines.join('\n'), assistantContext);
                                     return [4 /*yield*/, resolveAssistantWorkspaceRoot()];
@@ -1446,6 +1487,7 @@ function executeAiAssistantCodexRun(payload, context) {
                                     followupText = _u.sent();
                                     timingBreakdown.followupMs = Date.now() - followupStart;
                                     assistantContent = sanitizeAssistantResponse(followupText);
+                                    assistantContent = applyAssistantDisplayTableToResponse(assistantContent, toolPayload.result.output.display);
                                     return [3 /*break*/, 25];
                                 case 24:
                                     _e = _u.sent();
@@ -1513,6 +1555,7 @@ function executeAiAssistantCodexRun(payload, context) {
                                                     contextRoute: contextRoute || undefined,
                                                     termHints: termHints.length ? termHints : undefined,
                                                     collectionHints: collectionHints.length ? collectionHints : undefined,
+                                                    fieldHints: fieldHints.length ? fieldHints : undefined,
                                                     collectionTokenization: collectionTokenization || undefined,
                                                     collectionRanking: collectionRanking || undefined,
                                                     collectionSelection: collectionSelection || undefined,
@@ -4402,6 +4445,136 @@ function trimDisplayTable(display, options) {
     }) : [];
     return __assign(__assign({}, display), { columns: columns, rows: rows, truncated: display.truncated || display.columns.length > maxColumns || rowsSource.length > maxRows });
 }
+var assistantCurrencyFormatter = null;
+var assistantNumberFormatter = null;
+var assistantPercentFormatter = null;
+function getAssistantCurrencyFormatter() {
+    if (!assistantCurrencyFormatter) {
+        assistantCurrencyFormatter = new Intl.NumberFormat(AI_ASSISTANT_LOCALE, {
+            style: 'currency',
+            currency: AI_ASSISTANT_CURRENCY_CODE,
+            minimumFractionDigits: 2,
+            maximumFractionDigits: 2
+        });
+    }
+    return assistantCurrencyFormatter;
+}
+function getAssistantNumberFormatter() {
+    if (!assistantNumberFormatter) {
+        assistantNumberFormatter = new Intl.NumberFormat(AI_ASSISTANT_LOCALE, {
+            minimumFractionDigits: 0,
+            maximumFractionDigits: 2
+        });
+    }
+    return assistantNumberFormatter;
+}
+function getAssistantPercentFormatter() {
+    if (!assistantPercentFormatter) {
+        assistantPercentFormatter = new Intl.NumberFormat(AI_ASSISTANT_LOCALE, {
+            style: 'percent',
+            minimumFractionDigits: 0,
+            maximumFractionDigits: 2
+        });
+    }
+    return assistantPercentFormatter;
+}
+function resolveAssistantNumericValue(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        var cleaned = value.replace(/[^0-9.+-]/g, '');
+        if (!cleaned) {
+            return null;
+        }
+        var parsed = Number(cleaned);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function isAssistantPercentColumn(column) {
+    return /(percent|pct|percentage|ratio|rate)\b/.test(column);
+}
+function isAssistantCurrencyColumn(column) {
+    return /(amount|total|price|cost|balance|fee|revenue|invoice|usd|tax|subtotal|paid|billing|sales)\b/.test(column);
+}
+function isAssistantDateColumn(column) {
+    return /(date|time|created|updated|timestamp|at)\b/.test(column);
+}
+function isAssistantLikelyDateValue(value) {
+    if (!value) {
+        return false;
+    }
+    if (value instanceof Date) {
+        return true;
+    }
+    if (typeof value === 'string') {
+        if (!/[0-9]/.test(value)) {
+            return false;
+        }
+        var parsed = Date.parse(value);
+        return !Number.isNaN(parsed);
+    }
+    return false;
+}
+function formatAssistantDateValue(value) {
+    var dateValue = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(dateValue.getTime())) {
+        return String(value);
+    }
+    var iso = dateValue.toISOString();
+    var _a = __read(iso.split('T'), 2), datePart = _a[0], timePart = _a[1];
+    if (!timePart) {
+        return datePart || iso;
+    }
+    var trimmed = timePart.replace('Z', '');
+    if (trimmed.startsWith('00:00:00')) {
+        return datePart;
+    }
+    return "".concat(datePart, " ").concat(trimmed.slice(0, 5));
+}
+function formatAssistantDisplayCell(value, column) {
+    if (value === null || value === undefined || value === '') {
+        return '';
+    }
+    if (Array.isArray(value)) {
+        return value.map(function (item) { return formatAssistantDisplayCell(item, column); }).filter(Boolean).join(', ');
+    }
+    var columnKey = String(column || '').toLowerCase();
+    if (isAssistantDateColumn(columnKey) && isAssistantLikelyDateValue(value)) {
+        return formatAssistantDateValue(value);
+    }
+    var numericValue = resolveAssistantNumericValue(value);
+    if (numericValue !== null) {
+        if (isAssistantPercentColumn(columnKey)) {
+            var percentValue = numericValue > 1 && numericValue <= 100 ? numericValue / 100 : numericValue;
+            try {
+                return getAssistantPercentFormatter().format(percentValue);
+            }
+            catch (_a) {
+                return "".concat((0, common_1.round)(percentValue * 100), "%");
+            }
+        }
+        if (isAssistantCurrencyColumn(columnKey)) {
+            try {
+                return getAssistantCurrencyFormatter().format(numericValue);
+            }
+            catch (_b) {
+                return "$".concat(numericValue.toFixed(2));
+            }
+        }
+        try {
+            return getAssistantNumberFormatter().format(numericValue);
+        }
+        catch (_c) {
+            return String(numericValue);
+        }
+    }
+    if (isAssistantLikelyDateValue(value) && isAssistantDateColumn(columnKey)) {
+        return formatAssistantDateValue(value);
+    }
+    return String(value);
+}
 function formatDisplayTableMarkdown(display) {
     if (!display || !Array.isArray(display.columns) || !display.columns.length) {
         return '';
@@ -4409,11 +4582,38 @@ function formatDisplayTableMarkdown(display) {
     var header = "| ".concat(display.columns.join(' | '), " |");
     var separator = "| ".concat(display.columns.map(function () { return '---'; }).join(' | '), " |");
     var rows = (display.rows || []).map(function (row) {
-        var cells = display.columns.map(function (column) { return escapeMarkdownCell(row === null || row === void 0 ? void 0 : row[column]); });
+        var cells = display.columns.map(function (column) {
+            var rawValue = row === null || row === void 0 ? void 0 : row[column];
+            var formatted = formatAssistantDisplayCell(rawValue, column);
+            return escapeMarkdownCell(formatted);
+        });
         return "| ".concat(cells.join(' | '), " |");
     });
     return __spreadArray([header, separator], __read(rows), false).join('\n').trim();
 }
+function stripAssistantMarkdownTables(value) {
+    var raw = normalizeOptionalString(value);
+    if (!raw) {
+        return '';
+    }
+    var tablePattern = /(^|\n)\|[^\n]*\|\n\|[ \t:-|]+\|\n(?:\|[^\n]*\|\n?)*/g;
+    var cleaned = raw.replace(tablePattern, '\n').trim();
+    return cleaned;
+}
+function applyAssistantDisplayTableToResponse(value, display) {
+    if (!display || !Array.isArray(display.rows) || !display.rows.length) {
+        return value;
+    }
+    var table = formatDisplayTableMarkdown(display);
+    if (!table) {
+        return value;
+    }
+    var cleaned = stripAssistantMarkdownTables(value);
+    if (!cleaned) {
+        return table;
+    }
+    return "".concat(cleaned.trim(), "\n\n").concat(table).trim();
+}
 function escapeMarkdownCell(value) {
     var raw = value === null || value === undefined ? '' : String(value);
     return raw.replace(/\|/g, '\\|').replace(/\r?\n/g, ' ').trim();
@@ -6559,6 +6759,59 @@ function resolveCollectionHintsFromTokens(tokens, collectionNames, max) {
         .slice(0, Math.max(max, 0))
         .map(function (entry) { return entry.name; });
 }
+function mergeAssistantHintValues() {
+    var groups = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        groups[_i] = arguments[_i];
+    }
+    var result = [];
+    var seen = new Set();
+    groups.forEach(function (group) {
+        if (!Array.isArray(group)) {
+            return;
+        }
+        group.forEach(function (value) {
+            var normalized = normalizeOptionalString(value);
+            if (!normalized || seen.has(normalized)) {
+                return;
+            }
+            seen.add(normalized);
+            result.push(normalized);
+        });
+    });
+    return result;
+}
+function resolveCollectionHintsFromRoute(route, collectionNames) {
+    var normalizedRoute = normalizeOptionalString(route);
+    if (!normalizedRoute || !collectionNames.length) {
+        return [];
+    }
+    var parts = normalizedRoute.toLowerCase().split(/[/?#]+/g).filter(Boolean);
+    var hints = [];
+    parts.forEach(function (part) {
+        var cleaned = part.replace(/[^a-z0-9_-]/g, '');
+        if (!cleaned) {
+            return;
+        }
+        var base = cleaned.replace(/^-+|-+$/g, '');
+        if (!base) {
+            return;
+        }
+        if (collectionNames.includes(base)) {
+            hints.push(base);
+        }
+        if (!base.endsWith('s') && collectionNames.includes("".concat(base, "s"))) {
+            hints.push("".concat(base, "s"));
+        }
+        if (collectionNames.includes("report-".concat(base))) {
+            hints.push("report-".concat(base));
+        }
+        if (!base.endsWith('s') && collectionNames.includes("report-".concat(base, "s"))) {
+            hints.push("report-".concat(base, "s"));
+        }
+    });
+    return mergeAssistantHintValues(hints);
+}
 function buildCollectionRankingDebugFromTokens(tokens, collectionNames, max) {
     if (max === void 0) { max = 8; }
     var requestedKey = normalizeCollectionKey(tokens.join('-'));
@@ -7682,31 +7935,164 @@ function pathExists(target) {
         });
     });
 }
-function resolveAssistantWorkspaceRoot() {
+function directoryExists(target) {
+    return __awaiter(this, void 0, void 0, function () {
+        var stat, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, fs_1.promises.stat(target)];
+                case 1:
+                    stat = _b.sent();
+                    return [2 /*return*/, stat.isDirectory()];
+                case 2:
+                    _a = _b.sent();
+                    return [2 /*return*/, false];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+function isAssistantPathUnderRoot(target, root) {
+    if (!target || !root) {
+        return false;
+    }
+    var relative = path.relative(root, target);
+    if (!relative) {
+        return true;
+    }
+    return !relative.startsWith('..') && !path.isAbsolute(relative);
+}
+function isAssistantProjectRoot(candidate) {
     return __awaiter(this, void 0, void 0, function () {
-        var config, configured, candidate, stat, _a;
+        var serverPath, angularPath, _a, hasServer, hasPackage;
         return __generator(this, function (_b) {
             switch (_b.label) {
+                case 0:
+                    if (!candidate) {
+                        return [2 /*return*/, false];
+                    }
+                    return [4 /*yield*/, directoryExists(candidate)];
+                case 1:
+                    if (!(_b.sent())) {
+                        return [2 /*return*/, false];
+                    }
+                    serverPath = path.join(candidate, 'server');
+                    angularPath = path.join(candidate, 'angular');
+                    return [4 /*yield*/, directoryExists(serverPath)];
+                case 2:
+                    _a = (_b.sent());
+                    if (!_a) return [3 /*break*/, 4];
+                    return [4 /*yield*/, directoryExists(angularPath)];
+                case 3:
+                    _a = (_b.sent());
+                    _b.label = 4;
+                case 4:
+                    if (_a) {
+                        return [2 /*return*/, true];
+                    }
+                    return [4 /*yield*/, directoryExists(serverPath)];
+                case 5:
+                    hasServer = _b.sent();
+                    return [4 /*yield*/, pathExists(path.join(candidate, 'package.json'))];
+                case 6:
+                    hasPackage = _b.sent();
+                    return [2 /*return*/, hasServer && hasPackage];
+            }
+        });
+    });
+}
+function resolveAssistantProjectRoot(clientDir) {
+    return __awaiter(this, void 0, void 0, function () {
+        var normalized, resolved, root, parts, i, candidate;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    normalized = normalizeOptionalString(clientDir);
+                    if (!normalized) {
+                        return [2 /*return*/, ''];
+                    }
+                    resolved = path.resolve(normalized);
+                    root = path.parse(resolved).root || path.sep;
+                    parts = resolved.slice(root.length).split(path.sep).filter(Boolean);
+                    if (!parts.length) {
+                        return [2 /*return*/, ''];
+                    }
+                    i = parts.length;
+                    _a.label = 1;
+                case 1:
+                    if (!(i >= 1)) return [3 /*break*/, 4];
+                    candidate = path.join.apply(path, __spreadArray([root], __read(parts.slice(0, i)), false));
+                    return [4 /*yield*/, isAssistantProjectRoot(candidate)];
+                case 2:
+                    if (_a.sent()) {
+                        return [2 /*return*/, candidate];
+                    }
+                    _a.label = 3;
+                case 3:
+                    i -= 1;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/, ''];
+            }
+        });
+    });
+}
+function resolveAssistantWorkspaceRoot() {
+    return __awaiter(this, void 0, void 0, function () {
+        var config, configured, configuredRoot, clientDir, resolvedClientDir, projectRoot, _a, candidate, stat, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
                 case 0:
                     config = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
                     configured = normalizeOptionalString(config['AI_ASSISTANT_WORKSPACE_ROOT']
                         || process.env.AI_ASSISTANT_WORKSPACE_ROOT
                         || config['CODEX_WORKSPACE_ROOT']
                         || process.env.CODEX_WORKSPACE_ROOT);
-                    candidate = configured || resolveio_server_app_1.ResolveIOServer.getClientDir() || process.cwd();
-                    stat = null;
-                    _b.label = 1;
+                    configuredRoot = configured ? path.resolve(configured) : '';
+                    clientDir = normalizeOptionalString(resolveio_server_app_1.ResolveIOServer.getClientDir());
+                    resolvedClientDir = clientDir ? path.resolve(clientDir) : '';
+                    if (!resolvedClientDir) return [3 /*break*/, 2];
+                    return [4 /*yield*/, resolveAssistantProjectRoot(resolvedClientDir)];
                 case 1:
-                    _b.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, fs_1.promises.stat(candidate)];
+                    _a = _c.sent();
+                    return [3 /*break*/, 3];
                 case 2:
-                    stat = _b.sent();
-                    return [3 /*break*/, 4];
+                    _a = '';
+                    _c.label = 3;
                 case 3:
-                    _a = _b.sent();
+                    projectRoot = _a;
+                    candidate = configuredRoot || projectRoot || resolvedClientDir || process.cwd();
+                    if (configuredRoot) {
+                        if (projectRoot && isAssistantPathUnderRoot(projectRoot, configuredRoot)) {
+                            candidate = projectRoot;
+                        }
+                        else if (projectRoot && isAssistantPathUnderRoot(configuredRoot, projectRoot)) {
+                            candidate = configuredRoot;
+                        }
+                        else {
+                            candidate = configuredRoot;
+                        }
+                    }
+                    else if (projectRoot) {
+                        candidate = projectRoot;
+                    }
+                    else if (resolvedClientDir) {
+                        candidate = resolvedClientDir;
+                    }
                     stat = null;
-                    return [3 /*break*/, 4];
+                    _c.label = 4;
                 case 4:
+                    _c.trys.push([4, 6, , 7]);
+                    return [4 /*yield*/, fs_1.promises.stat(candidate)];
+                case 5:
+                    stat = _c.sent();
+                    return [3 /*break*/, 7];
+                case 6:
+                    _b = _c.sent();
+                    stat = null;
+                    return [3 /*break*/, 7];
+                case 7:
                     if (!stat || !stat.isDirectory()) {
                         throw new Error('AI assistant workspace root not found.');
                     }
@@ -7797,6 +8183,14 @@ function buildAssistantContext(input, userContext) {
     if (termHints.length) {
         lines.push("Term hints: ".concat(termHints.join('; ')));
     }
+    var fieldHints = Array.isArray(userContext === null || userContext === void 0 ? void 0 : userContext.fieldHints)
+        ? userContext.fieldHints.filter(Boolean)
+        : [];
+    if (fieldHints.length) {
+        fieldHints.forEach(function (hint) {
+            lines.push(hint);
+        });
+    }
     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)
@@ -7814,6 +8208,85 @@ function buildAssistantContext(input, userContext) {
     }
     return lines.join('\n');
 }
+function buildAssistantFieldHints(message, collectionNames, options) {
+    var normalizedMessage = normalizeOptionalString(message);
+    if (!normalizedMessage || !Array.isArray(collectionNames) || !collectionNames.length) {
+        return [];
+    }
+    var maxCollections = typeof (options === null || options === void 0 ? void 0 : options.maxCollections) === 'number'
+        ? Math.max(options.maxCollections, 0)
+        : AI_ASSISTANT_CONTEXT_MAX_COLLECTIONS;
+    var maxFields = typeof (options === null || options === void 0 ? void 0 : options.maxFields) === 'number'
+        ? Math.max(options.maxFields, 0)
+        : AI_ASSISTANT_CONTEXT_MAX_FIELDS_PER_COLLECTION;
+    if (!maxCollections || !maxFields) {
+        return [];
+    }
+    var baseTokens = tokenizeFieldKey(normalizedMessage);
+    var expandedTokens = expandFieldTokens(baseTokens);
+    var tokenSet = new Set(expandedTokens);
+    [
+        'date',
+        'status',
+        'total',
+        'amount',
+        'paid',
+        'balance',
+        'grand',
+        'subtotal',
+        'invoice',
+        'revenue',
+        'sales',
+        'billing',
+        'payment'
+    ].forEach(function (token) { return tokenSet.add(token); });
+    var hints = [];
+    var candidates = collectionNames.filter(Boolean).slice(0, maxCollections);
+    candidates.forEach(function (collection) {
+        var fields = getCollectionSchemaFieldNames(collection);
+        if (!fields.length) {
+            return;
+        }
+        var scored = fields
+            .filter(function (field) { return field && !shouldRedactField(field); })
+            .map(function (field) {
+            var tokens = tokenizeFieldKey(field);
+            if (!tokens.length) {
+                return null;
+            }
+            var score = tokens.filter(function (token) { return tokenSet.has(token); }).length;
+            var hasDate = tokens.includes('date');
+            var hasStatus = tokens.includes('status');
+            var hasTotal = tokens.includes('total') || tokens.includes('amount') || tokens.includes('paid') || tokens.includes('balance');
+            if (score === 0 && (hasDate || hasStatus || hasTotal)) {
+                score = 1;
+            }
+            if (score <= 0) {
+                return null;
+            }
+            if (isAssistantIdField(field)) {
+                score -= 1;
+            }
+            if (field.includes('.$.') && score < 2) {
+                return null;
+            }
+            return { field: field, score: score };
+        })
+            .filter(function (entry) { return !!entry; })
+            .sort(function (a, b) {
+            if (a.score !== b.score) {
+                return b.score - a.score;
+            }
+            return a.field.localeCompare(b.field);
+        })
+            .slice(0, maxFields)
+            .map(function (entry) { return entry.field; });
+        if (scored.length) {
+            hints.push("Field hints (".concat(collection, "): ").concat(scored.join(', ')));
+        }
+    });
+    return hints;
+}
 var cachedClientRouteIndex = null;
 function normalizeRouteKey(value) {
     var trimmed = normalizeOptionalString(value);
@@ -7988,7 +8461,11 @@ function sanitizeAssistantResponse(value) {
     if (!cleaned) {
         return 'I can’t share code, but I can point you to files or explain behavior at a high level.';
     }
-    var normalizedCurrency = cleaned.replace(/\bUSD\s*([0-9][0-9,]*(?:\.[0-9]+)?)/g, function (_match, amount) {
+    var normalizedCurrency = cleaned
+        .replace(/\bUSD(?:\s|&nbsp;|&#160;|[\u00A0\u202F\u2007])*\$?\s*([-+]?[0-9][0-9,]*(?:\.[0-9]+)?)/g, function (_match, amount) {
+        return "$".concat(amount);
+    })
+        .replace(/\bUS\$\s*([-+]?[0-9][0-9,]*(?:\.[0-9]+)?)/g, function (_match, amount) {
         return "$".concat(amount);
     });
     return normalizeAssistantRoutes(normalizedCurrency);