@resolveio/server-lib 22.1.6 → 22.1.7

package/methods/ai-terminal.js

@@ -131,7 +131,9 @@ exports.resolveAssistantAvailableCrossCollectionFallbacksFromNames = resolveAssi
 exports.collectUserViewPermissions = collectUserViewPermissions;
 exports.userHasInvoiceAccess = userHasInvoiceAccess;
 exports.resolveAssistantUserAccessTier = resolveAssistantUserAccessTier;
+exports.resolveCodexThoughtLevel = resolveCodexThoughtLevel;
 exports.classifyAssistantRequestType = classifyAssistantRequestType;
+exports.shouldRunAssistantPlanner = shouldRunAssistantPlanner;
 exports.collectAssistantAllowedRoutesForUser = collectAssistantAllowedRoutesForUser;
 exports.rankAssistantNavigationRoutes = rankAssistantNavigationRoutes;
 exports.shouldUseAssistantNavigationFastPath = shouldUseAssistantNavigationFastPath;
@@ -246,6 +248,9 @@ var AI_ASSISTANT_DATE_EXPANSION_SCHEMA_MAX_FIELDS = 12;
 var execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 var AI_ASSISTANT_CHANGE_HISTORY_DEFAULT_LIMIT = 10;
 var AI_ASSISTANT_CHANGE_HISTORY_MAX_LIMIT = 40;
+var AI_ASSISTANT_CHANGE_HISTORY_MIN_DEPTH = 80;
+var AI_ASSISTANT_CHANGE_HISTORY_MAX_DEPTH = 240;
+var AI_ASSISTANT_CHANGE_HISTORY_DURATION_MAX_DEPTH = 1200;
 var AI_ASSISTANT_GIT_COMMAND_TIMEOUT_MS = 15000;
 var AI_ASSISTANT_BLOCKED_COLLECTIONS = new Set([
     'user-groups',
@@ -1623,7 +1628,7 @@ function executeAiAssistantCodexRun(payload, context) {
                     insertResult = _e.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, requestClassification, dataQuestion, lastDirective, heuristicDirectivePrecomputed, usedDeterministicHeuristicFastPath, requestedTimeGrain, requestedBreakdownDimensions, enforceDatedDirective, enforceGroupedDirective, datedDirectiveRetryUsed, datedDirectiveResolved, toolResponseDebug, toolError, termHints, collectionHints, fieldHints, collectionTokenization, collectionRanking, collectionSelection, collectionOverride, collectionNames, plannerEnabled, plannerUsed, plannerOutput, plannerRaw, timingBreakdown, codexUsage, accumulateCodexUsage, contextRoute, contextMode, hintSeed, termExpansion, hintText, baseTokens, expandedTokens, baseWeights, expandedWeights, dbName, db, _a, routeHints, rankedCollections, hintCollections, assistantContext, hasDeterministicHeuristicFastPath, prompt_1, workspaceRoot, codexConfig, runOptions, shouldRunPlanner, plannerPrompt, plannerStart, _b, preferListDirective, directiveStyleHint, directivePromptMode, responseText, directiveText, directive, heuristicDirectiveFastPath, directivePrompt, directiveStart, forcedDirective, _c, initialStart, extractedDirective, error_2, directivePrompt, forcedStart, forcedDirective, _d, strictDirectivePrompt, strictStart, strictDirectiveText, strictDirective, strictDirectiveIsDated, shouldUseStrictDirective, _e, guardDirectivePrompt, guardStart, guardDirectiveText, guardDirective, _f, groupedDirectivePrompt, groupedStart, groupedDirectiveText, groupedDirective, _g, heuristicDirective, requestedCollection, cleanedResponseText, effectiveDirective, toolRequest, toolStart, toolResponse, _h, toolPayload, skipFollowupCodex, followupPrompt, followupStart, followupText, _j, error_3, error_4, finishedAt, finalNow, finishedAt, codexMs, draftingMs, finalMetadata, finalUsage, usageClientId, usageError_1, finalAssistantDoc, setPayload;
+                        var runStart, steps, recordStep, progressTracker, streamProgress, assistantContent, toolResult, assistantDebug, directiveSource, requestClassification, dataQuestion, lastDirective, heuristicDirectivePrecomputed, usedDeterministicHeuristicFastPath, requestedTimeGrain, requestedBreakdownDimensions, enforceDatedDirective, enforceGroupedDirective, datedDirectiveRetryUsed, datedDirectiveResolved, toolResponseDebug, toolError, termHints, collectionHints, fieldHints, collectionTokenization, collectionRanking, collectionSelection, collectionOverride, collectionNames, plannerEnabled, plannerUsed, plannerSkipReason, plannerOutput, plannerRaw, timingBreakdown, codexUsage, accumulateCodexUsage, contextRoute, contextMode, hintSeed, termExpansion, hintText, baseTokens, expandedTokens, baseWeights, expandedWeights, dbName, db, _a, routeHints, rankedCollections, hintCollections, assistantContext, hasDeterministicHeuristicFastPath, prompt_1, workspaceRoot, codexConfig, runOptions, plannerRunOptions, shouldRunPlanner, plannerPrompt, plannerStart, _b, preferListDirective, directiveStyleHint, directivePromptMode, responseText, directiveText, directive, heuristicDirectiveFastPath, directivePrompt, directiveStart, forcedDirective, _c, initialStart, extractedDirective, error_2, directivePrompt, forcedStart, forcedDirective, _d, strictDirectivePrompt, strictStart, strictDirectiveText, strictDirective, strictDirectiveIsDated, shouldUseStrictDirective, _e, guardDirectivePrompt, guardStart, guardDirectiveText, guardDirective, _f, groupedDirectivePrompt, groupedStart, groupedDirectiveText, groupedDirective, _g, heuristicDirective, requestedCollection, cleanedResponseText, effectiveDirective, toolRequest, toolStart, toolResponse, _h, toolPayload, skipFollowupCodex, followupPrompt, followupStart, followupText, _j, error_3, error_4, finishedAt, finalNow, finishedAt, codexMs, draftingMs, finalMetadata, finalUsage, usageClientId, usageError_1, finalAssistantDoc, setPayload;
                         var _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12;
                         return __generator(this, function (_13) {
                             switch (_13.label) {
@@ -1678,6 +1683,7 @@ function executeAiAssistantCodexRun(payload, context) {
                                     collectionNames = [];
                                     plannerEnabled = resolveAssistantPlannerEnabled();
                                     plannerUsed = false;
+                                    plannerSkipReason = '';
                                     plannerOutput = null;
                                     plannerRaw = '';
                                     timingBreakdown = {
@@ -1713,7 +1719,7 @@ function executeAiAssistantCodexRun(payload, context) {
                                     });
                                     _13.label = 1;
                                 case 1:
-                                    _13.trys.push([1, 49, 50, 51]);
+                                    _13.trys.push([1, 51, 52, 53]);
                                     hintSeed = [message, contextRoute].filter(Boolean).join(' ');
                                     termExpansion = expandAssistantTermSynonyms(hintSeed);
                                     hintText = termExpansion.expanded || hintSeed;
@@ -1811,7 +1817,8 @@ function executeAiAssistantCodexRun(payload, context) {
                                             skipGitRepoCheck: true,
                                             modelReasoningEffort: resolveCodexThoughtLevel({
                                                 message: message,
-                                                attachmentText: attachmentData.promptText
+                                                attachmentText: attachmentData.promptText,
+                                                requestType: requestClassification.type
                                             }),
                                             networkAccessEnabled: false,
                                             webSearchMode: 'disabled',
@@ -1819,10 +1826,13 @@ function executeAiAssistantCodexRun(payload, context) {
                                             approvalPolicy: 'never'
                                         }
                                     };
-                                    shouldRunPlanner = plannerEnabled
-                                        && !(requestClassification.type === 'navigation' && !dataQuestion)
-                                        && !hasDeterministicHeuristicFastPath;
-                                    if (!shouldRunPlanner) return [3 /*break*/, 10];
+                                    plannerRunOptions = __assign(__assign({}, runOptions), { threadOptions: __assign(__assign({}, (runOptions.threadOptions || {})), { modelReasoningEffort: 'minimal' }) });
+                                    shouldRunPlanner = shouldRunAssistantPlanner({
+                                        plannerEnabled: plannerEnabled,
+                                        requestClassification: requestClassification,
+                                        hasDeterministicHeuristicFastPath: hasDeterministicHeuristicFastPath
+                                    });
+                                    if (!shouldRunPlanner) return [3 /*break*/, 11];
                                     plannerUsed = true;
                                     recordStep('Planning: planner prompt');
                                     plannerPrompt = buildAssistantPlannerPrompt({
@@ -1839,7 +1849,7 @@ function executeAiAssistantCodexRun(payload, context) {
                                 case 7:
                                     _13.trys.push([7, 9, , 10]);
                                     plannerStart = Date.now();
-                                    return [4 /*yield*/, runCodexInWorkerThread(plannerPrompt, runOptions, codexConfig, streamProgress)];
+                                    return [4 /*yield*/, runCodexInWorkerThread(plannerPrompt, plannerRunOptions, codexConfig, streamProgress)];
                                 case 8:
                                     plannerRaw = _13.sent();
                                     accumulateCodexUsage(plannerPrompt, plannerRaw);
@@ -1851,7 +1861,22 @@ function executeAiAssistantCodexRun(payload, context) {
                                     _b = _13.sent();
                                     recordStep('Planning: planner result', { parsed: false });
                                     return [3 /*break*/, 10];
-                                case 10:
+                                case 10: return [3 /*break*/, 12];
+                                case 11:
+                                    if (plannerEnabled) {
+                                        if (hasDeterministicHeuristicFastPath) {
+                                            plannerSkipReason = 'heuristic_directive_fast_path';
+                                        }
+                                        else if (!requestClassification.dataQuestion) {
+                                            plannerSkipReason = "non_data_".concat(requestClassification.type || 'unknown');
+                                        }
+                                        else {
+                                            plannerSkipReason = 'policy';
+                                        }
+                                        recordStep('Planning: planner skipped', { reason: plannerSkipReason });
+                                    }
+                                    _13.label = 12;
+                                case 12:
                                     requestClassification = classifyAssistantRequestType(message, plannerOutput || undefined);
                                     dataQuestion = requestClassification.dataQuestion;
                                     requestedTimeGrain = resolveAssistantRequestedTimeGrain(message, plannerOutput || undefined);
@@ -1902,15 +1927,15 @@ function executeAiAssistantCodexRun(payload, context) {
                                             timeGrain: requestedTimeGrain || undefined
                                         });
                                     }
-                                    if (!(dataQuestion && !directive)) return [3 /*break*/, 14];
+                                    if (!(dataQuestion && !directive)) return [3 /*break*/, 16];
                                     recordStep('Directive: determine tool', { type: 'data-question' });
                                     directivePrompt = buildAssistantCodexDirectivePrompt(message, attachmentData.promptText, historyLines.join('\n'), assistantContext, directiveStyleHint, directivePromptMode);
-                                    _13.label = 11;
-                                case 11:
-                                    _13.trys.push([11, 13, , 14]);
+                                    _13.label = 13;
+                                case 13:
+                                    _13.trys.push([13, 15, , 16]);
                                     directiveStart = Date.now();
                                     return [4 /*yield*/, runCodexInWorkerThread(directivePrompt, runOptions, codexConfig, streamProgress)];
-                                case 12:
+                                case 14:
                                     directiveText = _13.sent();
                                     accumulateCodexUsage(directivePrompt, directiveText);
                                     timingBreakdown.directiveMs = Date.now() - directiveStart;
@@ -1927,19 +1952,19 @@ function executeAiAssistantCodexRun(payload, context) {
                                             permissionView: normalizeOptionalString((_t = directive.payload) === null || _t === void 0 ? void 0 : _t.permissionView) || undefined
                                         });
                                     }
-                                    return [3 /*break*/, 14];
-                                case 13:
+                                    return [3 /*break*/, 16];
+                                case 15:
                                     _c = _13.sent();
-                                    return [3 /*break*/, 14];
-                                case 14:
-                                    if (!(!directive && !dataQuestion)) return [3 /*break*/, 18];
+                                    return [3 /*break*/, 16];
+                                case 16:
+                                    if (!(!directive && !dataQuestion)) return [3 /*break*/, 20];
                                     recordStep('Response: draft initial answer', { mode: 'full' });
-                                    _13.label = 15;
-                                case 15:
-                                    _13.trys.push([15, 17, , 18]);
+                                    _13.label = 17;
+                                case 17:
+                                    _13.trys.push([17, 19, , 20]);
                                     initialStart = Date.now();
                                     return [4 /*yield*/, runCodexInWorkerThread(prompt_1, runOptions, codexConfig, streamProgress)];
-                                case 16:
+                                case 18:
                                     responseText = _13.sent();
                                     accumulateCodexUsage(prompt_1, responseText);
                                     timingBreakdown.initialResponseMs = Date.now() - initialStart;
@@ -1956,23 +1981,23 @@ function executeAiAssistantCodexRun(payload, context) {
                                             permissionView: normalizeOptionalString((_w = directive.payload) === null || _w === void 0 ? void 0 : _w.permissionView) || undefined
                                         });
                                     }
-                                    return [3 /*break*/, 18];
-                                case 17:
+                                    return [3 /*break*/, 20];
+                                case 19:
                                     error_2 = _13.sent();
                                     recordStep('Response: initial draft failed', {
                                         message: normalizeOptionalString(error_2 === null || error_2 === void 0 ? void 0 : error_2.message) || 'Unknown error'
                                     });
-                                    return [3 /*break*/, 18];
-                                case 18:
-                                    if (!(!directive && dataQuestion)) return [3 /*break*/, 22];
+                                    return [3 /*break*/, 20];
+                                case 20:
+                                    if (!(!directive && dataQuestion)) return [3 /*break*/, 24];
                                     recordStep('Directive: forced retry', { mode: 'directive-only' });
                                     directivePrompt = buildAssistantCodexDirectivePrompt(message, attachmentData.promptText, historyLines.join('\n'), assistantContext, directiveStyleHint, directivePromptMode);
-                                    _13.label = 19;
-                                case 19:
-                                    _13.trys.push([19, 21, , 22]);
+                                    _13.label = 21;
+                                case 21:
+                                    _13.trys.push([21, 23, , 24]);
                                     forcedStart = Date.now();
                                     return [4 /*yield*/, runCodexInWorkerThread(directivePrompt, runOptions, codexConfig, streamProgress)];
-                                case 20:
+                                case 22:
                                     directiveText = _13.sent();
                                     accumulateCodexUsage(directivePrompt, directiveText);
                                     timingBreakdown.forcedDirectiveMs = Date.now() - forcedStart;
@@ -1989,15 +2014,15 @@ function executeAiAssistantCodexRun(payload, context) {
                                             permissionView: normalizeOptionalString((_z = directive.payload) === null || _z === void 0 ? void 0 : _z.permissionView) || undefined
                                         });
                                     }
-                                    return [3 /*break*/, 22];
-                                case 21:
+                                    return [3 /*break*/, 24];
+                                case 23:
                                     _d = _13.sent();
-                                    return [3 /*break*/, 22];
-                                case 22:
+                                    return [3 /*break*/, 24];
+                                case 24:
                                     if (!(directive
                                         && enforceDatedDirective
                                         && !isAssistantDeterministicHeuristicDirective(directive)
-                                        && !isAssistantDirectiveDated(directive))) return [3 /*break*/, 26];
+                                        && !isAssistantDirectiveDated(directive))) return [3 /*break*/, 28];
                                     recordStep('Directive: dated retry', {
                                         currentType: directive.type,
                                         timeGrain: requestedTimeGrain || undefined
@@ -2009,12 +2034,12 @@ function executeAiAssistantCodexRun(payload, context) {
                                         requestedBreakdowns: requestedBreakdownDimensions,
                                         strict: true
                                     }), 'aggregate_only');
-                                    _13.label = 23;
-                                case 23:
-                                    _13.trys.push([23, 25, , 26]);
+                                    _13.label = 25;
+                                case 25:
+                                    _13.trys.push([25, 27, , 28]);
                                     strictStart = Date.now();
                                     return [4 /*yield*/, runCodexInWorkerThread(strictDirectivePrompt, runOptions, codexConfig, streamProgress)];
-                                case 24:
+                                case 26:
                                     strictDirectiveText = _13.sent();
                                     accumulateCodexUsage(strictDirectivePrompt, strictDirectiveText);
                                     timingBreakdown.forcedDirectiveMs += Date.now() - strictStart;
@@ -2036,15 +2061,15 @@ function executeAiAssistantCodexRun(payload, context) {
                                             timeGrain: requestedTimeGrain || undefined
                                         });
                                     }
-                                    return [3 /*break*/, 26];
-                                case 25:
+                                    return [3 /*break*/, 28];
+                                case 27:
                                     _e = _13.sent();
-                                    return [3 /*break*/, 26];
-                                case 26:
+                                    return [3 /*break*/, 28];
+                                case 28:
                                     if (!(directive
                                         && enforceDatedDirective
                                         && !isAssistantDeterministicHeuristicDirective(directive)
-                                        && directive.type === 'read')) return [3 /*break*/, 30];
+                                        && directive.type === 'read')) return [3 /*break*/, 32];
                                     recordStep('Directive: dated guard retry', {
                                         currentType: directive.type,
                                         timeGrain: requestedTimeGrain || undefined
@@ -2056,12 +2081,12 @@ function executeAiAssistantCodexRun(payload, context) {
                                         requestedBreakdowns: requestedBreakdownDimensions,
                                         strict: true
                                     }), 'aggregate_only');
-                                    _13.label = 27;
-                                case 27:
-                                    _13.trys.push([27, 29, , 30]);
+                                    _13.label = 29;
+                                case 29:
+                                    _13.trys.push([29, 31, , 32]);
                                     guardStart = Date.now();
                                     return [4 /*yield*/, runCodexInWorkerThread(guardDirectivePrompt, runOptions, codexConfig, streamProgress)];
-                                case 28:
+                                case 30:
                                     guardDirectiveText = _13.sent();
                                     accumulateCodexUsage(guardDirectivePrompt, guardDirectiveText);
                                     timingBreakdown.forcedDirectiveMs += Date.now() - guardStart;
@@ -2081,15 +2106,15 @@ function executeAiAssistantCodexRun(payload, context) {
                                             timeGrain: requestedTimeGrain || undefined
                                         });
                                     }
-                                    return [3 /*break*/, 30];
-                                case 29:
+                                    return [3 /*break*/, 32];
+                                case 31:
                                     _f = _13.sent();
-                                    return [3 /*break*/, 30];
-                                case 30:
+                                    return [3 /*break*/, 32];
+                                case 32:
                                     if (!(directive
                                         && enforceGroupedDirective
                                         && !isAssistantDeterministicHeuristicDirective(directive)
-                                        && !isAssistantDirectiveGrouped(directive))) return [3 /*break*/, 34];
+                                        && !isAssistantDirectiveGrouped(directive))) return [3 /*break*/, 36];
                                     recordStep('Directive: grouped guard retry', {
                                         currentType: directive.type,
                                         breakdownDimensions: requestedBreakdownDimensions.length ? requestedBreakdownDimensions : undefined
@@ -2101,12 +2126,12 @@ function executeAiAssistantCodexRun(payload, context) {
                                         requestedBreakdowns: requestedBreakdownDimensions,
                                         strict: true
                                     }), 'aggregate_only');
-                                    _13.label = 31;
-                                case 31:
-                                    _13.trys.push([31, 33, , 34]);
+                                    _13.label = 33;
+                                case 33:
+                                    _13.trys.push([33, 35, , 36]);
                                     groupedStart = Date.now();
                                     return [4 /*yield*/, runCodexInWorkerThread(groupedDirectivePrompt, runOptions, codexConfig, streamProgress)];
-                                case 32:
+                                case 34:
                                     groupedDirectiveText = _13.sent();
                                     accumulateCodexUsage(groupedDirectivePrompt, groupedDirectiveText);
                                     timingBreakdown.forcedDirectiveMs += Date.now() - groupedStart;
@@ -2129,11 +2154,11 @@ function executeAiAssistantCodexRun(payload, context) {
                                             timeGrain: requestedTimeGrain || undefined
                                         });
                                     }
-                                    return [3 /*break*/, 34];
-                                case 33:
+                                    return [3 /*break*/, 36];
+                                case 35:
                                     _g = _13.sent();
-                                    return [3 /*break*/, 34];
-                                case 34:
+                                    return [3 /*break*/, 36];
+                                case 36:
                                     if (!directive && dataQuestion) {
                                         heuristicDirective = buildAssistantHeuristicDirective(message, collectionHints);
                                         if (isAssistantExecutableDirective(heuristicDirective)) {
@@ -2172,7 +2197,7 @@ function executeAiAssistantCodexRun(payload, context) {
                                     if (cleanedResponseText) {
                                         assistantContent = sanitizeAssistantResponse(cleanedResponseText);
                                     }
-                                    if (!((directive === null || directive === void 0 ? void 0 : directive.payload) && AI_ASSISTANT_TOOL_MAX_STEPS > 0)) return [3 /*break*/, 47];
+                                    if (!((directive === null || directive === void 0 ? void 0 : directive.payload) && AI_ASSISTANT_TOOL_MAX_STEPS > 0)) return [3 /*break*/, 49];
                                     effectiveDirective = collectionOverride
                                         ? __assign(__assign({}, directive), { payload: __assign(__assign({}, (directive.payload || {})), { collection: collectionOverride.to }) }) : directive;
                                     toolRequest = buildAssistantToolRequest(effectiveDirective, input);
@@ -2182,20 +2207,20 @@ function executeAiAssistantCodexRun(payload, context) {
                                         collection: normalizeOptionalString(toolRequest === null || toolRequest === void 0 ? void 0 : toolRequest.collection) || undefined,
                                         permissionView: normalizeOptionalString(toolRequest === null || toolRequest === void 0 ? void 0 : toolRequest.permissionView) || undefined
                                     });
-                                    _13.label = 35;
-                                case 35:
-                                    _13.trys.push([35, 45, , 46]);
+                                    _13.label = 37;
+                                case 37:
+                                    _13.trys.push([37, 47, , 48]);
                                     toolStart = Date.now();
-                                    if (!(effectiveDirective.type === 'aggregate')) return [3 /*break*/, 37];
+                                    if (!(effectiveDirective.type === 'aggregate')) return [3 /*break*/, 39];
                                     return [4 /*yield*/, executeAiAssistantReportBuilderAggregate(toolRequest, context)];
-                                case 36:
-                                    _h = _13.sent();
-                                    return [3 /*break*/, 39];
-                                case 37: return [4 /*yield*/, executeAiAssistantReportBuilderRead(toolRequest, context)];
                                 case 38:
                                     _h = _13.sent();
-                                    _13.label = 39;
-                                case 39:
+                                    return [3 /*break*/, 41];
+                                case 39: return [4 /*yield*/, executeAiAssistantReportBuilderRead(toolRequest, context)];
+                                case 40:
+                                    _h = _13.sent();
+                                    _13.label = 41;
+                                case 41:
                                     toolResponse = _h;
                                     timingBreakdown.toolMs = Date.now() - toolStart;
                                     toolResponseDebug = (toolResponse === null || toolResponse === void 0 ? void 0 : toolResponse.debug) && typeof toolResponse.debug === 'object'
@@ -2211,53 +2236,53 @@ function executeAiAssistantCodexRun(payload, context) {
                                     progressTracker.push('Drafting response');
                                     skipFollowupCodex = usedDeterministicHeuristicFastPath
                                         || isAssistantDeterministicHeuristicDirective(effectiveDirective);
-                                    if (!skipFollowupCodex) return [3 /*break*/, 40];
+                                    if (!skipFollowupCodex) return [3 /*break*/, 42];
                                     recordStep('Drafting response: deterministic summary', {
                                         reason: normalizeOptionalString(effectiveDirective.rawLine) || 'deterministic_heuristic'
                                     });
                                     assistantContent = buildAssistantToolFallbackResponse(toolPayload.result);
                                     assistantContent = applyAssistantDisplayTableToResponse(assistantContent, toolPayload.result.output.display);
-                                    return [3 /*break*/, 44];
-                                case 40:
+                                    return [3 /*break*/, 46];
+                                case 42:
                                     recordStep('Drafting response');
                                     followupPrompt = buildAssistantCodexToolFollowupPrompt(message, attachmentData.promptText, historyLines.join('\n'), assistantContext, toolPayload.prompt);
-                                    _13.label = 41;
-                                case 41:
-                                    _13.trys.push([41, 43, , 44]);
+                                    _13.label = 43;
+                                case 43:
+                                    _13.trys.push([43, 45, , 46]);
                                     followupStart = Date.now();
                                     return [4 /*yield*/, runCodexInWorkerThread(followupPrompt, runOptions, codexConfig, streamProgress)];
-                                case 42:
+                                case 44:
                                     followupText = _13.sent();
                                     accumulateCodexUsage(followupPrompt, followupText);
                                     timingBreakdown.followupMs = Date.now() - followupStart;
                                     assistantContent = sanitizeAssistantResponse(followupText);
                                     assistantContent = applyAssistantDisplayTableToResponse(assistantContent, toolPayload.result.output.display);
-                                    return [3 /*break*/, 44];
-                                case 43:
+                                    return [3 /*break*/, 46];
+                                case 45:
                                     _j = _13.sent();
                                     assistantContent = buildAssistantToolFallbackResponse(toolPayload.result);
-                                    return [3 /*break*/, 44];
-                                case 44: return [3 /*break*/, 46];
-                                case 45:
-                                    error_3 = _13.sent();
-                                    assistantContent = buildAssistantToolErrorMessage(error_3);
-                                    toolError = error_3;
                                     return [3 /*break*/, 46];
                                 case 46: return [3 /*break*/, 48];
                                 case 47:
+                                    error_3 = _13.sent();
+                                    assistantContent = buildAssistantToolErrorMessage(error_3);
+                                    toolError = error_3;
+                                    return [3 /*break*/, 48];
+                                case 48: return [3 /*break*/, 50];
+                                case 49:
                                     progressTracker.push('Drafting response');
                                     recordStep('Drafting response');
-                                    _13.label = 48;
-                                case 48: return [3 /*break*/, 51];
-                                case 49:
+                                    _13.label = 50;
+                                case 50: return [3 /*break*/, 53];
+                                case 51:
                                     error_4 = _13.sent();
                                     assistantContent = buildAssistantCodexErrorMessage(error_4);
                                     recordStep('Error', { message: normalizeOptionalString(error_4 === null || error_4 === void 0 ? void 0 : error_4.message) || 'Unknown error' });
-                                    return [3 /*break*/, 51];
-                                case 50:
+                                    return [3 /*break*/, 53];
+                                case 52:
                                     progressTracker.stop();
                                     return [7 /*endfinally*/];
-                                case 51:
+                                case 53:
                                     if (!assistantContent) {
                                         assistantContent = buildAssistantCodexErrorMessage(null);
                                     }
@@ -2327,7 +2352,7 @@ function executeAiAssistantCodexRun(payload, context) {
                                                             : undefined
                                                     } : (plannerEnabled ? {
                                                         enabled: false,
-                                                        reason: 'skipped_for_navigation'
+                                                        reason: plannerSkipReason || 'skipped_by_policy'
                                                     } : undefined)
                                                 },
                                                 timings: {
@@ -2353,14 +2378,14 @@ function executeAiAssistantCodexRun(payload, context) {
                                         output_tokens: codexUsage.output_tokens,
                                         total_tokens: codexUsage.total_tokens
                                     } : null;
-                                    if (!finalUsage) return [3 /*break*/, 56];
+                                    if (!finalUsage) return [3 /*break*/, 58];
                                     return [4 /*yield*/, resolveClientId(conversation, input.id_client, context === null || context === void 0 ? void 0 : context.id_user)];
-                                case 52:
+                                case 54:
                                     usageClientId = _13.sent();
-                                    if (!usageClientId) return [3 /*break*/, 56];
-                                    _13.label = 53;
-                                case 53:
-                                    _13.trys.push([53, 55, , 56]);
+                                    if (!usageClientId) return [3 /*break*/, 58];
+                                    _13.label = 55;
+                                case 55:
+                                    _13.trys.push([55, 57, , 58]);
                                     return [4 /*yield*/, (0, openai_usage_ledger_manager_1.recordOpenAIUsage)({
                                             id_client: usageClientId,
                                             model: finalUsage.model,
@@ -2371,16 +2396,16 @@ function executeAiAssistantCodexRun(payload, context) {
                                             id_request: requestId || undefined,
                                             id_conversation: conversation._id
                                         })];
-                                case 54:
+                                case 56:
                                     _13.sent();
-                                    return [3 /*break*/, 56];
-                                case 55:
+                                    return [3 /*break*/, 58];
+                                case 57:
                                     usageError_1 = _13.sent();
                                     console.error(new Date(), 'Failed to record codex usage', usageError_1);
-                                    return [3 /*break*/, 56];
-                                case 56:
+                                    return [3 /*break*/, 58];
+                                case 58:
                                     finalAssistantDoc = __assign(__assign(__assign(__assign({}, assistantDoc), { _id: assistantMessageId, content: assistantContent, metadata: finalMetadata }), (finalUsage ? { usage: finalUsage } : {})), { updatedAt: finalNow });
-                                    if (!assistantMessageId) return [3 /*break*/, 58];
+                                    if (!assistantMessageId) return [3 /*break*/, 60];
                                     setPayload = {
                                         content: assistantContent,
                                         metadata: finalMetadata,
@@ -2390,18 +2415,18 @@ function executeAiAssistantCodexRun(payload, context) {
                                         setPayload.usage = finalUsage;
                                     }
                                     return [4 /*yield*/, updateAssistantMessageWithFallback(assistantMessageId, setPayload)];
-                                case 57:
-                                    _13.sent();
-                                    _13.label = 58;
-                                case 58: return [4 /*yield*/, touchConversation(conversation._id, finalNow, assistantMessageId ? String(assistantMessageId) : undefined)];
                                 case 59:
                                     _13.sent();
-                                    if (!(input.delete_files_after_run !== false)) return [3 /*break*/, 61];
+                                    _13.label = 60;
+                                case 60: return [4 /*yield*/, touchConversation(conversation._id, finalNow, assistantMessageId ? String(assistantMessageId) : undefined)];
+                                case 61:
+                                    _13.sent();
+                                    if (!(input.delete_files_after_run !== false)) return [3 /*break*/, 63];
                                     return [4 /*yield*/, cleanupAttachments(attachmentData.attachments)];
-                                case 60:
+                                case 62:
                                     _13.sent();
-                                    _13.label = 61;
-                                case 61: return [2 /*return*/, finalAssistantDoc];
+                                    _13.label = 63;
+                                case 63: return [2 /*return*/, finalAssistantDoc];
                             }
                         });
                     }); });
@@ -14000,38 +14025,6 @@ function resolveConfiguredCodexAutoThoughtLevel(kind) {
         || process.env["AI_DASHBOARD_CODEX_".concat(levelKey, "_THOUGHT_LEVEL")]);
     return configured || fallbackLevel;
 }
-function resolveAutoCodexThoughtLevel(params) {
-    var combinedText = [
-        normalizeOptionalString(params === null || params === void 0 ? void 0 : params.message),
-        normalizeOptionalString(params === null || params === void 0 ? void 0 : params.attachmentText)
-    ].filter(Boolean).join('\n').toLowerCase();
-    var simpleLevel = resolveConfiguredCodexAutoThoughtLevel('simple');
-    var complexLevel = resolveConfiguredCodexAutoThoughtLevel('complex');
-    if (!combinedText) {
-        return simpleLevel;
-    }
-    var bugOrIssuePatterns = [
-        /\bbug\b/i,
-        /\bissue\b/i,
-        /\berror\b/i,
-        /\bexception\b/i,
-        /\bfail(?:ed|ing|ure)?\b/i,
-        /\bbroken\b/i,
-        /\bnot\s+working\b/i,
-        /\bdoesn['’]t\s+work\b/i,
-        /\bwhy\s+is\s+this\s+happening\b/i,
-        /\broot\s+cause\b/i,
-        /\bregression\b/i,
-        /\bdebug\b/i,
-        /\binvestigat(?:e|ion)\b/i,
-        /\bfix\b/i,
-        /\bcrash(?:ed|ing)?\b/i,
-        /\btimeout\b/i,
-        /\bwrong\b/i,
-        /\bincorrect\b/i
-    ];
-    return bugOrIssuePatterns.some(function (pattern) { return pattern.test(combinedText); }) ? complexLevel : simpleLevel;
-}
 function resolveCodexThoughtLevel(params) {
     var config = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
     var raw = normalizeOptionalString(config['AI_ASSISTANT_CODEX_THOUGHT_LEVEL']
@@ -14042,13 +14035,17 @@ function resolveCodexThoughtLevel(params) {
         || process.env.AI_DASHBOARD_CODEX_THOUGHT_LEVEL);
     var normalized = (raw || '').trim().toLowerCase();
     var explicitLevel = normalizeCodexThoughtLevel(normalized);
+    var isBugIssueRequest = (params === null || params === void 0 ? void 0 : params.requestType) === 'bug_issue';
+    if (!isBugIssueRequest) {
+        return 'medium';
+    }
     if (explicitLevel) {
         return explicitLevel;
     }
     if (normalized === 'auto' || !normalized) {
-        return resolveAutoCodexThoughtLevel(params);
+        return resolveConfiguredCodexAutoThoughtLevel('complex');
     }
-    return 'medium';
+    return 'high';
 }
 function resolveCodexSettings(options) {
     var serverConfig = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
@@ -14729,6 +14726,20 @@ function classifyAssistantRequestType(message, plannerOutput) {
         plannerIntentType: plannerIntentRaw || undefined
     };
 }
+function shouldRunAssistantPlanner(params) {
+    if (!(params === null || params === void 0 ? void 0 : params.plannerEnabled)) {
+        return false;
+    }
+    if (params === null || params === void 0 ? void 0 : params.hasDeterministicHeuristicFastPath) {
+        return false;
+    }
+    var requestClassification = params === null || params === void 0 ? void 0 : params.requestClassification;
+    if (requestClassification === null || requestClassification === void 0 ? void 0 : requestClassification.dataQuestion) {
+        return true;
+    }
+    var type = (requestClassification === null || requestClassification === void 0 ? void 0 : requestClassification.type) || 'unknown';
+    return type === 'unknown' || type === 'mixed';
+}
 function resolveAssistantRequestedTimeGrain(message, plannerOutput) {
     var _a, _b;
     var plannerGrain = normalizeOptionalString((_b = (_a = plannerOutput === null || plannerOutput === void 0 ? void 0 : plannerOutput.dataPlan) === null || _a === void 0 ? void 0 : _a.timeRange) === null || _b === void 0 ? void 0 : _b.grain).toLowerCase();
@@ -15701,13 +15712,88 @@ var AI_ASSISTANT_CHANGE_HISTORY_PATTERNS = [
     /\bwhat\s+did\s+(?:the\s+)?last\s+(?:system\s+)?update\s+(?:just\s+)?do\b/i,
     /\blast\s+system\s+update\b[\s\S]{0,40}\bdo\b/i,
     /\bhow\s+long\b.*\bbeen\s+(this|that)\s+way\b/i,
+    /\bhow\s+long\b[\s\S]{0,80}\bbeen\s+around\b/i,
     /\bsince\s+when\b/i,
+    /\bwhen\s+was\b[\s\S]{0,80}\bintroduced\b/i,
     /\bchangelog\b/i,
     /\brelease\s+notes?\b/i,
     /\bgithub\b/i,
     /\bcommits?\b/i,
     /\bupdate\s+history\b/i
 ];
+var AI_ASSISTANT_CHANGE_HISTORY_TOKEN_STOPWORDS = new Set([
+    'the',
+    'a',
+    'an',
+    'to',
+    'for',
+    'of',
+    'in',
+    'on',
+    'at',
+    'and',
+    'or',
+    'i',
+    'me',
+    'my',
+    'we',
+    'us',
+    'you',
+    'our',
+    'is',
+    'are',
+    'do',
+    'did',
+    'does',
+    'can',
+    'could',
+    'would',
+    'should',
+    'what',
+    'when',
+    'where',
+    'which',
+    'why',
+    'how',
+    'long',
+    'has',
+    'have',
+    'had',
+    'been',
+    'this',
+    'that',
+    'these',
+    'those',
+    'it',
+    'new',
+    'changed',
+    'change',
+    'recent',
+    'recently',
+    'latest',
+    'last',
+    'time',
+    'updated',
+    'update',
+    'updates',
+    'added',
+    'around',
+    'page',
+    'screen',
+    'feature',
+    'features',
+    'history',
+    'list',
+    'dashboard',
+    'server',
+    'management',
+    'system',
+    'release',
+    'notes',
+    'github',
+    'commits',
+    'commit'
+]);
 function isAssistantChangeHistoryQuestion(message) {
     var text = normalizeOptionalString(message).toLowerCase();
     if (!text) {
@@ -15739,6 +15825,13 @@ function resolveAssistantChangeHistoryLimit(message) {
     }
     return AI_ASSISTANT_CHANGE_HISTORY_DEFAULT_LIMIT;
 }
+function resolveAssistantChangeHistoryDepth(message, limit) {
+    var normalizedLimit = Math.min(Math.max((0, common_1.round)(limit || 0), 1), AI_ASSISTANT_CHANGE_HISTORY_MAX_LIMIT);
+    if (isAssistantChangeDurationQuestion(message)) {
+        return Math.min(Math.max(normalizedLimit * 40, AI_ASSISTANT_CHANGE_HISTORY_MAX_DEPTH), AI_ASSISTANT_CHANGE_HISTORY_DURATION_MAX_DEPTH);
+    }
+    return Math.min(Math.max(normalizedLimit * 8, AI_ASSISTANT_CHANGE_HISTORY_MIN_DEPTH), AI_ASSISTANT_CHANGE_HISTORY_MAX_DEPTH);
+}
 function resolveAssistantChangeHistoryFetchEnabled() {
     var config = resolveio_server_app_1.ResolveIOServer.getServerConfig() || {};
     var normalized = normalizeOptionalBoolean(config['AI_ASSISTANT_GIT_FETCH_ENABLED']
@@ -15754,6 +15847,43 @@ function shouldAssistantFetchGitRemote(message) {
     }
     return /\b(github|latest|newest|up to date|up-to-date|pull|remote)\b/i.test(text);
 }
+function resolveAssistantChangeHistoryKeywords(message) {
+    var rawTokens = normalizeOptionalString(message)
+        .toLowerCase()
+        .split(/[^a-z0-9]+/g)
+        .map(function (token) { return token.trim(); })
+        .filter(Boolean);
+    var keywords = [];
+    rawTokens.forEach(function (token) {
+        normalizeCollectionToken(token).forEach(function (normalized) {
+            if (!normalized || normalized.length < 4 || AI_ASSISTANT_CHANGE_HISTORY_TOKEN_STOPWORDS.has(normalized)) {
+                return;
+            }
+            keywords.push(normalized);
+        });
+    });
+    return Array.from(new Set(keywords));
+}
+function scoreAssistantChangeHistoryCommitByKeywords(commit, keywords) {
+    if (!Array.isArray(keywords) || !keywords.length) {
+        return 0;
+    }
+    var subject = normalizeOptionalString(commit === null || commit === void 0 ? void 0 : commit.subject).toLowerCase();
+    var files = Array.isArray(commit === null || commit === void 0 ? void 0 : commit.files)
+        ? commit.files.map(function (file) { return normalizeOptionalString(file).toLowerCase(); }).filter(Boolean).join(' ')
+        : '';
+    var haystack = "".concat(subject, " ").concat(files).trim();
+    if (!haystack) {
+        return 0;
+    }
+    var score = 0;
+    keywords.forEach(function (keyword) {
+        if (keyword && haystack.includes(keyword)) {
+            score += keyword.length >= 8 ? 2 : 1;
+        }
+    });
+    return score;
+}
 function resolveAssistantChangeModulesFromText(message) {
     var text = normalizeOptionalString(message).toLowerCase();
     if (!text) {
@@ -16058,9 +16188,22 @@ function buildAssistantChangeHistorySummaryFromCommits(params) {
         }
         return __assign({ response: lines_3.join('\n'), reason: 'generic', commitCount: 0, generic: true }, (branch ? { branch: branch } : {}));
     }
-    var themes = summarizeAssistantChangeThemes(permittedCommits);
+    var featureKeywords = resolveAssistantChangeHistoryKeywords(message);
+    var keywordScopedCommits = featureKeywords.length
+        ? permittedCommits
+            .map(function (commit, index) { return ({
+            commit: commit,
+            index: index,
+            score: scoreAssistantChangeHistoryCommitByKeywords(commit, featureKeywords)
+        }); })
+            .filter(function (entry) { return entry.score > 0; })
+            .sort(function (a, b) { return (b.score - a.score) || (a.index - b.index); })
+            .map(function (entry) { return entry.commit; })
+        : [];
+    var relevantCommits = keywordScopedCommits.length ? keywordScopedCommits : permittedCommits;
+    var themes = summarizeAssistantChangeThemes(relevantCommits);
     var limit = resolveAssistantChangeHistoryLimit(message);
-    var topCommits = permittedCommits.slice(0, Math.max(limit, 1));
+    var topCommits = relevantCommits.slice(0, Math.max(limit, 1));
     var lines = [title];
     if (themes.length) {
         lines.push("- Themes: ".concat(themes.join(', '), "."));
@@ -16070,7 +16213,10 @@ function buildAssistantChangeHistorySummaryFromCommits(params) {
         lines.push("- ".concat(dateText, ": ").concat(sanitizeAssistantChangeSubject(commit.subject), "."));
     });
     if (asksDuration) {
-        var datedCommits = permittedCommits
+        if (featureKeywords.length && !keywordScopedCommits.length) {
+            lines.push('- I could not find exact feature-term matches in recent commits, so this estimate uses the closest available history.');
+        }
+        var datedCommits = relevantCommits
             .map(function (commit) { return ({ commit: commit, date: new Date(commit.date) }); })
             .filter(function (entry) { return !Number.isNaN(entry.date.getTime()); });
         if (datedCommits.length) {
@@ -16159,7 +16305,7 @@ function resolveAssistantChangeHistoryFastPathResponse(params) {
                     return [3 /*break*/, 14];
                 case 14:
                     limit = resolveAssistantChangeHistoryLimit(params.message);
-                    historyDepth = Math.min(Math.max(limit * 8, 80), 240);
+                    historyDepth = resolveAssistantChangeHistoryDepth(params.message, limit);
                     return [4 /*yield*/, runAssistantGitCommand(gitRoot, [
                             'log',
                             '-n',