vigthoria-cli 1.11.25 → 1.11.28

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;

package/dist/commands/chat.js

@@ -17,32 +17,29 @@ 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, isTrivialHtmlPageRequest, resolvePlannerAgentTimeoutMs, resolveWorkflowType, shouldSkipAnalysisRescue, taskRequiresWorkspaceChanges as promptRequiresWorkspaceChanges, buildExecutionHints, isAgentContinuePrompt, isAgentRetryPrompt, isBuiltContinuePrompt, isBuiltRetryPrompt, } 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) {
-        return 300000;
+        return 0;
     }
     const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 300000;
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
 })();
 const DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_AGENT_IDLE_TIMEOUT_MS || process.env.V3_AGENT_IDLE_TIMEOUT_MS;
     if (!rawValue) {
-        return 90000;
+        return 0;
     }
     const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 90000;
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
 })();
 const DEFAULT_V3_AGENT_SOFT_TIMEOUT_MS = (() => {
-    const rawValue = process.env.VIGTHORIA_AGENT_SOFT_TIMEOUT_MS || process.env.V3_AGENT_SOFT_TIMEOUT_MS;
-    if (!rawValue) {
-        return 180000;
-    }
+    const rawValue = process.env.VIGTHORIA_AGENT_SOFT_TIMEOUT_MS || process.env.V3_AGENT_SOFT_TIMEOUT_MS || '300000';
     const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 180000;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 300000;
 })();
 export class ChatCommand {
     config;
@@ -1408,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({
@@ -1680,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;
             }
@@ -2168,7 +2172,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
@@ -2176,13 +2181,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;
@@ -2190,12 +2195,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;
@@ -2207,7 +2212,95 @@ export class ChatCommand {
             this.saveSession();
             return;
         }
-        await this.runLocalAgentLoop(prompt);
+        await this.runLocalAgentLoop(resolvedPrompt);
+    }
+    resolveAgentTurnPrompt(prompt) {
+        if (isBuiltContinuePrompt(prompt) || isBuiltRetryPrompt(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;
+            }
+        }
+        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();
@@ -2223,8 +2316,9 @@ export class ChatCommand {
         return liveOutcome;
     }
     persistLocalLoopOutcome(prompt, evaluation, liveOutcome) {
-        this.lastAgentRunOutcome = {
+        this.commitAgentRunOutcome({
             prompt,
+            originalPrompt: null,
             taskId: null,
             contextId: null,
             tasksSucceeded: liveOutcome.tasksSucceeded,
@@ -2245,7 +2339,7 @@ export class ChatCommand {
             workspacePath: this.currentProjectPath || null,
             workspaceSyncIssue: null,
             finishedAt: Date.now(),
-        };
+        }, prompt);
     }
     async runLocalAgentLoop(prompt) {
         if (!this.tools) {
@@ -2583,8 +2677,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,
@@ -2605,7 +2700,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'));
@@ -3201,8 +3296,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,
@@ -3225,9 +3321,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) {
@@ -3299,8 +3397,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,
@@ -3321,7 +3420,7 @@ export class ChatCommand {
                 workspacePath: workspacePath || null,
                 workspaceSyncIssue: null,
                 finishedAt: Date.now(),
-            };
+            }, prompt);
             if (!this.jsonOutput) {
                 process.exitCode = 1;
             }
@@ -3349,7 +3448,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;
         }
@@ -3800,6 +3901,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(', ') : '';
@@ -3814,9 +3916,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;
@@ -3834,9 +3936,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
@@ -3845,7 +3948,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

@@ -259,15 +259,18 @@ export function propagateError(err) {
 const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS;
     if (!rawValue) {
-        return 300000;
+        return 0;
     }
     const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 300000;
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
 })();
 const DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS = (() => {
-    const rawValue = process.env.VIGTHORIA_AGENT_IDLE_TIMEOUT_MS || process.env.V3_AGENT_IDLE_TIMEOUT_MS || '90000';
+    const rawValue = process.env.VIGTHORIA_AGENT_IDLE_TIMEOUT_MS || process.env.V3_AGENT_IDLE_TIMEOUT_MS;
+    if (!rawValue) {
+        return 0;
+    }
     const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 90000;
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
 })();
 const DEFAULT_OPERATOR_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_OPERATOR_TIMEOUT_MS || process.env.OPERATOR_TIMEOUT_MS;
@@ -2643,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;
                 }
             }
         }
@@ -2851,9 +2824,30 @@ menu {
                 return { success: true, output: matches.slice(0, 100).join('\n') || '(no matches)' };
             }
             if (name === 'syntax_check') {
-                const content = fs.readFileSync(target.absolutePath, 'utf8');
-                if (/\.json$/i.test(target.absolutePath))
-                    JSON.parse(content);
+                if (!fs.existsSync(target.absolutePath)) {
+                    return {
+                        success: false,
+                        output: '',
+                        error: `File not found: ${target.relativePath}. Write the file before running syntax_check.`,
+                    };
+                }
+                const ext = path.extname(target.absolutePath).toLowerCase();
+                if (ext === '.json') {
+                    JSON.parse(fs.readFileSync(target.absolutePath, 'utf8'));
+                    return { success: true, output: `Syntax check passed: ${target.relativePath}` };
+                }
+                if (ext === '.js' || ext === '.mjs' || ext === '.cjs') {
+                    const { execSync } = await import('child_process');
+                    try {
+                        execSync(`node --check "${target.absolutePath}"`, { stdio: 'pipe' });
+                        return { success: true, output: `Syntax check passed: ${target.relativePath}` };
+                    }
+                    catch (error) {
+                        const stderr = error?.stderr?.toString?.() || error?.message || String(error);
+                        return { success: false, output: '', error: stderr.trim() || `Syntax check failed: ${target.relativePath}` };
+                    }
+                }
+                fs.readFileSync(target.absolutePath, 'utf8');
                 return { success: true, output: `Syntax check passed: ${target.relativePath}` };
             }
             if (name === 'run_command') {
@@ -3563,48 +3557,71 @@ document.addEventListener('DOMContentLoaded', () => {
         this.activeV3StreamContext = context;
         context.__v3StreamedFiles = streamedFiles;
         const idleTimeoutMs = (() => {
-            const base = context.agentIdleTimeoutMs || DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS;
-            if (isPlannerBuildTask(String(context.agentTaskType || ''), String(context.rawPrompt || ''))) {
-                const raw = process.env.VIGTHORIA_AGENT_PLANNER_IDLE_TIMEOUT_MS || '300000';
-                const extended = Number.parseInt(raw, 10);
-                return Math.max(base, Number.isFinite(extended) && extended > 0 ? extended : 300000);
+            const base = context.agentIdleTimeoutMs ?? DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS;
+            if (base <= 0) {
+                return 0;
             }
-            return base;
+            if (!isPlannerBuildTask(String(context.agentTaskType || ''), String(context.rawPrompt || ''))) {
+                return base;
+            }
+            const raw = process.env.VIGTHORIA_AGENT_PLANNER_IDLE_TIMEOUT_MS || process.env.V3_AGENT_PLANNER_IDLE_TIMEOUT_MS;
+            if (!raw) {
+                return base;
+            }
+            const extended = Number.parseInt(raw, 10);
+            return Number.isFinite(extended) && extended > 0 ? Math.max(base, extended) : base;
         })();
         try {
             while (true) {
                 let chunk;
                 try {
-                    const readPromise = reader.read();
-                    while (true) {
-                        const timeoutSentinel = Symbol('v3-agent-idle-timeout');
-                        const result = idleTimeoutMs > 0
-                            ? await Promise.race([
-                                readPromise,
-                                new Promise((resolve) => {
-                                    setTimeout(() => resolve(timeoutSentinel), idleTimeoutMs);
-                                }),
-                            ])
-                            : await readPromise;
-                        if (result !== timeoutSentinel) {
-                            chunk = result;
-                            break;
-                        }
-                        if (this.pendingV3ClientToolTasks.size > 0) {
-                            continue;
-                        }
-                        if (this.hasAgentWorkspaceOutput(context)) {
-                            const stalledError = new Error('V3 agent stream stalled after writing workspace output');
-                            stalledError.name = 'AbortError';
-                            stalledError.partialData = {
-                                task_id: events.find((event) => event && event.task_id)?.task_id || null,
-                                context_id: contextId,
-                                result: final,
-                                events,
-                                files: streamedFiles,
+                    if (idleTimeoutMs <= 0) {
+                        chunk = await reader.read();
+                    }
+                    else {
+                        chunk = await new Promise((resolve, reject) => {
+                            let idleTimer = null;
+                            const clearIdleTimer = () => {
+                                if (idleTimer) {
+                                    clearTimeout(idleTimer);
+                                    idleTimer = null;
+                                }
                             };
-                            throw stalledError;
-                        }
+                            const scheduleIdleTimer = () => {
+                                clearIdleTimer();
+                                idleTimer = setTimeout(() => {
+                                    if (this.pendingV3ClientToolTasks.size > 0) {
+                                        scheduleIdleTimer();
+                                        return;
+                                    }
+                                    if (this.hasAgentWorkspaceOutput(context)) {
+                                        const stalledError = new Error('V3 agent stream stalled after writing workspace output');
+                                        stalledError.name = 'AbortError';
+                                        stalledError.partialData = {
+                                            task_id: events.find((event) => event && event.task_id)?.task_id || null,
+                                            context_id: contextId,
+                                            result: final,
+                                            events,
+                                            files: streamedFiles,
+                                        };
+                                        clearIdleTimer();
+                                        reject(stalledError);
+                                        return;
+                                    }
+                                    scheduleIdleTimer();
+                                }, idleTimeoutMs);
+                            };
+                            scheduleIdleTimer();
+                            reader.read()
+                                .then((result) => {
+                                clearIdleTimer();
+                                resolve(result);
+                            })
+                                .catch((error) => {
+                                clearIdleTimer();
+                                reject(error);
+                            });
+                        });
                     }
                 }
                 catch (error) {
@@ -3770,11 +3787,7 @@ document.addEventListener('DOMContentLoaded', () => {
         const resolvedModel = this.resolvePermittedModelId(requestedModel);
         const preferLocalV3 = /(premium|polished|landing|site|page|dashboard|saas|frontend|ui|responsive|animated|create the required project files and write them to the workspace)/i.test(message)
             && context.localMachineCapable !== false;
-        const rescueEligibleSaaS = preferLocalV3
-            && /(saas|dashboard|analytics|billing|team management|activity feed|login screen)/i.test(message);
-        const timeoutMs = rescueEligibleSaaS
-            ? Math.min(resolvePlannerAgentTimeoutMs(baseTimeoutMs, String(executionContext.agentTaskType || ''), String(executionContext.rawPrompt || message || '')), 210000)
-            : resolvePlannerAgentTimeoutMs(baseTimeoutMs, String(executionContext.agentTaskType || ''), String(executionContext.rawPrompt || message || ''));
+        const timeoutMs = resolvePlannerAgentTimeoutMs(baseTimeoutMs, String(executionContext.agentTaskType || ''), String(executionContext.rawPrompt || message || ''));
         const maxAttempts = preferLocalV3 ? 2 : 1;
         let lastErrors = [];
         for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
@@ -5560,11 +5573,20 @@ document.addEventListener('DOMContentLoaded', () => {
             'vigthoria-code': 'vigthoria-v3-code-35b',
             'vigthoria-agent': 'vigthoria-v3-code-35b',
             // ═══════════════════════════════════════════════════════════════
-            // VIGTHORIA CLOUD - Premium cloud models (internal routing)
+            // VIGTHORIA CLOUD - current billing catalog aliases
             // ═══════════════════════════════════════════════════════════════
-            'cloud': 'vigthoria-cloud-pro',
-            'cloud-reason': 'vigthoria-cloud-k2',
-            'ultra': 'vigthoria-cloud-ultra',
+            'cloud': 'vigthoria-cloud-balanced',
+            'cloud-code': 'vigthoria-cloud-code',
+            'cloud-balanced': 'vigthoria-cloud-balanced',
+            'cloud-fast': 'vigthoria-cloud-fast',
+            'cloud-power': 'vigthoria-cloud-power',
+            'cloud-maximum': 'vigthoria-cloud-maximum',
+            'cloud-reason': 'vigthoria-cloud-power',
+            'ultra': 'vigthoria-cloud-maximum',
+            // Legacy aliases kept for backward compatibility
+            'cloud-pro': 'vigthoria-cloud-power',
+            'cloud-k2': 'vigthoria-cloud-power',
+            'cloud-ultra': 'vigthoria-cloud-maximum',
         };
         // If already a full model ID, return as-is
         if (shortName.includes('vigthoria') || shortName.includes('/') || shortName.includes(':')) {

package/dist/utils/requestIntent.d.ts

@@ -7,6 +7,12 @@ 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;

package/dist/utils/requestIntent.js

@@ -41,9 +41,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);
@@ -150,16 +198,24 @@ export function resolvePlannerAgentTimeoutMs(baseTimeoutMs, agentTaskType, promp
     if (!isPlannerBuildTask(agentTaskType, prompt)) {
         return baseTimeoutMs;
     }
-    const raw = process.env.VIGTHORIA_AGENT_PLANNER_TIMEOUT_MS || process.env.V3_AGENT_PLANNER_TIMEOUT_MS || '900000';
+    const raw = process.env.VIGTHORIA_AGENT_PLANNER_TIMEOUT_MS || process.env.V3_AGENT_PLANNER_TIMEOUT_MS;
+    if (!raw) {
+        return baseTimeoutMs;
+    }
     const extended = Number.parseInt(raw, 10);
-    const floor = Number.isFinite(extended) && extended > 0 ? extended : 900000;
-    return Math.max(baseTimeoutMs, floor);
+    if (!Number.isFinite(extended) || extended <= 0) {
+        return baseTimeoutMs;
+    }
+    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) {
     if (hasAnalyzeAndBuildIntent(prompt)) {
         return 'full';
     }
+    if (isBuiltContinuePrompt(prompt) || isBuiltRetryPrompt(prompt)) {
+        return taskRequiresWorkspaceChanges(prompt) ? 'full' : 'analysis_only';
+    }
     if (!taskRequiresWorkspaceChanges(prompt)) {
         return 'analysis_only';
     }

package/dist/utils/v3-workspace-path.js

@@ -36,7 +36,7 @@ export function normalizeV3WorkspaceRelativePath(rawPath, rootPath) {
         return null;
     };
     const decodeBoundaryUri = (value) => {
-        const match = value.match(/^vigthoria:\/\/(?:workspace|server-internal)\/?(.*)$/i);
+        const match = value.match(/^vigthoria:\/\/(?:workspace|server-internal|local-workspace)\/?(.*)$/i);
         if (match) {
             return safeRelative(match[1] || '');
         }

package/package.json

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