vigthoria-cli 1.13.18 → 1.13.22

package/dist/utils/agent-stream-state.d.ts

@@ -0,0 +1,27 @@
+import type { Ora } from './logger.js';
+export interface AgentStreamStateDependencies {
+    isJsonOutput(): boolean;
+    idleTimeoutMs(): number;
+}
+/** Owns the mutable lifecycle and deduplication state for one rendered agent stream. */
+export declare class AgentStreamState {
+    private readonly dependencies;
+    iterationCount: number;
+    toolCallCount: number;
+    lastActivity: number;
+    streamingStarted: boolean;
+    streamedAnswerBuffer: string;
+    streamedAnswerDisplayed: boolean;
+    suppressThinkingStream: boolean;
+    startSeen: boolean;
+    readonly seenToolCalls: Set<string>;
+    readonly seenToolResults: Set<string>;
+    private idleWatchInterval;
+    private idleNoticeShown;
+    constructor(dependencies: AgentStreamStateDependencies);
+    reset(): void;
+    noteActivity(): void;
+    startIdleWatch(spinner: Ora | null): void;
+    stopIdleWatch(): void;
+    sanitizeVisibleText(text: string): string;
+}

package/dist/utils/agent-stream-state.js

@@ -0,0 +1,93 @@
+import chalk from 'chalk';
+/** Owns the mutable lifecycle and deduplication state for one rendered agent stream. */
+export class AgentStreamState {
+    dependencies;
+    iterationCount = 0;
+    toolCallCount = 0;
+    lastActivity = Date.now();
+    streamingStarted = false;
+    streamedAnswerBuffer = '';
+    streamedAnswerDisplayed = false;
+    suppressThinkingStream = false;
+    startSeen = false;
+    seenToolCalls = new Set();
+    seenToolResults = new Set();
+    idleWatchInterval = null;
+    idleNoticeShown = false;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    reset() {
+        this.iterationCount = 0;
+        this.toolCallCount = 0;
+        this.lastActivity = Date.now();
+        this.streamingStarted = false;
+        this.streamedAnswerBuffer = '';
+        this.streamedAnswerDisplayed = false;
+        this.suppressThinkingStream = false;
+        this.startSeen = false;
+        this.seenToolCalls.clear();
+        this.seenToolResults.clear();
+        this.idleNoticeShown = false;
+    }
+    noteActivity() { this.lastActivity = Date.now(); }
+    startIdleWatch(spinner) {
+        this.stopIdleWatch();
+        if (this.dependencies.isJsonOutput() || !spinner)
+            return;
+        this.idleWatchInterval = setInterval(() => {
+            const idleMs = Date.now() - this.lastActivity;
+            if (idleMs < 15_000) {
+                this.idleNoticeShown = false;
+                return;
+            }
+            if (this.idleNoticeShown)
+                return;
+            this.idleNoticeShown = true;
+            if (spinner.isSpinning)
+                spinner.stop();
+            const seconds = Math.round(idleMs / 1000);
+            const timeoutSeconds = Math.round(this.dependencies.idleTimeoutMs() / 1000);
+            process.stderr.write(chalk.yellow(`  [Wait] Model still working (${seconds}s) — this can legitimately take a while for large tasks. `
+                + (timeoutSeconds > 0
+                    ? `Only complete silence (~${timeoutSeconds}s with zero bytes received) will trigger an auto-recover/retry — active progress is never interrupted.\n`
+                    : '\n')));
+            spinner.start();
+            spinner.text = 'Waiting for model response...';
+        }, 5_000);
+    }
+    stopIdleWatch() {
+        if (this.idleWatchInterval)
+            clearInterval(this.idleWatchInterval);
+        this.idleWatchInterval = null;
+        this.idleNoticeShown = false;
+    }
+    sanitizeVisibleText(text) {
+        let output = String(text || '').replace(/<\/think>/gi, '</thinking>').replace(/<think>/gi, '<thinking>').replace(/<\/redacted_thinking>/gi, '</thinking>');
+        if (!output)
+            return '';
+        if (this.suppressThinkingStream) {
+            const closeIndex = output.search(/<\/thinking>/i);
+            if (closeIndex < 0)
+                return '';
+            output = output.slice(closeIndex).replace(/^<\/thinking>/i, '');
+            this.suppressThinkingStream = false;
+        }
+        output = output.replace(/<thinking>[\s\S]*?<\/thinking>/gi, '');
+        if (/<thinking>/i.test(output)) {
+            output = output.replace(/<thinking>[\s\S]*$/i, '');
+            this.suppressThinkingStream = true;
+        }
+        return output
+            .replace(/```json\s*\[\s*\{[\s\S]*?"tool"[\s\S]*?\}\s*\]\s*```/gi, '')
+            .replace(/```json\s*\{[\s\S]*?"tool"[\s\S]*?\}\s*```/gi, '')
+            .replace(/^\s*(?:json\s*)?\[\s*\{[\s\S]*?"tool"[\s\S]*$/gim, '')
+            .replace(/^\s*(?:list_dir|read_file|write_file|edit_file|glob|grep|bash)\s*$/gim, '')
+            .replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, '')
+            .replace(/<tool_code>[\s\S]*?<\/tool_code>/gi, '')
+            .replace(/<read_file>\s*<path>[\s\S]*?<\/path>\s*<\/read_file>/gi, '')
+            .replace(/<(?:grep|list_directory|search_files|glob|tool_result)\b[\s\S]*?<\/(?:grep|list_directory|search_files|glob|tool_result)>/gi, '')
+            .replace(/bootstrap discovery completed\s*[—-]\s*inspect the most relevant files next\.?/gi, '')
+            .replace(/\n{3,}/g, '\n\n');
+    }
+}

package/dist/utils/agentRoute.d.ts

@@ -1,5 +1,6 @@
 /**
- * Unified agent routing: regex (instant) → optional Balanced 4B → V3 execution hints.
+ * Unified agent routing: regex → optional semantic classifier → V3 execution hints.
+ * The CLI always dispatches through V3; fastPath and taskKind describe server-side handling.
  */
 import type { APIClient } from './api.js';
 import { type AgentRoutePath } from './fastAgentRouter.js';

package/dist/utils/agentRoute.js

@@ -1,5 +1,6 @@
 /**
- * Unified agent routing: regex (instant) → optional Balanced 4B → V3 execution hints.
+ * Unified agent routing: regex → optional semantic classifier → V3 execution hints.
+ * The CLI always dispatches through V3; fastPath and taskKind describe server-side handling.
  */
 import { inferAgentTaskType, isTrivialHtmlPageRequest, isAgentContinuePrompt, isAgentRetryPrompt, hasGameIntent, hasWebPageIntent, taskRequiresWorkspaceChanges, stripExecutionShaping, } from './requestIntent.js';
 import { isFastInferenceRouterAvailable, routeWithBalanced4b, shouldUseBalancedRouter, } from './fastAgentRouter.js';
@@ -26,10 +27,13 @@ function mergeLlmRoute(regexTask, prompt, parsed) {
     const llmFast = parsed.fast_path ?? parsed.fastPath ?? undefined;
     const confidence = Number(parsed.confidence) || 0.75;
     const reason = String(parsed.reason || 'balanced-4b router');
-    // Regex game/web signals override wrong LLM labels (hello-world → v3-agent bug).
-    if (isTrivialHtmlPageRequest(prompt) || (hasWebPageIntent(prompt) && !hasGameIntent(prompt) && llmTask === 'game-build')) {
+    // Regex signals are authoritative when the small semantic router confuses
+    // web-design language such as "desktop canvas" with an actual playable
+    // game. Only genuinely trivial pages belong on template-instant; substantial
+    // web builds must retain the full V3 planner/executor path.
+    if (isTrivialHtmlPageRequest(prompt)) {
         return {
-            path: 'template-instant',
+            path: 'v3-agent',
             taskKind: 'web-build',
             fastPath: 'template-instant',
             confidence: Math.max(confidence, 0.92),
@@ -37,10 +41,19 @@ function mergeLlmRoute(regexTask, prompt, parsed) {
             source: 'merged',
         };
     }
+    if (hasWebPageIntent(prompt) && !hasGameIntent(prompt) && llmTask === 'game-build') {
+        return {
+            path: 'v3-agent',
+            taskKind: 'web-build',
+            confidence: Math.max(confidence, 0.96),
+            reason: 'authoritative web-build override for false game classification',
+            source: 'merged',
+        };
+    }
     if (llmPath === 'template-instant' || llmPath === 'html-template' || llmFast === 'template-instant') {
         if (hasWebPageIntent(prompt) || isTrivialHtmlPageRequest(prompt)) {
             return {
-                path: 'template-instant',
+                path: 'v3-agent',
                 taskKind: 'web-build',
                 fastPath: 'template-instant',
                 confidence,
@@ -52,7 +65,7 @@ function mergeLlmRoute(regexTask, prompt, parsed) {
     if (llmPath === 'analysis-only' || llmTask === 'analysis' || llmTask === 'debugging') {
         if (!taskRequiresWorkspaceChanges(prompt)) {
             return {
-                path: 'analysis-only',
+                path: 'v3-agent',
                 taskKind: llmTask === 'debugging' ? 'debugging' : 'analysis',
                 confidence,
                 reason,
@@ -103,7 +116,7 @@ export async function resolveAgentRoute(api, prompt) {
     }
     if (isTrivialHtmlPageRequest(stripped)) {
         return {
-            path: 'template-instant',
+            path: 'v3-agent',
             taskKind: 'web-build',
             fastPath: 'template-instant',
             confidence: 1,
@@ -114,7 +127,7 @@ export async function resolveAgentRoute(api, prompt) {
     const regexTask = inferAgentTaskType(stripped);
     if (!taskRequiresWorkspaceChanges(stripped) && (regexTask === 'analysis' || regexTask === 'debugging')) {
         return {
-            path: 'analysis-only',
+            path: 'v3-agent',
             taskKind: regexTask,
             confidence: 0.95,
             reason: 'read-only analysis (regex)',
@@ -124,7 +137,7 @@ export async function resolveAgentRoute(api, prompt) {
     if (hasGameIntent(stripped) && regexTask === 'game-build') {
         if (forceTemplateScaffold() || wantsInstantTemplatePath(stripped)) {
             return {
-                path: 'template-instant',
+                path: 'v3-agent',
                 taskKind: 'game-build',
                 fastPath: 'template-instant',
                 confidence: 0.98,

package/dist/utils/agentRunOutcome.d.ts

@@ -27,6 +27,11 @@ export interface TaskSummaryEvent {
     task_id?: string;
     id?: string;
 }
+export interface RunCompleteTaskEvent {
+    tasks_total?: number | string;
+    tasks_completed?: number | string;
+    tasks_failed?: number | string;
+}
 export interface RunEvaluation {
     executorSucceeded: boolean;
     statusHeadline: string;
@@ -35,6 +40,9 @@ export interface RunEvaluation {
 export declare function createLiveOutcome(): LiveOutcome;
 export declare function isExecutorTimeoutFailure(liveOutcome: LiveOutcome): boolean;
 export declare function isInferenceDegradedFailure(liveOutcome: LiveOutcome): boolean;
+/** Reject a planner summary that labels a task completed while its handoff
+ * plainly announces more implementation work. */
+export declare function hasUnfinishedTaskHandoff(text: string): 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;
@@ -46,6 +54,14 @@ export declare function isSubstantiveAgentAnswer(text: string): boolean;
 export declare function normalizeAgentAnswerContent(...sources: Array<string | undefined | null>): string;
 /** Process executor_complete / task summary events from the V3 SSE stream. */
 export declare function handleTaskEvent(summary: TaskSummaryEvent, liveOutcome: LiveOutcome): void;
+/** Reconcile counters with the authoritative terminal planner event.
+ *
+ * Some plans contain a synthetic T00 analysis task which is counted in
+ * `tasks_total`/`tasks_completed` but intentionally has no executor_complete
+ * event. Without this reconciliation the CLI sees only T01..Tn and exits 1
+ * after the server truthfully reports every task complete.
+ */
+export declare function handleRunCompleteEvent(event: RunCompleteTaskEvent, liveOutcome: LiveOutcome): void;
 /** Track read/discovery tool usage for analysis-turn accountability. */
 export declare function noteAnalysisToolUse(toolName: string, liveOutcome: LiveOutcome): void;
 /**

package/dist/utils/agentRunOutcome.js

@@ -45,6 +45,14 @@ export function isInferenceDegradedFailure(liveOutcome) {
     return isGenericFallbackAnswer(answer)
         && (liveOutcome.analysisToolsUsed > 0 || liveOutcome.requiresWorkspaceChanges);
 }
+/** Reject a planner summary that labels a task completed while its handoff
+ * plainly announces more implementation work. */
+export function hasUnfinishedTaskHandoff(text) {
+    const normalized = stripAgentThinkingTags(String(text || ''));
+    if (!normalized)
+        return false;
+    return /(?:^|\n)\s*T\d+\s*:\s*(?:i\s+(?:still\s+)?need\s+to|let\s+me\s+(?:apply|implement|finish|complete|run|fix|edit|write|verify|check|test|read)|remaining\s+(?:required\s+)?(?:work|changes?|features?|steps?)|not\s+yet\s+(?:implemented|finished|completed|verified)|unable\s+to\s+(?:complete|apply|implement|finish))/im.test(normalized);
+}
 function looksLikeRawV3EventPayload(text) {
     const trimmed = String(text || '').trim();
     if (!/^[{[]/.test(trimmed))
@@ -174,6 +182,31 @@ export function handleTaskEvent(summary, liveOutcome) {
         }
     }
 }
+/** Reconcile counters with the authoritative terminal planner event.
+ *
+ * Some plans contain a synthetic T00 analysis task which is counted in
+ * `tasks_total`/`tasks_completed` but intentionally has no executor_complete
+ * event. Without this reconciliation the CLI sees only T01..Tn and exits 1
+ * after the server truthfully reports every task complete.
+ */
+export function handleRunCompleteEvent(event, liveOutcome) {
+    const total = Number(event.tasks_total);
+    const completed = Number(event.tasks_completed);
+    const failed = Number(event.tasks_failed);
+    if (Number.isFinite(total) && total > 0) {
+        liveOutcome.tasksTotal = total;
+    }
+    if (Number.isFinite(completed) && completed >= 0) {
+        liveOutcome.tasksSucceeded = Math.max(liveOutcome.tasksSucceeded, completed);
+    }
+    if (Number.isFinite(failed)
+        && failed === 0
+        && liveOutcome.tasksTotal > 0
+        && liveOutcome.tasksSucceeded >= liveOutcome.tasksTotal) {
+        liveOutcome.failedTaskIds.clear();
+        liveOutcome.executorFailed = false;
+    }
+}
 const READ_DISCOVERY_TOOLS = new Set([
     'read_file',
     'grep',
@@ -200,10 +233,12 @@ export function noteAnalysisToolUse(toolName, liveOutcome) {
  * When tasks were planned, ALL must succeed — file changes alone never imply victory.
  */
 export function evaluateExecutorSuccess(liveOutcome) {
+    const unfinishedTaskHandoff = hasUnfinishedTaskHandoff(liveOutcome.answerContent || '');
     const hasFatalError = liveOutcome.executorFailed
         || Boolean(liveOutcome.plannerError)
         || Boolean(liveOutcome.executorError)
-        || Boolean(liveOutcome.streamAborted);
+        || Boolean(liveOutcome.streamAborted)
+        || unfinishedTaskHandoff;
     if (liveOutcome.streamAborted && liveOutcome.tasksTotal > 0) {
         const partial = liveOutcome.tasksSucceeded > 0;
         if (isExecutorTimeoutFailure(liveOutcome)) {
@@ -244,7 +279,7 @@ 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) {
+        if (allTasksPassed && failedCount === 0 && !liveOutcome.streamAborted && !unfinishedTaskHandoff) {
             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

package/dist/utils/api-client-factory.d.ts

@@ -0,0 +1,8 @@
+import { APIClient, type APIClientDependencies } from './api.js';
+import type { Config } from './config.js';
+import type { Logger } from './logger.js';
+/**
+ * The sole production construction boundary for the compatibility API facade.
+ * Commands keep owning independent clients until their typed ports are extracted.
+ */
+export declare function createAPIClient(config: Config, logger: Logger, dependencies?: APIClientDependencies): APIClient;

package/dist/utils/api-client-factory.js

@@ -0,0 +1,8 @@
+import { APIClient } from './api.js';
+/**
+ * The sole production construction boundary for the compatibility API facade.
+ * Commands keep owning independent clients until their typed ports are extracted.
+ */
+export function createAPIClient(config, logger, dependencies = {}) {
+    return new APIClient(config, logger, dependencies);
+}