vigthoria-cli 1.11.27 → 1.11.29

package/dist/commands/chat.d.ts

@@ -171,6 +171,11 @@ export declare class ChatCommand {
     private runOperatorDirectAnswer;
     private runSimplePrompt;
     private runAgentTurn;
+    private resolveAgentTurnPrompt;
+    private shouldPreserveBuildOutcomeForContinue;
+    private resolveOriginalPrompt;
+    private commitAgentRunOutcome;
+    private printResumeContinuationHint;
     private buildLocalLoopLiveOutcome;
     private persistLocalLoopOutcome;
     private runLocalAgentLoop;
@@ -180,7 +185,6 @@ export declare class ChatCommand {
      */
     private tryTemplateInstantPath;
     private tryDirectSingleFileFlow;
-    private isConfirmationFollowUp;
     private taskRequiresWorkspaceChanges;
     private getPreviousActionablePrompt;
     private buildContextualAgentPrompt;

package/dist/commands/chat.js

@@ -17,7 +17,7 @@ import { runAgentSessionMenu, shouldShowAgentSessionMenu } from './agent-session
 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 { inferAgentTaskType as sharedInferAgentTaskType, inferAgentTaskTypeWithContext, isTrivialHtmlPageRequest, resolvePlannerAgentTimeoutMs, resolveWorkflowType, shouldSkipAnalysisRescue, taskRequiresWorkspaceChanges as promptRequiresWorkspaceChanges, taskRequiresWorkspaceChangesWithContext, buildExecutionHints, isAgentContinuePrompt, isAgentRetryPrompt, isBuiltContinuePrompt, isBuiltRetryPrompt, isBuiltWriteConfirmationPrompt, isConfirmationFollowUp, isWritePermissionGrant, } from '../utils/requestIntent.js';
 import { resolveAgentRoute } from '../utils/agentRoute.js';
 import { runTemplateInstantPath } from '../utils/templateInstantPath.js';
 const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
@@ -1405,6 +1405,9 @@ export class ChatCommand {
         this.directToolContinuationCount = 0;
         this.tools = new AgenticTools(this.logger, this.currentProjectPath, async (action) => this.requestPermission(action), this.autoApprove);
         this.initializeSession(options.resume === true || options.retry === true || options.continue === true);
+        if (options.resume && this.lastAgentRunOutcome && !this.jsonOutput && !options.prompt) {
+            this.printResumeContinuationHint();
+        }
         // ── Commando Bridge: connect if --bridge was specified ──────────
         if (options.bridge) {
             const bridgeClient = new BridgeClient({
@@ -1677,7 +1680,11 @@ export class ChatCommand {
                 this.operatorMode = this.currentSession.operatorMode || this.operatorMode;
                 this.currentModel = this.currentSession.model || this.currentModel;
                 if (this.currentSession.lastAgentRunOutcome) {
-                    this.lastAgentRunOutcome = this.currentSession.lastAgentRunOutcome;
+                    const saved = this.currentSession.lastAgentRunOutcome;
+                    this.lastAgentRunOutcome = {
+                        ...saved,
+                        originalPrompt: saved.originalPrompt ?? null,
+                    };
                 }
                 return;
             }
@@ -2037,7 +2044,22 @@ export class ChatCommand {
     }
     async runSimplePrompt(prompt) {
         if (!this.directPromptMode && !this.operatorMode) {
-            const promptToRun = this.isConfirmationFollowUp(prompt) && this.lastActionableUserInput && this.isRepoGroundedPrompt(this.lastActionableUserInput)
+            const isWriteFollowUp = isConfirmationFollowUp(prompt) || isWritePermissionGrant(prompt);
+            if (isWriteFollowUp && (this.lastActionableUserInput || this.getPreviousActionablePrompt())) {
+                if (!this.tools) {
+                    throw new Error('Agent tools are not initialized.');
+                }
+                this.agentMode = true;
+                this.syncInteractiveModeModel('agent');
+                if (this.currentSession) {
+                    this.currentSession.agentMode = true;
+                    this.currentSession.model = this.currentModel;
+                }
+                console.log(chalk.yellow('Write confirmation detected — switching to Agent mode with full file access.'));
+                await this.runAgentTurn(prompt);
+                return;
+            }
+            const promptToRun = isConfirmationFollowUp(prompt) && this.lastActionableUserInput && this.isRepoGroundedPrompt(this.lastActionableUserInput)
                 ? this.lastActionableUserInput
                 : prompt;
             if (this.isRepoGroundedPrompt(promptToRun) || /\b(build|implement|complete|fix|create|make|edit|write|change|finish)\b/i.test(promptToRun)) {
@@ -2165,7 +2187,8 @@ export class ChatCommand {
         if (!this.tools) {
             throw new Error('Agent tools are not initialized.');
         }
-        this.lastAgentRoute = await resolveAgentRoute(this.api, prompt);
+        const resolvedPrompt = this.resolveAgentTurnPrompt(prompt);
+        this.lastAgentRoute = await resolveAgentRoute(this.api, resolvedPrompt);
         if (!this.jsonOutput) {
             const r = this.lastAgentRoute;
             const routerNote = r.routerLatencyMs
@@ -2173,13 +2196,13 @@ export class ChatCommand {
                 : '';
             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);
+        const requiresV3Workflow = this.shouldRequireV3AgentWorkflow(resolvedPrompt);
+        const handledByTemplateInstant = await this.tryTemplateInstantPath(resolvedPrompt);
         if (handledByTemplateInstant) {
             this.saveSession();
             return;
         }
-        const handledByDirectFileFlow = await this.tryDirectSingleFileFlow(prompt);
+        const handledByDirectFileFlow = await this.tryDirectSingleFileFlow(resolvedPrompt);
         if (handledByDirectFileFlow) {
             this.saveSession();
             return;
@@ -2187,12 +2210,12 @@ export class ChatCommand {
         // Prime the message context with the target file when the direct-file flow was
         // bypassed (e.g. HTML files routed to V3) so the local agent loop has file
         // awareness and the ⚙ Executing: read_file banner is always emitted.
-        await this.primeBypassedTargetFileContext(prompt);
-        if (this.shouldPreferLocalAgentLoop(prompt)) {
-            await this.runLocalAgentLoop(prompt);
+        await this.primeBypassedTargetFileContext(resolvedPrompt);
+        if (this.shouldPreferLocalAgentLoop(resolvedPrompt)) {
+            await this.runLocalAgentLoop(resolvedPrompt);
             return;
         }
-        const handledByV3Workflow = await this.tryV3AgentWorkflow(prompt);
+        const handledByV3Workflow = await this.tryV3AgentWorkflow(resolvedPrompt);
         if (handledByV3Workflow) {
             this.saveSession();
             return;
@@ -2204,7 +2227,104 @@ export class ChatCommand {
             this.saveSession();
             return;
         }
-        await this.runLocalAgentLoop(prompt);
+        await this.runLocalAgentLoop(resolvedPrompt);
+    }
+    resolveAgentTurnPrompt(prompt) {
+        if (isBuiltContinuePrompt(prompt) || isBuiltRetryPrompt(prompt) || isBuiltWriteConfirmationPrompt(prompt)) {
+            return prompt;
+        }
+        if (isAgentContinuePrompt(prompt)) {
+            const followUp = this.buildContinuePrompt();
+            if (followUp) {
+                if (!this.jsonOutput) {
+                    console.log(chalk.cyan('↪ Treating your message as /continue — resuming the previous agent run.'));
+                }
+                return followUp;
+            }
+        }
+        if (isAgentRetryPrompt(prompt)) {
+            const followUp = this.buildRetryPrompt();
+            if (followUp) {
+                if (!this.jsonOutput) {
+                    console.log(chalk.cyan('↪ Treating your message as /retry — re-running failed tasks from the previous run.'));
+                }
+                return followUp;
+            }
+        }
+        if ((isConfirmationFollowUp(prompt) || isWritePermissionGrant(prompt)) && !isAgentContinuePrompt(prompt)) {
+            const expanded = this.buildContextualAgentPrompt(prompt);
+            if (expanded !== prompt) {
+                if (!this.jsonOutput) {
+                    console.log(chalk.cyan('↪ Treating your message as write confirmation — applying the previous task with full write access.'));
+                }
+                return expanded;
+            }
+        }
+        return prompt;
+    }
+    shouldPreserveBuildOutcomeForContinue(runPrompt, prior) {
+        if (this.taskRequiresWorkspaceChanges(runPrompt)) {
+            return false;
+        }
+        if (isBuiltContinuePrompt(runPrompt) || isBuiltRetryPrompt(runPrompt)) {
+            return false;
+        }
+        const chainPrompt = prior.originalPrompt || prior.prompt;
+        if (!this.taskRequiresWorkspaceChanges(chainPrompt)) {
+            return false;
+        }
+        return isAgentContinuePrompt(runPrompt);
+    }
+    resolveOriginalPrompt(runPrompt) {
+        const prior = this.lastAgentRunOutcome;
+        if (prior?.originalPrompt) {
+            return prior.originalPrompt;
+        }
+        if (this.taskRequiresWorkspaceChanges(runPrompt) && !isBuiltContinuePrompt(runPrompt) && !isBuiltRetryPrompt(runPrompt)) {
+            return runPrompt;
+        }
+        if (prior && this.taskRequiresWorkspaceChanges(prior.originalPrompt || prior.prompt)) {
+            return prior.originalPrompt || prior.prompt;
+        }
+        return null;
+    }
+    commitAgentRunOutcome(outcome, runPrompt) {
+        const prior = this.lastAgentRunOutcome;
+        if (prior && this.shouldPreserveBuildOutcomeForContinue(runPrompt, prior)) {
+            if (!this.jsonOutput) {
+                console.log(chalk.yellow('↪ Keeping the previous build run state — use /continue to resume implementation.'));
+            }
+            return;
+        }
+        outcome.originalPrompt = this.resolveOriginalPrompt(runPrompt);
+        this.lastAgentRunOutcome = outcome;
+    }
+    printResumeContinuationHint() {
+        const outcome = this.lastAgentRunOutcome;
+        if (!outcome) {
+            return;
+        }
+        const sourcePrompt = outcome.originalPrompt || outcome.prompt;
+        const isBuild = this.taskRequiresWorkspaceChanges(sourcePrompt);
+        const openWork = outcome.failedTaskIds.length > 0
+            || outcome.unfinishedTaskIds.length > 0
+            || (outcome.tasksTotal > 0 && outcome.tasksSucceeded < outcome.tasksTotal);
+        if (!isBuild && !openWork) {
+            return;
+        }
+        console.log('');
+        console.log(chalk.cyan('Prior agent run restored for this project.'));
+        if (openWork) {
+            const taskIds = [...new Set([...outcome.failedTaskIds, ...outcome.unfinishedTaskIds])].slice(0, 8);
+            if (taskIds.length > 0) {
+                console.log(chalk.gray(`  Unfinished tasks: ${taskIds.join(', ')}`));
+            }
+            else {
+                console.log(chalk.gray(`  Progress: ${outcome.tasksSucceeded}/${outcome.tasksTotal} tasks completed`));
+            }
+        }
+        console.log(chalk.gray('  Type ') + chalk.cyan('/continue') + chalk.gray(' to resume implementation, or ') + chalk.cyan('/retry') + chalk.gray(' for failed tasks only.'));
+        console.log('');
     }
     buildLocalLoopLiveOutcome(prompt) {
         const liveOutcome = createLiveOutcome();
@@ -2220,8 +2340,9 @@ export class ChatCommand {
         return liveOutcome;
     }
     persistLocalLoopOutcome(prompt, evaluation, liveOutcome) {
-        this.lastAgentRunOutcome = {
+        this.commitAgentRunOutcome({
             prompt,
+            originalPrompt: null,
             taskId: null,
             contextId: null,
             tasksSucceeded: liveOutcome.tasksSucceeded,
@@ -2242,7 +2363,7 @@ export class ChatCommand {
             workspacePath: this.currentProjectPath || null,
             workspaceSyncIssue: null,
             finishedAt: Date.now(),
-        };
+        }, prompt);
     }
     async runLocalAgentLoop(prompt) {
         if (!this.tools) {
@@ -2580,8 +2701,9 @@ export class ChatCommand {
         liveOutcome.tasksSucceeded = 1;
         liveOutcome.answerContent = summary;
         const evaluation = evaluateExecutorSuccess(liveOutcome);
-        this.lastAgentRunOutcome = {
+        this.commitAgentRunOutcome({
             prompt,
+            originalPrompt: null,
             taskId: null,
             contextId: null,
             tasksSucceeded: 1,
@@ -2602,7 +2724,7 @@ export class ChatCommand {
             workspacePath: workspacePath || null,
             workspaceSyncIssue: null,
             finishedAt: Date.now(),
-        };
+        }, prompt);
         if (!this.jsonOutput) {
             console.log(chalk.green(`✓ ${summary}`));
             console.log(chalk.gray('  Run: vigthoria preview'));
@@ -2724,15 +2846,11 @@ export class ChatCommand {
         }
         return true;
     }
-    isConfirmationFollowUp(prompt) {
-        const normalized = prompt.trim().toLowerCase().replace(/[.!?]+$/g, '').replace(/\s+/g, ' ');
-        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) {
         return promptRequiresWorkspaceChanges(prompt);
     }
     getPreviousActionablePrompt() {
-        if (this.lastActionableUserInput && !this.isConfirmationFollowUp(this.lastActionableUserInput)) {
+        if (this.lastActionableUserInput && !isConfirmationFollowUp(this.lastActionableUserInput)) {
             return this.lastActionableUserInput;
         }
         for (let i = this.messages.length - 1; i >= 0; i -= 1) {
@@ -2740,7 +2858,9 @@ export class ChatCommand {
             if (message.role !== 'user')
                 continue;
             const content = (message.content || '').trim();
-            if (!content || this.isConfirmationFollowUp(content))
+            if (!content || isConfirmationFollowUp(content) || isWritePermissionGrant(content))
+                continue;
+            if (isBuiltWriteConfirmationPrompt(content) || isBuiltContinuePrompt(content) || isBuiltRetryPrompt(content))
                 continue;
             return content
                 .replace(/\n\nProject root:[\s\S]*$/i, '')
@@ -2750,7 +2870,7 @@ export class ChatCommand {
         return '';
     }
     buildContextualAgentPrompt(prompt) {
-        if (!this.isConfirmationFollowUp(prompt)) {
+        if (!isConfirmationFollowUp(prompt) && !isWritePermissionGrant(prompt)) {
             return prompt;
         }
         const previousPrompt = this.getPreviousActionablePrompt();
@@ -2758,13 +2878,14 @@ export class ChatCommand {
             return prompt;
         }
         return [
-            'The user confirmed the previous agent task. Continue and execute that original task now.',
+            'The user confirmed they want file changes applied. Execute the original task with full write access.',
             '',
             'Original task:',
             previousPrompt,
             '',
-            `Latest confirmation: ${prompt}`,
+            `User confirmation: ${prompt}`,
             '',
+            'Apply the requested file changes now. Do not stop at analysis or ask for permission again.',
             'Do not reinterpret this confirmation as a new website, landing page, template, or index.html task.',
         ].join('\n');
     }
@@ -2782,7 +2903,7 @@ export class ChatCommand {
         }
         const workspacePath = promptWorkspacePath || this.currentProjectPath;
         const contextualPrompt = this.buildContextualAgentPrompt(prompt);
-        if (contextualPrompt === prompt && !this.isConfirmationFollowUp(prompt)) {
+        if (contextualPrompt === prompt && !isConfirmationFollowUp(prompt) && !isWritePermissionGrant(prompt)) {
             this.lastActionableUserInput = prompt;
         }
         this.messages.push({ role: 'user', content: contextualPrompt });
@@ -2872,10 +2993,15 @@ export class ChatCommand {
             }
         };
         const executionPrompt = this.buildExecutionPrompt(contextualPrompt);
-        const agentTaskType = this.lastAgentRoute?.taskKind || this.inferAgentTaskType(prompt);
-        const workflowType = resolveWorkflowType(agentTaskType, prompt);
-        const executionHints = buildExecutionHints(agentTaskType, prompt, {
+        const priorPrompt = this.getPreviousActionablePrompt();
+        const intentContext = { priorPrompt: priorPrompt || null };
+        const classificationPrompt = contextualPrompt;
+        const agentTaskType = this.lastAgentRoute?.taskKind
+            || inferAgentTaskTypeWithContext(classificationPrompt, intentContext);
+        const workflowType = resolveWorkflowType(agentTaskType, classificationPrompt, intentContext);
+        const executionHints = buildExecutionHints(agentTaskType, classificationPrompt, {
             fastPath: this.lastAgentRoute?.fastPath,
+            priorPrompt: priorPrompt || null,
         });
         const workspaceContext = {
             workspacePath: workspacePath,
@@ -3012,7 +3138,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 = promptRequiresWorkspaceChanges(prompt);
+            const requiresWorkspaceChanges = taskRequiresWorkspaceChangesWithContext(contextualPrompt, intentContext);
             const answerContent = normalizeAgentAnswerContent(response.content, this.v3StreamedAnswerBuffer);
             liveOutcome.changedFileCount = changedFileCount;
             liveOutcome.requiresWorkspaceChanges = requiresWorkspaceChanges;
@@ -3198,8 +3324,9 @@ export class ChatCommand {
             if (!executorSucceeded) {
                 process.exitCode = 1;
             }
-            this.lastAgentRunOutcome = {
+            this.commitAgentRunOutcome({
                 prompt,
+                originalPrompt: null,
                 taskId: response.taskId || null,
                 contextId: response.contextId || null,
                 tasksSucceeded: liveOutcome.tasksSucceeded,
@@ -3222,9 +3349,11 @@ export class ChatCommand {
                     ? 'Local workspace has files but the agent did not confirm tracked changes.'
                     : null,
                 finishedAt: Date.now(),
-            };
+            }, prompt);
             if (!this.jsonOutput && !this.directPromptMode) {
-                this.printAgentRunSummary(this.lastAgentRunOutcome, runEvaluation, changedFileCount);
+                if (this.lastAgentRunOutcome) {
+                    this.printAgentRunSummary(this.lastAgentRunOutcome, runEvaluation, changedFileCount);
+                }
             }
             if (this.jsonOutput) {
                 if (!executorSucceeded) {
@@ -3296,8 +3425,9 @@ export class ChatCommand {
                 taskDisplay.finalize();
             }
             catch (_) { /* render is best-effort */ }
-            this.lastAgentRunOutcome = {
+            this.commitAgentRunOutcome({
                 prompt,
+                originalPrompt: null,
                 taskId: null,
                 contextId: null,
                 tasksSucceeded: liveOutcome.tasksSucceeded,
@@ -3318,7 +3448,7 @@ export class ChatCommand {
                 workspacePath: workspacePath || null,
                 workspaceSyncIssue: null,
                 finishedAt: Date.now(),
-            };
+            }, prompt);
             if (!this.jsonOutput) {
                 process.exitCode = 1;
             }
@@ -3346,7 +3476,9 @@ export class ChatCommand {
                     requiresWorkspaceChanges: this.taskRequiresWorkspaceChanges(prompt),
                     workspaceHasOutput: this.api.hasAgentWorkspaceOutput(workspaceContext),
                 });
-                this.printAgentRunSummary(this.lastAgentRunOutcome, failedEval, 0);
+                if (this.lastAgentRunOutcome) {
+                    this.printAgentRunSummary(this.lastAgentRunOutcome, failedEval, 0);
+                }
             }
             return true;
         }
@@ -3368,7 +3500,9 @@ export class ChatCommand {
         this.v3StreamingStarted = false;
         this.v3StartSeen = false;
         try {
-            const retryTaskType = this.inferAgentTaskType(rawPrompt);
+            const retryPriorPrompt = this.getPreviousActionablePrompt();
+            const retryContext = { priorPrompt: retryPriorPrompt || null };
+            const retryTaskType = inferAgentTaskTypeWithContext(rawPrompt, retryContext);
             const retryResponse = await this.api.runV3AgentWorkflow(executionPrompt, {
                 workspace: { path: this.currentProjectPath },
                 ...workspaceContext,
@@ -3376,7 +3510,7 @@ export class ChatCommand {
                 clientSurface: 'cli',
                 localMachineCapable: true,
                 agentTaskType: retryTaskType,
-                workflowType: resolveWorkflowType(retryTaskType, rawPrompt),
+                workflowType: resolveWorkflowType(retryTaskType, rawPrompt, retryContext),
                 agentTimeoutMs: resolvePlannerAgentTimeoutMs(DEFAULT_V3_AGENT_TIMEOUT_MS, retryTaskType, rawPrompt),
                 agentIdleTimeoutMs: DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS,
                 agentSoftTimeoutMs: DEFAULT_V3_AGENT_SOFT_TIMEOUT_MS,
@@ -3797,6 +3931,7 @@ export class ChatCommand {
         const o = this.lastAgentRunOutcome;
         if (!o || !o.prompt)
             return null;
+        const sourcePrompt = o.originalPrompt || o.prompt;
         const runtime = this.getRuntimeEnvironmentContext();
         const remaining = [...new Set([...o.failedTaskIds, ...o.unfinishedTaskIds])];
         const taskList = remaining.length > 0 ? remaining.join(', ') : '';
@@ -3811,9 +3946,9 @@ export class ChatCommand {
             ? '\nUse local workspace tools and local filesystem paths first; do not assume server-side workspace access.'
             : '';
         if (taskList) {
-            return `Resume the previous agent run. Re-execute only these tasks and make them pass: ${taskList}.${blockerLine}${missingLine}${envLine}${localPreferenceLine}\nOriginal request was: ${o.prompt}`;
+            return `Resume the previous agent run. Re-execute only these tasks and make them pass: ${taskList}.${blockerLine}${missingLine}${envLine}${localPreferenceLine}\nOriginal request was: ${sourcePrompt}`;
         }
-        return `Retry the previous request and make sure it finishes successfully.${blockerLine}${missingLine}${envLine}${localPreferenceLine}\nOriginal request was: ${o.prompt}`;
+        return `Retry the previous request and make sure it finishes successfully.${blockerLine}${missingLine}${envLine}${localPreferenceLine}\nOriginal request was: ${sourcePrompt}`;
     }
     computeRetryPromptSignature() {
         const o = this.lastAgentRunOutcome;
@@ -3831,9 +3966,10 @@ export class ChatCommand {
         const o = this.lastAgentRunOutcome;
         if (!o || !o.prompt)
             return null;
+        const sourcePrompt = o.originalPrompt || o.prompt;
         const remaining = [...new Set([...o.failedTaskIds, ...o.unfinishedTaskIds])];
         const taskList = remaining.length > 0 ? `\nRemaining tasks to finish: ${remaining.join(', ')}.` : '';
-        const mustChangeFiles = this.taskRequiresWorkspaceChanges(o.prompt)
+        const mustChangeFiles = this.taskRequiresWorkspaceChanges(sourcePrompt)
             ? '\nThis was a build/edit request. Do not stop after analysis or tool JSON; make real workspace file changes and verify them before finishing.'
             : '';
         const blockerLine = o.qualityBlockers.length > 0
@@ -3842,7 +3978,7 @@ export class ChatCommand {
         const missingLine = o.qualityMissing.length > 0
             ? `\nMissing pieces: ${o.qualityMissing.slice(0, 6).join(', ')}.`
             : '';
-        return `Continue the previous agent run from the current workspace state without re-doing already-completed work.${taskList}${mustChangeFiles}${blockerLine}${missingLine}\nOriginal request was: ${o.prompt}`;
+        return `Continue the previous agent run from the current workspace state without re-doing already-completed work.${taskList}${mustChangeFiles}${blockerLine}${missingLine}\nOriginal request was: ${sourcePrompt}`;
     }
     /**
      * Re-print the last agent run summary, or guide the user when there isn't one.

package/dist/utils/agentRoute.js

@@ -1,7 +1,7 @@
 /**
  * Unified agent routing: regex (instant) → optional Balanced 4B → V3 execution hints.
  */
-import { inferAgentTaskType, isTrivialHtmlPageRequest, isContinueOrRetryPrompt, hasGameIntent, hasWebPageIntent, taskRequiresWorkspaceChanges, stripExecutionShaping, } from './requestIntent.js';
+import { inferAgentTaskType, isTrivialHtmlPageRequest, isAgentContinuePrompt, isAgentRetryPrompt, 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();
@@ -74,13 +74,23 @@ function mergeLlmRoute(regexTask, prompt, parsed) {
 }
 export async function resolveAgentRoute(api, prompt) {
     const stripped = stripExecutionShaping(prompt);
-    if (isContinueOrRetryPrompt(stripped)) {
+    if (isAgentContinuePrompt(stripped)) {
         const regexTask = inferAgentTaskType(stripped);
         return {
             path: 'v3-agent',
             taskKind: regexTask === 'analysis' ? 'implementation' : regexTask,
-            confidence: 0.9,
-            reason: 'continue/retry follow-up (regex)',
+            confidence: 0.92,
+            reason: 'continue follow-up (regex)',
+            source: 'regex',
+        };
+    }
+    if (isAgentRetryPrompt(stripped)) {
+        const regexTask = inferAgentTaskType(stripped);
+        return {
+            path: 'v3-agent',
+            taskKind: regexTask === 'analysis' ? 'implementation' : regexTask,
+            confidence: 0.92,
+            reason: 'retry follow-up (regex)',
             source: 'regex',
         };
     }

package/dist/utils/api.js

@@ -2646,48 +2646,18 @@ menu {
             }
             return;
         }
-        if (event.type === 'workspace_snapshot' && event.files && typeof event.files === 'object') {
-            for (const [rawPath, content] of Object.entries(event.files)) {
-                if (typeof content !== 'string') {
-                    continue;
-                }
-                const filePath = this.normalizeAgentWorkspaceRelativePath(rawPath, serverRoot || undefined);
-                if (filePath) {
-                    streamedFiles[filePath] = content;
-                }
-            }
-            return;
-        }
-        if (event.type !== 'tool_call') {
-            if (event.type === 'tool_result' && event.success) {
-                const name = String(event.name || event.tool || '').trim();
-                const args = event.arguments || {};
-                const targetPath = typeof event.target === 'string'
-                    ? event.target
-                    : (typeof args.path === 'string' ? args.path : '');
-                if ((name === 'write_file' || name === 'edit_file') && targetPath) {
-                    const filePath = this.normalizeAgentWorkspaceRelativePath(targetPath, serverRoot || undefined);
-                    if (filePath && typeof args.content === 'string') {
-                        streamedFiles[filePath] = args.content;
-                    }
-                }
-            }
-            return;
-        }
-        const args = event.arguments || {};
-        if ((event.name === 'write_file' || event.name === 'edit_file') && typeof args.path === 'string') {
-            const filePath = this.normalizeAgentWorkspaceRelativePath(args.path, serverRoot || undefined);
-            if (!filePath) {
-                return;
-            }
-            if (event.name === 'write_file' && typeof args.content === 'string') {
-                streamedFiles[filePath] = args.content;
-                return;
-            }
-            if (event.name === 'edit_file' && typeof args.old_string === 'string' && typeof args.new_string === 'string') {
-                const existing = streamedFiles[filePath];
-                if (typeof existing === 'string' && existing.includes(args.old_string)) {
-                    streamedFiles[filePath] = existing.replace(args.old_string, args.new_string);
+        // Only count confirmed mutations — not workspace snapshots (hydrated baseline)
+        // or tool_call previews that may still fail client-side / read-only guards.
+        if (event.type === 'tool_result' && event.success) {
+            const name = String(event.name || event.tool || '').trim();
+            const args = event.arguments || {};
+            const targetPath = typeof event.target === 'string'
+                ? event.target
+                : (typeof args.path === 'string' ? args.path : '');
+            if ((name === 'write_file' || name === 'edit_file') && targetPath) {
+                const filePath = this.normalizeAgentWorkspaceRelativePath(targetPath, serverRoot || undefined);
+                if (filePath && typeof args.content === 'string') {
+                    streamedFiles[filePath] = args.content;
                 }
             }
         }

package/dist/utils/requestIntent.d.ts

@@ -2,19 +2,38 @@
  * Shared prompt intent detection for CLI routing, V3 hints, and rescue gating.
  * Keep aligned with V3-Code-Agent/agent.py _classify_request heuristics.
  */
+export type IntentContext = {
+    priorPrompt?: string | null;
+};
 /** Strip CLI-appended platform / mode shaping so it cannot flip quality profiles. */
 export declare function stripExecutionShaping(prompt: string): string;
 export declare function hasBuildVerb(prompt: string): boolean;
 export declare function hasArtifactNoun(prompt: string): boolean;
 export declare function hasGameIntent(prompt: string): boolean;
+/** True when the CLI already expanded a /continue-style follow-up prompt. */
+export declare function isBuiltContinuePrompt(prompt: string): boolean;
+/** True when the CLI already expanded a /retry-style follow-up prompt. */
+export declare function isBuiltRetryPrompt(prompt: string): boolean;
+export declare function isAgentContinuePrompt(prompt: string): boolean;
+export declare function isAgentRetryPrompt(prompt: string): boolean;
 export declare function isContinueOrRetryPrompt(prompt: string): boolean;
 export declare function hasWebPageIntent(prompt: string): boolean;
 export declare function isTrivialHtmlPageRequest(prompt: string): boolean;
 export declare function hasCloneBuildIntent(prompt: string): boolean;
+export declare function isWritePermissionGrant(prompt: string): boolean;
+/** Short or extended confirmations that should chain to the prior actionable request. */
+export declare function isConfirmationFollowUp(prompt: string): boolean;
+/** True when the CLI expanded a write-confirmation follow-up for V3. */
+export declare function isBuiltWriteConfirmationPrompt(prompt: string): boolean;
+export declare function hasFixOrCorrectIntent(prompt: string): boolean;
+export declare function isReadOnlyCheckIntent(prompt: string): boolean;
 export declare function hasExplicitWriteIntent(prompt: string): boolean;
 export declare function taskRequiresWorkspaceChanges(prompt: string): boolean;
+export declare function resolveClassificationPrompt(prompt: string, context?: IntentContext): string;
+export declare function taskRequiresWorkspaceChangesWithContext(prompt: string, context?: IntentContext): boolean;
 export declare function hasAnalyzeAndBuildIntent(prompt: string): boolean;
 export declare function inferAgentTaskType(prompt: string): string;
+export declare function inferAgentTaskTypeWithContext(prompt: string, context?: IntentContext): string;
 export declare function shouldSkipAnalysisRescue(liveOutcome: {
     tasksTotal?: number;
     changedFileCount?: number;
@@ -23,9 +42,10 @@ export declare function shouldSkipAnalysisRescue(liveOutcome: {
 export declare function isPlannerBuildTask(agentTaskType: string, prompt: string): boolean;
 export declare function resolvePlannerAgentTimeoutMs(baseTimeoutMs: number, agentTaskType: string, prompt: string): number;
 /** V3 workflow mode: suppress write path when the user did not ask for file changes. */
-export declare function resolveWorkflowType(agentTaskType: string, prompt: string): 'analysis_only' | 'full';
+export declare function resolveWorkflowType(agentTaskType: string, prompt: string, context?: IntentContext): 'analysis_only' | 'full';
 export declare function buildExecutionHints(agentTaskType: string, prompt: string, options?: {
     fastPath?: string;
+    priorPrompt?: string | null;
 }): {
     task_kind: string;
     requires_file_changes: boolean | undefined;

package/dist/utils/requestIntent.js

@@ -11,8 +11,14 @@ const GAME_INTENT = /\b(game|spiel|playable|html5\s+(?:game|canvas)|html5\s+game
 const WEB_PAGE_INTENT = /\b(website|web\s*site|webpage|web\s*page|landing\s+page|home\s*page|index\.html|html\s+page|static\s+page|single\s+page|popup|alert|modal|hello\s+world)\b/i;
 const CLONE_BUILD = /\bclone\s+of\b|\b(build|create|make)\s+(?:a|an|the|us|me)?\s*(?:clone|replica|remake|port)\b/i;
 const READ_ONLY_INTENT = /\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;
-const EXPLICIT_WRITE_VERBS = /\b(implement|write|edit|modify|update|fix|repair|create|build|generate|scaffold|deploy|refactor|develop|integrate)\b/i;
+const EXPLICIT_WRITE_VERBS = /\b(implement|write|edit|modify|update|fix|repair|create|build|generate|scaffold|deploy|refactor|develop|integrate|correct|apply|patch)\b/i;
 const TRIVIAL_HTML_PAGE = /\b(hello\s*world|simple\s+(?:html|web|page|site)|html5\s+website|html\s+5\s+website|popup|alert\s*\(|show\s+a\s+popup|one\s+page|single\s+html)\b/i;
+/** User explicitly grants write permission after an analysis or confirmation gate. */
+const WRITE_PERMISSION_GRANT = /\b(?:hereby\s+confirm|i\s+confirm|confirm(?:ed)?\s+that|give\s+(?:you|permission)|granting\s+permission|allow\s+(?:you|me\s+to)|you\s+(?:may|can|have\s+permission\s+to)|permission\s+to|authorized?\s+to|approve(?:d)?\s+(?:the\s+)?(?:changes?|writes?|edits?)|go\s+ahead\s+and(?:\s+write|\s+apply|\s+make|\s+do)?|do\s+all\s+the\s+changes|apply\s+(?:the\s+)?(?:changes?|fixes?|fix)|proceed\s+with\s+(?:the\s+)?(?:changes?|fixes?|implementation|writes?)|make\s+(?:the\s+)?changes|please\s+write)\b/i;
+/** Fix/correct/repair syntax or errors — write path without requiring artifact nouns. */
+const FIX_CORRECT_INTENT = /\b(correct|fix|repair|resolve|patch|address|remedy)\b[\s\S]{0,48}\b(syntax|errors?|bugs?|issues?|mistakes?|typos?)\b|\b(syntax|errors?|bugs?|issues?)\b[\s\S]{0,48}\b(correct|fix|repair|resolve|patch)\b/i;
+/** Read-only audit: check/review/find issues without an paired fix/implement verb nearby. */
+const READ_ONLY_CHECK = /\b(check|verify|audit|inspect|review|investigate|look\s+for|find|scan|validate|examine)\b[\s\S]{0,60}\b(syntax|errors?|bugs?|issues?|missing|gaps?|functionality)\b/i;
 /** Strip CLI-appended platform / mode shaping so it cannot flip quality profiles. */
 export function stripExecutionShaping(prompt) {
     return String(prompt || '')
@@ -41,9 +47,57 @@ export function hasGameIntent(prompt) {
     }
     return false;
 }
+const CONTINUE_VERB = /\b(?:continue|contiune|continu|proceed|resume|keep\s+going|go\s+on|carry\s+on|pick\s+up\s+where)\b/i;
+const CONTINUE_OBJECT = /\b(?:task|tasks|work|build|building|implementation|project|run|plan|planning|remaining|unfinished|missing|components?|next\s+steps?|previous|last|where\s+we\s+left|hyperloop|report)\b/i;
+/** True when the CLI already expanded a /continue-style follow-up prompt. */
+export function isBuiltContinuePrompt(prompt) {
+    return /^Continue the previous agent run/i.test(stripExecutionShaping(prompt));
+}
+/** True when the CLI already expanded a /retry-style follow-up prompt. */
+export function isBuiltRetryPrompt(prompt) {
+    const text = stripExecutionShaping(prompt);
+    return /^(?:Resume the previous agent run|Retry the previous request)/i.test(text);
+}
+export function isAgentContinuePrompt(prompt) {
+    const text = stripExecutionShaping(prompt).trim();
+    if (!text) {
+        return false;
+    }
+    if (isBuiltContinuePrompt(text) || isBuiltRetryPrompt(text)) {
+        return false;
+    }
+    if (/^\/(?:continue|contiune|contiunue)$/i.test(text)) {
+        return true;
+    }
+    if (/\bcontinue\s+(?:the\s+)?(?:previous|last|current)\s+(?:agent\s+)?run\b/i.test(text)) {
+        return true;
+    }
+    if (/\bresume\s+(?:the\s+)?(?:failed|unfinished)\b/i.test(text)) {
+        return true;
+    }
+    if (/\bplanner\s+produced\s+\d+\s+execution\s+tasks\b/i.test(text)) {
+        return true;
+    }
+    if (CONTINUE_VERB.test(text) && CONTINUE_OBJECT.test(text)) {
+        return true;
+    }
+    if (/^(?:please\s+)?(?:continue|contiune|proceed)(?:[!?.]|$)/i.test(text)) {
+        return true;
+    }
+    return false;
+}
+export function isAgentRetryPrompt(prompt) {
+    const text = stripExecutionShaping(prompt).trim();
+    if (!text || isBuiltContinuePrompt(text) || isBuiltRetryPrompt(text)) {
+        return false;
+    }
+    if (/^\/retry$/i.test(text)) {
+        return true;
+    }
+    return /\b(?:retry|re-?try)\s+(?:the\s+)?(?:failed|last|previous|unfinished)\b/i.test(text);
+}
 export function isContinueOrRetryPrompt(prompt) {
-    const text = stripExecutionShaping(prompt).toLowerCase();
-    return /\b(continue\s+(?:the\s+)?(?:previous|last|current)\s+(?:agent\s+)?run|\/retry|\/continue|resume\s+(?:the\s+)?(?:failed|unfinished)|planner\s+produced\s+\d+\s+execution\s+tasks)\b/i.test(text);
+    return isAgentContinuePrompt(prompt) || isAgentRetryPrompt(prompt);
 }
 export function hasWebPageIntent(prompt) {
     const text = stripExecutionShaping(prompt);
@@ -72,8 +126,57 @@ export function isTrivialHtmlPageRequest(prompt) {
 export function hasCloneBuildIntent(prompt) {
     return CLONE_BUILD.test(stripExecutionShaping(prompt)) && hasBuildVerb(prompt);
 }
+export function isWritePermissionGrant(prompt) {
+    const text = stripExecutionShaping(prompt);
+    return WRITE_PERMISSION_GRANT.test(text)
+        || /\ballow\s+you\s+to\s+do\s+all\s+the\s+changes\b/i.test(text)
+        || /\b(?:i\s+)?(?:allow|permit)\s+you\s+to\s+write\b/i.test(text);
+}
+/** Short or extended confirmations that should chain to the prior actionable request. */
+export function isConfirmationFollowUp(prompt) {
+    const normalized = stripExecutionShaping(prompt).trim().toLowerCase().replace(/[.!?]+$/g, '').replace(/\s+/g, ' ');
+    if (!normalized) {
+        return false;
+    }
+    if (/^(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)) {
+        return true;
+    }
+    if (/^(please\s+)?(?:do\s+it|make\s+(?:the\s+)?changes|apply\s+(?:them|the\s+fixes|changes|the\s+fix)|fix\s+(?:them|it|now)|go\s+ahead)$/.test(normalized)) {
+        return true;
+    }
+    return isWritePermissionGrant(prompt);
+}
+/** True when the CLI expanded a write-confirmation follow-up for V3. */
+export function isBuiltWriteConfirmationPrompt(prompt) {
+    return /^The user confirmed they want file changes applied/i.test(stripExecutionShaping(prompt));
+}
+export function hasFixOrCorrectIntent(prompt) {
+    return FIX_CORRECT_INTENT.test(stripExecutionShaping(prompt));
+}
+export function isReadOnlyCheckIntent(prompt) {
+    const text = stripExecutionShaping(prompt);
+    if (!READ_ONLY_CHECK.test(text)) {
+        return false;
+    }
+    if (hasFixOrCorrectIntent(prompt) || isWritePermissionGrant(prompt)) {
+        return false;
+    }
+    if (/\b(?:fix|correct|repair|implement|apply|write|change|update)\b/i.test(text)) {
+        return false;
+    }
+    return true;
+}
 export function hasExplicitWriteIntent(prompt) {
     const text = stripExecutionShaping(prompt);
+    if (isWritePermissionGrant(prompt)) {
+        return true;
+    }
+    if (hasFixOrCorrectIntent(prompt)) {
+        return true;
+    }
+    if (isReadOnlyCheckIntent(prompt)) {
+        return false;
+    }
     return (BUILD_VERBS.test(text) && ARTIFACT_NOUNS.test(text))
         || hasCloneBuildIntent(prompt)
         || (BUILD_VERBS.test(text) && hasGameIntent(prompt));
@@ -81,13 +184,41 @@ export function hasExplicitWriteIntent(prompt) {
 export function taskRequiresWorkspaceChanges(prompt) {
     const text = String(prompt || '').trim();
     const shaped = stripExecutionShaping(text);
-    const readOnlyIntent = READ_ONLY_INTENT.test(shaped);
+    const readOnlyIntent = READ_ONLY_INTENT.test(shaped) || isReadOnlyCheckIntent(text);
     const explicitWriteIntent = hasExplicitWriteIntent(text);
     if (readOnlyIntent && !explicitWriteIntent) {
         return false;
     }
     return explicitWriteIntent;
 }
+export function resolveClassificationPrompt(prompt, context = {}) {
+    if (isBuiltContinuePrompt(prompt) || isBuiltRetryPrompt(prompt) || isBuiltWriteConfirmationPrompt(prompt)) {
+        return prompt;
+    }
+    const prior = String(context.priorPrompt || '').trim();
+    if (prior && (isConfirmationFollowUp(prompt) || isWritePermissionGrant(prompt))) {
+        return `${prompt}\n\nPrior actionable request:\n${prior}`;
+    }
+    return prompt;
+}
+export function taskRequiresWorkspaceChangesWithContext(prompt, context = {}) {
+    if (isBuiltWriteConfirmationPrompt(prompt) || isWritePermissionGrant(prompt)) {
+        const prior = String(context.priorPrompt || '').trim();
+        if (prior) {
+            return true;
+        }
+        return isWritePermissionGrant(prompt);
+    }
+    const effective = resolveClassificationPrompt(prompt, context);
+    if (taskRequiresWorkspaceChanges(effective)) {
+        return true;
+    }
+    const prior = String(context.priorPrompt || '').trim();
+    if (prior && isConfirmationFollowUp(prompt)) {
+        return true;
+    }
+    return false;
+}
 export function hasAnalyzeAndBuildIntent(prompt) {
     const text = stripExecutionShaping(prompt);
     return /\b(analy[sz]e|analyse)\b/i.test(text)
@@ -96,6 +227,21 @@ export function hasAnalyzeAndBuildIntent(prompt) {
 }
 export function inferAgentTaskType(prompt) {
     const text = stripExecutionShaping(prompt);
+    if (isBuiltWriteConfirmationPrompt(prompt)) {
+        if (hasGameIntent(prompt)) {
+            return 'game-build';
+        }
+        if (hasFixOrCorrectIntent(prompt) || /\bsyntax\b/i.test(text)) {
+            return 'repair';
+        }
+        return 'implementation';
+    }
+    if (hasFixOrCorrectIntent(prompt)) {
+        if (hasGameIntent(prompt)) {
+            return 'game-build';
+        }
+        return 'repair';
+    }
     if (hasAnalyzeAndBuildIntent(prompt)) {
         if (hasGameIntent(prompt)) {
             return 'game-build';
@@ -105,7 +251,10 @@ export function inferAgentTaskType(prompt) {
         }
         return 'implementation';
     }
-    if (/\b(inspect|analyze|analyse|audit|review|find|diagnose|debug|trace|compare|diff|check|investigate)\b/i.test(text)
+    if (isReadOnlyCheckIntent(prompt)) {
+        return 'debugging';
+    }
+    if (/\b(inspect|analyze|analyse|audit|review|find|diagnose|debug|trace|compare|diff|investigate)\b/i.test(text)
         && !hasExplicitWriteIntent(prompt)) {
         return 'debugging';
     }
@@ -122,7 +271,31 @@ export function inferAgentTaskType(prompt) {
         }
         return 'implementation';
     }
-    return 'analysis';
+    if (hasExplicitWriteIntent(prompt)) {
+        return 'implementation';
+    }
+    return 'general';
+}
+export function inferAgentTaskTypeWithContext(prompt, context = {}) {
+    const prior = String(context.priorPrompt || '').trim();
+    if ((isConfirmationFollowUp(prompt) || isWritePermissionGrant(prompt) || isBuiltWriteConfirmationPrompt(prompt)) && prior) {
+        const priorType = inferAgentTaskType(prior);
+        if (isWritePermissionGrant(prompt) || isBuiltWriteConfirmationPrompt(prompt)) {
+            if (priorType === 'analysis' || priorType === 'debugging' || priorType === 'general') {
+                if (hasFixOrCorrectIntent(prior) || /\bsyntax\b/i.test(prior)) {
+                    return 'repair';
+                }
+                if (hasGameIntent(prior)) {
+                    return 'game-build';
+                }
+                return 'implementation';
+            }
+        }
+        if (priorType !== 'general') {
+            return priorType;
+        }
+    }
+    return inferAgentTaskType(resolveClassificationPrompt(prompt, context));
 }
 export function shouldSkipAnalysisRescue(liveOutcome) {
     if (liveOutcome.requiresWorkspaceChanges) {
@@ -161,22 +334,36 @@ export function resolvePlannerAgentTimeoutMs(baseTimeoutMs, agentTaskType, promp
     return Math.max(baseTimeoutMs, extended);
 }
 /** V3 workflow mode: suppress write path when the user did not ask for file changes. */
-export function resolveWorkflowType(agentTaskType, prompt) {
+export function resolveWorkflowType(agentTaskType, prompt, context = {}) {
+    if (isBuiltWriteConfirmationPrompt(prompt) || isWritePermissionGrant(prompt)) {
+        return 'full';
+    }
     if (hasAnalyzeAndBuildIntent(prompt)) {
         return 'full';
     }
-    if (!taskRequiresWorkspaceChanges(prompt)) {
+    if (isBuiltContinuePrompt(prompt) || isBuiltRetryPrompt(prompt)) {
+        return taskRequiresWorkspaceChangesWithContext(prompt, context) ? 'full' : 'analysis_only';
+    }
+    const prior = String(context.priorPrompt || '').trim();
+    if (prior && isConfirmationFollowUp(prompt)) {
+        return 'full';
+    }
+    if (!taskRequiresWorkspaceChangesWithContext(prompt, context)) {
         return 'analysis_only';
     }
     const kind = String(agentTaskType || '').toLowerCase();
-    if (kind === 'analysis' || kind === 'debugging' || kind === 'verification') {
+    if ((kind === 'analysis' || kind === 'debugging' || kind === 'verification')
+        && !hasFixOrCorrectIntent(prompt)
+        && !isWritePermissionGrant(prompt)) {
         return 'analysis_only';
     }
     return 'full';
 }
 export function buildExecutionHints(agentTaskType, prompt, options = {}) {
-    const workflowType = resolveWorkflowType(agentTaskType, prompt);
-    const kind = String(agentTaskType || 'general').toLowerCase();
+    const context = { priorPrompt: options.priorPrompt ?? null };
+    const effectiveTaskType = inferAgentTaskTypeWithContext(prompt, context);
+    const workflowType = resolveWorkflowType(effectiveTaskType, prompt, context);
+    const kind = String(effectiveTaskType || agentTaskType || 'general').toLowerCase();
     const hints = {
         task_kind: kind,
         requires_file_changes: workflowType === 'analysis_only' ? false : undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.11.27",
+  "version": "1.11.29",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "type": "module",
   "main": "dist/index.js",

package/scripts/release/validate-no-go-gates.sh

@@ -97,9 +97,23 @@ python3 - << 'PY'
 import json
 ids={m.get('id','') for m in json.load(open('/tmp/vig-models.json')).get('data',[])}
 if ids:
-  assert ('vigthoria-balanced-4b' in ids) or ('vigthoria-balanced-4b:latest' in ids) or ('vigthoria-v3-balanced-4b' in ids) or ('vigthoria-v3-balanced-4b:latest' in ids)
-  assert 'vigthoria-creative-9b-v4' in ids
-  assert any('vigthoria-v3-code-35b' in i for i in ids)
+  has_router = any(
+    m in ids for m in (
+      'vigthoria-balanced-4b', 'vigthoria-balanced-4b:latest',
+      'vigthoria-v3-balanced-4b', 'vigthoria-v3-balanced-4b:latest',
+      'vigthoria-fast-9b', 'vigthoria-fast-9b:latest',
+    )
+  )
+  has_creative = any(
+    m in ids for m in (
+      'vigthoria-creative-9b-v4', 'vigthoria-creative-9b-v4:latest',
+      'vigthoria-fast-9b', 'vigthoria-fast-9b:latest',
+    )
+  )
+  has_code = any('vigthoria-v3-code-35b' in i for i in ids)
+  assert has_router, f'missing router model in inventory: {sorted(ids)}'
+  assert has_creative, f'missing creative/fast model in inventory: {sorted(ids)}'
+  assert has_code, f'missing code model in inventory: {sorted(ids)}'
 else:
   print('[warn] model inventory empty on this host; route proof above is authoritative')
 print('[pass] model inventory gates')