vigthoria-cli 1.9.22 → 1.10.0

package/dist/commands/chat.d.ts

@@ -40,6 +40,8 @@ export declare class ChatCommand {
     private savePlanToVigFlow;
     private jsonOutput;
     private modelGovernanceFallback;
+    private retryPromptSignature;
+    private retryPromptStreak;
     private lastAgentRunOutcome;
     private isJwtExpirationError;
     private isNetworkError;
@@ -155,10 +157,7 @@ export declare class ChatCommand {
      * Resumes only the failed/unfinished tasks from the previous run.
      */
     private buildRetryPrompt;
-    /**
-     * Build the prompt sent to the agent when the user types `/continue`.
-     * Tells the agent to keep working from the current workspace state.
-     */
+    private computeRetryPromptSignature;
     private buildContinuePrompt;
     /**
      * Re-print the last agent run summary, or guide the user when there isn't one.
@@ -175,6 +174,7 @@ export declare class ChatCommand {
     private workspaceContainsHtmlEntry;
     private shouldBypassDirectSingleFileFlow;
     private shouldPreferLocalAgentLoop;
+    private getRuntimeEnvironmentContext;
     private shouldRequireV3AgentWorkflow;
     private isServerBindableWorkspace;
     private isProtectedFileReferenceSafe;

package/dist/commands/chat.js

@@ -59,6 +59,8 @@ export class ChatCommand {
     savePlanToVigFlow = false;
     jsonOutput = false;
     modelGovernanceFallback = null;
+    retryPromptSignature = null;
+    retryPromptStreak = 0;
     // Last completed Agent run — used by /retry, /continue, and the final summary block.
     lastAgentRunOutcome = null;
     isJwtExpirationError(error) {
@@ -381,15 +383,22 @@ export class ChatCommand {
     }
     buildTaskShapingInstructions(prompt) {
         const instructions = [];
+        const runtime = this.getRuntimeEnvironmentContext();
         // Platform-aware routing hints
-        if (os.platform() === 'win32') {
+        if (runtime.platform === 'windows') {
             instructions.push('Platform: Windows. Use list_dir, glob, read_file, and the grep tool for searching.', 'The grep tool handles Windows automatically — do not use bash to call grep, findstr, or Select-String manually.', 'Do not use bash for Unix commands (cat, head, tail, awk, sed, wc).', 'Use read_file to inspect file contents instead of shell commands.', 'All file paths use forward slashes internally.');
         }
+        else if (runtime.platform === 'macos') {
+            instructions.push('Platform: macOS. Prefer list_dir, grep, and read_file tools for deterministic results.', 'Use workspace-relative paths and verify file existence before claiming a file is missing.');
+        }
+        else if (runtime.platform === 'linux') {
+            instructions.push('Platform: Linux. Prefer list_dir, grep, and read_file for grounded repository inspection.', 'Use exact file paths from tool output when reporting findings or fixes.');
+        }
         if (this.isDiagnosticPrompt(prompt)) {
             instructions.push('Diagnostic mode is active.', 'Treat this as a debugging task, not a generic code review or feature request.', 'Start with concrete evidence: logs, runtime errors, config, launch files, and exact symbol references.', 'If log files exist, inspect them before proposing fixes.', 'Do not claim a file, definition, asset, or symbol is missing until you verify that with tools.', 'If a prior diagnosis mentioned a missing symbol or YAML entry, re-check the actual files before repeating it.', 'Prefer grep plus read_file around the exact references involved in the failure.', 'Separate your reasoning into: Evidence, Confirmed Cause, and Remaining Hypotheses.', 'Do not suggest speculative fixes when the current evidence contradicts them.', 'CRITICAL GROUNDING RULE: Every key name, variable name, symbol, or identifier you mention in your final answer MUST appear verbatim in the tool output you received. If a key/symbol does NOT appear in tool output, you MUST NOT mention it as involved in any conflict or issue.', 'CROSS-FILE ATTRIBUTION: When reporting conflicts between two files, a key/symbol is conflicting ONLY if it appears in BOTH files. Read each file carefully and list only the exact keys that appear in the relevant handler/function of EACH file. Do not assume that because one file handles a key, the other file does too.', 'When reporting conflicts between files, cite the exact file name, line number, and the exact string/key from the tool output. Do not paraphrase or substitute key names.', 'Before concluding, re-check: (1) does every key/symbol in my answer actually appear in the evidence I gathered? (2) for each claimed conflict, did I verify the key appears in BOTH files? If not, correct your answer.');
         }
         if (this.isBrowserTaskPrompt(prompt)) {
-            instructions.push('Browser-debug mode is active.', 'Prefer concrete browser evidence such as console errors, network failures, DOM state, and websocket behavior.', 'If a DevTools Bridge is available, use it as the primary browser observability path.');
+            instructions.push('Browser-debug mode is active.', 'Prefer concrete browser evidence such as console errors, network failures, DOM state, and websocket behavior.', 'Use the DevTools Bridge only when the user has explicitly enabled it for this run; otherwise ask for permission before requiring local browser tooling.');
         }
         if (instructions.length === 0) {
             return '';
@@ -444,7 +453,9 @@ export class ChatCommand {
         }
     }
     async getPromptRuntimeContext(prompt) {
-        const runtimeContext = {};
+        const runtimeContext = {
+            agentRuntime: this.getRuntimeEnvironmentContext(),
+        };
         const brainContext = this.buildProjectBrainRuntimeContext(prompt, this.operatorMode ? 'vigthoria-cli.operator' : this.agentMode ? 'vigthoria-cli.agent' : 'vigthoria-cli.chat');
         if (brainContext) {
             runtimeContext.vigthoriaBrain = brainContext;
@@ -452,6 +463,19 @@ export class ChatCommand {
         if (!this.isBrowserTaskPrompt(prompt)) {
             return runtimeContext;
         }
+        const devtoolsBridgeAllowed = /^(1|true|yes)$/i.test(String(process.env.VIGTHORIA_DEVTOOLS_BRIDGE_ALLOWED || process.env.VIGTHORIA_BRIDGE_ALLOWED || ''));
+        if (!devtoolsBridgeAllowed) {
+            if (!this.jsonOutput) {
+                console.log(chalk.yellow('Browser task detected. DevTools Bridge is opt-in; the agent will ask before relying on local browser tooling.'));
+            }
+            return {
+                ...runtimeContext,
+                browserTask: true,
+                devtoolsBridgeAvailable: false,
+                devtoolsBridgeAllowed: false,
+                devtoolsBridgeEndpoint: null,
+            };
+        }
         const bridgeStatus = await this.callApi('Checking DevTools Bridge status', () => this.api.getDevtoolsBridgeStatus(), 0);
         if (!this.jsonOutput && bridgeStatus.ok) {
             console.log(chalk.gray(`Browser task detected. DevTools Bridge is reachable at ${bridgeStatus.endpoint}.`));
@@ -463,6 +487,7 @@ export class ChatCommand {
             ...runtimeContext,
             browserTask: true,
             devtoolsBridgeAvailable: bridgeStatus.ok,
+            devtoolsBridgeAllowed: true,
             devtoolsBridgeEndpoint: bridgeStatus.endpoint,
         };
     }
@@ -2527,6 +2552,27 @@ export class ChatCommand {
                     console.log(chalk.yellow('Nothing to retry — run an agent task first.'));
                     continue;
                 }
+                const nextSignature = this.computeRetryPromptSignature();
+                if (nextSignature && this.retryPromptSignature === nextSignature) {
+                    this.retryPromptStreak += 1;
+                }
+                else {
+                    this.retryPromptSignature = nextSignature;
+                    this.retryPromptStreak = 1;
+                }
+                if (this.retryPromptStreak >= 3) {
+                    const continuePrompt = this.buildContinuePrompt();
+                    if (continuePrompt) {
+                        console.log(chalk.yellow('Repeated /retry detected with the same failing task set. Escalating to /continue to avoid planner loops.'));
+                        if (!this.agentMode) {
+                            this.agentMode = true;
+                            this.syncInteractiveModeModel('agent');
+                            console.log(chalk.gray('Agent mode re-enabled for continuation.'));
+                        }
+                        await this.runAgentTurn(continuePrompt);
+                        continue;
+                    }
+                }
                 if (!this.agentMode) {
                     this.agentMode = true;
                     this.syncInteractiveModeModel('agent');
@@ -2681,6 +2727,7 @@ export class ChatCommand {
         const o = this.lastAgentRunOutcome;
         if (!o || !o.prompt)
             return null;
+        const runtime = this.getRuntimeEnvironmentContext();
         const remaining = [...new Set([...o.failedTaskIds, ...o.unfinishedTaskIds])];
         const taskList = remaining.length > 0 ? remaining.join(', ') : '';
         const blockerLine = o.qualityBlockers.length > 0
@@ -2689,15 +2736,27 @@ export class ChatCommand {
         const missingLine = o.qualityMissing.length > 0
             ? `\nMissing pieces: ${o.qualityMissing.slice(0, 6).join(', ')}.`
             : '';
+        const envLine = `\nExecution environment: ${runtime.platform}; machine scope: ${runtime.machineScope}; workspace path: ${runtime.workspacePath}.`;
+        const localPreferenceLine = runtime.machineScope === 'local-machine'
+            ? '\nUse local workspace tools and local filesystem paths first; do not assume server-side workspace access.'
+            : '';
         if (taskList) {
-            return `Resume the previous agent run. Re-execute only these tasks and make them pass: ${taskList}.${blockerLine}${missingLine}\nOriginal request was: ${o.prompt}`;
+            return `Resume the previous agent run. Re-execute only these tasks and make them pass: ${taskList}.${blockerLine}${missingLine}${envLine}${localPreferenceLine}\nOriginal request was: ${o.prompt}`;
         }
-        return `Retry the previous request and make sure it finishes successfully.${blockerLine}${missingLine}\nOriginal request was: ${o.prompt}`;
+        return `Retry the previous request and make sure it finishes successfully.${blockerLine}${missingLine}${envLine}${localPreferenceLine}\nOriginal request was: ${o.prompt}`;
+    }
+    computeRetryPromptSignature() {
+        const o = this.lastAgentRunOutcome;
+        if (!o) {
+            return null;
+        }
+        const remaining = [...new Set([...o.failedTaskIds, ...o.unfinishedTaskIds])].sort();
+        if (remaining.length === 0) {
+            return null;
+        }
+        const blockers = [...(o.qualityBlockers || [])].slice(0, 3).sort();
+        return `${remaining.join('|')}::${blockers.join('|')}`;
     }
-    /**
-     * Build the prompt sent to the agent when the user types `/continue`.
-     * Tells the agent to keep working from the current workspace state.
-     */
     buildContinuePrompt() {
         const o = this.lastAgentRunOutcome;
         if (!o || !o.prompt)
@@ -2743,6 +2802,14 @@ export class ChatCommand {
         else {
             console.log(chalk.gray('No compact session memory summary yet.'));
         }
+        const runtime = this.getRuntimeEnvironmentContext();
+        console.log();
+        console.log(chalk.white('Runtime Environment:'));
+        console.log(chalk.gray(`Platform: ${runtime.platform} (${runtime.osPlatform})`));
+        console.log(chalk.gray(`Machine scope: ${runtime.machineScope}`));
+        console.log(chalk.gray(`Workspace: ${runtime.workspacePath}`));
+        console.log(chalk.gray(`CWD: ${runtime.cwd}`));
+        console.log(chalk.gray(`Server-bindable workspace: ${runtime.serverBindableWorkspace ? 'yes' : 'no'}`));
         this.showProjectMemory();
     }
     showProjectMemory() {
@@ -2904,19 +2971,52 @@ export class ChatCommand {
         if (this.shouldRequireV3AgentWorkflow(prompt)) {
             return false;
         }
-        if (!this.directPromptMode) {
+        const forceV3 = /^(1|true|yes)$/i.test(String(process.env.VIGTHORIA_FORCE_V3_AGENT || ''));
+        if (forceV3) {
             return false;
         }
-        // Always prefer V3 agent first — it supports workspace hydration for
-        // non-server-bindable workspaces (Windows paths, remote machines).
-        // The V3 path will fall back to local-agent-loop if V3 is unreachable.
-        // This ensures runs get archived for history/replay/fork.
-        return false;
+        const runtime = this.getRuntimeEnvironmentContext();
+        // Local machines and non-server-bindable workspaces should run locally first.
+        if (!runtime.serverBindableWorkspace) {
+            return true;
+        }
+        // Interactive sessions should prioritize local edits unless V3 is explicitly forced.
+        if (!this.directPromptMode) {
+            return true;
+        }
+        // For direct prompts on server-bindable Linux roots, keep V3-first behavior.
+        return runtime.platform !== 'linux';
+    }
+    getRuntimeEnvironmentContext() {
+        const osPlatform = os.platform();
+        const platform = osPlatform === 'win32'
+            ? 'windows'
+            : osPlatform === 'darwin'
+                ? 'macos'
+                : osPlatform === 'linux'
+                    ? 'linux'
+                    : 'unknown';
+        const workspacePath = this.currentProjectPath || process.cwd();
+        const serverBindableWorkspace = this.isServerBindableWorkspace(workspacePath);
+        return {
+            osPlatform,
+            platform,
+            nodeVersion: process.version,
+            cwd: process.cwd(),
+            workspacePath,
+            directPromptMode: this.directPromptMode,
+            serverBindableWorkspace,
+            machineScope: serverBindableWorkspace ? 'server-workspace' : 'local-machine',
+        };
     }
     shouldRequireV3AgentWorkflow(prompt) {
         if (!this.directPromptMode) {
             return false;
         }
+        const runtime = this.getRuntimeEnvironmentContext();
+        if (runtime.machineScope === 'local-machine') {
+            return false;
+        }
         if (this.inferTargetFilesFromPrompt(prompt).length > 0) {
             return false;
         }

package/dist/commands/config.d.ts

@@ -9,12 +9,20 @@ interface ConfigOptions {
     list?: boolean;
     reset?: boolean;
 }
+interface InitOptions {
+    model?: string;
+    ignorePatterns?: string;
+    autoApplyFixes?: boolean;
+    profile?: 'safe' | 'balanced' | 'fast';
+    yes?: boolean;
+    nonInteractive?: boolean;
+}
 export declare class ConfigCommand {
     private config;
     private logger;
     constructor(config: Config, logger: Logger);
     run(options: ConfigOptions): Promise<void>;
-    init(): Promise<void>;
+    init(options?: InitOptions): Promise<void>;
     private setConfig;
     private formatConfigValueForDisplay;
     private redactConfigUrl;

package/dist/commands/config.js

@@ -33,56 +33,93 @@ export class ConfigCommand {
         // Interactive mode
         await this.interactiveConfig();
     }
-    async init() {
+    async init(options = {}) {
         console.log();
         console.log(chalk.cyan(`${CH.hDouble.repeat(3)} Initialize Vigthoria in Project ${CH.hDouble.repeat(3)}`));
         console.log();
         const cwd = process.cwd();
         const configFile = path.join(cwd, '.vigthoria.json');
+        const allowedModels = new Set(['code', 'code-35b', 'code-9b', 'balanced', 'balanced-4b']);
+        const hasOverrides = Boolean(options.model ||
+            options.ignorePatterns !== undefined ||
+            options.autoApplyFixes !== undefined ||
+            options.profile);
+        const nonInteractive = Boolean(options.nonInteractive || options.yes || hasOverrides);
         if (fs.existsSync(configFile)) {
-            const { overwrite } = await inquirer.prompt([
+            if (nonInteractive) {
+                if (!options.yes) {
+                    this.logger.error('.vigthoria.json already exists. Re-run with --yes to overwrite in non-interactive mode.');
+                    return;
+                }
+            }
+            else {
+                const { overwrite } = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'overwrite',
+                        message: '.vigthoria.json already exists. Overwrite?',
+                        default: false,
+                    },
+                ]);
+                if (!overwrite) {
+                    this.logger.info('Initialization cancelled');
+                    return;
+                }
+            }
+        }
+        let settings;
+        if (nonInteractive) {
+            const profileDefaults = {
+                safe: { defaultModel: 'balanced', autoApplyFixes: false },
+                balanced: { defaultModel: 'code', autoApplyFixes: false },
+                fast: { defaultModel: 'code-9b', autoApplyFixes: true },
+            };
+            const profile = options.profile && profileDefaults[options.profile] ? options.profile : 'balanced';
+            const defaults = profileDefaults[profile];
+            const model = options.model || defaults.defaultModel;
+            if (!allowedModels.has(model)) {
+                this.logger.error(`Invalid --model: ${model}`);
+                this.logger.info('Allowed values: code, code-35b, code-9b, balanced, balanced-4b');
+                return;
+            }
+            settings = {
+                defaultModel: model,
+                ignorePatterns: options.ignorePatterns || '',
+                autoApplyFixes: options.autoApplyFixes !== undefined ? options.autoApplyFixes : defaults.autoApplyFixes,
+            };
+        }
+        else {
+            // Gather project settings interactively
+            settings = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'defaultModel',
+                    message: 'Default AI model:',
+                    choices: [
+                        { name: '═══ Code Models ═══', disabled: true },
+                        { name: 'Vigthoria v3 Code 35B - Flagship coding model', value: 'code' },
+                        { name: 'Vigthoria v3 Code 35B - Explicit 35B selection', value: 'code-35b' },
+                        { name: 'Vigthoria v3 Code 9B - Fast coding specialist', value: 'code-9b' },
+                        { name: '═══ General Models ═══', disabled: true },
+                        { name: 'Vigthoria Master 7.6B - Balanced general model', value: 'balanced' },
+                        { name: 'Vigthoria v3 Balanced 4B - Efficient general purpose', value: 'balanced-4b' },
+                    ],
+                    default: 'code',
+                },
+                {
+                    type: 'input',
+                    name: 'ignorePatterns',
+                    message: 'Additional ignore patterns (comma-separated):',
+                    default: '',
+                },
                 {
                     type: 'confirm',
-                    name: 'overwrite',
-                    message: '.vigthoria.json already exists. Overwrite?',
+                    name: 'autoApplyFixes',
+                    message: 'Auto-apply fixes without confirmation?',
                     default: false,
                 },
             ]);
-            if (!overwrite) {
-                this.logger.info('Initialization cancelled');
-                return;
-            }
         }
-        // Gather project settings
-        const settings = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'defaultModel',
-                message: 'Default AI model:',
-                choices: [
-                    { name: '═══ Code Models ═══', disabled: true },
-                    { name: 'Vigthoria v3 Code 35B - Flagship coding model', value: 'code' },
-                    { name: 'Vigthoria v3 Code 35B - Explicit 35B selection', value: 'code-35b' },
-                    { name: 'Vigthoria v3 Code 9B - Fast coding specialist', value: 'code-9b' },
-                    { name: '═══ General Models ═══', disabled: true },
-                    { name: 'Vigthoria Master 7.6B - Balanced general model', value: 'balanced' },
-                    { name: 'Vigthoria v3 Balanced 4B - Efficient general purpose', value: 'balanced-4b' },
-                ],
-                default: 'code',
-            },
-            {
-                type: 'input',
-                name: 'ignorePatterns',
-                message: 'Additional ignore patterns (comma-separated):',
-                default: '',
-            },
-            {
-                type: 'confirm',
-                name: 'autoApplyFixes',
-                message: 'Auto-apply fixes without confirmation?',
-                default: false,
-            },
-        ]);
         // Create project config
         const projectConfig = {
             defaultModel: settings.defaultModel,
@@ -104,7 +141,10 @@ export class ConfigCommand {
             }
         }
         console.log();
-        console.log(chalk.gray('Project initialized! Run `vigthoria chat` or `npx vigthoria-chat` to start.'));
+        if (nonInteractive) {
+            console.log(chalk.gray('Project initialized in non-interactive mode.'));
+        }
+        console.log(chalk.gray('Project initialized! Run vigthoria start for a beginner guide or vigthoria chat to begin.'));
         console.log();
     }
     setConfig(keyValue) {

package/dist/index.js

@@ -1357,6 +1357,41 @@ Examples:
         }
         process.exitCode = 0;
     });
+    // Start command - beginner quick guide
+    program
+        .command('start')
+        .alias('guide')
+        .description('Show beginner quick-start steps and recommended first commands')
+        .option('--json', 'Emit machine-readable guide output', false)
+        .action(async (options) => {
+        const steps = [
+            '1. Authenticate: vigthoria login',
+            '2. Verify account: vigthoria status',
+            '3. Initialize project: vigthoria init',
+            '4. Start coding: vigthoria chat --agent',
+            '5. Check for updates: vigthoria update --check',
+        ];
+        if (options.json) {
+            console.log(JSON.stringify({
+                command: 'start',
+                steps,
+                tips: [
+                    'Use vigthoria init --non-interactive for CI/bootstrap scripts.',
+                    'Run vigthoria doctor when environment checks fail.',
+                ],
+            }, null, 2));
+        }
+        else {
+            console.log();
+            console.log(chalk.bold('Vigthoria quick start'));
+            for (const step of steps) {
+                console.log(chalk.gray('- ' + step));
+            }
+            console.log();
+            console.log(chalk.gray('Tip: use vigthoria init --profile safe --non-interactive for conservative defaults.'));
+        }
+        process.exitCode = 0;
+    });
     // Config command
     program
         .command('config')
@@ -1385,7 +1420,6 @@ Examples:
         const manifestUrl = typeof options.manifest === 'string' ? options.manifest.trim() : VIGTHORIA_DEFAULT_MANIFEST_URL.trim();
         const channel = typeof options.channel === 'string' ? options.channel.trim() : 'stable';
         const allowDowngrade = !!options.allowDowngrade;
-        const gitPackageSpec = 'git+https://market.vigthoria.io/vigthoria/vigthoria-cli.git';
         if (updateTarget) {
             if (!isSafeNpmPackageSpec(updateTarget)) {
                 console.error(chalk.red('Refusing to run installer with unsafe package spec.'));
@@ -1483,7 +1517,7 @@ Examples:
             }
             catch (error) {
                 console.error(chalk.red('Failed to process manifest update:'), error.message);
-                console.log(chalk.gray('Falling back to npm/git update channels...'));
+                console.log(chalk.gray('Falling back to npm registry update channel...'));
             }
         }
         if (isOfflineMode()) {
@@ -1518,21 +1552,11 @@ Examples:
         catch (error) {
             console.error(chalk.red('Failed to check/install via npm registry:'), error.message);
             if (options.check) {
-                console.log(chalk.gray(`npm registry check failed; fallback install target is ${gitPackageSpec}`));
+                console.log(chalk.gray('npm registry check failed. Try again later or use --manifest with a valid release manifest URL.'));
                 return;
             }
-            try {
-                console.log(chalk.cyan('Attempting git package fallback...'));
-                await installGlobalPackageWithNpm(gitPackageSpec);
-                console.log(chalk.green('Updated via git package fallback'));
-                console.log(chalk.gray('Please restart the CLI to use the new version'));
-            }
-            catch (fallbackError) {
-                console.error(chalk.red('Fallback update also failed:'), fallbackError.message);
-                console.log(chalk.gray('Try manually: npm install -g vigthoria-cli@latest'));
-                console.log(chalk.gray(`Or: npm install -g ${gitPackageSpec}`));
-                process.exitCode = 1;
-            }
+            console.log(chalk.gray('Try manually: npm install -g vigthoria-cli@latest'));
+            process.exitCode = 1;
         }
     });
     // Hyper Loop command alias (maps to legion --status for checklist gate 6.9)
@@ -1569,9 +1593,15 @@ Examples:
     program
         .command('init')
         .description('Initialize Vigthoria in current project')
-        .action(async () => {
+        .option('--model <model>', 'Default model (code, code-35b, code-9b, balanced, balanced-4b)')
+        .option('--ignore-patterns <patterns>', 'Comma-separated ignore patterns for this project')
+        .option('--auto-apply-fixes', 'Enable auto-apply fixes for this project profile')
+        .option('--profile <preset>', 'Quick preset: safe, balanced, fast')
+        .option('-y, --yes', 'Overwrite existing .vigthoria.json without prompting')
+        .option('--non-interactive', 'Do not prompt; use provided flags/defaults')
+        .action(async (options) => {
         const configCmd = new ConfigCommand(config, logger);
-        await configCmd.init();
+        await configCmd.init(options);
     });
     const codingCommandDefinitions = [
         { name: 'edit', description: 'Edit code by describing the desired change', instruction: 'Edit the project according to this request' },

package/dist/utils/api.d.ts

@@ -302,6 +302,8 @@ export declare class APIClient {
     private resolveAgentTargetPath;
     private isLikelyWindowsPath;
     private resolveServerBindableWorkspacePath;
+    private buildPublicWorkspaceDescriptor;
+    private buildPublicRuntimeEnvironment;
     private buildLocalWorkspaceSummary;
     /**
      * Collect text file contents from the workspace for V3 agent hydration.

package/dist/utils/api.js

@@ -1265,13 +1265,22 @@ export class APIClient {
         const localWorkspaceSummary = this.buildLocalWorkspaceSummary(localWorkspacePath);
         const requestedModel = String(resolvedContext.model || resolvedContext.requestedModel || 'agent');
         const resolvedModel = this.resolvePermittedModelId(requestedModel);
+        const localWorkspaceName = localWorkspacePath ? path.basename(localWorkspacePath) : null;
+        const localWorkspaceRef = localWorkspaceName ? `vigthoria://local-workspace/${localWorkspaceName}` : null;
+        const publicRuntimeEnvironment = this.buildPublicRuntimeEnvironment(resolvedContext.agentRuntime, {
+            localWorkspacePath,
+            serverWorkspacePath,
+        });
         // When the server cannot directly access the workspace (e.g. Windows
         // client), use the local path as a hint and flag that the workspace
         // files are provided inline in localWorkspaceSummary.workspaceFiles.
         const effectiveWorkspacePath = serverWorkspacePath || null;
         const needsHydration = !serverWorkspacePath && !!localWorkspacePath;
         const payload = {
-            workspace: resolvedContext.workspace || null,
+            workspace: this.buildPublicWorkspaceDescriptor(resolvedContext.workspace, {
+                localWorkspacePath,
+                serverWorkspacePath,
+            }),
             activeFile: resolvedContext.activeFile || null,
             history: resolvedContext.history || [],
             agentTaskType: resolvedContext.agentTaskType || 'general',
@@ -1283,11 +1292,16 @@ export class APIClient {
             executionSurface: resolvedContext.executionSurface || 'cli',
             clientSurface: resolvedContext.clientSurface || 'cli',
             localMachineCapable: resolvedContext.localMachineCapable !== false,
+            runtimeEnvironment: publicRuntimeEnvironment,
             workspacePath: effectiveWorkspacePath,
             projectPath: effectiveWorkspacePath,
             targetPath: effectiveWorkspacePath,
-            localWorkspacePath: localWorkspacePath || null,
-            localWorkspaceName: localWorkspacePath ? path.basename(localWorkspacePath) : null,
+            // Never send a client-local absolute path to the V3 model boundary.
+            // The server only needs a stable label; file contents are carried by
+            // localWorkspaceSummary.workspaceFiles and hydrated into a temp workspace.
+            localWorkspacePath: serverWorkspacePath ? serverWorkspacePath : localWorkspaceRef,
+            localWorkspaceRef,
+            localWorkspaceName,
             localWorkspaceSummary,
             // Signal to the server that the workspace filesystem is not locally
             // accessible — it must hydrate a temp directory from the provided
@@ -1395,19 +1409,30 @@ export class APIClient {
             || resolvedContext.workspacePath
             || resolvedContext.projectRoot
             || process.cwd();
+        const serverWorkspacePath = this.resolveServerBindableWorkspacePath(resolvedContext);
+        const localWorkspaceName = targetPath ? path.basename(targetPath) : null;
+        const localWorkspaceRef = localWorkspaceName ? `vigthoria://local-workspace/${localWorkspaceName}` : null;
         return JSON.stringify({
-            workspace: resolvedContext.workspace || null,
+            workspace: this.buildPublicWorkspaceDescriptor(resolvedContext.workspace, {
+                localWorkspacePath: targetPath,
+                serverWorkspacePath,
+            }),
             activeFile: resolvedContext.activeFile || null,
             history: resolvedContext.history || [],
             agentTaskType: resolvedContext.agentTaskType || 'general',
             executionSurface: resolvedContext.executionSurface || 'cli',
             clientSurface: resolvedContext.clientSurface || 'cli',
             localMachineCapable: resolvedContext.localMachineCapable !== false,
-            workspacePath: resolvedContext.workspacePath || targetPath,
-            projectPath: resolvedContext.projectPath || targetPath,
-            targetPath,
-            localWorkspacePath: targetPath,
-            localWorkspaceName: targetPath ? path.basename(targetPath) : null,
+            runtimeEnvironment: this.buildPublicRuntimeEnvironment(resolvedContext.agentRuntime, {
+                localWorkspacePath: targetPath,
+                serverWorkspacePath,
+            }),
+            workspacePath: serverWorkspacePath || null,
+            projectPath: serverWorkspacePath || null,
+            targetPath: serverWorkspacePath || null,
+            localWorkspacePath: serverWorkspacePath || localWorkspaceRef,
+            localWorkspaceRef,
+            localWorkspaceName,
             contextId: resolvedContext.contextId,
             traceId: resolvedContext.traceId,
             requestStartedAt: resolvedContext.requestStartedAt,
@@ -1894,6 +1919,7 @@ menu {
             workspacePath: workspacePath || null,
             localWorkspacePath: localWorkspacePath || null,
             localWorkspaceSummary,
+            runtimeEnvironment: executionContext.agentRuntime || null,
             requestStartedAt: executionContext.requestStartedAt,
             subscriptionPlan: this.config.getNormalizedPlan() || null,
             email: this.config.get('email') || null,
@@ -1907,6 +1933,7 @@ menu {
             targetPath: workspacePath || null,
             localWorkspacePath: localWorkspacePath || null,
             localWorkspaceSummary,
+            runtimeEnvironment: executionContext.agentRuntime || null,
             activeFile: executionContext.activeFile || null,
             executionSurface: executionContext.executionSurface || 'cli',
             clientSurface: executionContext.clientSurface || 'cli',
@@ -1999,13 +2026,49 @@ menu {
         }
         return '';
     }
+    buildPublicWorkspaceDescriptor(workspace, paths = {}) {
+        const localName = paths.localWorkspacePath ? path.basename(paths.localWorkspacePath) : null;
+        const isServerBindable = !!paths.serverWorkspacePath;
+        const descriptor = {
+            name: localName,
+            path: isServerBindable ? paths.serverWorkspacePath : (localName ? `vigthoria://local-workspace/${localName}` : null),
+            scheme: isServerBindable ? 'server-bindable' : 'local-workspace',
+        };
+        if (workspace && typeof workspace === 'object') {
+            for (const [key, value] of Object.entries(workspace)) {
+                if (key === 'path' || key === 'workspacePath' || key === 'projectPath' || key === 'targetPath' || key === 'cwd') {
+                    continue;
+                }
+                descriptor[key] = value;
+            }
+        }
+        return descriptor.name || descriptor.path ? descriptor : null;
+    }
+    buildPublicRuntimeEnvironment(runtime, paths = {}) {
+        if (!runtime || typeof runtime !== 'object') {
+            return null;
+        }
+        const localName = paths.localWorkspacePath ? path.basename(paths.localWorkspacePath) : null;
+        const serverBindableWorkspace = !!paths.serverWorkspacePath || runtime.serverBindableWorkspace === true;
+        return {
+            osPlatform: runtime.osPlatform || null,
+            platform: runtime.platform || null,
+            nodeVersion: runtime.nodeVersion || null,
+            directPromptMode: runtime.directPromptMode === true,
+            serverBindableWorkspace,
+            machineScope: serverBindableWorkspace ? 'server-workspace' : 'local-machine',
+            workspaceName: localName,
+            workspacePath: serverBindableWorkspace ? paths.serverWorkspacePath || null : (localName ? `vigthoria://local-workspace/${localName}` : null),
+            cwd: serverBindableWorkspace ? paths.serverWorkspacePath || null : (localName ? `vigthoria://local-workspace/${localName}` : null),
+        };
+    }
     buildLocalWorkspaceSummary(rootPath) {
         if (!rootPath || !fs.existsSync(rootPath)) {
             return null;
         }
         try {
             const summary = {
-                path: rootPath,
+                path: 'vigthoria://workspace/',
                 name: path.basename(rootPath),
                 files: [],
             };

package/package.json

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