vigthoria-cli 1.11.11 → 1.11.17

package/dist/commands/chat.d.ts

@@ -28,6 +28,7 @@ export declare class ChatCommand {
     private tools;
     private sessionManager;
     private projectMemory;
+    private workspaceBrain;
     private currentSession;
     private agentMode;
     private currentProjectPath;
@@ -51,6 +52,7 @@ export declare class ChatCommand {
     private v3StreamedAnswerDisplayed;
     private v3SeenToolCalls;
     private v3SeenToolResults;
+    private lastAgentRoute;
     private lastAgentRunOutcome;
     private isJwtExpirationError;
     private isNetworkError;
@@ -103,7 +105,11 @@ export declare class ChatCommand {
     private buildTaskShapingInstructions;
     private buildExecutionPrompt;
     private isProjectBrainRuntimeDisabled;
+    private getWorkspaceBrainService;
+    private canPromptForWorkspaceIndex;
+    private promptWorkspaceIndex;
     private buildProjectBrainRuntimeContext;
+    private buildWorkspaceBrainRuntimeContext;
     private rememberBrainEvent;
     private getPromptRuntimeContext;
     private v3IterationCount;
@@ -168,6 +174,10 @@ export declare class ChatCommand {
     private persistLocalLoopOutcome;
     private runLocalAgentLoop;
     private primeBypassedTargetFileContext;
+    /**
+     * Sub-second path for trivial HTML/hello-world: Template Service → index.html (no V3 planner).
+     */
+    private tryTemplateInstantPath;
     private tryDirectSingleFileFlow;
     private isConfirmationFollowUp;
     private taskRequiresWorkspaceChanges;

package/dist/commands/chat.js

@@ -11,10 +11,15 @@ import { BridgeClient, getBridgeClient } from '../utils/bridge-client.js';
 import { WorkspaceWatcher } from '../utils/workspace-stream.js';
 import { TaskDisplay } from '../utils/task-display.js';
 import { ProjectMemoryService } from '../utils/project-memory.js';
+import { WorkspaceBrainService } from '../utils/workspace-brain-service.js';
 import { buildPersonaOverlay, normalizePersonaMode } from '../utils/persona.js';
 import { runAgentSessionMenu, shouldShowAgentSessionMenu } from './agent-session-menu.js';
 import { createLiveOutcome, evaluateExecutorSuccess, handleTaskEvent, isSubstantiveAgentAnswer, isToolEvidenceStubAnswer, normalizeAgentAnswerContent, noteAnalysisToolUse, } from '../utils/agentRunOutcome.js';
 import { looksLikeMarkdownReport, renderMarkdownToTerminal, summarizeMarkdownReport, } from '../utils/terminalMarkdown.js';
+import { emitDeckEvent, isDeckModeEnabled } from '../utils/deckEvents.js';
+import { inferAgentTaskType as sharedInferAgentTaskType, isTrivialHtmlPageRequest, resolvePlannerAgentTimeoutMs, resolveWorkflowType, shouldSkipAnalysisRescue, taskRequiresWorkspaceChanges as promptRequiresWorkspaceChanges, buildExecutionHints, } from '../utils/requestIntent.js';
+import { resolveAgentRoute } from '../utils/agentRoute.js';
+import { runTemplateInstantPath } from '../utils/templateInstantPath.js';
 const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS;
     if (!rawValue) {
@@ -47,6 +52,7 @@ export class ChatCommand {
     tools = null;
     sessionManager;
     projectMemory = null;
+    workspaceBrain = null;
     currentSession = null;
     agentMode = false;
     currentProjectPath = process.cwd();
@@ -71,6 +77,7 @@ export class ChatCommand {
     v3StreamedAnswerDisplayed = false;
     v3SeenToolCalls = new Set();
     v3SeenToolResults = new Set();
+    lastAgentRoute = null;
     // Last completed Agent run — used by /retry, /continue, and the final summary block.
     lastAgentRunOutcome = null;
     isJwtExpirationError(error) {
@@ -304,6 +311,16 @@ export class ChatCommand {
                 routeReason: 'explicit-model-selection',
             };
         }
+        if (this.lastAgentRoute?.path === 'template-instant') {
+            return {
+                selectedModel: 'agent',
+                explicitModel: false,
+                heavyTask,
+                cloudEligible,
+                cloudSelected: false,
+                routeReason: `template-instant [${this.lastAgentRoute.source}]`,
+            };
+        }
         if (requiresV3Workflow) {
             return {
                 selectedModel: 'agent',
@@ -314,6 +331,16 @@ export class ChatCommand {
                 routeReason: 'v3-required-frontend-task',
             };
         }
+        if (this.lastAgentRoute?.source === 'balanced-4b' || this.lastAgentRoute?.source === 'merged') {
+            return {
+                selectedModel: 'agent',
+                explicitModel: false,
+                heavyTask,
+                cloudEligible,
+                cloudSelected: false,
+                routeReason: `balanced-4b-router → ${this.lastAgentRoute.taskKind}`,
+            };
+        }
         if (this.config.shouldUseCloudForHeavyTask(prompt)) {
             return {
                 selectedModel: 'cloud',
@@ -550,14 +577,7 @@ export class ChatCommand {
             return 'debugging';
         if (this.isAnalysisLookupPrompt(prompt))
             return 'analysis';
-        if (/\b(analy[sz]e|analyse|audit|review|inspect|identify\s+gaps?|gap\s+analysis|production\s+blockers?|read[\s-]?only)\b/i.test(prompt)) {
-            return 'analysis';
-        }
-        if (/\b(implement|build|create|write|fix|repair|scaffold|deploy|add feature)\b/i.test(prompt)
-            && !/\b(analy[sz]e|analyse|audit|review|inspect)\b/i.test(prompt)) {
-            return /\b(game|html5|pacman|rogue|playable)\b/i.test(prompt) ? 'game-build' : 'implementation';
-        }
-        return 'analysis';
+        return sharedInferAgentTaskType(prompt);
     }
     buildTaskShapingInstructions(prompt) {
         const instructions = [];
@@ -593,6 +613,45 @@ export class ChatCommand {
     isProjectBrainRuntimeDisabled() {
         return /^(1|true|yes)$/i.test(String(process.env.VIGTHORIA_NO_BRAIN || process.env.VIGTHORIA_BRAIN_DISABLED || ''));
     }
+    getWorkspaceBrainService() {
+        if (this.isProjectBrainRuntimeDisabled()) {
+            return null;
+        }
+        try {
+            if (!this.workspaceBrain) {
+                this.workspaceBrain = new WorkspaceBrainService({
+                    workspacePath: this.currentProjectPath,
+                    apiBase: this.config.get('apiUrl'),
+                    getAuthToken: () => this.config.get('authToken'),
+                    autoIndex: false,
+                });
+            }
+            return this.workspaceBrain;
+        }
+        catch {
+            return null;
+        }
+    }
+    canPromptForWorkspaceIndex() {
+        if (this.jsonOutput || !process.stdin.isTTY || !process.stdout.isTTY) {
+            return false;
+        }
+        return !/^(1|true|yes)$/i.test(String(process.env.VIGTHORIA_NO_INDEX_PROMPT || ''));
+    }
+    async promptWorkspaceIndex(fileCount, workspaceName) {
+        if (!this.canPromptForWorkspaceIndex()) {
+            return 'later';
+        }
+        const answer = await new Promise((resolve) => {
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const prompt = `Index "${workspaceName}" for Vigthoria Brain (${fileCount} files) to improve large-context tasks? [y/N] `;
+            rl.question(chalk.cyan(prompt), (value) => {
+                rl.close();
+                resolve(value);
+            });
+        });
+        return /^(y|yes)$/i.test(answer.trim()) ? 'index_now' : 'later';
+    }
     buildProjectBrainRuntimeContext(prompt, source) {
         if (this.isProjectBrainRuntimeDisabled()) {
             return undefined;
@@ -619,6 +678,42 @@ export class ChatCommand {
             return undefined;
         }
     }
+    async buildWorkspaceBrainRuntimeContext(prompt) {
+        const service = this.getWorkspaceBrainService();
+        if (!service) {
+            return {};
+        }
+        try {
+            const result = await service.ensureIndexed({
+                promptIfMissing: this.canPromptForWorkspaceIndex(),
+                askToIndex: (fileCount, workspaceName) => this.promptWorkspaceIndex(fileCount, workspaceName),
+            });
+            const status = service.getStatus();
+            const context = {
+                workspaceBrain: {
+                    schema: 'vigthoria.workspace-brain.v1',
+                    indexed: result.indexed,
+                    prompted: result.prompted || null,
+                    indexedFileCount: status.indexedFileCount || result.fileCount,
+                    totalChunks: status.totalChunks || result.chunkCount,
+                    indexedAt: status.meta?.indexedAt || null,
+                    indexHash: status.meta?.indexHash || null,
+                },
+            };
+            const codebaseContext = service.buildCodebaseContext(prompt);
+            if (codebaseContext) {
+                context.codebaseContext = codebaseContext;
+            }
+            const accountBrainContext = await service.fetchAccountBrainContext().catch(() => '');
+            if (accountBrainContext) {
+                context.accountBrainContext = accountBrainContext;
+            }
+            return context;
+        }
+        catch {
+            return {};
+        }
+    }
     rememberBrainEvent(type, text, mode) {
         if (this.isProjectBrainRuntimeDisabled()) {
             return;
@@ -640,6 +735,19 @@ export class ChatCommand {
         const brainContext = this.buildProjectBrainRuntimeContext(prompt, this.operatorMode ? 'vigthoria-cli.operator' : this.agentMode ? 'vigthoria-cli.agent' : 'vigthoria-cli.chat');
         if (brainContext) {
             runtimeContext.vigthoriaBrain = brainContext;
+            if (typeof brainContext.context === 'string' && brainContext.context.trim()) {
+                runtimeContext.projectMemory = brainContext.context;
+            }
+        }
+        const workspaceBrainContext = await this.buildWorkspaceBrainRuntimeContext(prompt);
+        if (workspaceBrainContext.workspaceBrain) {
+            runtimeContext.workspaceBrain = workspaceBrainContext.workspaceBrain;
+        }
+        if (typeof workspaceBrainContext.codebaseContext === 'string' && workspaceBrainContext.codebaseContext.trim()) {
+            runtimeContext.codebaseContext = workspaceBrainContext.codebaseContext;
+        }
+        if (typeof workspaceBrainContext.accountBrainContext === 'string' && workspaceBrainContext.accountBrainContext.trim()) {
+            runtimeContext.accountBrainContext = workspaceBrainContext.accountBrainContext;
         }
         if (!this.isBrowserTaskPrompt(prompt)) {
             return runtimeContext;
@@ -803,6 +911,11 @@ export class ChatCommand {
         if (!isSubstantiveAgentAnswer(content)) {
             return;
         }
+        emitDeckEvent({ type: 'report_ready', markdown: content });
+        if (isDeckModeEnabled()) {
+            this.v3StreamedAnswerDisplayed = true;
+            return;
+        }
         console.log('');
         console.log(renderMarkdownToTerminal(content, this.getTerminalContentWidth()));
         this.v3StreamedAnswerDisplayed = true;
@@ -875,6 +988,13 @@ export class ChatCommand {
             }
             this.v3SeenToolCalls.add(eventKey);
             this.v3ToolCallCount += 1;
+            const toolName = event.name || event.tool || event.tool_name || '';
+            emitDeckEvent({
+                type: 'tool_start',
+                tool: toolName,
+                index: this.v3ToolCallCount,
+                target: event.arguments?.path || event.arguments?.file_path || event.arguments?.pattern || '',
+            });
             const toolDesc = this.describeV3AgentTool(event.tool || event.name || event.tool_name);
             const toolTarget = event.arguments?.path || event.arguments?.file_path || event.arguments?.pattern || '';
             const sanitizedTarget = this.sanitizeServerPath(String(toolTarget));
@@ -885,16 +1005,16 @@ export class ChatCommand {
             this.writeAgentActivityLine(this.fitTerminalText(stepLabel) + '\n');
             // Show extra detail for key tools
             const args = event.arguments || {};
-            const toolName = event.name || event.tool || '';
-            if ((toolName === 'write_file' || toolName === 'edit_file') && typeof args.content === 'string') {
+            const toolNameForDetail = event.name || event.tool || '';
+            if ((toolNameForDetail === 'write_file' || toolNameForDetail === 'edit_file') && typeof args.content === 'string') {
                 const len = args.content.length;
                 this.writeAgentActivityLine(chalk.gray(`      ${len > 1000 ? Math.round(len / 1024) + ' KB' : len + ' bytes'} content\n`));
             }
-            else if (toolName === 'bash' && typeof args.command === 'string') {
+            else if (toolNameForDetail === 'bash' && typeof args.command === 'string') {
                 const command = this.sanitizeServerPath(args.command);
                 this.writeAgentActivityLine(chalk.gray(`      ${this.fitTerminalText(`$ ${command}`, 6)}\n`));
             }
-            else if (toolName === 'read_file') {
+            else if (toolNameForDetail === 'read_file') {
                 this.writeAgentActivityLine(chalk.gray(`      ${this.fitTerminalText(`reading ${sanitizedTarget || 'file'}`, 6)}\n`));
             }
             spinner.text = `Running ${toolDesc}...`;
@@ -909,6 +1029,12 @@ export class ChatCommand {
                 this.v3SeenToolResults.add(eventKey);
             const success = event.success !== false;
             const toolName = event.name || event.tool || '';
+            emitDeckEvent({
+                type: 'tool_end',
+                tool: toolName,
+                success,
+                index: this.v3ToolCallCount,
+            });
             const indicator = success ? chalk.green('  ✓') : chalk.red('  ✗');
             if (spinner.isSpinning)
                 spinner.stop();
@@ -981,6 +1107,13 @@ export class ChatCommand {
             if (spinner.isSpinning)
                 spinner.stop();
             this.displayV3StreamedAnswer();
+            emitDeckEvent({
+                type: 'run_complete',
+                success: true,
+                tools: event.tool_calls || this.v3ToolCallCount,
+                iterations: event.iterations || this.v3IterationCount,
+                elapsed: event.elapsed || '',
+            });
             let statLine = `${iters} iterations, ${tools} tool calls`;
             if (elapsed)
                 statLine += `, ${elapsed}`;
@@ -2031,7 +2164,20 @@ export class ChatCommand {
         if (!this.tools) {
             throw new Error('Agent tools are not initialized.');
         }
+        this.lastAgentRoute = await resolveAgentRoute(this.api, prompt);
+        if (!this.jsonOutput) {
+            const r = this.lastAgentRoute;
+            const routerNote = r.routerLatencyMs
+                ? chalk.gray(` (${r.routerModel || 'balanced-4b'} ${r.routerLatencyMs}ms)`)
+                : '';
+            this.logger.debug(`Agent route: ${r.path} / ${r.taskKind} [${r.source}]${routerNote} — ${r.reason}`);
+        }
         const requiresV3Workflow = this.shouldRequireV3AgentWorkflow(prompt);
+        const handledByTemplateInstant = await this.tryTemplateInstantPath(prompt);
+        if (handledByTemplateInstant) {
+            this.saveSession();
+            return;
+        }
         const handledByDirectFileFlow = await this.tryDirectSingleFileFlow(prompt);
         if (handledByDirectFileFlow) {
             this.saveSession();
@@ -2371,6 +2517,98 @@ export class ChatCommand {
             this.messages.push({ role: 'system', content: readSummary });
         }
     }
+    /**
+     * Sub-second path for trivial HTML/hello-world: Template Service → index.html (no V3 planner).
+     */
+    async tryTemplateInstantPath(prompt) {
+        const route = this.lastAgentRoute;
+        if (route?.path !== 'template-instant' && !isTrivialHtmlPageRequest(prompt)) {
+            return false;
+        }
+        let workspacePath = this.currentProjectPath;
+        try {
+            const fromPrompt = this.resolvePromptWorkspacePath(prompt, this.currentProjectPath);
+            if (fromPrompt)
+                workspacePath = fromPrompt;
+        }
+        catch {
+            // use default workspace
+        }
+        if (!this.jsonOutput) {
+            console.log();
+            console.log(chalk.gray('━━━ ROUTING DECISION ━━━'));
+            const r = this.lastAgentRoute;
+            console.log(chalk.gray(`Reason: ${r?.reason || 'template-instant (trivial HTML page)'}`));
+            console.log(chalk.gray(`Path: template-instant [${r?.source || 'regex'}]`));
+            console.log(chalk.gray('Model: template-service'));
+            console.log(chalk.gray('Cloud Eligible: false'));
+            console.log(chalk.gray('Cloud Selected: false'));
+            console.log(chalk.gray('━'.repeat(30)));
+            console.log();
+            console.log(chalk.cyan('⚡ Template instant path — matching template and writing index.html...'));
+        }
+        this.messages.push({ role: 'user', content: prompt });
+        const mustComplete = route?.path === 'template-instant';
+        let result = await runTemplateInstantPath(this.api, prompt, workspacePath, {
+            allowFallback: true,
+        });
+        if (!result.ok && mustComplete) {
+            result = await runTemplateInstantPath(this.api, prompt, workspacePath, {
+                allowFallback: true,
+                forceMinimalFallback: true,
+            });
+        }
+        if (!result.ok) {
+            if (!this.jsonOutput) {
+                console.log(chalk.yellow(`Template instant path skipped: ${result.error || 'no match'}`));
+            }
+            return false;
+        }
+        const summary = [
+            `Created ${result.entryPath || 'index.html'} via template-instant`,
+            result.templateName ? `(${result.templateName})` : '',
+            result.processingMs ? `in ${Math.round(result.processingMs)}ms` : '',
+            result.usedFallback ? '(minimal fallback)' : '',
+        ].filter(Boolean).join(' ');
+        this.messages.push({ role: 'assistant', content: summary });
+        const liveOutcome = createLiveOutcome();
+        liveOutcome.requiresWorkspaceChanges = true;
+        liveOutcome.workspaceHasOutput = true;
+        liveOutcome.changedFileCount = 1;
+        liveOutcome.tasksTotal = 1;
+        liveOutcome.tasksSucceeded = 1;
+        liveOutcome.answerContent = summary;
+        const evaluation = evaluateExecutorSuccess(liveOutcome);
+        this.lastAgentRunOutcome = {
+            prompt,
+            taskId: null,
+            contextId: null,
+            tasksSucceeded: 1,
+            tasksTotal: 1,
+            failedTaskIds: [],
+            unfinishedTaskIds: [],
+            qualityScore: null,
+            qualityMissing: [],
+            qualityBlockers: [],
+            hasOutput: true,
+            answerContent: summary,
+            selfHealStatus: 'skipped',
+            selfHealTool: null,
+            plannerError: null,
+            executorError: null,
+            clientToolErrors: [],
+            transportErrors: [],
+            workspacePath: workspacePath || null,
+            workspaceSyncIssue: null,
+            finishedAt: Date.now(),
+        };
+        if (!this.jsonOutput) {
+            console.log(chalk.green(`✓ ${summary}`));
+            console.log(chalk.gray('  Run: vigthoria preview'));
+            this.printAgentRunSummary(this.lastAgentRunOutcome, evaluation, 1);
+        }
+        return true;
+    }
     async tryDirectSingleFileFlow(prompt) {
         if (!this.directPromptMode || !this.tools) {
             return false;
@@ -2490,13 +2728,7 @@ export class ChatCommand {
         return /^(ja|ja bitte|ja bitte mach das|mach das|bitte mach das|genau|ok|okay|yes|yes please|please do|do it|go ahead|continue|proceed|make it so)$/.test(normalized);
     }
     taskRequiresWorkspaceChanges(prompt) {
-        const text = String(prompt || '').trim();
-        const readOnlyIntent = /\b(analy[sz]e|analyse|analysis|audit|review|inspect|proof|understand|summari[sz]e|scan|read[\s-]?only|where we left|what is|how does|show me|tell me|identify\s+gaps?|gap\s+analysis|production\s+blockers?)\b/i.test(text);
-        const explicitWriteIntent = /\b(build|create|make|implement|complete|fix|repair|edit|modify|write|generate|add|finish|scaffold|develop|update|change|refactor)\b/i.test(text);
-        if (readOnlyIntent && !explicitWriteIntent) {
-            return false;
-        }
-        return explicitWriteIntent && /\b(file|project|game|app|website|html5|frontend|component|feature|code|workspace|repo)\b/i.test(text);
+        return promptRequiresWorkspaceChanges(prompt);
     }
     getPreviousActionablePrompt() {
         if (this.lastActionableUserInput && !this.isConfirmationFollowUp(this.lastActionableUserInput)) {
@@ -2578,6 +2810,7 @@ export class ChatCommand {
         this.v3StreamedAnswerDisplayed = false;
         this.v3SeenToolCalls.clear();
         this.v3SeenToolResults.clear();
+        emitDeckEvent({ type: 'agent_start' });
         const taskDisplay = new TaskDisplay(['Analyse workspace', 'Execute tasks', 'Validate output', 'Self-heal'], false);
         taskDisplay.start(0);
         const spinner = this.jsonOutput ? null : createSpinner({
@@ -2636,7 +2869,11 @@ export class ChatCommand {
             }
         };
         const executionPrompt = this.buildExecutionPrompt(contextualPrompt);
-        const agentTaskType = this.inferAgentTaskType(prompt);
+        const agentTaskType = this.lastAgentRoute?.taskKind || this.inferAgentTaskType(prompt);
+        const workflowType = resolveWorkflowType(agentTaskType, prompt);
+        const executionHints = buildExecutionHints(agentTaskType, prompt, {
+            fastPath: this.lastAgentRoute?.fastPath,
+        });
         const workspaceContext = {
             workspacePath: workspacePath,
             projectPath: workspacePath,
@@ -2672,10 +2909,14 @@ export class ChatCommand {
                 workspace: { path: workspacePath },
                 ...workspaceContext,
                 agentTaskType,
+                workflowType,
+                executionHints,
+                fastPath: this.lastAgentRoute?.fastPath,
+                agentRoute: this.lastAgentRoute,
                 executionSurface: 'cli',
                 clientSurface: 'cli',
                 localMachineCapable: true,
-                agentTimeoutMs: DEFAULT_V3_AGENT_TIMEOUT_MS,
+                agentTimeoutMs: resolvePlannerAgentTimeoutMs(DEFAULT_V3_AGENT_TIMEOUT_MS, agentTaskType, prompt),
                 agentIdleTimeoutMs: DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS,
                 agentSoftTimeoutMs: DEFAULT_V3_AGENT_SOFT_TIMEOUT_MS,
                 model: routingPolicy.selectedModel,
@@ -2768,7 +3009,7 @@ export class ChatCommand {
             const previewGate = (response.metadata?.previewGate || null);
             const workspaceHasOutput = this.api.hasAgentWorkspaceOutput(workspaceContext);
             const changedFileCount = response.changedFiles ? Object.keys(response.changedFiles).length : 0;
-            const requiresWorkspaceChanges = this.taskRequiresWorkspaceChanges(prompt);
+            const requiresWorkspaceChanges = promptRequiresWorkspaceChanges(prompt);
             const answerContent = normalizeAgentAnswerContent(response.content, this.v3StreamedAnswerBuffer);
             liveOutcome.changedFileCount = changedFileCount;
             liveOutcome.requiresWorkspaceChanges = requiresWorkspaceChanges;
@@ -2847,7 +3088,11 @@ export class ChatCommand {
             if (isToolEvidenceStubAnswer(finalAnswer)) {
                 finalAnswer = '';
             }
-            const needsAnalysisRescue = !requiresWorkspaceChanges && !this.jsonOutput
+            const needsAnalysisRescue = !shouldSkipAnalysisRescue({
+                tasksTotal: liveOutcome.tasksTotal,
+                changedFileCount,
+                requiresWorkspaceChanges,
+            }) && !this.jsonOutput
                 && (!executorSucceeded || !isSubstantiveAgentAnswer(finalAnswer));
             if (needsAnalysisRescue) {
                 const rescued = await this.tryAnalysisLocalRescue(prompt, workspacePath);
@@ -3119,13 +3364,16 @@ export class ChatCommand {
         this.v3LastActivity = Date.now();
         this.v3StreamingStarted = false;
         try {
+            const retryTaskType = this.inferAgentTaskType(rawPrompt);
             const retryResponse = await this.api.runV3AgentWorkflow(executionPrompt, {
                 workspace: { path: this.currentProjectPath },
                 ...workspaceContext,
                 executionSurface: 'cli',
                 clientSurface: 'cli',
                 localMachineCapable: true,
-                agentTimeoutMs: DEFAULT_V3_AGENT_TIMEOUT_MS,
+                agentTaskType: retryTaskType,
+                workflowType: resolveWorkflowType(retryTaskType, rawPrompt),
+                agentTimeoutMs: resolvePlannerAgentTimeoutMs(DEFAULT_V3_AGENT_TIMEOUT_MS, retryTaskType, rawPrompt),
                 agentIdleTimeoutMs: DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS,
                 agentSoftTimeoutMs: DEFAULT_V3_AGENT_SOFT_TIMEOUT_MS,
                 model: routingPolicy.selectedModel,
@@ -3397,6 +3645,15 @@ export class ChatCommand {
      */
     printAgentRunSummary(outcome, evaluation, changedFileCount) {
         const executorSucceeded = evaluation.executorSucceeded;
+        if (outcome.answerContent && isSubstantiveAgentAnswer(outcome.answerContent)) {
+            const reportSummary = summarizeMarkdownReport(outcome.answerContent);
+            emitDeckEvent({
+                type: 'run_summary',
+                success: executorSucceeded,
+                title: reportSummary?.title || 'Agent run complete',
+                sections: reportSummary?.sections || [],
+            });
+        }
         const bar = chalk.gray('─'.repeat(63));
         const ok = chalk.green('✓');
         const warn = chalk.yellow('⚠');

package/dist/utils/agentRoute.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Unified agent routing: regex (instant) → optional Balanced 4B → V3 execution hints.
+ */
+import type { APIClient } from './api.js';
+import { type AgentRoutePath } from './fastAgentRouter.js';
+export type { AgentRoutePath };
+export interface AgentRouteDecision {
+    path: AgentRoutePath;
+    taskKind: string;
+    fastPath?: string;
+    confidence: number;
+    reason: string;
+    source: 'regex-trivial' | 'regex' | 'balanced-4b' | 'merged';
+    routerLatencyMs?: number;
+    routerModel?: string;
+}
+export declare function resolveAgentRoute(api: APIClient, prompt: string): Promise<AgentRouteDecision>;

package/dist/utils/agentRoute.js

@@ -0,0 +1,137 @@
+/**
+ * Unified agent routing: regex (instant) → optional Balanced 4B → V3 execution hints.
+ */
+import { inferAgentTaskType, isTrivialHtmlPageRequest, isContinueOrRetryPrompt, hasGameIntent, hasWebPageIntent, taskRequiresWorkspaceChanges, stripExecutionShaping, } from './requestIntent.js';
+import { isFastInferenceRouterAvailable, routeWithBalanced4b, shouldUseBalancedRouter, } from './fastAgentRouter.js';
+function normalizeTaskKind(value, fallback) {
+    const kind = String(value || fallback).trim().toLowerCase();
+    const allowed = new Set([
+        'web-build', 'game-build', 'implementation', 'analysis', 'debugging', 'verification', 'build', 'repair',
+    ]);
+    if (allowed.has(kind)) {
+        return kind === 'build' ? 'implementation' : kind;
+    }
+    return fallback;
+}
+function mergeLlmRoute(regexTask, prompt, parsed) {
+    const llmPath = String(parsed.path || '').toLowerCase();
+    const llmTask = normalizeTaskKind(parsed.task_kind || parsed.taskKind, regexTask);
+    const llmFast = parsed.fast_path ?? parsed.fastPath ?? undefined;
+    const confidence = Number(parsed.confidence) || 0.75;
+    const reason = String(parsed.reason || 'balanced-4b router');
+    // Regex game/web signals override wrong LLM labels (hello-world → v3-agent bug).
+    if (isTrivialHtmlPageRequest(prompt) || (hasWebPageIntent(prompt) && !hasGameIntent(prompt) && llmTask === 'game-build')) {
+        return {
+            path: 'template-instant',
+            taskKind: 'web-build',
+            fastPath: 'template-instant',
+            confidence: Math.max(confidence, 0.92),
+            reason: 'regex web-page override',
+            source: 'merged',
+        };
+    }
+    if (llmPath === 'template-instant' || llmPath === 'html-template' || llmFast === 'template-instant') {
+        if (hasWebPageIntent(prompt) || isTrivialHtmlPageRequest(prompt)) {
+            return {
+                path: 'template-instant',
+                taskKind: 'web-build',
+                fastPath: 'template-instant',
+                confidence,
+                reason,
+                source: 'merged',
+            };
+        }
+    }
+    if (llmPath === 'analysis-only' || llmTask === 'analysis' || llmTask === 'debugging') {
+        if (!taskRequiresWorkspaceChanges(prompt)) {
+            return {
+                path: 'analysis-only',
+                taskKind: llmTask === 'debugging' ? 'debugging' : 'analysis',
+                confidence,
+                reason,
+                source: 'balanced-4b',
+            };
+        }
+    }
+    if (hasGameIntent(prompt) || llmTask === 'game-build') {
+        return {
+            path: 'v3-agent',
+            taskKind: 'game-build',
+            confidence,
+            reason,
+            source: 'merged',
+        };
+    }
+    const taskKind = (regexTask === 'web-build' || regexTask === 'game-build') ? regexTask : (llmTask || regexTask);
+    return {
+        path: 'v3-agent',
+        taskKind,
+        fastPath: typeof llmFast === 'string' ? llmFast : undefined,
+        confidence,
+        reason,
+        source: 'balanced-4b',
+    };
+}
+export async function resolveAgentRoute(api, prompt) {
+    const stripped = stripExecutionShaping(prompt);
+    if (isContinueOrRetryPrompt(stripped)) {
+        const regexTask = inferAgentTaskType(stripped);
+        return {
+            path: 'v3-agent',
+            taskKind: regexTask === 'analysis' ? 'implementation' : regexTask,
+            confidence: 0.9,
+            reason: 'continue/retry follow-up (regex)',
+            source: 'regex',
+        };
+    }
+    if (isTrivialHtmlPageRequest(stripped)) {
+        return {
+            path: 'template-instant',
+            taskKind: 'web-build',
+            fastPath: 'template-instant',
+            confidence: 1,
+            reason: 'trivial html page (regex)',
+            source: 'regex-trivial',
+        };
+    }
+    const regexTask = inferAgentTaskType(stripped);
+    if (!taskRequiresWorkspaceChanges(stripped) && (regexTask === 'analysis' || regexTask === 'debugging')) {
+        return {
+            path: 'analysis-only',
+            taskKind: regexTask,
+            confidence: 0.95,
+            reason: 'read-only analysis (regex)',
+            source: 'regex',
+        };
+    }
+    if (hasGameIntent(stripped) && regexTask === 'game-build') {
+        return {
+            path: 'v3-agent',
+            taskKind: 'game-build',
+            confidence: 0.95,
+            reason: 'game build (regex)',
+            source: 'regex',
+        };
+    }
+    const selfHosted = api.getSelfHostedModelsApiUrl();
+    const tryLlm = shouldUseBalancedRouter(stripped, regexTask)
+        && await isFastInferenceRouterAvailable(selfHosted);
+    if (tryLlm) {
+        const llm = await routeWithBalanced4b(stripped, selfHosted);
+        if (llm.ok && llm.parsed) {
+            const merged = mergeLlmRoute(regexTask, stripped, llm.parsed);
+            return {
+                ...merged,
+                routerLatencyMs: llm.latencyMs,
+                routerModel: llm.model,
+            };
+        }
+    }
+    return {
+        path: 'v3-agent',
+        taskKind: regexTask,
+        confidence: 0.8,
+        reason: 'default v3 agent (regex)',
+        source: 'regex',
+    };
+}