vigthoria-cli 1.11.29 → 1.11.36

package/dist/commands/chat.d.ts

@@ -54,6 +54,7 @@ export declare class ChatCommand {
     private v3SeenToolResults;
     private v3StartSeen;
     private lastAgentRoute;
+    private pendingGoaContext;
     private lastAgentRunOutcome;
     private isJwtExpirationError;
     private isNetworkError;
@@ -116,6 +117,8 @@ export declare class ChatCommand {
     private v3IterationCount;
     private v3ToolCallCount;
     private v3LastActivity;
+    private v3IdleWatchInterval;
+    private v3IdleNoticeShown;
     private v3StreamingStarted;
     /**
      * Strip server-internal path prefixes from tool output strings.
@@ -123,6 +126,8 @@ export declare class ChatCommand {
      */
     private sanitizeServerPath;
     private stripHiddenThoughtBlocks;
+    private startV3IdleWatch;
+    private stopV3IdleWatch;
     private describeV3AgentTool;
     private terminalColumns;
     private fitTerminalText;

package/dist/commands/chat.js

@@ -17,9 +17,11 @@ 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 { formatGoaSystemGrounding, splitGoaContextFromInput, } from '../utils/goaEvents.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';
+import { isV3StreamKeepaliveEvent } from '../utils/v3-stream-events.js';
 const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS;
     if (!rawValue) {
@@ -76,6 +78,7 @@ export class ChatCommand {
     v3SeenToolResults = new Set();
     v3StartSeen = false;
     lastAgentRoute = null;
+    pendingGoaContext = null;
     // Last completed Agent run — used by /retry, /continue, and the final summary block.
     lastAgentRunOutcome = null;
     isJwtExpirationError(error) {
@@ -781,6 +784,8 @@ export class ChatCommand {
     v3IterationCount = 0;
     v3ToolCallCount = 0;
     v3LastActivity = Date.now();
+    v3IdleWatchInterval = null;
+    v3IdleNoticeShown = false;
     v3StreamingStarted = false;
     /**
      * Strip server-internal path prefixes from tool output strings.
@@ -796,10 +801,41 @@ export class ChatCommand {
             return text;
         return text
             .replace(/<\|mask_start\|>[\s\S]*?<\|mask_end\|>/g, '')
-            .replace(/<think>[\s\S]*?<\/think>/gi, '')
+            .replace(/<think>[\s\S]*?<\/redacted_thinking>/gi, '')
+            .replace(/<thinking>[\s\S]*?<\/thinking>/gi, '')
+            .replace(/<\/redacted_thinking>/gi, '')
+            .replace(/<\/thinking>/gi, '')
             .replace(/<\|(?:mask_start|mask_end)\|>/g, '')
             .trim();
     }
+    startV3IdleWatch(spinner) {
+        this.stopV3IdleWatch();
+        this.v3IdleNoticeShown = false;
+        if (this.jsonOutput || !spinner) {
+            return;
+        }
+        this.v3IdleWatchInterval = setInterval(() => {
+            const idleMs = Date.now() - this.v3LastActivity;
+            if (idleMs < 15_000 || this.v3IdleNoticeShown) {
+                return;
+            }
+            this.v3IdleNoticeShown = true;
+            if (spinner.isSpinning) {
+                spinner.stop();
+            }
+            const seconds = Math.round(idleMs / 1000);
+            process.stderr.write(chalk.yellow(`  [Wait] Model still working (${seconds}s) — large context or server retry may take up to 90s...\n`));
+            spinner.start();
+            spinner.text = 'Waiting for model response...';
+        }, 5_000);
+    }
+    stopV3IdleWatch() {
+        if (this.v3IdleWatchInterval) {
+            clearInterval(this.v3IdleWatchInterval);
+            this.v3IdleWatchInterval = null;
+        }
+        this.v3IdleNoticeShown = false;
+    }
     describeV3AgentTool(toolName) {
         const normalized = String(toolName || '').toLowerCase();
         if (/read|grep|search|list|find|glob/.test(normalized)) {
@@ -934,6 +970,7 @@ export class ChatCommand {
             return '';
         output = output.replace(/<\/think>/gi, '</thinking>');
         output = output.replace(/<think>/gi, '<thinking>');
+        output = output.replace(/<\/redacted_thinking>/gi, '</thinking>');
         if (this.v3SuppressThinkingStream) {
             const closeIdx = output.search(/<\/thinking>/i);
             if (closeIdx < 0) {
@@ -979,6 +1016,9 @@ export class ChatCommand {
             return;
         }
         this.v3LastActivity = Date.now();
+        if (isV3StreamKeepaliveEvent(event)) {
+            return;
+        }
         if (event.type === 'tool_call') {
             const eventKey = this.toolEventKey(event);
             if (this.v3SeenToolCalls.has(eventKey)) {
@@ -1091,6 +1131,13 @@ export class ChatCommand {
                 : (event.content || '');
             if (text) {
                 this.v3LastActivity = Date.now();
+                if (event.type === 'message' && /^\[Context\]/i.test(String(text).trim())) {
+                    if (spinner.isSpinning)
+                        spinner.stop();
+                    process.stderr.write(chalk.cyan(`  ${this.fitTerminalText(String(text).trim(), 8)}\n`));
+                    spinner.text = 'Analyzing...';
+                    return;
+                }
                 this.writeV3StreamText(spinner, text);
             }
             else {
@@ -1138,11 +1185,6 @@ export class ChatCommand {
             const quality = this.sanitizeServerPath(plan.quality_profile || '');
             const status = typeof plan.status === 'string' ? plan.status : '';
             const summary = typeof plan.summary === 'string' ? this.sanitizeServerPath(plan.summary) : '';
-            if (status === 'planning') {
-                const elapsed = Number.isFinite(Number(plan.elapsed_seconds)) ? Number(plan.elapsed_seconds) : 0;
-                spinner.text = elapsed > 0 ? `Planning... (${elapsed}s elapsed)` : 'Planning...';
-                return;
-            }
             if (spinner.isSpinning)
                 spinner.stop();
             process.stdout.write(chalk.cyan(`  [Plan] `) + this.fitTerminalText(`Task: ${planKind || 'analyzing'}${quality ? ` (${quality})` : ''}`, 9) + '\n');
@@ -1721,6 +1763,10 @@ export class ChatCommand {
         return false;
     }
     async handleDirectPrompt(prompt) {
+        const { goaContext, userPrompt } = splitGoaContextFromInput(prompt);
+        if (goaContext)
+            this.pendingGoaContext = goaContext;
+        const effectivePrompt = userPrompt || prompt;
         // Suppress all setup banners in direct-prompt mode so only the final
         // answer reaches stdout.  Interactive (REPL) mode still shows them.
         if (!this.jsonOutput) {
@@ -1733,18 +1779,18 @@ export class ChatCommand {
             console.log();
         }
         if (this.workflowTarget) {
-            await this.runWorkflowTargetPrompt(prompt);
+            await this.runWorkflowTargetPrompt(effectivePrompt);
             return;
         }
         // Smart routing: for agent mode, determine if prompt needs tool access
         if (this.agentMode) {
-            if (this.isSimpleDirectPrompt(prompt)) {
+            if (this.isSimpleDirectPrompt(effectivePrompt)) {
                 // Simple prompt: downgrade to plain chat model, no agent system prompt
                 this.currentModel = this.getDefaultChatModel();
-                await this.runSimplePrompt(prompt);
+                await this.runSimplePrompt(effectivePrompt);
             }
             else {
-                await this.runAgentTurn(prompt);
+                await this.runAgentTurn(effectivePrompt);
             }
             return;
         }
@@ -1753,10 +1799,10 @@ export class ChatCommand {
                 this.logger.error(this.operatorAccessMessage());
                 return;
             }
-            await this.runOperatorTurn(prompt);
+            await this.runOperatorTurn(effectivePrompt);
             return;
         }
-        await this.runSimplePrompt(prompt);
+        await this.runSimplePrompt(effectivePrompt);
     }
     formatWorkflowTargetResult(result) {
         if (typeof result === 'string') {
@@ -2187,7 +2233,19 @@ export class ChatCommand {
         if (!this.tools) {
             throw new Error('Agent tools are not initialized.');
         }
-        const resolvedPrompt = this.resolveAgentTurnPrompt(prompt);
+        const { goaContext, userPrompt } = splitGoaContextFromInput(prompt);
+        if (goaContext) {
+            this.pendingGoaContext = goaContext;
+        }
+        const effectivePrompt = userPrompt || prompt;
+        if (this.pendingGoaContext) {
+            this.messages.push({
+                role: 'system',
+                content: formatGoaSystemGrounding(this.pendingGoaContext),
+            });
+            this.pendingGoaContext = null;
+        }
+        const resolvedPrompt = this.resolveAgentTurnPrompt(effectivePrompt);
         this.lastAgentRoute = await resolveAgentRoute(this.api, resolvedPrompt);
         if (!this.jsonOutput) {
             const r = this.lastAgentRoute;
@@ -2942,6 +3000,7 @@ export class ChatCommand {
             spinner: 'clock',
             isSilent: true,
         }).start();
+        this.startV3IdleWatch(spinner);
         // Live run telemetry, used both for the final summary block and for /retry, /continue.
         const liveOutcome = {
             ...createLiveOutcome(),
@@ -3003,6 +3062,21 @@ export class ChatCommand {
             fastPath: this.lastAgentRoute?.fastPath,
             priorPrompt: priorPrompt || null,
         });
+        const priorOutcome = this.lastAgentRunOutcome;
+        const resumeTaskIds = priorOutcome
+            ? [...new Set([...(priorOutcome.failedTaskIds || []), ...(priorOutcome.unfinishedTaskIds || [])])]
+            : [];
+        const shouldResumePlan = isAgentContinuePrompt(contextualPrompt)
+            || isAgentRetryPrompt(contextualPrompt)
+            || isBuiltContinuePrompt(contextualPrompt)
+            || isBuiltRetryPrompt(contextualPrompt);
+        const agentExecutionHints = shouldResumePlan
+            ? {
+                ...executionHints,
+                resume_existing_plan: true,
+                ...(resumeTaskIds.length > 0 ? { remaining_task_ids: resumeTaskIds } : {}),
+            }
+            : executionHints;
         const workspaceContext = {
             workspacePath: workspacePath,
             projectPath: workspacePath,
@@ -3039,7 +3113,7 @@ export class ChatCommand {
                 ...workspaceContext,
                 agentTaskType,
                 workflowType,
-                executionHints,
+                executionHints: agentExecutionHints,
                 fastPath: this.lastAgentRoute?.fastPath,
                 agentRoute: this.lastAgentRoute,
                 executionSurface: 'cli',
@@ -3057,20 +3131,15 @@ export class ChatCommand {
                 history: this.getMessagesForModel(),
                 ...runtimeContext,
                 onStreamEvent: (event) => {
+                    if (isV3StreamKeepaliveEvent(event)) {
+                        return;
+                    }
                     if (event.type === 'plan') {
-                        const plan = event?.plan || {};
-                        const isPlanningKeepalive = plan.status === 'planning' && !Array.isArray(plan.tasks);
-                        if (isPlanningKeepalive) {
-                            const elapsed = Number.isFinite(Number(plan.elapsed_seconds)) ? Number(plan.elapsed_seconds) : 0;
-                            taskDisplay.start(0, elapsed > 0 ? `planning (${elapsed}s)` : 'planning...');
-                        }
-                        else {
-                            taskDisplay.complete(0);
-                            const tasks = plan?.tasks;
-                            if (Array.isArray(tasks) && tasks.length > 0) {
-                                taskDisplay.start(1);
-                                liveOutcome.tasksTotal = tasks.length;
-                            }
+                        taskDisplay.complete(0);
+                        const tasks = event?.plan?.tasks;
+                        if (Array.isArray(tasks) && tasks.length > 0) {
+                            taskDisplay.start(1);
+                            liveOutcome.tasksTotal = tasks.length;
                         }
                     }
                     else if (event.type === 'executor_start') {
@@ -3113,10 +3182,19 @@ export class ChatCommand {
                     }
                     else if (event.type === 'error') {
                         const msg = typeof event.message === 'string' ? event.message : '';
-                        if (/plan|planner|dependency graph/i.test(msg)) {
+                        parsePlannerSummary(msg);
+                        const plannerSummary = /Planner-Executor completed/i.test(msg);
+                        const allTasksSucceeded = liveOutcome.tasksTotal > 0
+                            && liveOutcome.tasksSucceeded >= liveOutcome.tasksTotal
+                            && liveOutcome.failedTaskIds.size === 0;
+                        if (plannerSummary) {
+                            if (!allTasksSucceeded && !liveOutcome.plannerError) {
+                                liveOutcome.plannerError = msg;
+                            }
+                        }
+                        else if (/plan|planner|dependency graph/i.test(msg)) {
                             if (!liveOutcome.plannerError)
                                 liveOutcome.plannerError = msg;
-                            parsePlannerSummary(msg);
                         }
                         else if (/executor|task failed|iteration/i.test(msg)) {
                             if (!liveOutcome.executorError)
@@ -3189,8 +3267,8 @@ export class ChatCommand {
                     console.log(chalk.yellow(`Template Service preview gate: failed${previewGate.error ? ` - ${previewGate.error}` : ''}`));
                 }
             }
-            // Show change summary for files touched by the agent
-            if (!this.jsonOutput && !this.directPromptMode && response.changedFiles) {
+            // Show change summary only when the agent actually wrote files this run
+            if (!this.jsonOutput && !this.directPromptMode && response.changedFiles && requiresWorkspaceChanges) {
                 const fileCount = changedFileCount;
                 if (fileCount > 0) {
                     console.log(chalk.gray(`\nFiles changed: ${fileCount}`));
@@ -3384,10 +3462,12 @@ export class ChatCommand {
                 }, null, 2));
             }
             this.messages.push({ role: 'assistant', content: finalAnswer || runEvaluation.statusHeadline });
+            this.stopV3IdleWatch();
             watcher?.stop();
             return true;
         }
         catch (error) {
+            this.stopV3IdleWatch();
             watcher?.stop();
             if (!this.api.hasAgentWorkspaceOutput(workspaceContext)) {
                 const recovered = await this.tryRecoverV3ServiceAndRetry(executionPrompt, prompt, workspaceContext, routingPolicy, spinner, error);
@@ -3601,7 +3681,12 @@ export class ChatCommand {
             return lines.join('\n');
         };
         while (true) {
-            const input = await readMultiLineInput();
+            const rawInput = await readMultiLineInput();
+            const { goaContext, userPrompt: strippedInput } = splitGoaContextFromInput(rawInput);
+            if (goaContext) {
+                this.pendingGoaContext = goaContext;
+            }
+            const input = strippedInput || rawInput;
             const trimmed = input.trim();
             if (!trimmed) {
                 continue;

package/dist/utils/agentRunOutcome.d.ts

@@ -34,6 +34,10 @@ export interface RunEvaluation {
 }
 export declare function createLiveOutcome(): LiveOutcome;
 export declare function isExecutorTimeoutFailure(liveOutcome: LiveOutcome): boolean;
+export declare function isInferenceDegradedFailure(liveOutcome: LiveOutcome): boolean;
+/** Strip model thinking blocks and stray closing tags from user-visible answer text. */
+export declare function stripAgentThinkingTags(text: string): string;
+export declare function isGenericFallbackAnswer(text: string): boolean;
 /** Tool-trace stubs like `[read_file] "index.html"` or `<read_file>…</read_file>` — not a user-facing answer. */
 export declare function isToolEvidenceStubAnswer(text: string): boolean;
 /** True when text looks like a real answer, not an executor/system placeholder. */

package/dist/utils/agentRunOutcome.js

@@ -30,10 +30,21 @@ const LIST_ONLY_DISCOVERY_TOOLS = new Set([
     'dir',
 ]);
 const GENERIC_SUMMARY_RE = /^(completed the requested analysis|reviewed the workspace without writing changes|task completed|done|finished|analysis completed)([.\s]|$)/i;
+/** Planner fallback / degraded inference — generic greeting unrelated to the user question. */
+const GENERIC_FALLBACK_GREETING_RE = /^(?:hello!?|hi!?|hey!?)\s*(?:how can i assist|how can i help|what would you like|whether you'?re looking to build)/i;
+/** System-prompt fragments leaked when the model falls back without real context. */
+const SYSTEM_PROMPT_LEAK_RE = /avoid global namespace pollution unless explicitly needed|minify assets only when explicitly requested|include proper accessibility attributes \(aria-label/i;
 export function isExecutorTimeoutFailure(liveOutcome) {
     const errorText = String(liveOutcome.executorError || '').trim();
     return /executor llm call timed out|fast fallback also failed|executor model timed out/i.test(errorText);
 }
+export function isInferenceDegradedFailure(liveOutcome) {
+    const answer = stripAgentThinkingTags(liveOutcome.answerContent || '');
+    if (!answer)
+        return false;
+    return isGenericFallbackAnswer(answer)
+        && (liveOutcome.analysisToolsUsed > 0 || liveOutcome.requiresWorkspaceChanges);
+}
 function looksLikeRawV3EventPayload(text) {
     const trimmed = String(text || '').trim();
     if (!/^[{[]/.test(trimmed))
@@ -56,9 +67,34 @@ function looksLikeRawV3EventPayload(text) {
         return false;
     }
 }
+/** Strip model thinking blocks and stray closing tags from user-visible answer text. */
+export function stripAgentThinkingTags(text) {
+    let output = String(text || '');
+    if (!output)
+        return '';
+    output = output.replace(/<\/think>/gi, '</thinking>');
+    output = output.replace(/<think>/gi, '<thinking>');
+    output = output.replace(/<\/redacted_thinking>/gi, '</thinking>');
+    output = output.replace(/<thinking>[\s\S]*?<\/thinking>/gi, '');
+    output = output.replace(/<thinking>[\s\S]*$/i, '');
+    output = output.replace(/<\/thinking>/gi, '');
+    return output.trim();
+}
+export function isGenericFallbackAnswer(text) {
+    const trimmed = stripAgentThinkingTags(text);
+    if (!trimmed)
+        return true;
+    if (GENERIC_FALLBACK_GREETING_RE.test(trimmed))
+        return true;
+    if (SYSTEM_PROMPT_LEAK_RE.test(trimmed))
+        return true;
+    if (/^now,?\s+i'?m ready to assist/i.test(trimmed) && trimmed.length < 400)
+        return true;
+    return false;
+}
 /** Tool-trace stubs like `[read_file] "index.html"` or `<read_file>…</read_file>` — not a user-facing answer. */
 export function isToolEvidenceStubAnswer(text) {
-    const trimmed = String(text || '').trim();
+    const trimmed = stripAgentThinkingTags(text);
     if (!trimmed)
         return true;
     if (looksLikeRawV3EventPayload(trimmed))
@@ -89,13 +125,15 @@ export function isToolEvidenceStubAnswer(text) {
 }
 /** True when text looks like a real answer, not an executor/system placeholder. */
 export function isSubstantiveAgentAnswer(text) {
-    const trimmed = String(text || '').trim();
+    const trimmed = stripAgentThinkingTags(text);
     if (trimmed.length < 80)
         return false;
     if (EXECUTOR_PLACEHOLDER_RE.test(trimmed))
         return false;
     if (/^v3 agent workflow completed\.?$/i.test(trimmed))
         return false;
+    if (isGenericFallbackAnswer(trimmed))
+        return false;
     if (isToolEvidenceStubAnswer(trimmed))
         return false;
     return true;
@@ -103,7 +141,7 @@ export function isSubstantiveAgentAnswer(text) {
 /** Pick the first substantive answer from response body and/or streamed text. */
 export function normalizeAgentAnswerContent(...sources) {
     for (const source of sources) {
-        const text = String(source || '').trim();
+        const text = stripAgentThinkingTags(String(source || ''));
         if (isSubstantiveAgentAnswer(text))
             return text;
     }
@@ -206,6 +244,23 @@ export function evaluateExecutorSuccess(liveOutcome) {
         const allTasksPassed = liveOutcome.tasksSucceeded === liveOutcome.tasksTotal;
         const partialTasksPassed = liveOutcome.tasksSucceeded > 0;
         const failedCount = liveOutcome.failedTaskIds.size;
+        if (allTasksPassed && failedCount === 0 && !liveOutcome.streamAborted) {
+            const qualityOnlyPlannerNote = Boolean(liveOutcome.plannerError)
+                && /Planner-Executor completed:\s*\d+\s*\/\s*\d+\s+tasks succeeded/i.test(String(liveOutcome.plannerError));
+            const recoveredAfterTransientErrors = liveOutcome.executorFailed
+                || Boolean(liveOutcome.executorError)
+                || qualityOnlyPlannerNote;
+            if (!liveOutcome.plannerError || qualityOnlyPlannerNote || recoveredAfterTransientErrors) {
+                const qualityNote = qualityOnlyPlannerNote || /Quality (?:audit|blockers)/i.test(String(liveOutcome.plannerError || ''));
+                return {
+                    executorSucceeded: true,
+                    statusHeadline: qualityNote
+                        ? `✓ Tasks complete (${liveOutcome.tasksSucceeded}/${liveOutcome.tasksTotal}) — quality audit below target`
+                        : `✓ Agent run finished (${liveOutcome.tasksSucceeded}/${liveOutcome.tasksTotal} tasks completed)`,
+                    uiTheme: qualityNote ? 'warning' : 'success',
+                };
+            }
+        }
         if (allTasksPassed && !hasFatalError) {
             return {
                 executorSucceeded: true,
@@ -235,6 +290,13 @@ export function evaluateExecutorSuccess(liveOutcome) {
             || (liveOutcome.analysisToolsUsed >= 4
                 && liveOutcome.analysisReadToolsUsed >= 3
                 && answerText.length >= 700);
+        if (isInferenceDegradedFailure(liveOutcome)) {
+            return {
+                executorSucceeded: false,
+                statusHeadline: '✕ Model inference degraded — generic fallback answer, not your question — try /retry',
+                uiTheme: 'error',
+            };
+        }
         if (hasFatalError && !hasSubstantiveAnswer) {
             return {
                 executorSucceeded: false,
@@ -276,6 +338,13 @@ export function evaluateExecutorSuccess(liveOutcome) {
             uiTheme: 'success',
         };
     }
+    if (isInferenceDegradedFailure(liveOutcome)) {
+        return {
+            executorSucceeded: false,
+            statusHeadline: '✕ Model inference degraded — server could not run the code model — try /retry in a minute',
+            uiTheme: 'error',
+        };
+    }
     const legacySuccess = liveOutcome.workspaceHasOutput && liveOutcome.changedFileCount > 0;
     return {
         executorSucceeded: legacySuccess && !hasFatalError,

package/dist/utils/api.d.ts

@@ -272,6 +272,7 @@ export declare class APIClient {
      */
     isAnalysisOnlyTask(message?: string, context?: Record<string, any>): boolean;
     private normalizeWorkspaceRelativePath;
+    private collectAgentStateSyncPaths;
     private listFrontendWorkspaceFiles;
     private chooseFrontendPreviewEntry;
     private extractLinkedFrontendAssets;
@@ -322,8 +323,11 @@ export declare class APIClient {
         executionOptions?: Record<string, unknown>;
     }): Promise<VigFlowExecutionResult>;
     getVigFlowExecutionStatus(executionId: string): Promise<VigFlowExecutionStatus>;
-    /** Maximum serialized context length accepted by the V3 server. */
+    /** Legacy cap — prefer resolveV3ContextCharLimit() for token-aligned budgets. */
     private static readonly V3_CONTEXT_CHAR_LIMIT;
+    private static readonly HYDRATION_PRIORITY_BASENAMES;
+    /** Keep critical workspace files for server hydration when context must shrink. */
+    private compactWorkspaceFilesToBudget;
     buildV3AgentContext(context?: Record<string, any>): string;
     /**
      * Compact a V3 context payload so the serialized JSON stays under
@@ -335,6 +339,9 @@ export declare class APIClient {
      *   5. Drop readmeExcerpt
      */
     private compactV3Context;
+    /** Normalize common Unix-only commands before Windows cmd/powershell execution. */
+    private normalizeWindowsRunCommand;
+    private resolveRunCommandCwd;
     /** Remove duplicate functionIndex entries that poison model context after compaction. */
     private dedupeBrainPayload;
     buildMinimalV3AgentContext(context?: Record<string, any>): string;

package/dist/utils/api.js

@@ -14,6 +14,8 @@ import { getChangedFiles } from './workspace-cache.js';
 import { isSubstantiveAgentAnswer, isToolEvidenceStubAnswer } from './agentRunOutcome.js';
 import { joinV3WorkspacePath, normalizeV3WorkspaceRelativePath } from './v3-workspace-path.js';
 import { buildExecutionHints, isPlannerBuildTask, resolvePlannerAgentTimeoutMs } from './requestIntent.js';
+import { isV3StreamKeepaliveEvent } from './v3-stream-events.js';
+import { resolveV3ContextCharLimit, WORKSPACE_FILE_CHAR_CAP, } from './contextBudget.js';
 export const VIGTHORIA_HUB_CREDITS_URL = 'https://hub.vigthoria.io/credits';
 export const VIGTHORIA_SERVER_TEMPORARILY_UNAVAILABLE_MESSAGE = 'Vigthoria Server is temporarily not available. Please try again later. If the issue persists, please contact support.';
 export class CLIError extends Error {
@@ -732,6 +734,30 @@ export class APIClient {
     normalizeWorkspaceRelativePath(filePath) {
         return String(filePath || '').trim().replace(/\\/g, '/').replace(/^\.\//, '');
     }
+    collectAgentStateSyncPaths(rootPath) {
+        const paths = [];
+        const progressPath = path.join(rootPath, '.vigthoria', 'agent-state', 'progress.json');
+        if (!fs.existsSync(progressPath)) {
+            return paths;
+        }
+        paths.push('.vigthoria/agent-state/progress.json');
+        const tasksDir = path.join(rootPath, '.vigthoria', 'agent-state', 'tasks');
+        if (!fs.existsSync(tasksDir)) {
+            return paths;
+        }
+        try {
+            for (const entry of fs.readdirSync(tasksDir, { withFileTypes: true })) {
+                if (!entry.isFile() || !entry.name.endsWith('.json')) {
+                    continue;
+                }
+                paths.push(`.vigthoria/agent-state/tasks/${entry.name}`);
+            }
+        }
+        catch {
+            // Ignore unreadable task snapshots.
+        }
+        return paths;
+    }
     listFrontendWorkspaceFiles(rootPath) {
         const results = [];
         const stack = [rootPath];
@@ -1424,8 +1450,41 @@ export class APIClient {
             return payload.execution;
         });
     }
-    /** Maximum serialized context length accepted by the V3 server. */
-    static V3_CONTEXT_CHAR_LIMIT = 95_000;
+    /** Legacy cap — prefer resolveV3ContextCharLimit() for token-aligned budgets. */
+    static V3_CONTEXT_CHAR_LIMIT = 100_000;
+    static HYDRATION_PRIORITY_BASENAMES = new Set([
+        'package.json', 'index.html', 'game.js', 'main.js', 'app.js', 'script.js',
+        'styles.css', 'style.css', 'README.md', 'manifest.json',
+    ]);
+    /** Keep critical workspace files for server hydration when context must shrink. */
+    compactWorkspaceFilesToBudget(files, budgetChars) {
+        const entries = Object.entries(files);
+        const rank = (filePath) => {
+            const normalized = filePath.replace(/\\/g, '/');
+            const base = normalized.split('/').pop() || '';
+            if (APIClient.HYDRATION_PRIORITY_BASENAMES.has(base))
+                return 0;
+            if (/^\.vigthoria\/agent-state\//i.test(normalized))
+                return 1;
+            if (/\.(html?|js|mjs|cjs|css|json|ts|tsx|jsx)$/i.test(base))
+                return 2;
+            return 3;
+        };
+        entries.sort((a, b) => rank(a[0]) - rank(b[0]) || a[0].localeCompare(b[0]));
+        const trimmed = {};
+        let used = 2;
+        for (const [filePath, content] of entries) {
+            const maxContentLen = rank(filePath) <= 1 ? content.length : Math.min(content.length, WORKSPACE_FILE_CHAR_CAP);
+            const clipped = content.length > maxContentLen ? `${content.slice(0, maxContentLen)}\n/* … truncated for remote context … */` : content;
+            const entryLen = JSON.stringify(filePath).length + 1 + JSON.stringify(clipped).length + 1;
+            if (used + entryLen > budgetChars) {
+                continue;
+            }
+            trimmed[filePath] = clipped;
+            used += entryLen;
+        }
+        return trimmed;
+    }
     buildV3AgentContext(context = {}) {
         const resolvedContext = this.ensureExecutionContext(context);
         const targetPath = resolvedContext.targetPath || resolvedContext.projectPath || resolvedContext.workspacePath || resolvedContext.projectRoot || process.cwd();
@@ -1533,7 +1592,16 @@ export class APIClient {
      *   5. Drop readmeExcerpt
      */
     compactV3Context(payload) {
-        const LIMIT = APIClient.V3_CONTEXT_CHAR_LIMIT;
+        const LIMIT = resolveV3ContextCharLimit();
+        const phases = [];
+        const compactionMeta = {
+            applied: false,
+            beforeChars: 0,
+            afterChars: 0,
+            charLimit: LIMIT,
+            estimatedInputBudget: Math.floor(LIMIT / 4),
+            phases,
+        };
         if (payload.vigthoriaBrain) {
             payload.vigthoriaBrain = this.dedupeBrainPayload(payload.vigthoriaBrain);
         }
@@ -1541,80 +1609,155 @@ export class APIClient {
             payload.vigthoria_brain = payload.vigthoriaBrain || this.dedupeBrainPayload(payload.vigthoria_brain);
         }
         let json = JSON.stringify(payload);
-        if (json.length <= LIMIT)
+        compactionMeta.beforeChars = json.length;
+        if (json.length <= LIMIT) {
+            compactionMeta.afterChars = json.length;
+            payload.contextBudgetMeta = compactionMeta;
             return json;
+        }
+        compactionMeta.applied = true;
+        phases.push('over_limit');
         if (!/^(1|true|yes)$/i.test(String(process.env.VIGTHORIA_QUIET_CONTEXT_COMPACTION || ''))) {
-            process.stderr.write(`Workspace context is large - sent a focused summary (${Math.round(LIMIT / 1000)}k limit).\n`);
+            process.stderr.write(`Workspace context is large — sending a focused summary (~${Math.round(LIMIT / 1000)}k char budget, token-aligned).\n`);
         }
         if (process.env.DEBUG || process.env.VIGTHORIA_DEBUG) {
             process.stderr.write(`[context] Payload ${json.length} chars exceeds ${LIMIT} limit, compacting...\n`);
         }
-        // Phase 1 — shrink workspaceFiles to fit
         const summary = payload.localWorkspaceSummary;
+        const hydrationRequired = payload.workspaceHydrationRequired === true;
+        const finish = () => {
+            compactionMeta.afterChars = json.length;
+            payload.contextBudgetMeta = compactionMeta;
+            return json;
+        };
+        // Phase 1 — truncate history before touching workspace file hydration
+        if (Array.isArray(payload.history) && payload.history.length > 6) {
+            payload.history = payload.history.slice(-6);
+            phases.push('trim_history_6');
+            json = JSON.stringify(payload);
+            if (json.length <= LIMIT)
+                return finish();
+        }
+        // Phase 2 — shrink workspaceFiles (priority order) to fit
         if (summary?.workspaceFiles && typeof summary.workspaceFiles === 'object') {
-            const fileEntries = Object.entries(summary.workspaceFiles);
             const overhead = json.length - JSON.stringify(summary.workspaceFiles).length;
-            const budget = LIMIT - overhead - 512; // reserve a little headroom
+            const budget = LIMIT - overhead - 1024;
             if (budget > 0) {
-                const trimmed = {};
-                let used = 2; // {}
-                for (const [k, v] of fileEntries) {
-                    const entryLen = JSON.stringify(k).length + 1 + JSON.stringify(v).length + 1;
-                    if (used + entryLen > budget)
-                        break;
-                    trimmed[k] = v;
-                    used += entryLen;
-                }
-                summary.workspaceFiles = trimmed;
+                summary.workspaceFiles = this.compactWorkspaceFilesToBudget(summary.workspaceFiles, budget);
+                summary.workspaceFilesCompaction = Object.keys(summary.workspaceFiles).length > 0 ? 'priority-trimmed' : 'empty';
+            }
+            else if (hydrationRequired) {
+                summary.workspaceFiles = this.compactWorkspaceFilesToBudget(summary.workspaceFiles, 8_000);
+                summary.workspaceFilesCompaction = 'priority-minimal';
             }
             else {
                 delete summary.workspaceFiles;
             }
             json = JSON.stringify(payload);
             if (json.length <= LIMIT)
-                return json;
+                return finish();
         }
-        // Phase 2 — drop workspaceFiles entirely
-        if (summary?.workspaceFiles) {
+        // Phase 3 — drop readme before dropping hydration payload
+        if (summary?.readmeExcerpt) {
+            delete summary.readmeExcerpt;
+            json = JSON.stringify(payload);
+            if (json.length <= LIMIT)
+                return finish();
+        }
+        // Phase 4 — never fully drop workspaceFiles when remote hydration is required
+        if (summary?.workspaceFiles && !hydrationRequired) {
             delete summary.workspaceFiles;
             json = JSON.stringify(payload);
             if (json.length <= LIMIT)
-                return json;
+                return finish();
         }
-        // Phase 3 — truncate history to last 6 messages
-        if (Array.isArray(payload.history) && payload.history.length > 6) {
-            payload.history = payload.history.slice(-6);
+        if (hydrationRequired && summary?.workspaceFiles && typeof summary.workspaceFiles === 'object') {
+            summary.workspaceFiles = this.compactWorkspaceFilesToBudget(summary.workspaceFiles, 4_000);
+            summary.workspaceFilesCompaction = 'priority-minimal';
             json = JSON.stringify(payload);
             if (json.length <= LIMIT)
-                return json;
+                return finish();
         }
-        // Phase 4 — truncate file list
-        if (summary?.files && Array.isArray(summary.files) && summary.files.length > 15) {
-            summary.files = summary.files.slice(0, 15);
+        // Phase 5 — truncate history to last 3 messages
+        if (Array.isArray(payload.history) && payload.history.length > 3) {
+            payload.history = payload.history.slice(-3);
             json = JSON.stringify(payload);
             if (json.length <= LIMIT)
-                return json;
+                return finish();
         }
-        // Phase 5 — drop readmeExcerpt
-        if (summary?.readmeExcerpt) {
-            delete summary.readmeExcerpt;
+        // Phase 6 — truncate file list
+        if (summary?.files && Array.isArray(summary.files) && summary.files.length > 15) {
+            summary.files = summary.files.slice(0, 15);
             json = JSON.stringify(payload);
             if (json.length <= LIMIT)
-                return json;
+                return finish();
         }
-        // Phase 6 — drop history entirely
+        // Phase 7 — drop history entirely
         if (Array.isArray(payload.history) && payload.history.length > 0) {
             payload.history = [];
             json = JSON.stringify(payload);
             if (json.length <= LIMIT)
-                return json;
+                return finish();
         }
-        // Phase 7 — drop localWorkspaceSummary entirely as last resort
+        // Phase 8 — drop localWorkspaceSummary metadata but keep hydration files for remote clients
         if (payload.localWorkspaceSummary) {
-            payload.localWorkspaceSummary = { path: summary?.path, name: summary?.name, fileCount: summary?.fileCount };
+            const keepFiles = hydrationRequired && summary?.workspaceFiles && typeof summary.workspaceFiles === 'object'
+                ? summary.workspaceFiles
+                : undefined;
+            payload.localWorkspaceSummary = {
+                path: summary?.path,
+                name: summary?.name,
+                fileCount: summary?.fileCount,
+                files: Array.isArray(summary?.files) ? summary.files.slice(0, 20) : [],
+                ...(keepFiles ? { workspaceFiles: keepFiles, workspaceFilesCompaction: summary?.workspaceFilesCompaction || 'priority-minimal' } : {}),
+            };
             json = JSON.stringify(payload);
         }
-        return json;
+        if (hydrationRequired && json.length > LIMIT) {
+            process.stderr.write('Warning: workspace context is still large after compaction; remote agent may have partial project visibility. Consider closing other context or using /compact.\n');
+        }
+        return finish();
+    }
+    /** Normalize common Unix-only commands before Windows cmd/powershell execution. */
+    normalizeWindowsRunCommand(command) {
+        let cmd = String(command || '').trim();
+        if (!cmd)
+            return cmd;
+        if (/^\/[^\s/]/.test(cmd) && !/^\/[a-z]:/i.test(cmd)) {
+            throw new Error('Command starts with "/" which Windows interprets as an invalid switch. Use workspace-relative paths without a leading slash.');
+        }
+        const replacements = [
+            [/^ls(\s|$)/i, 'dir$1'],
+            [/^cat\s+/i, 'type '],
+            [/^pwd\s*$/i, 'cd'],
+            [/^rm\s+-rf?\s+/i, 'rmdir /s /q '],
+            [/^rm\s+/i, 'del '],
+            [/^cp\s+/i, 'copy '],
+            [/^mv\s+/i, 'move '],
+        ];
+        for (const [pattern, replacement] of replacements) {
+            cmd = cmd.replace(pattern, replacement);
+        }
+        return cmd;
+    }
+    resolveRunCommandCwd(rootPath, args, serverRoot) {
+        const cwdRaw = args.cwd ?? args.path ?? '.';
+        let target = this.resolveV3ClientToolPath(rootPath, cwdRaw, serverRoot ? [serverRoot] : []);
+        if (!target) {
+            target = this.resolveV3ClientToolPath(rootPath, '.', serverRoot ? [serverRoot] : []);
+        }
+        if (!target) {
+            return path.resolve(rootPath);
+        }
+        try {
+            if (fs.existsSync(target.absolutePath) && fs.statSync(target.absolutePath).isFile()) {
+                return path.dirname(target.absolutePath);
+            }
+        }
+        catch {
+            // fall through to directory cwd
+        }
+        return target.absolutePath;
     }
     /** Remove duplicate functionIndex entries that poison model context after compaction. */
     dedupeBrainPayload(brain) {
@@ -2401,7 +2544,8 @@ menu {
             };
             const snapshot = this.getAgentWorkspaceSnapshot(rootPath);
             const candidatePaths = snapshot.paths.filter((entry) => !/(^|[\/\\])\.vigthoria([\/\\]|$)/.test(entry));
-            let orderedPaths = candidatePaths;
+            const agentStatePaths = this.collectAgentStateSyncPaths(rootPath);
+            let orderedPaths = [...agentStatePaths, ...candidatePaths];
             try {
                 const ranked = buildSemanticContext(rootPath, requestFocus, 60).topFiles.map((file) => file.path);
                 const changes = getChangedFiles(rootPath, candidatePaths);
@@ -2478,7 +2622,9 @@ menu {
                 continue;
             if (/(^|[\/\\])\.(git|hg)([\/\\]|$)/.test(relativePath))
                 continue;
-            if (/(^|[\/\\])\.vigthoria([\/\\]|$)/.test(relativePath))
+            const normalizedPath = relativePath.replace(/\\/g, '/');
+            const isAgentStateSync = /^\.vigthoria\/agent-state\//i.test(normalizedPath);
+            if (!isAgentStateSync && /(^|[\/\\])\.vigthoria([\/\\]|$)/.test(relativePath))
                 continue;
             const absolutePath = path.join(rootPath, relativePath);
             try {
@@ -2646,6 +2792,8 @@ menu {
             }
             return;
         }
+        // workspace_snapshot is handled by applyV3AgentStreamEventToWorkspace only —
+        // never count hydrated baselines as "files changed".
         // 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) {
@@ -2694,9 +2842,17 @@ menu {
         }
         return false;
     }
-    resolveV3ClientToolPath(rootPath, rawPath) {
-        const relativePath = this.normalizeAgentWorkspaceRelativePath(String(rawPath || '.'), rootPath);
-        if (!relativePath && String(rawPath || '.').trim() !== '.') {
+    resolveV3ClientToolPath(rootPath, rawPath, sourceRoots = []) {
+        const raw = String(rawPath || '.').trim();
+        const roots = [rootPath, ...sourceRoots.filter(Boolean)];
+        let relativePath = '';
+        for (const sourceRoot of roots) {
+            relativePath = this.normalizeAgentWorkspaceRelativePath(raw, sourceRoot);
+            if (relativePath || raw === '.' || raw === '') {
+                break;
+            }
+        }
+        if (!relativePath && raw !== '.' && raw !== '') {
             return null;
         }
         const absolutePath = relativePath ? joinV3WorkspacePath(rootPath, relativePath) : path.resolve(rootPath);
@@ -2747,7 +2903,13 @@ menu {
         }
         const name = String(event.name || event.tool || '').trim();
         const args = event.arguments || {};
-        const target = this.resolveV3ClientToolPath(rootPath, args.path || args.cwd || '.');
+        const serverRoot = String(context.__v3ServerWorkspaceRoot || '').trim();
+        const isRunCommand = name === 'run_command';
+        const pathArg = isRunCommand ? (args.cwd ?? args.path ?? '.') : (args.path || args.cwd || '.');
+        let target = this.resolveV3ClientToolPath(rootPath, pathArg, serverRoot ? [serverRoot] : []);
+        if (!target && isRunCommand) {
+            target = this.resolveV3ClientToolPath(rootPath, '.', serverRoot ? [serverRoot] : []);
+        }
         if (!target) {
             return { success: false, output: '', error: 'Tool path is outside the workspace.' };
         }
@@ -2831,6 +2993,14 @@ menu {
                         error: `File not found: ${target.relativePath}. Write the file before running syntax_check.`,
                     };
                 }
+                const stat = fs.statSync(target.absolutePath);
+                if (stat.isDirectory()) {
+                    return {
+                        success: false,
+                        output: '',
+                        error: `Expected a file, but path is a directory: ${target.relativePath}`,
+                    };
+                }
                 const ext = path.extname(target.absolutePath).toLowerCase();
                 if (ext === '.json') {
                     JSON.parse(fs.readFileSync(target.absolutePath, 'utf8'));
@@ -2851,12 +3021,37 @@ menu {
                 return { success: true, output: `Syntax check passed: ${target.relativePath}` };
             }
             if (name === 'run_command') {
-                const command = String(args.command || '').trim();
+                let command = String(args.command || '').trim();
                 if (!command)
                     return { success: false, output: '', error: 'run_command requires command.' };
+                try {
+                    if (process.platform === 'win32') {
+                        command = this.normalizeWindowsRunCommand(command);
+                    }
+                }
+                catch (error) {
+                    return { success: false, output: '', error: error.message };
+                }
+                const cwd = this.resolveRunCommandCwd(rootPath, args, serverRoot);
+                const usePowerShell = process.platform === 'win32'
+                    && /^(npm|npx|node|yarn|pnpm|git|python|pip|powershell)\b/i.test(command);
                 const { exec } = await import('child_process');
                 return await new Promise((resolve) => {
-                    exec(command, { cwd: target.absolutePath, timeout: Number(args.timeout || 30000) }, (error, stdout, stderr) => {
+                    const execOptions = {
+                        cwd,
+                        timeout: Number(args.timeout || 30000),
+                        maxBuffer: 1024 * 1024,
+                        env: process.env,
+                    };
+                    if (usePowerShell) {
+                        execOptions.shell = 'powershell.exe';
+                        execOptions.windowsHide = true;
+                        command = `-NoProfile -ExecutionPolicy Bypass -Command ${JSON.stringify(command)}`;
+                    }
+                    else if (process.platform === 'win32') {
+                        execOptions.shell = 'cmd.exe';
+                    }
+                    exec(command, execOptions, (error, stdout, stderr) => {
                         resolve({
                             success: !error,
                             output: String(stdout || stderr || '').slice(0, 12000),
@@ -3688,6 +3883,7 @@ document.addEventListener('DOMContentLoaded', () => {
                     }
                     if (!serverWorkspaceRoot && event.type === 'context' && typeof event.workspace_root === 'string' && event.workspace_root.trim()) {
                         serverWorkspaceRoot = event.workspace_root.trim();
+                        context.__v3ServerWorkspaceRoot = serverWorkspaceRoot;
                     }
                     if (event.type === 'client_tool_request') {
                         const toolTask = this.handleV3ClientToolRequest(event, context, response.url).catch((error) => {
@@ -3721,7 +3917,7 @@ document.addEventListener('DOMContentLoaded', () => {
                             }
                         }
                     }
-                    if (typeof context.onStreamEvent === 'function') {
+                    if (typeof context.onStreamEvent === 'function' && !isV3StreamKeepaliveEvent(userEvent)) {
                         try {
                             context.onStreamEvent(userEvent);
                         }

package/dist/utils/contextBudget.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Client-side context budget helpers — aligned with V3 server context_budget.py.
+ * Initial agent context JSON should leave headroom for system prompt + tool loops.
+ */
+export declare const DEFAULT_CODE_RUNTIME_CTX: number;
+export declare const CONTEXT_SAFETY_MARGIN: number;
+export declare const DEFAULT_MAX_OUTPUT_TOKENS: number;
+export declare const TOKEN_BUDGET_SAFETY_FACTOR: number;
+export declare const CHARS_PER_TOKEN_EST = 4;
+/** Max chars per file in workspaceFiles hydration (matches server TOOL_HISTORY cap order-of-magnitude). */
+export declare const WORKSPACE_FILE_CHAR_CAP: number;
+export declare function estimateTokens(text: string): number;
+export declare function estimateTokensForBudget(text: string): number;
+export declare function estimateJsonTokens(value: unknown): number;
+export declare function resolveInputBudget(runtimeNctx?: number, maxOutput?: number): number;
+/**
+ * Char limit for the initial V3 context JSON payload.
+ * ~45% of input token budget × 4 chars/token, clamped 32k–100k.
+ */
+export declare function resolveV3ContextCharLimit(runtimeNctx?: number): number;
+export declare function compactToolListingOutput(name: string, output: string, charCap: number): string;
+export interface ContextCompactionMeta {
+    applied: boolean;
+    beforeChars: number;
+    afterChars: number;
+    charLimit: number;
+    estimatedInputBudget: number;
+    phases: string[];
+}

package/dist/utils/contextBudget.js

@@ -0,0 +1,55 @@
+/**
+ * Client-side context budget helpers — aligned with V3 server context_budget.py.
+ * Initial agent context JSON should leave headroom for system prompt + tool loops.
+ */
+export const DEFAULT_CODE_RUNTIME_CTX = Number(process.env.V3_CODE_35B_RUNTIME_CTX || '49152');
+export const CONTEXT_SAFETY_MARGIN = Number(process.env.V3_CONTEXT_SAFETY_MARGIN || '2048');
+export const DEFAULT_MAX_OUTPUT_TOKENS = Number(process.env.V3_MAX_TOKENS || '16384');
+export const TOKEN_BUDGET_SAFETY_FACTOR = Number(process.env.V3_TOKEN_BUDGET_SAFETY_FACTOR || '1.2');
+export const CHARS_PER_TOKEN_EST = 4;
+/** Max chars per file in workspaceFiles hydration (matches server TOOL_HISTORY cap order-of-magnitude). */
+export const WORKSPACE_FILE_CHAR_CAP = Number(process.env.V3_TOOL_HISTORY_CHAR_CAP || '12000');
+export function estimateTokens(text) {
+    return Math.max(1, Math.ceil(String(text || '').length / CHARS_PER_TOKEN_EST));
+}
+export function estimateTokensForBudget(text) {
+    return Math.ceil(estimateTokens(text) * TOKEN_BUDGET_SAFETY_FACTOR);
+}
+export function estimateJsonTokens(value) {
+    try {
+        return estimateTokens(JSON.stringify(value ?? ''));
+    }
+    catch {
+        return 1;
+    }
+}
+export function resolveInputBudget(runtimeNctx = DEFAULT_CODE_RUNTIME_CTX, maxOutput = DEFAULT_MAX_OUTPUT_TOKENS) {
+    const cappedOutput = Math.max(4096, Math.min(maxOutput, Math.floor(runtimeNctx / 4)));
+    return Math.max(4096, Math.floor((runtimeNctx - cappedOutput - CONTEXT_SAFETY_MARGIN) / TOKEN_BUDGET_SAFETY_FACTOR));
+}
+/**
+ * Char limit for the initial V3 context JSON payload.
+ * ~45% of input token budget × 4 chars/token, clamped 32k–100k.
+ */
+export function resolveV3ContextCharLimit(runtimeNctx = DEFAULT_CODE_RUNTIME_CTX) {
+    const inputBudget = resolveInputBudget(runtimeNctx);
+    const initialTurnTokens = Math.floor(inputBudget * 0.45);
+    const charLimit = initialTurnTokens * CHARS_PER_TOKEN_EST;
+    return Math.min(100_000, Math.max(32_000, charLimit));
+}
+export function compactToolListingOutput(name, output, charCap) {
+    const text = String(output || '');
+    if (text.length <= charCap)
+        return text;
+    if (['list_directory', 'glob', 'grep', 'search_project'].includes(name)) {
+        const lines = text.split('\n');
+        if (lines.length > 80) {
+            const head = lines.slice(0, 40).join('\n');
+            const tail = lines.slice(-20).join('\n');
+            return `${head}\n\n... [${lines.length} lines total, middle omitted for context budget] ...\n\n${tail}`;
+        }
+    }
+    const head = Math.max(1200, Math.floor(charCap / 3));
+    const tail = Math.max(1200, Math.floor(charCap / 3));
+    return `${text.slice(0, head)}\n\n...[truncated for context budget]...\n\n${text.slice(-tail)}`;
+}

package/dist/utils/goaEvents.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Workbench GOA orchestrator context (VIGTHORIA_DECK_MODE / comfort prompt auto-route).
+ * Emitted as: @vigthoria-goa:{json}
+ */
+export interface GoaOrchestratorContext {
+    workspace_type?: 'GREENFIELD' | 'BROWNFIELD';
+    analysis?: Record<string, unknown>;
+    instruction_count?: number;
+    executed?: boolean;
+    [key: string]: unknown;
+}
+export declare function parseGoaLine(line: string): GoaOrchestratorContext | null;
+export declare function stripGoaLines(text: string): string;
+/** Split Workbench-injected GOA prefix from the user prompt. */
+export declare function splitGoaContextFromInput(input: string): {
+    goaContext: GoaOrchestratorContext | null;
+    userPrompt: string;
+};
+export declare function formatGoaSystemGrounding(context: GoaOrchestratorContext): string;

package/dist/utils/goaEvents.js

@@ -0,0 +1,63 @@
+/**
+ * Workbench GOA orchestrator context (VIGTHORIA_DECK_MODE / comfort prompt auto-route).
+ * Emitted as: @vigthoria-goa:{json}
+ */
+const GOA_PREFIX = '@vigthoria-goa:';
+export function parseGoaLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith(GOA_PREFIX))
+        return null;
+    try {
+        return JSON.parse(trimmed.slice(GOA_PREFIX.length));
+    }
+    catch {
+        return null;
+    }
+}
+export function stripGoaLines(text) {
+    return text
+        .split('\n')
+        .filter((line) => !line.trim().startsWith(GOA_PREFIX))
+        .join('\n');
+}
+/** Split Workbench-injected GOA prefix from the user prompt. */
+export function splitGoaContextFromInput(input) {
+    const lines = input.split('\n');
+    let goaContext = null;
+    const rest = [];
+    for (const line of lines) {
+        const parsed = parseGoaLine(line);
+        if (parsed && !goaContext) {
+            goaContext = parsed;
+            continue;
+        }
+        rest.push(line);
+    }
+    return { goaContext, userPrompt: rest.join('\n').trim() };
+}
+export function formatGoaSystemGrounding(context) {
+    const parts = [
+        'VIGTHORIA GOA ORCHESTRATOR CONTEXT (pre-executed by Workbench — do not re-scaffold greenfield templates):',
+        `- workspace_type: ${context.workspace_type || 'unknown'}`,
+    ];
+    if (context.executed === true) {
+        parts.push('- Workbench already executed the GOA payload (template write / AST pre-scan / stabilize).');
+        parts.push('- Continue from the current workspace state; prefer surgical edits over full rewrites.');
+    }
+    if (context.analysis && typeof context.analysis === 'object') {
+        const a = context.analysis;
+        if (typeof a.detected_framework === 'string')
+            parts.push(`- framework: ${a.detected_framework}`);
+        if (Array.isArray(a.target_files) && a.target_files.length) {
+            parts.push(`- target_files: ${a.target_files.slice(0, 6).join(', ')}`);
+        }
+        if (typeof a.anchor_hint === 'string')
+            parts.push(`- anchor: ${a.anchor_hint}`);
+        if (typeof a.template_match === 'string')
+            parts.push(`- template_match: ${a.template_match}`);
+    }
+    if (typeof context.instruction_count === 'number') {
+        parts.push(`- instructions_planned: ${context.instruction_count}`);
+    }
+    return parts.join('\n');
+}

package/dist/utils/v3-stream-events.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Detect V3 agent SSE keepalive/heartbeat events that exist only to keep
+ * connections alive — not substantive work the CLI should surface as progress.
+ */
+export declare function isV3StreamKeepaliveEvent(event: unknown): boolean;

package/dist/utils/v3-stream-events.js

@@ -0,0 +1,41 @@
+/**
+ * Detect V3 agent SSE keepalive/heartbeat events that exist only to keep
+ * connections alive — not substantive work the CLI should surface as progress.
+ */
+const PLANNING_KEEPALIVE = /^Planning in progress\.\.\.\s*\(\d+s(?:\s+elapsed)?\)$/i;
+const PARALLEL_KEEPALIVE = /^Parallel tasks in progress\.\.\.\s*\(\d+s(?:\s+elapsed)?\)$/i;
+const GENERIC_ELAPSED_KEEPALIVE = /\bin progress\b.*\(\d+s(?:\s+elapsed)?\)$/i;
+export function isV3StreamKeepaliveEvent(event) {
+    if (!event || typeof event !== 'object') {
+        return false;
+    }
+    const record = event;
+    const type = typeof record.type === 'string' ? record.type : '';
+    if (type === 'heartbeat') {
+        return true;
+    }
+    if (type === 'progress' || type === 'status') {
+        const content = String(record.content || record.message || record.status || '').trim();
+        if (!content) {
+            return false;
+        }
+        if (PLANNING_KEEPALIVE.test(content) || PARALLEL_KEEPALIVE.test(content)) {
+            return true;
+        }
+        if (GENERIC_ELAPSED_KEEPALIVE.test(content)) {
+            return true;
+        }
+    }
+    if (type === 'plan') {
+        const plan = record.plan;
+        if (plan && typeof plan === 'object') {
+            const planRecord = plan;
+            const status = typeof planRecord.status === 'string' ? planRecord.status : '';
+            const tasks = planRecord.tasks;
+            if (status === 'planning' && !Array.isArray(tasks)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}

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

@@ -42,6 +42,45 @@ export function normalizeV3WorkspaceRelativePath(rawPath, rootPath) {
         }
         return null;
     };
+    const stripScrubbedPlaceholder = (value) => {
+        let candidate = String(value || '').replace(/^\/+/, '');
+        // Hybrid paths models echo back after SSE scrubbing, e.g. C:/var/www/[internal]/game.js
+        const hybridWin = candidate.match(/^[a-zA-Z]:\/(?:var\/)?www\/\[internal\](?:\/(.*))?$/i);
+        if (hybridWin) {
+            return safeRelative(hybridWin[1] || '');
+        }
+        const hybridWinBare = candidate.match(/^[a-zA-Z]:\/\[internal\](?:\/(.*))?$/i);
+        if (hybridWinBare) {
+            return safeRelative(hybridWinBare[1] || '');
+        }
+        const placeholderPatterns = [
+            [/^(?:var\/)?www\/\[internal\](?:\/(.*))?$/i, 1],
+            [/^\[internal\](?:\/(.*))?$/i, 1],
+            [/^\[Vigthoria service\](?:\/(.*))?$/i, 1],
+            [/^\[Vigthoria Agent\](?:\/(.*))?$/i, 1],
+            [/^\[Vigthoria storage\](?:\/(.*))?$/i, 1],
+            [/^\[temp\](?:\/(.*))?$/i, 1],
+            [/^\[home\](?:\/(.*))?$/i, 1],
+            [/^\[workspace\](?:\/(.*))?$/i, 1],
+            [/^(?:var\/)?www\/\[Vigthoria service\](?:\/(.*))?$/i, 1],
+        ];
+        for (const [pattern, groupIndex] of placeholderPatterns) {
+            const match = candidate.match(pattern);
+            if (match) {
+                return safeRelative(match[groupIndex] || '');
+            }
+        }
+        const bracketSplit = candidate.split(/\[(?:internal|Vigthoria service|Vigthoria Agent|temp|home|workspace)\]/i);
+        if (bracketSplit.length > 1) {
+            const tail = bracketSplit[bracketSplit.length - 1].replace(/^\/+/, '');
+            return safeRelative(tail);
+        }
+        return null;
+    };
+    const scrubbed = stripScrubbedPlaceholder(input);
+    if (scrubbed !== null) {
+        return scrubbed;
+    }
     const decoded = decodeBoundaryUri(input);
     if (decoded !== null) {
         return decoded;
@@ -72,6 +111,18 @@ export function normalizeV3WorkspaceRelativePath(rawPath, rootPath) {
     }
     const normalizedRoot = String(rootPath || '').trim().replace(/\\/g, '/').replace(/\/+$/g, '');
     if (normalizedRoot) {
+        if (/^[a-zA-Z]:\//.test(input)) {
+            const winRoot = normalizedRoot;
+            const inputLower = input.toLowerCase();
+            const winRootLower = winRoot.toLowerCase();
+            if (inputLower === winRootLower || inputLower === `${winRootLower}/`) {
+                return '';
+            }
+            if (inputLower.startsWith(`${winRootLower}/`)) {
+                return safeRelative(input.slice(winRoot.length + 1));
+            }
+            return '';
+        }
         const rootNoLeadingSlash = normalizedRoot.replace(/^\//, '');
         const rootBase = path.posix.basename(normalizedRoot);
         const prefixes = [
@@ -90,7 +141,11 @@ export function normalizeV3WorkspaceRelativePath(rawPath, rootPath) {
             return safeRelative(input.slice(embeddedIndex + embeddedRoot.length));
         }
     }
-    return safeRelative(input);
+    const relative = safeRelative(input);
+    if (relative === 'workspace') {
+        return '';
+    }
+    return relative;
 }
 /** Join workspace root + relative path without path.resolve URI corruption on Windows. */
 export function joinV3WorkspacePath(rootPath, relativePath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.11.29",
+  "version": "1.11.36",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "type": "module",
   "main": "dist/index.js",
@@ -37,7 +37,7 @@
     "dev": "ts-node src/index.ts",
     "test": "npm run test:cli",
     "test:agent:outcome": "npm run build && node scripts/test-agent-run-outcome.js",
-    "test:cli": "npm run build && npm run precheck:services && node scripts/test-cli-suite.js && npm run test:agent:outcome",
+    "test:cli": "npm run build && npm run precheck:services && node scripts/test-cli-suite.js && npm run test:agent:outcome && npm run test:v3-stream-mutation",
     "test:regression": "npm run build && node scripts/test-regression-1.6.22.js",
     "test:agent:smoke": "npm run build && node scripts/test-agent-smoke.js",
     "test:agent:routing": "npm run build && node scripts/test-agent-routing-policy.js",
@@ -68,7 +68,11 @@
     "test:model:governance": "npm run build && node scripts/test-model-governance-no-agent.js",
     "validate:no-go": "bash scripts/release/validate-no-go-gates.sh",
     "test:legion:billing:e2e": "npm run build && node scripts/test-legion-godmode-billing-e2e.js",
-    "test:windows:v3-sync": "npm run build && node scripts/test-windows-v3-sync-recovery.js"
+    "test:windows:v3-sync": "npm run build && node scripts/test-windows-v3-sync-recovery.js",
+    "test:v3-workspace-path": "npm run build && node scripts/test-v3-workspace-path.js",
+    "test:v3-stream-mutation": "npm run build && node scripts/test-v3-stream-mutation.js",
+    "test:context:budget": "npm run build && node scripts/test-context-budget.js",
+    "test:pitfall:context": "npm run build && node scripts/test-pitfall-context-smoke.js"
   },
   "keywords": [
     "ai",