vigthoria-cli 1.11.47 → 1.12.1

package/dist/commands/agent-session-menu.d.ts

@@ -3,12 +3,14 @@ export interface AgentSessionConfig {
     debugMode: boolean;
     autoApprove: boolean;
     autoSave: boolean;
+    engine: 'v3' | 'v4';
 }
 export interface AgentSessionMenuDefaults {
     workspacePath?: string;
     debugMode?: boolean;
     autoApprove?: boolean;
     autoSave?: boolean;
+    engine?: 'v3' | 'v4';
 }
 export interface AgentSessionMenuOptions {
     prompt?: string;

package/dist/commands/agent-session-menu.js

@@ -90,12 +90,34 @@ export async function runAgentSessionMenu(defaults = {}) {
         debugMode: defaults.debugMode === true,
         autoApprove: defaults.autoApprove === true,
         autoSave: defaults.autoSave !== false,
+        engine: defaults.engine === 'v4' ? 'v4' : 'v3',
     };
     console.log();
     console.log(chalk.cyan('═══ Agent Session Setup ═══'));
     console.log(chalk.gray(fitLine(`Workspace: ${session.workspacePath}`)));
     console.log(chalk.gray(fitLine(`Debug: ${session.debugMode ? 'on' : 'off'} | Auto-approve: ${session.autoApprove ? 'on' : 'off'} | Auto-save: ${session.autoSave ? 'on' : 'off'}`)));
     console.log();
+    const { engine } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'engine',
+            message: 'Agent engine',
+            default: session.engine,
+            choices: [
+                { name: 'V3 Code Agent (default, stable)', value: 'v3' },
+                { name: 'V4 Operating Agent (experimental, requires local V4-Operating-Agent checkout)', value: 'v4' },
+            ],
+        },
+    ]);
+    session.engine = engine;
+    if (session.engine === 'v4') {
+        console.log();
+        console.log(chalk.cyan('── Session ready ──'));
+        console.log(chalk.gray(fitLine(`Workspace: ${session.workspacePath}`)));
+        console.log(chalk.gray('Engine: V4 Operating Agent'));
+        console.log();
+        return session;
+    }
     const { action } = await inquirer.prompt([
         {
             type: 'list',

package/dist/commands/chat.js

@@ -14,6 +14,7 @@ import { ProjectMemoryService } from '../utils/project-memory.js';
 import { WorkspaceBrainService } from '../utils/workspace-brain-service.js';
 import { buildPersonaOverlay, normalizePersonaMode } from '../utils/persona.js';
 import { runAgentSessionMenu, shouldShowAgentSessionMenu } from './agent-session-menu.js';
+import { V4Command } from './v4.js';
 import { createLiveOutcome, evaluateExecutorSuccess, handleTaskEvent, isSubstantiveAgentAnswer, isToolEvidenceStubAnswer, normalizeAgentAnswerContent, noteAnalysisToolUse, } from '../utils/agentRunOutcome.js';
 import { looksLikeMarkdownReport, renderMarkdownToTerminal, summarizeMarkdownReport, } from '../utils/terminalMarkdown.js';
 import { emitDeckEvent, isDeckModeEnabled } from '../utils/deckEvents.js';
@@ -1503,6 +1504,11 @@ export class ChatCommand {
             if (sessionConfig.debugMode) {
                 process.env.DEBUG = process.env.DEBUG || 'vigthoria:*';
             }
+            if (sessionConfig.engine === 'v4') {
+                const v4 = new V4Command(this.config, this.logger);
+                await v4.run({ v4Path: process.env.VIGTHORIA_V4_AGENT_DIR });
+                return;
+            }
             console.log(chalk.green(this.fitTerminalText(`Using workspace: ${this.currentProjectPath}`)));
         }
         if (this.jsonOutput && !options.prompt && !options.retry && !options.continue) {
@@ -3913,7 +3919,20 @@ export class ChatCommand {
             }
             if (trimmed.startsWith('/model ')) {
                 this.currentModel = trimmed.slice(7).trim() || this.currentModel;
-                this.modelExplicitlySelected = true;
+                // BUGFIX: previously this unconditionally set modelExplicitlySelected = true,
+                // which permanently locked resolveAgentExecutionPolicy() into its
+                // 'explicit-model-selection' branch for the rest of the session -- even for
+                // light chat aliases like 'balanced'/'fast'. Since 'balanced' resolves
+                // server-side to vigthoria-fast-9b, every subsequent /retry, /continue, or
+                // agent/operator task silently executed on the 9b model instead of the
+                // expected 35b executor, causing repeated "0 tool calls" task failures.
+                // Reuse the same hard-explicit rule applied at CLI startup so agent-mode
+                // aliases don't lock out the dispatcher's auto-upgrade-to-agent-model logic.
+                this.modelExplicitlySelected = this.isHardExplicitAgentModelSelection({
+                    model: this.currentModel,
+                    agent: this.agentMode,
+                    operator: this.operatorMode,
+                });
                 console.log(chalk.yellow(`Model changed to: ${this.currentModel}`));
                 if (this.currentSession) {
                     this.currentSession.model = this.currentModel;

package/dist/commands/index.js

@@ -17,6 +17,7 @@ import { ReplayCommand } from './replay.js';
 import { RepoCommand } from './repo.js';
 import { ReviewCommand } from './review.js';
 import { WorkflowCommand } from './workflow.js';
+import { V4Command } from './v4.js';
 function isRegisterableCommand(value) {
     return Boolean(value && typeof value === 'object');
 }
@@ -114,6 +115,11 @@ const commandRegistry = [
         name: 'bridge',
         handler: createClassRegistrar(BridgeCommand),
     },
+    {
+        name: 'v4',
+        aliases: ['v4-agent'],
+        handler: createClassRegistrar(V4Command),
+    },
     {
         name: 'workflow',
         handler: createClassRegistrar(WorkflowCommand),

package/dist/commands/v4.d.ts

@@ -0,0 +1,24 @@
+import { Command } from 'commander';
+import { Config } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+type V4Options = {
+    provider?: 'cloud' | 'v3_local' | 'byok';
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    transport?: 'auto' | 'ws' | 'sse';
+    harnessStreamUrl?: string;
+    harnessControlUrl?: string;
+    sessionId?: string;
+    nonInteractive?: boolean;
+    python?: string;
+    v4Path?: string;
+};
+export declare class V4Command {
+    private readonly _config;
+    private readonly logger;
+    constructor(_config: Config, logger: Logger);
+    register(program: Command): void;
+    run(options: V4Options): Promise<void>;
+}
+export {};

package/dist/commands/v4.js

@@ -0,0 +1,105 @@
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+const DEFAULT_V4_AGENT_DIR_UNIX = '/var/www/V4-Operating-Agent';
+function defaultV4PythonBin() {
+    return process.env.VIGTHORIA_V4_PYTHON || (process.platform === 'win32' ? 'python' : 'python3');
+}
+function defaultV4AgentDir() {
+    if (process.env.VIGTHORIA_V4_AGENT_DIR) {
+        return process.env.VIGTHORIA_V4_AGENT_DIR;
+    }
+    // The historical hardcoded default only ever existed on this project's Linux
+    // dev/test boxes. Never assume it on Windows/macOS — only use it as a
+    // fallback when it actually exists on disk, so real users get a clear
+    // "not found" error instead of a silently-wrong path.
+    if (process.platform !== 'win32' && fs.existsSync(DEFAULT_V4_AGENT_DIR_UNIX)) {
+        return DEFAULT_V4_AGENT_DIR_UNIX;
+    }
+    return undefined;
+}
+export class V4Command {
+    _config;
+    logger;
+    constructor(_config, logger) {
+        this._config = _config;
+        this.logger = logger;
+    }
+    register(program) {
+        program
+            .command('v4')
+            .alias('v4-agent')
+            .description('Launch Vigthoria V4 Operating Agent (DeerFlow 2.0 harness)')
+            .option('--provider <provider>', 'Provider: cloud | v3_local | byok')
+            .option('--api-key <key>', 'BYOK API key for non-interactive mode')
+            .option('--base-url <url>', 'Provider base URL override')
+            .option('--model <name>', 'Provider model override')
+            .option('--transport <mode>', 'Bridge transport: auto | ws | sse', 'auto')
+            .option('--harness-stream-url <url>', 'Override harness stream URL')
+            .option('--harness-control-url <url>', 'Override harness control URL')
+            .option('--session-id <id>', 'Explicit V4 session id')
+            .option('--non-interactive', 'Disable interactive menu and use CLI options', false)
+            .option('--python <bin>', 'Python binary to use', defaultV4PythonBin())
+            .option('--v4-path <path>', 'V4 agent root path (or set VIGTHORIA_V4_AGENT_DIR)', defaultV4AgentDir())
+            .action(async (options) => {
+            await this.run(options);
+        });
+    }
+    async run(options) {
+        const resolvedV4Path = options.v4Path || defaultV4AgentDir();
+        if (!resolvedV4Path) {
+            throw Object.assign(new Error('V4 agent path not set. Pass --v4-path <dir> or set the VIGTHORIA_V4_AGENT_DIR environment variable.'), { skipPathScrub: true });
+        }
+        const v4Path = path.resolve(String(resolvedV4Path));
+        const pythonBin = String(options.python || defaultV4PythonBin());
+        const mainScript = path.join(v4Path, 'main_agent.py');
+        if (!fs.existsSync(mainScript)) {
+            throw Object.assign(new Error(`V4 launcher not found: ${mainScript}. Check --v4-path/VIGTHORIA_V4_AGENT_DIR points at a valid V4-Operating-Agent checkout.`), { skipPathScrub: true });
+        }
+        const args = [mainScript];
+        if (options.nonInteractive) {
+            args.push('--non-interactive');
+        }
+        if (options.provider) {
+            args.push('--provider', String(options.provider));
+        }
+        if (options.apiKey) {
+            args.push('--api-key', String(options.apiKey));
+        }
+        if (options.baseUrl) {
+            args.push('--base-url', String(options.baseUrl));
+        }
+        if (options.model) {
+            args.push('--model', String(options.model));
+        }
+        if (options.transport) {
+            args.push('--transport', String(options.transport));
+        }
+        if (options.harnessStreamUrl) {
+            args.push('--harness-stream-url', String(options.harnessStreamUrl));
+        }
+        if (options.harnessControlUrl) {
+            args.push('--harness-control-url', String(options.harnessControlUrl));
+        }
+        if (options.sessionId) {
+            args.push('--session-id', String(options.sessionId));
+        }
+        this.logger.info(chalk.cyan(`Launching V4 Operating Agent from ${v4Path}`));
+        const child = spawn(pythonBin, args, {
+            cwd: v4Path,
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                PYTHONUNBUFFERED: '1',
+            },
+        });
+        const exitCode = await new Promise((resolve, reject) => {
+            child.on('error', reject);
+            child.on('close', (code) => resolve(code ?? 1));
+        });
+        if (exitCode !== 0) {
+            throw new Error(`V4 agent exited with status ${exitCode}`);
+        }
+    }
+}

package/dist/index.js

@@ -38,6 +38,7 @@ import { ForkCommand } from './commands/fork.js';
 import { CancelCommand } from './commands/cancel.js';
 import { BackgroundCommand } from './commands/background.js';
 import { SecurityCommand } from './commands/security.js';
+import { V4Command } from './commands/v4.js';
 import { Config } from './utils/config.js';
 import { Logger, CH } from './utils/logger.js';
 import chalk from 'chalk';
@@ -472,8 +473,14 @@ function normalizeCliError(error) {
                 ? extended.response.data.message
                 : undefined;
         const rawMessage = responseMessage || extended.message || 'An unexpected CLI error occurred.';
+        // Purely local, client-side errors (e.g. "this config path doesn't exist
+        // on YOUR machine") can legitimately mention local paths that happen to
+        // look like internal server paths (e.g. `/var/www/...`-style directories
+        // the user copied/typed themselves). Scrubbing those makes an otherwise
+        // actionable message unreadable, so commands that construct their own
+        // local filesystem errors can opt out via `skipPathScrub`.
         return {
-            message: scrubMessageForUser(rawMessage),
+            message: extended.skipPathScrub ? rawMessage : scrubMessageForUser(rawMessage),
             code: extended.code,
             status: extended.status || extended.statusCode || extended.response?.status,
             details: extended.details || extended.response?.data,
@@ -739,6 +746,37 @@ export async function main(args) {
             bridge: options.bridge,
         });
     });
+    program
+        .command('v4')
+        .alias('v4-agent')
+        .description('Launch Vigthoria V4 Operating Agent (DeerFlow 2.0 harness)')
+        .option('--provider <provider>', 'Provider: cloud | v3_local | byok')
+        .option('--api-key <key>', 'BYOK API key for non-interactive mode')
+        .option('--base-url <url>', 'Provider base URL override')
+        .option('--model <name>', 'Provider model override')
+        .option('--transport <mode>', 'Bridge transport: auto | ws | sse', 'auto')
+        .option('--harness-stream-url <url>', 'Override harness stream URL')
+        .option('--harness-control-url <url>', 'Override harness control URL')
+        .option('--session-id <id>', 'Explicit V4 session id')
+        .option('--non-interactive', 'Disable interactive menu and use CLI options', false)
+        .option('--python <bin>', 'Python binary to use', process.env.VIGTHORIA_V4_PYTHON || 'python3')
+        .option('--v4-path <path>', 'V4 agent root path', process.env.VIGTHORIA_V4_AGENT_DIR || '/var/www/V4-Operating-Agent')
+        .action(async (options) => {
+        const v4 = new V4Command(config, logger);
+        await v4.run({
+            provider: options.provider,
+            apiKey: options.apiKey,
+            baseUrl: options.baseUrl,
+            model: options.model,
+            transport: options.transport,
+            harnessStreamUrl: options.harnessStreamUrl,
+            harnessControlUrl: options.harnessControlUrl,
+            sessionId: options.sessionId,
+            nonInteractive: options.nonInteractive,
+            python: options.python,
+            v4Path: options.v4Path,
+        });
+    });
     program
         .command('bridge')
         .description('Inspect local DevTools Bridge availability for browser debugging tasks')

package/dist/utils/templateInstantPath.js

@@ -124,9 +124,17 @@ function minimalHelloWorldHtml(popupMessage = 'Hello World') {
 </html>
 `;
 }
+// The Template Service (port 4011) hard-rejects any `vision` payload over
+// 2000 characters with an HTTP 400. Real prompts (especially resumed-session
+// `/retry` context on an existing project) routinely exceed that, which
+// otherwise made this fast-path fail every single time for non-trivial
+// requests instead of ever getting a chance to match. Cap to the server's
+// own limit so template matching still gets a fair shot on long prompts.
+const TEMPLATE_SERVICE_MAX_VISION_CHARS = 2000;
 async function fetchTemplateMatch(api, vision, timeoutMs = 15000) {
     const bases = api.getTemplateServiceBaseUrls();
     let lastError = 'Template Service unreachable';
+    const boundedVision = String(vision || '').slice(0, TEMPLATE_SERVICE_MAX_VISION_CHARS);
     for (const base of bases) {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -134,7 +142,7 @@ async function fetchTemplateMatch(api, vision, timeoutMs = 15000) {
             const response = await fetch(`${base}/match`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ vision }),
+                body: JSON.stringify({ vision: boundedVision }),
                 signal: controller.signal,
             });
             clearTimeout(timer);

package/package.json

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