vigthoria-cli 1.13.13 → 1.13.18

package/dist/commands/background.d.ts

@@ -4,6 +4,8 @@ interface BackgroundOptions {
     json?: boolean;
     limit?: number;
     workspace?: string;
+    deny?: boolean;
+    model?: string;
 }
 export declare class BackgroundCommand {
     private config;
@@ -16,5 +18,6 @@ export declare class BackgroundCommand {
     apply(jobId: string, options?: BackgroundOptions): Promise<void>;
     cancel(jobId: string, options?: BackgroundOptions): Promise<void>;
     private extractBackgroundOutcome;
+    approve(jobId: string, approvalId: string, options?: BackgroundOptions): Promise<void>;
 }
 export {};

package/dist/commands/background.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { createSpinner, CH } from '../utils/logger.js';
 import { APIClient } from '../utils/api.js';
+import { buildExecutionHints, inferAgentTaskType } from '../utils/requestIntent.js';
 export class BackgroundCommand {
     config;
     logger;
@@ -17,6 +18,15 @@ export class BackgroundCommand {
             return;
         }
         const workspacePath = options.workspace || process.cwd();
+        const requestedModel = String(options.model || 'agent').trim().toLowerCase();
+        const allowedModels = new Set(['agent', 'cloud', 'cloud-reason', 'ultra']);
+        if (!allowedModels.has(requestedModel)) {
+            this.logger.error('Background model must be one of: agent, cloud, cloud-reason, ultra');
+            return;
+        }
+        const cloudSelected = ['cloud', 'cloud-reason', 'ultra'].includes(requestedModel);
+        const agentTaskType = inferAgentTaskType(prompt);
+        const routedHints = buildExecutionHints(agentTaskType, prompt);
         const spinner = createSpinner('Starting background agent job...').start();
         try {
             const job = await this.api.startV3BackgroundJob(prompt, {
@@ -27,6 +37,19 @@ export class BackgroundCommand {
                 executionSurface: 'cli',
                 clientSurface: 'cli',
                 clientToolExecution: false,
+                model: requestedModel,
+                requestedModel,
+                agentTaskType,
+                workflowType: routedHints.workflow_type,
+                executionHints: {
+                    ...routedHints,
+                    cloud_selected: cloudSelected,
+                    // Detached jobs must preserve the selected transport.  This stops a
+                    // paid cloud request from being silently reinterpreted as a local
+                    // router alias during recovery.
+                    enforce_cloud_only: cloudSelected,
+                    background_model: requestedModel,
+                },
             });
             spinner.stop();
             if (options.json) {
@@ -37,6 +60,7 @@ export class BackgroundCommand {
             console.log(chalk.gray(`  Job:       ${job.job_id}`));
             console.log(chalk.gray(`  Status:    ${job.status}`));
             console.log(chalk.gray(`  Workspace: ${workspacePath}`));
+            console.log(chalk.gray(`  Model:      ${requestedModel}`));
             console.log();
             console.log(chalk.gray(`Use ${chalk.cyan(`vigthoria background status ${job.job_id}`)} to check progress.`));
             console.log(chalk.gray(`Use ${chalk.cyan(`vigthoria background apply ${job.job_id}`)} when it is completed.`));
@@ -100,6 +124,14 @@ export class BackgroundCommand {
             }
             if (job.error)
                 console.log(chalk.red(`Error:     ${job.error}`));
+            const approvals = Array.isArray(job.pending_approvals) ? job.pending_approvals : [];
+            if (approvals.length > 0) {
+                console.log(chalk.yellow(`Gate:      ${approvals.length} command approval(s) required`));
+                for (const approval of approvals) {
+                    console.log(chalk.gray(`  ${approval.approval_id}: ${approval.command || '(empty command)'}`));
+                    console.log(chalk.gray(`  Resolve: vigthoria background approve ${job.job_id} ${approval.approval_id}`));
+                }
+            }
             console.log(chalk.gray(`\n${String(job.request || '').slice(0, 500)}`));
             if (job.status === 'completed' && (job.file_count || 0) > 0) {
                 console.log(chalk.gray(`\nUse ${chalk.cyan(`vigthoria background apply ${job.job_id}`)} to apply files locally.`));
@@ -170,6 +202,8 @@ export class BackgroundCommand {
         let tasksCompleted = Number(result.tasks_completed ?? result.tasksCompleted ?? 0);
         let tasksTotal = Number(result.tasks_total ?? result.tasksTotal ?? 0);
         let success = typeof result.success === 'boolean' ? result.success : null;
+        if (result.type === 'error')
+            success = false;
         for (const event of events) {
             if (!event || typeof event !== 'object')
                 continue;
@@ -192,7 +226,7 @@ export class BackgroundCommand {
         if (success == null && tasksTotal > 0) {
             success = tasksCompleted >= tasksTotal;
         }
-        if (success == null && job?.status === 'completed') {
+        if (success == null && job?.status === 'completed' && result.type !== 'error') {
             success = true;
         }
         if (success == null && job?.status === 'failed') {
@@ -211,4 +245,27 @@ export class BackgroundCommand {
         }
         return { tasksCompleted, tasksTotal, success, headline };
     }
+    async approve(jobId, approvalId, options = {}) {
+        if (!jobId || !approvalId) {
+            this.logger.error('Usage: vigthoria background approve <job-id> <approval-id>');
+            return;
+        }
+        const approved = !options.deny;
+        const spinner = createSpinner(`${approved ? 'Approving' : 'Denying'} background command...`).start();
+        try {
+            const result = await this.api.resolveV3BackgroundApproval(jobId, approvalId, approved, 'once');
+            spinner.stop();
+            if (options.json) {
+                console.log(JSON.stringify({ ...result, job_id: jobId, approval_id: approvalId, approved }, null, 2));
+                return;
+            }
+            console.log(approved
+                ? chalk.green(`${CH.success} Approved ${approvalId} once for ${jobId}`)
+                : chalk.yellow(`${CH.warn} Denied ${approvalId} for ${jobId}`));
+        }
+        catch (error) {
+            spinner.stop();
+            this.logger.error(error?.message || String(error));
+        }
+    }
 }

package/dist/commands/chat.js

@@ -1179,6 +1179,32 @@ export class ChatCommand {
             spinner.text = this.sanitizeServerPath(String(event.content || 'Routing to V3 Agent...'));
             return;
         }
+        if (event.type === 'pipeline_stage') {
+            if (spinner.isSpinning)
+                spinner.stop();
+            const stageIndex = Number.isFinite(Number(event.stage_index)) ? Number(event.stage_index) : 0;
+            const stageTotal = Number.isFinite(Number(event.stage_total)) ? Number(event.stage_total) : 3;
+            const stage = String(event.stage || '').trim().toLowerCase();
+            const label = stage === 'dispatcher'
+                ? 'Dispatcher'
+                : stage === 'architect'
+                    ? 'Architect'
+                    : stage === 'executor'
+                        ? 'Executor'
+                        : 'Pipeline';
+            const model = this.sanitizeServerPath(String(event.model || event.executor_model || ''));
+            const route = this.sanitizeServerPath(String(event.route || ''));
+            const details = [model, route ? `route=${route}` : ''].filter(Boolean).join(' · ');
+            process.stderr.write(chalk.cyan(`  [${stageIndex || '?'}\/${stageTotal} ${label}] `)
+                + `${details || 'ready'}\n`);
+            spinner.start();
+            spinner.text = stage === 'dispatcher'
+                ? 'Olivia routed the request. Starting Architect...'
+                : stage === 'architect'
+                    ? 'Architect is producing the execution plan...'
+                    : '35B Executor is executing the approved plan...';
+            return;
+        }
         if (event.type === 'thinking') {
             this.v3IterationCount += 1;
             const iterText = this.sanitizeServerPath(event.content || '');
@@ -1481,7 +1507,8 @@ export class ChatCommand {
         this.sessionManager = new SessionManager();
     }
     async run(options) {
-        if (!this.config.isAuthenticated()) {
+        const hasRuntimeToken = Boolean(process.env.VIGTHORIA_TOKEN || process.env.VIGTHORIA_AUTH_TOKEN);
+        if (!this.config.isAuthenticated() && !hasRuntimeToken) {
             if (options.json) {
                 process.exitCode = 1;
                 emitAgentJsonOutput({ success: false, error: 'Not authenticated. Run: vigthoria login' });
@@ -2337,6 +2364,12 @@ export class ChatCommand {
                 : '';
             this.logger.debug(`Agent route: ${r.path} / ${r.taskKind} [${r.source}]${routerNote} — ${r.reason}`);
         }
+        // V3 owns high-fidelity HTML and other complex single-file rewrites, but
+        // the CLI still has the authoritative local workspace. Prime the target
+        // through the client-tool bridge before handing the task to V3 so the
+        // model receives the real current file and the terminal records a
+        // verifiable read-before-write operation.
+        await this.primeBypassedTargetFileContext(resolvedPrompt);
         const handledByV3Workflow = await this.tryV3AgentWorkflow(resolvedPrompt);
         if (handledByV3Workflow) {
             this.saveSession();
@@ -3209,6 +3242,7 @@ export class ChatCommand {
                 requestedModel: this.currentModel,
                 agentExecutionPolicy: routingPolicy,
                 legacyFallbackAllowed: this.isLegacyAgentFallbackAllowed(),
+                approvalLevel: this.autoApprove ? 'auto' : 'confirm',
                 rawPrompt: prompt,
                 contextualPrompt,
                 history: this.getMessagesForModel(),
@@ -3688,6 +3722,7 @@ export class ChatCommand {
                 requestedModel: this.currentModel,
                 agentExecutionPolicy: routingPolicy,
                 legacyFallbackAllowed: this.isLegacyAgentFallbackAllowed(),
+                approvalLevel: this.autoApprove ? 'auto' : 'confirm',
                 rawPrompt,
                 history: this.getMessagesForModel(),
                 onStreamEvent: spinner ? (event) => this.updateV3AgentSpinner(spinner, event) : undefined,

package/dist/commands/legion.js

@@ -48,19 +48,31 @@ export class LegionCommand {
     }
     getHyperloopUrls() {
         const urls = new Set();
-        const configuredApiUrl = String(this.config.get('apiUrl') || '').trim().replace(/\/$/, '');
-        if (configuredApiUrl) {
-            urls.add(`${configuredApiUrl}/api/hyperloop`);
-        }
-        const envUrl = String(process.env.VIGTHORIA_HYPERLOOP_URL || '').trim().replace(/\/$/, '');
-        if (envUrl) {
-            urls.add(envUrl);
-        }
+        const normalizeBase = (raw) => {
+            let base = String(raw || '').trim().replace(/\/$/, '');
+            base = base.replace(/\/api\/hyperloop\/(?:health|modules|execute)$/i, '/api/hyperloop');
+            if (base && !/\/api\/hyperloop$/i.test(base))
+                base += '/api/hyperloop';
+            return base;
+        };
+        // On-server checks must try loopback first. The former configured 10.0.0.2
+        // route could consume the entire timeout while the same node was healthy.
         if (isServerRuntime()) {
             for (const internal of buildServerHyperloopUrls()) {
-                urls.add(internal.replace(/\/$/, ''));
+                const normalized = normalizeBase(internal);
+                if (normalized)
+                    urls.add(normalized);
             }
         }
+        const envUrl = normalizeBase(process.env.VIGTHORIA_HYPERLOOP_URL || '');
+        if (envUrl)
+            urls.add(envUrl);
+        const configuredApiUrl = String(this.config.get('apiUrl') || '').trim().replace(/\/$/, '');
+        if (configuredApiUrl) {
+            const normalized = normalizeBase(configuredApiUrl);
+            if (normalized)
+                urls.add(normalized);
+        }
         return Array.from(urls);
     }
     getHeaders() {
@@ -1495,19 +1507,42 @@ export class LegionCommand {
         for (const baseUrl of this.getHyperloopUrls()) {
             try {
                 const response = await fetch(`${baseUrl}/status`, {
-                    signal: AbortSignal.timeout(10000),
+                    signal: AbortSignal.timeout(8000),
                     headers: this.getHeaders(),
                 });
+                let data;
+                let healthOnly = false;
                 if (!response.ok) {
-                    lastError = `Legion status check at ${baseUrl} failed: ${response.status} ${describeUpstreamStatus(response.status)}`;
-                    continue;
+                    // /status is authenticated, while the root /health endpoint is the
+                    // authoritative liveness probe. A CLI without the internal service
+                    // credential must still report a live node as online rather than
+                    // falling through to a stale private-network address.
+                    const parsed = new URL(baseUrl);
+                    const healthUrl = /^(?:127\.0\.0\.1|localhost|::1)$/i.test(parsed.hostname)
+                        ? `${parsed.origin}/health`
+                        : `${baseUrl}/health`;
+                    const healthResponse = await fetch(healthUrl, {
+                        signal: AbortSignal.timeout(3000),
+                        headers: this.getHeaders(),
+                    });
+                    if (!healthResponse.ok) {
+                        lastError = `Legion status check at ${baseUrl} failed: ${response.status} ${describeUpstreamStatus(response.status)}`;
+                        continue;
+                    }
+                    data = await this.readJsonResponse(healthResponse, `health check at ${healthUrl}`);
+                    healthOnly = true;
+                }
+                else {
+                    data = await this.readJsonResponse(response, `status check at ${baseUrl}`);
                 }
-                const data = await this.readJsonResponse(response, `status check at ${baseUrl}`);
                 spinner.stop();
                 console.log();
                 console.log(chalk.bold.white(`  ${CH.hLine.repeat(3)} Legion Infrastructure ${CH.hLine.repeat(37)}`));
                 console.log();
                 console.log(chalk.gray(`  Hyper Loop: `) + chalk.green('online'));
+                if (healthOnly) {
+                    console.log(chalk.gray('  Control plane: liveness verified; authenticated worker details not exposed'));
+                }
                 if (data.workers || data.active_workers) {
                     const count = data.workers || data.active_workers;
                     console.log(chalk.gray(`  Active workers: `) + chalk.white(String(typeof count === 'number' ? count : Object.keys(count).length)));

package/dist/index.js

@@ -472,10 +472,10 @@ async function enforceGatewayAuthSession(config, logger, jsonOutputRequested) {
     if (isLocalTestfarmMode()) {
         return true;
     }
-    if (!config.isAuthenticated()) {
+    const explicitEnvToken = Boolean(process.env.VIGTHORIA_TOKEN || process.env.VIGTHORIA_AUTH_TOKEN);
+    if (!config.isAuthenticated() && !explicitEnvToken) {
         return true;
     }
-    const explicitEnvToken = Boolean(process.env.VIGTHORIA_TOKEN || process.env.VIGTHORIA_AUTH_TOKEN);
     // Offline mode disables every outbound preflight call.
     if (isOfflineMode()) {
         return true;
@@ -1317,6 +1317,7 @@ Examples:
         .command('start <prompt...>')
         .description('Start an Agent job in the background and return immediately')
         .option('--workspace <path>', 'Local workspace path', process.cwd())
+        .option('--model <model>', 'Execution lane: agent, cloud, cloud-reason, or ultra', 'agent')
         .option('--json', 'Emit JSON output', false)
         .action(async (prompt, options) => {
         const bg = new BackgroundCommand(config, logger);
@@ -1357,6 +1358,15 @@ Examples:
         const bg = new BackgroundCommand(config, logger);
         await bg.cancel(jobId, options);
     });
+    backgroundCommand
+        .command('approve <jobId> <approvalId>')
+        .description('Resolve a pending two-stage command gate for a background job')
+        .option('--deny', 'Deny the command instead of approving it', false)
+        .option('--json', 'Emit JSON output', false)
+        .action(async (jobId, approvalId, options) => {
+        const bg = new BackgroundCommand(config, logger);
+        await bg.approve(jobId, approvalId, options);
+    });
     backgroundCommand.action(() => {
         backgroundCommand.outputHelp();
     });

package/dist/utils/api.d.ts

@@ -261,6 +261,7 @@ export declare class APIClient {
     getV3AgentRunUrl(baseUrl: string): string;
     getV3AgentContinueUrl(baseUrl: string): string;
     getV3AgentBackgroundUrl(baseUrl: string, suffix?: string): string;
+    getV3AgentApprovalUrl(baseUrl: string): string;
     getOperatorBaseUrls(): string[];
     getOperatorStreamUrl(baseUrl: string): string;
     getMcpBaseUrls(): string[];
@@ -359,6 +360,12 @@ export declare class APIClient {
     private buildPublicWorkspaceDescriptor;
     private buildPublicRuntimeEnvironment;
     private buildLocalWorkspaceSummary;
+    /**
+     * Build complete workspace hydration separately from model context.
+     * Remote audits must inspect the same byte-complete assets the user has
+     * locally; context compaction must never become filesystem compaction.
+     */
+    private buildOutOfBandWorkspaceFiles;
     /**
      * Collect text file contents from the workspace for V3 agent hydration.
      * Budget: up to ~2 MB total, per-file cap 200 KB, skip binary extensions.
@@ -405,10 +412,12 @@ export declare class APIClient {
     listV3BackgroundJobs(limit?: number): Promise<any[]>;
     getV3BackgroundJob(jobId: string): Promise<any>;
     cancelV3BackgroundJob(jobId: string): Promise<any>;
+    resolveV3BackgroundApproval(jobId: string, approvalId: string, approved: boolean, allowMode?: string): Promise<any>;
     getV3BackgroundJobFiles(jobId: string): Promise<{
         status: string;
         files: Record<string, string>;
         file_count: number;
+        confirmed_mutations?: string[];
         local_workspace_path?: string;
     }>;
     applyV3BackgroundJobFiles(jobId: string, context?: Record<string, any>): Promise<{

package/dist/utils/api.js

@@ -659,6 +659,7 @@ export class APIClient {
     getV3AgentBaseUrls(preferLocal = false) {
         const configuredApiUrl = String(this.config.get('apiUrl') || 'https://coder.vigthoria.io').replace(/\/$/, '');
         const localTestMode = isLocalTestfarmMode();
+        const explicitV3EndpointConfigured = Boolean(process.env.VIGTHORIA_V3_AGENT_URL || process.env.V3_AGENT_URL);
         const includeLoopbackV3Agent = process.env.VIGTHORIA_ALLOW_LOCAL_V3_AGENT === '1'
             || (preferLocal && isServerRuntime());
         const localCandidates = [
@@ -672,7 +673,10 @@ export class APIClient {
         const normalizedRemote = remoteCandidates
             .filter(Boolean)
             .map((url) => String(url).replace(/\/$/, ''));
-        const urls = preferLocal && localCandidates.length > 0
+        // An explicit V3 endpoint is an operator routing decision, not a fallback.
+        // Keep it ahead of the public Coder relay so stale remote user credentials
+        // cannot abort a healthy service-key-authenticated internal CLI run.
+        const urls = (preferLocal || localTestMode || explicitV3EndpointConfigured) && localCandidates.length > 0
             ? [...localCandidates, ...normalizedRemote]
             : [...normalizedRemote, ...localCandidates];
         return [...new Set(urls)];
@@ -696,6 +700,12 @@ export class APIClient {
         }
         return `${baseUrl}/api/v3-agent/background${cleanSuffix}`;
     }
+    getV3AgentApprovalUrl(baseUrl) {
+        if (this.isDirectV3AgentBaseUrl(baseUrl)) {
+            return `${baseUrl}/api/agent/approval`;
+        }
+        return `${baseUrl}/api/v3-agent/approval`;
+    }
     getOperatorBaseUrls() {
         const configuredModelsApiUrl = String(this.config.get('modelsApiUrl') || 'https://api.vigthoria.io').replace(/\/$/, '');
         const urls = [
@@ -876,6 +886,7 @@ export class APIClient {
     extractLinkedFrontendAssets(html, entryPath) {
         const css = new Set();
         const js = new Set();
+        const assets = new Set();
         const entryDir = path.posix.dirname(this.normalizeWorkspaceRelativePath(entryPath) || '.');
         const normalizeAsset = (assetPath) => {
             const clean = String(assetPath || '').trim();
@@ -887,7 +898,10 @@ export class APIClient {
                 return null;
             }
             if (withoutQuery.startsWith('/')) {
-                return this.normalizeWorkspaceRelativePath(withoutQuery.slice(1));
+                // Preview/runtime serve a nested HTML entry from its containing
+                // directory, so `/styles.css` beside `showcase/index.html` resolves to
+                // `showcase/styles.css` in the hydrated workspace.
+                return this.normalizeWorkspaceRelativePath(path.posix.normalize(path.posix.join(entryDir, withoutQuery.slice(1))));
             }
             return this.normalizeWorkspaceRelativePath(path.posix.normalize(path.posix.join(entryDir, withoutQuery)));
         };
@@ -906,9 +920,17 @@ export class APIClient {
                 js.add(resolved);
             }
         }
+        const assetPattern = /<(?:link|img|source|video|audio)\b[^>]+(?:href|src)=["']([^"']+)["'][^>]*>/gi;
+        while ((match = assetPattern.exec(String(html || ''))) !== null) {
+            const resolved = normalizeAsset(match[1]);
+            if (resolved) {
+                assets.add(resolved);
+            }
+        }
         return {
             css: Array.from(css),
             js: Array.from(js),
+            assets: Array.from(assets),
         };
     }
     async buildFrontendForPreview(rootPath) {
@@ -1568,10 +1590,15 @@ export class APIClient {
         'styles.css', 'style.css', 'README.md', 'manifest.json',
     ]);
     /** Keep critical workspace files for server hydration when context must shrink. */
-    compactWorkspaceFilesToBudget(files, budgetChars) {
+    compactWorkspaceFilesToBudget(files, budgetChars, priorityPaths = [], mandatoryPaths = priorityPaths) {
         const entries = Object.entries(files);
+        const explicitPriority = new Map(priorityPaths.map((filePath, index) => [this.normalizeWorkspaceRelativePath(filePath), index]));
+        const mandatory = new Set(mandatoryPaths.map((filePath) => this.normalizeWorkspaceRelativePath(filePath)));
         const rank = (filePath) => {
             const normalized = filePath.replace(/\\/g, '/');
+            const explicitIndex = explicitPriority.get(normalized);
+            if (explicitIndex !== undefined)
+                return -100 + Math.min(explicitIndex, 50);
             const base = normalized.split('/').pop() || '';
             if (APIClient.HYDRATION_PRIORITY_BASENAMES.has(base))
                 return 0;
@@ -1589,6 +1616,28 @@ export class APIClient {
             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) {
+                const normalizedPath = this.normalizeWorkspaceRelativePath(filePath);
+                if (mandatory.has(normalizedPath)) {
+                    // Explicit prompt targets are hydration requirements, not ranking
+                    // hints.  Skipping an HTML entry merely because a larger targeted
+                    // stylesheet consumed the provisional budget creates false preview
+                    // failures in the remote V3 workspace.  Keep the complete explicit
+                    // file and let later context-compaction phases shed history/metadata.
+                    trimmed[filePath] = clipped;
+                    used += entryLen;
+                }
+                else if (explicitPriority.has(normalizedPath)) {
+                    // Linked preview assets are important enough to hydrate, but unlike
+                    // edit targets they may be compacted. Keep a bounded prefix so the
+                    // remote static server resolves the asset instead of returning 404.
+                    const envelope = JSON.stringify(filePath).length + 128;
+                    const available = Math.max(256, budgetChars - used - envelope);
+                    const dependencyClip = content.length > available
+                        ? `${content.slice(0, available)}\n/* … compacted linked preview dependency … */`
+                        : content;
+                    trimmed[filePath] = dependencyClip;
+                    used += JSON.stringify(filePath).length + 1 + JSON.stringify(dependencyClip).length + 1;
+                }
                 continue;
             }
             trimmed[filePath] = clipped;
@@ -1603,16 +1652,30 @@ export class APIClient {
         const serverWorkspacePath = this.resolveServerBindableWorkspacePath(resolvedContext);
         const promptFocus = String(resolvedContext.rawPrompt || resolvedContext.contextualPrompt || resolvedContext.prompt || '');
         const localWorkspaceSummary = this.buildLocalWorkspaceSummary(localWorkspacePath, promptFocus);
+        if (resolvedContext.workspaceFilesOutOfBand === true && localWorkspaceSummary?.workspaceFiles) {
+            localWorkspaceSummary.workspaceHydration = {
+                delivery: 'out-of-band',
+                fileCount: Object.keys(localWorkspaceSummary.workspaceFiles).length,
+                complete: true,
+            };
+            delete localWorkspaceSummary.workspaceFiles;
+        }
         const requestedModel = String(resolvedContext.model || resolvedContext.requestedModel || 'agent');
         const resolvedModel = this.resolvePermittedModelId(requestedModel);
         const localWorkspaceName = this.getDisplayWorkspaceName(localWorkspacePath);
         const localWorkspaceRef = localWorkspaceName ? `vigthoria://local-workspace/${localWorkspaceName}` : null;
         const executionSurface = String(resolvedContext.executionSurface || resolvedContext.clientSurface || 'cli');
         const localMachineCapable = resolvedContext.localMachineCapable !== false;
+        // A workspace under a configured server root is already available to the
+        // V3 service. Keep tool execution on the server in that case; delegating
+        // tools back to the CLI can turn server paths into invalid client paths.
+        // An explicit caller override remains authoritative for specialist flows.
         const clientToolExecution = resolvedContext.clientToolExecution === false
             ? false
             : (resolvedContext.clientToolExecution === true
-                || (localMachineCapable && ['cli', 'fork', 'local-ide', 'desktop', 'local'].includes(executionSurface)));
+                || (!serverWorkspacePath
+                    && localMachineCapable
+                    && ['cli', 'fork', 'local-ide', 'desktop', 'local'].includes(executionSurface)));
         const publicRuntimeEnvironment = this.buildPublicRuntimeEnvironment(resolvedContext.agentRuntime, {
             localWorkspacePath,
             serverWorkspacePath,
@@ -1658,6 +1721,8 @@ export class APIClient {
             requestedModelResolved: resolvedModel,
             agentExecutionPolicy: resolvedContext.agentExecutionPolicy || null,
             legacyFallbackAllowed: resolvedContext.legacyFallbackAllowed === true,
+            approvalLevel: resolvedContext.approvalLevel === 'auto' ? 'auto' : 'confirm',
+            approval_level: resolvedContext.approvalLevel === 'auto' ? 'auto' : 'confirm',
             executionSurface: resolvedContext.executionSurface || 'cli',
             clientSurface: resolvedContext.clientSurface || 'cli',
             localMachineCapable,
@@ -1752,11 +1817,11 @@ export class APIClient {
             const overhead = json.length - JSON.stringify(summary.workspaceFiles).length;
             const budget = LIMIT - overhead - 1024;
             if (budget > 0) {
-                summary.workspaceFiles = this.compactWorkspaceFilesToBudget(summary.workspaceFiles, budget);
+                summary.workspaceFiles = this.compactWorkspaceFilesToBudget(summary.workspaceFiles, budget, summary.focusFiles || [], summary.explicitFocusFiles || summary.focusFiles || []);
                 summary.workspaceFilesCompaction = Object.keys(summary.workspaceFiles).length > 0 ? 'priority-trimmed' : 'empty';
             }
             else if (hydrationRequired) {
-                summary.workspaceFiles = this.compactWorkspaceFilesToBudget(summary.workspaceFiles, 8_000);
+                summary.workspaceFiles = this.compactWorkspaceFilesToBudget(summary.workspaceFiles, 8_000, summary.focusFiles || [], summary.explicitFocusFiles || summary.focusFiles || []);
                 summary.workspaceFilesCompaction = 'priority-minimal';
             }
             else {
@@ -1781,7 +1846,7 @@ export class APIClient {
                 return finish();
         }
         if (hydrationRequired && summary?.workspaceFiles && typeof summary.workspaceFiles === 'object') {
-            summary.workspaceFiles = this.compactWorkspaceFilesToBudget(summary.workspaceFiles, 4_000);
+            summary.workspaceFiles = this.compactWorkspaceFilesToBudget(summary.workspaceFiles, 4_000, summary.focusFiles || [], summary.explicitFocusFiles || summary.focusFiles || []);
             summary.workspaceFilesCompaction = 'priority-minimal';
             json = JSON.stringify(payload);
             if (json.length <= LIMIT)
@@ -2657,8 +2722,30 @@ menu {
             };
             const snapshot = this.getAgentWorkspaceSnapshot(rootPath);
             const candidatePaths = snapshot.paths.filter((entry) => !/(^|[\/\\])\.vigthoria([\/\\]|$)/.test(entry));
+            const focusFiles = this.extractExpectedWorkspaceFiles(requestFocus)
+                .map((entry) => this.normalizeWorkspaceRelativePath(entry))
+                .filter((entry) => candidatePaths.includes(entry));
+            const linkedFocusAssets = [];
+            for (const focusPath of focusFiles) {
+                if (!/\.html?$/i.test(focusPath))
+                    continue;
+                try {
+                    const html = fs.readFileSync(path.join(rootPath, focusPath), 'utf8');
+                    const linkedAssets = this.extractLinkedFrontendAssets(html, focusPath);
+                    for (const assetPath of [...linkedAssets.assets, ...linkedAssets.css, ...linkedAssets.js]) {
+                        if (candidatePaths.includes(assetPath) && !linkedFocusAssets.includes(assetPath)) {
+                            linkedFocusAssets.push(assetPath);
+                        }
+                    }
+                }
+                catch {
+                    // Missing/unreadable focused HTML remains visible to the server via
+                    // the original focus list; dependency expansion is best effort.
+                }
+            }
+            const hydrationFocusFiles = [...focusFiles, ...linkedFocusAssets];
             const agentStatePaths = this.collectAgentStateSyncPaths(rootPath);
-            let orderedPaths = [...agentStatePaths, ...candidatePaths];
+            let orderedPaths = [...agentStatePaths, ...hydrationFocusFiles, ...candidatePaths];
             try {
                 const ranked = buildSemanticContext(rootPath, requestFocus, 60).topFiles.map((file) => file.path);
                 const changes = getChangedFiles(rootPath, candidatePaths);
@@ -2670,6 +2757,8 @@ menu {
                 // silently dropped progress.json and forced /continue to re-plan.
                 for (const filePath of agentStatePaths)
                     ordered.add(filePath);
+                for (const filePath of hydrationFocusFiles)
+                    ordered.add(filePath);
                 for (const filePath of changes.changed)
                     ordered.add(filePath);
                 for (const filePath of ranked)
@@ -2685,9 +2774,11 @@ menu {
                 };
             }
             catch {
-                orderedPaths = [...agentStatePaths, ...candidatePaths];
+                orderedPaths = [...agentStatePaths, ...hydrationFocusFiles, ...candidatePaths];
             }
             summary.fileCount = snapshot.fileCount;
+            summary.focusFiles = hydrationFocusFiles;
+            summary.explicitFocusFiles = focusFiles;
             summary.files = orderedPaths.slice(0, 40);
             const packageJsonPath = path.join(rootPath, 'package.json');
             if (fs.existsSync(packageJsonPath)) {
@@ -2714,6 +2805,22 @@ menu {
             return null;
         }
     }
+    /**
+     * Build complete workspace hydration separately from model context.
+     * Remote audits must inspect the same byte-complete assets the user has
+     * locally; context compaction must never become filesystem compaction.
+     */
+    buildOutOfBandWorkspaceFiles(context) {
+        const resolvedContext = this.ensureExecutionContext(context);
+        const localWorkspacePath = this.resolveAgentTargetPath(resolvedContext);
+        const serverWorkspacePath = this.resolveServerBindableWorkspacePath(resolvedContext);
+        if (serverWorkspacePath || !localWorkspacePath)
+            return undefined;
+        const promptFocus = String(resolvedContext.rawPrompt || resolvedContext.contextualPrompt || resolvedContext.prompt || '');
+        const summary = this.buildLocalWorkspaceSummary(localWorkspacePath, promptFocus);
+        const files = summary?.workspaceFiles;
+        return files && typeof files === 'object' ? files : undefined;
+    }
     /**
      * Collect text file contents from the workspace for V3 agent hydration.
      * Budget: up to ~2 MB total, per-file cap 200 KB, skip binary extensions.
@@ -2722,7 +2829,7 @@ menu {
         const MAX_TOTAL_BYTES = 2 * 1024 * 1024;
         const MAX_FILE_BYTES = 200 * 1024;
         const BINARY_EXTENSIONS = new Set([
-            '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.svg', '.webp', '.avif',
+            '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.avif',
             '.mp3', '.mp4', '.wav', '.ogg', '.webm', '.flac', '.aac',
             '.zip', '.gz', '.tar', '.rar', '.7z', '.bz2',
             '.exe', '.dll', '.so', '.dylib', '.bin', '.dat',
@@ -3028,7 +3135,9 @@ menu {
         const args = event.arguments || {};
         const serverRoot = String(context.__v3ServerWorkspaceRoot || '').trim();
         const isRunCommand = name === 'run_command';
-        const pathArg = isRunCommand ? (args.cwd ?? args.path ?? '.') : (args.path || args.cwd || '.');
+        const pathArg = isRunCommand
+            ? (args.cwd ?? args.path ?? args.directory ?? '.')
+            : (args.path || args.directory || args.cwd || '.');
         let target = this.resolveV3ClientToolPath(rootPath, pathArg, serverRoot ? [serverRoot] : []);
         if (!target && isRunCommand) {
             target = this.resolveV3ClientToolPath(rootPath, '.', serverRoot ? [serverRoot] : []);
@@ -4120,6 +4229,7 @@ document.addEventListener('DOMContentLoaded', () => {
         const expectedFiles = this.extractExpectedWorkspaceFiles(message, executionContext);
         const requestedModel = String(executionContext.model || executionContext.requestedModel || 'agent');
         const resolvedModel = this.resolvePermittedModelId(requestedModel);
+        const workspaceFiles = this.buildOutOfBandWorkspaceFiles(executionContext);
         const preferLocalV3 = /(premium|polished|landing|site|page|dashboard|saas|frontend|ui|responsive|animated|create the required project files and write them to the workspace)/i.test(message)
             && context.localMachineCapable !== false;
         const timeoutMs = resolvePlannerAgentTimeoutMs(baseTimeoutMs, String(executionContext.agentTaskType || ''), String(executionContext.rawPrompt || message || ''));
@@ -4149,7 +4259,8 @@ document.addEventListener('DOMContentLoaded', () => {
                 strict_mode: useRelaxedAttempt ? false : requestExecutionContext.legacyFallbackAllowed !== true,
                 context: useRelaxedAttempt
                     ? this.buildMinimalV3AgentContext(requestExecutionContext)
-                    : this.buildV3AgentContext(requestExecutionContext),
+                    : this.buildV3AgentContext({ ...requestExecutionContext, workspaceFilesOutOfBand: !!workspaceFiles }),
+                workspace_files: useRelaxedAttempt ? undefined : workspaceFiles,
                 context_id: contextIdOverride ?? requestExecutionContext.contextId,
                 mcp_context_id: useRelaxedAttempt ? null : requestExecutionContext.mcpContextId || null,
                 stream: true,
@@ -4364,18 +4475,29 @@ document.addEventListener('DOMContentLoaded', () => {
         await this.ensureV3ServiceKey();
         const executionContext = await this.bindExecutionContext({
             ...context,
+            // Background callers historically supplied only workspace metadata.
+            // Without the request in the execution context, buildV3AgentContext()
+            // classified every detached job from an empty prompt and emitted an
+            // `analysis_only` workflow.  V3 would then inspect the workspace but was
+            // correctly forbidden from writing.  Preserve an explicit caller value,
+            // otherwise make the submitted job request authoritative for routing.
+            rawPrompt: context.rawPrompt || context.prompt || message,
+            prompt: context.prompt || context.rawPrompt || message,
             backgroundJob: true,
             clientToolExecution: false,
         });
         const requestedModel = String(executionContext.model || executionContext.requestedModel || 'agent');
         const resolvedModel = this.resolvePermittedModelId(requestedModel);
+        const workspaceFiles = this.buildOutOfBandWorkspaceFiles(executionContext);
         const body = {
             request: message,
             context: this.buildV3AgentContext({
                 ...executionContext,
                 backgroundJob: true,
                 clientToolExecution: false,
+                workspaceFilesOutOfBand: !!workspaceFiles,
             }),
+            workspace_files: workspaceFiles,
             stream: false,
             model: resolvedModel,
             mcp_context_id: executionContext.mcpContextId || undefined,
@@ -4464,6 +4586,33 @@ document.addEventListener('DOMContentLoaded', () => {
         }
         throw new Error(`Unable to cancel background job: ${errors.join('; ')}`);
     }
+    async resolveV3BackgroundApproval(jobId, approvalId, approved, allowMode = 'once') {
+        await this.ensureV3ServiceKey();
+        const errors = [];
+        for (const baseUrl of this.getV3AgentBaseUrls(false)) {
+            try {
+                const response = await fetch(this.getV3AgentApprovalUrl(baseUrl), {
+                    method: 'POST',
+                    headers: await this.getV3AgentHeaders(),
+                    body: JSON.stringify({
+                        context_id: jobId,
+                        approval_id: approvalId,
+                        approved,
+                        allow_mode: allowMode,
+                    }),
+                });
+                if (!response.ok) {
+                    errors.push(`${baseUrl}: ${response.status}`);
+                    continue;
+                }
+                return await response.json();
+            }
+            catch (error) {
+                errors.push(`${baseUrl}: ${error?.message || String(error)}`);
+            }
+        }
+        throw new Error(`Unable to resolve background approval: ${errors.join('; ')}`);
+    }
     async getV3BackgroundJobFiles(jobId) {
         await this.ensureV3ServiceKey();
         const errors = [];
@@ -4486,7 +4635,47 @@ document.addEventListener('DOMContentLoaded', () => {
         throw new Error(`Unable to fetch background job files: ${errors.join('; ')}`);
     }
     async applyV3BackgroundJobFiles(jobId, context = {}) {
-        const data = await this.getV3BackgroundJobFiles(jobId);
+        const [data, job] = await Promise.all([
+            this.getV3BackgroundJobFiles(jobId),
+            this.getV3BackgroundJob(jobId),
+        ]);
+        if (job?.status !== 'completed' || job?.result?.success === false || job?.result?.type === 'error') {
+            throw new Error(`Background job ${jobId} is not a successful completed job and cannot be applied.`);
+        }
+        const mutatedPaths = new Set();
+        const addMutatedPath = (value) => {
+            const normalized = this.normalizeWorkspaceRelativePath(String(value || ''));
+            if (!normalized || path.isAbsolute(normalized) || normalized.split('/').includes('..'))
+                return;
+            mutatedPaths.add(normalized);
+        };
+        for (const filePath of data.confirmed_mutations || []) {
+            addMutatedPath(filePath);
+        }
+        for (const event of Array.isArray(job?.events) ? job.events : []) {
+            if (event?.type === 'file_mutation' && event?.action !== 'delete') {
+                addMutatedPath(event.path);
+            }
+            if (event?.type === 'executor_complete') {
+                let summary = event.summary;
+                if (typeof summary === 'string') {
+                    try {
+                        summary = JSON.parse(summary);
+                    }
+                    catch {
+                        summary = null;
+                    }
+                }
+                if (summary?.status === 'completed') {
+                    for (const filePath of [...(summary.changed_files || []), ...(summary.created_files || [])]) {
+                        addMutatedPath(filePath);
+                    }
+                }
+            }
+        }
+        if (mutatedPaths.size === 0) {
+            throw new Error(`Background job ${jobId} has no confirmed successful file mutations to apply.`);
+        }
         const rootPath = this.resolveAgentTargetPath({
             ...context,
             workspacePath: context.workspacePath || data.local_workspace_path,
@@ -4499,6 +4688,11 @@ document.addEventListener('DOMContentLoaded', () => {
         const applied = [];
         const skipped = [];
         for (const [relativePath, content] of Object.entries(data.files || {})) {
+            const normalizedRelativePath = this.normalizeWorkspaceRelativePath(relativePath);
+            if (!mutatedPaths.has(normalizedRelativePath)) {
+                skipped.push(relativePath);
+                continue;
+            }
             if (typeof content !== 'string') {
                 skipped.push(relativePath);
                 continue;

package/dist/utils/clientManifest.d.ts

@@ -1,5 +1,14 @@
 export type ClientManifestPayload = {
     product_id: string;
+    context_contract_version: string;
+    source_product_id: string;
+    active_application_id: string;
+    active_surface_id: string;
+    target_product_id: string;
+    workspace_kind: string;
+    selected_engine_id: string;
+    capability_catalog_version: string;
+    capability_scope_id: string;
     version: string;
     os: string;
     execution_mode: string;

package/dist/utils/clientManifest.js

@@ -56,8 +56,18 @@ export function resolveClientOsSlug() {
 }
 export function buildClientManifest(overrides = {}) {
     const ios = isIOSEnvironment() && !overrides.os;
+    const productId = overrides.product_id || process.env.VIGTHORIA_SOURCE_PRODUCT_ID || 'vigthoria-cli';
     return {
-        product_id: overrides.product_id || 'vigthoria-cli',
+        product_id: productId,
+        context_contract_version: overrides.context_contract_version || '2.0',
+        source_product_id: overrides.source_product_id || process.env.VIGTHORIA_SOURCE_PRODUCT_ID || productId,
+        active_application_id: overrides.active_application_id || process.env.VIGTHORIA_ACTIVE_APPLICATION_ID || 'cli-agent-chat',
+        active_surface_id: overrides.active_surface_id || process.env.VIGTHORIA_ACTIVE_SURFACE_ID || 'agent-session',
+        target_product_id: overrides.target_product_id || 'none',
+        workspace_kind: overrides.workspace_kind || process.env.VIGTHORIA_WORKSPACE_KIND || 'local-development-workspace',
+        selected_engine_id: overrides.selected_engine_id || 'none',
+        capability_catalog_version: overrides.capability_catalog_version || process.env.VIGTHORIA_CAPABILITY_CATALOG_VERSION || '2026.08.03.1',
+        capability_scope_id: overrides.capability_scope_id || process.env.VIGTHORIA_CAPABILITY_SCOPE_ID || 'cli.ecosystem-user',
         version: overrides.version || readPackageVersion(),
         os: overrides.os || resolveClientOsSlug(),
         execution_mode: overrides.execution_mode || (ios ? 'mobile-terminal-sandbox' : 'local-user-machine'),

package/dist/utils/command-menu.js

@@ -3,6 +3,10 @@ const AGENT_COMMANDS = new Set([
     'agent', 'chat', 'chat-resume', 'operator', 'legion', 'workflow',
     'history', 'replay', 'fork', 'cancel',
 ]);
+// Subprocess protocols are not user-facing commands. Presenting one in the
+// root picker caused `v4-menu` to be launched without its required output
+// file, which is exactly the failure reported from CLI 1.13.13.
+const INTERNAL_COMMANDS = new Set(['v4-menu']);
 function familyFor(commandPath) {
     const root = commandPath.split(' ')[0];
     if (root === 'repo')
@@ -15,6 +19,8 @@ export function buildCommandCatalog(program) {
     const entries = [];
     const visit = (command, parents) => {
         const commandPath = [...parents, command.name()].join(' ');
+        if (parents.length === 0 && INTERNAL_COMMANDS.has(commandPath))
+            return;
         entries.push({
             path: commandPath,
             description: command.description() || '',

package/dist/utils/contextBudget.d.ts

@@ -15,7 +15,11 @@ 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.
+ * The hydration payload is transport-only: the server writes workspaceFiles
+ * to an isolated directory and exposes only a compact filename summary to the
+ * model. It can therefore use the full calculated input envelope without
+ * consuming system/tool framing tokens. Clamp at 180k, far below the gateway
+ * body limit, while preserving compaction for genuinely large workspaces.
  */
 export declare function resolveV3ContextCharLimit(runtimeNctx?: number): number;
 export declare function compactToolListingOutput(name: string, output: string, charCap: number): string;

package/dist/utils/contextBudget.js

@@ -29,13 +29,16 @@ export function resolveInputBudget(runtimeNctx = DEFAULT_CODE_RUNTIME_CTX, maxOu
 }
 /**
  * Char limit for the initial V3 context JSON payload.
- * ~45% of input token budget × 4 chars/token, clamped 32k–100k.
+ * The hydration payload is transport-only: the server writes workspaceFiles
+ * to an isolated directory and exposes only a compact filename summary to the
+ * model. It can therefore use the full calculated input envelope without
+ * consuming system/tool framing tokens. Clamp at 180k, far below the gateway
+ * body limit, while preserving compaction for genuinely large workspaces.
  */
 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));
+    const hydrationChars = inputBudget * CHARS_PER_TOKEN_EST;
+    return Math.min(180_000, Math.max(32_000, hydrationChars));
 }
 export function compactToolListingOutput(name, output, charCap) {
     const text = String(output || '');

package/dist/utils/requestIntent.js

@@ -4,14 +4,15 @@
  */
 const CLI_SHAPING_BLOCK = /(?:^|\n\n)Platform:\s*(?:Windows|macOS|Linux)\.[\s\S]*?(?=\n\n[A-Z][^\n]{0,40}:|\s*$)/i;
 const READONLY_SHAPING_BLOCK = /(?:^|\n\n)(?:Read-only analysis mode is active\.|Diagnostic mode is active\.)[\s\S]*?(?=\n\n[A-Z][^\n]{0,40}:|\s*$)/i;
-const BUILD_VERBS = /\b(build|create|make|implement|complete|fix|repair|edit|modify|write|generate|add|finish|scaffold|develop|update|change|refactor|want|need|require|looking for|let's|let us|we need|we should|erstelle|erstellen|schreib|schreibe|bearbeite)\b/i;
-const ARTIFACT_NOUNS = /\b(file|files|project|game|spiel|app|website|html5|frontend|component|feature|code|workspace|repo|clone|replica|remake|page|site|screen|button|popup|modal|alert|canvas|sprite|level|levels|enemy|enemies|character|npc|world|scene|script|module|api|database|config|landing|dashboard|platformer|arcade|playable|collectible|scoreboard|leaderboard|pitfall|pacman|rogue|html|css|javascript|typescript)\b/i;
+const BUILD_VERBS = /\b(build|create|make|implement|complete|redesign|overhaul|rebuild|transform|polish|art-direct|fix|repair|edit|modify|write|generate|add|finish|scaffold|develop|update|change|refactor|want|need|require|looking for|let's|let us|we need|we should|erstelle|erstellen|schreib|schreibe|bearbeite)\b/i;
+const ARTIFACT_NOUNS = /\b(file|files|project|game|spiel|app|website|html5|frontend|component|feature|code|workspace|repo|clone|replica|remake|page|site|design|showcase|screen|button|popup|modal|alert|canvas|sprite|level|levels|enemy|enemies|character|npc|world|scene|script|module|api|database|config|landing|dashboard|platformer|arcade|playable|collectible|scoreboard|leaderboard|pitfall|pacman|rogue|html|css|javascript|typescript)\b/i;
 /** Canvas/playable games only — bare "html5" or "website" must NOT match. */
 const GAME_INTENT = /\b(game|spiel|playable|babylon(?:\.js|js)?|vge|webgl|3d\s+(?:game|runner|prototype|world|experience)|html5\s+(?:game|canvas)|html5\s+game|canvas\s+game|game\s+canvas|arcade|platformer|side[- ]?scroller|pitfall|pac[- ]?man|tetris|snake|breakout|pong|roguelike|metroidvania|tower\s+defense|clone\s+of\s+(?:a\s+)?(?:game|pitfall|pac|mario|zelda|arcade)|gameplay|collectible|boss\s+fight|level\s+design|sprite\s+sheet|wild\s+(?:boar|pig|forest)|forest\s+pig)\b/i;
 const WEB_PAGE_INTENT = /\b(website|web\s*site|webpage|web\s*page|landing\s+page|home\s*page|index\.html|html\s+page|static\s+page|single\s+page|popup|alert|modal|hello\s+world)\b/i;
+const WEB_SHOWCASE_INTENT = /\b(web[- ]?design\s+showcase|frontend|marketing\s+site|dashboard|saas)\b/i;
 const CLONE_BUILD = /\bclone\s+of\b|\b(build|create|make)\s+(?:a|an|the|us|me)?\s*(?:clone|replica|remake|port)\b/i;
 const READ_ONLY_INTENT = /\b(analy[sz]e|analyse|analysis|audit|review|inspect|proof|understand|summari[sz]e|scan|read[\s-]?only|where we left|what is|how does|show me|tell me|identify\s+gaps?|gap\s+analysis|production\s+blockers?)\b/i;
-const EXPLICIT_WRITE_VERBS = /\b(implement|write|edit|modify|update|fix|repair|create|build|generate|scaffold|deploy|refactor|develop|integrate|correct|apply|patch)\b/i;
+const EXPLICIT_WRITE_VERBS = /\b(implement|write|edit|modify|update|redesign|overhaul|rebuild|transform|polish|art-direct|fix|repair|create|build|generate|scaffold|deploy|refactor|develop|integrate|correct|apply|patch)\b/i;
 const TRIVIAL_HTML_PAGE = /\b(hello\s*world|simple\s+(?:html|web|page|site)|html5\s+website|html\s+5\s+website|popup|alert\s*\(|show\s+a\s+popup|one\s+page|single\s+html)\b/i;
 /** User explicitly grants write permission after an analysis or confirmation gate. */
 const WRITE_PERMISSION_GRANT = /\b(?:hereby\s+confirm|i\s+confirm|confirm(?:ed)?\s+that|give\s+(?:you|permission)|granting\s+permission|allow\s+(?:you|me\s+to)|you\s+(?:may|can|have\s+permission\s+to)|permission\s+to|authorized?\s+to|approve(?:d)?\s+(?:the\s+)?(?:changes?|writes?|edits?)|go\s+ahead\s+and(?:\s+write|\s+apply|\s+make|\s+do)?|do\s+all\s+the\s+changes|apply\s+(?:the\s+)?(?:changes?|fixes?|fix)|proceed\s+with\s+(?:the\s+)?(?:changes?|fixes?|implementation|writes?)|make\s+(?:the\s+)?changes|please\s+write)\b/i;
@@ -111,7 +112,7 @@ export function isContinueOrRetryPrompt(prompt) {
 }
 export function hasWebPageIntent(prompt) {
     const text = stripExecutionShaping(prompt);
-    return WEB_PAGE_INTENT.test(text) || /\bhtml5\s+website\b/i.test(text);
+    return WEB_PAGE_INTENT.test(text) || WEB_SHOWCASE_INTENT.test(text) || /\bhtml5\s+website\b/i.test(text);
 }
 export function isTrivialHtmlPageRequest(prompt) {
     const text = stripExecutionShaping(prompt);

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

@@ -4,7 +4,7 @@ function stripInlineWorkspacePlaceholders(value) {
     // Only strip placeholders when they were appended to a segment (e.g. pitfall[Vigthoria service]).
     // Keep canonical scrubbed segments like /[internal]/ intact for dedicated mapping logic.
     return String(value || '')
-        .replace(/(^|[^/])\[(?:internal|Vigthoria service|Vigthoria Agent|Vigthoria storage|temp|home|workspace)\](?=(?:\/|$))/ig, '$1')
+        .replace(/([^/])\[(?:internal|Vigthoria service|Vigthoria Agent|Vigthoria storage|temp|home|workspace)\](?=(?:\/|$))/ig, '$1')
         .replace(/\/+$/g, '');
 }
 /**
@@ -16,6 +16,9 @@ export function normalizeV3WorkspaceRelativePath(rawPath, rootPath) {
     if (!input) {
         return '';
     }
+    input = input
+        .replace(/^var\/?\[internal\]/i, '[internal]')
+        .replace(/^varwww\[internal\]/i, '[internal]');
     input = stripInlineWorkspacePlaceholders(input);
     const safeRelative = (candidate) => {
         const stripped = String(candidate || '').replace(/^\/+/, '');
@@ -64,6 +67,8 @@ export function normalizeV3WorkspaceRelativePath(rawPath, rootPath) {
         }
         const placeholderPatterns = [
             [/^(?:var\/)?www\/\[internal\](?:\/(.*))?$/i, 1],
+            [/^var\/?\[internal\](?:\/(.*))?$/i, 1],
+            [/^varwww\[internal\](?:\/(.*))?$/i, 1],
             [/^\[internal\](?:\/(.*))?$/i, 1],
             [/^\[Vigthoria service\](?:\/(.*))?$/i, 1],
             [/^\[Vigthoria Agent\](?:\/(.*))?$/i, 1],
@@ -134,6 +139,9 @@ export function normalizeV3WorkspaceRelativePath(rawPath, rootPath) {
         }
         const rootNoLeadingSlash = normalizedRoot.replace(/^\//, '');
         const rootBase = path.posix.basename(normalizedRoot);
+        if (input.replace(/\/+$/g, '').toLowerCase() === normalizedRoot.toLowerCase()) {
+            return '';
+        }
         const prefixes = [
             `${normalizedRoot}/`,
             `${rootNoLeadingSlash}/`,
@@ -150,6 +158,11 @@ export function normalizeV3WorkspaceRelativePath(rawPath, rootPath) {
             return safeRelative(input.slice(embeddedIndex + embeddedRoot.length));
         }
     }
+    // An unmatched POSIX absolute path belongs to another filesystem boundary.
+    // Never reinterpret it as a workspace-relative path by merely trimming '/'.
+    if (input.startsWith('/')) {
+        return '';
+    }
     const relative = safeRelative(input);
     if (relative === 'workspace') {
         return '';
@@ -167,7 +180,11 @@ export function isV3WorkspaceRootAliasPath(rawPath, rootPath) {
     if (!original || original === '.') {
         return true;
     }
-    const sanitized = stripInlineWorkspacePlaceholders(original).replace(/\\/g, '/').trim();
+    const compactCanonical = original
+        .replace(/\\/g, '/')
+        .replace(/^var\/?\[internal\]/i, '[internal]')
+        .replace(/^varwww\[internal\]/i, '[internal]');
+    const sanitized = stripInlineWorkspacePlaceholders(compactCanonical).trim();
     if (!sanitized || sanitized === '.' || sanitized === '/') {
         return true;
     }
@@ -181,6 +198,9 @@ export function isV3WorkspaceRootAliasPath(rawPath, rootPath) {
         || lowered === '[internal]'
         || lowered === 'www/[internal]'
         || lowered === 'var/www/[internal]'
+        || lowered === 'var[internal]'
+        || lowered === 'var/[internal]'
+        || lowered === 'varwww[internal]'
         || lowered === '[vigthoria service]'
         || lowered === 'var/www/[vigthoria service]') {
         return true;

package/install.ps1

@@ -5,7 +5,7 @@
 $ErrorActionPreference = "Stop"
 
 # Configuration
-$CLI_VERSION = "1.13.13"
+$CLI_VERSION = "1.13.18"
 $INSTALL_DIR = "$env:USERPROFILE\.vigthoria"
 $NPM_PACKAGE = "vigthoria-cli"
 $GIT_PACKAGE_URL = "git+https://market.vigthoria.io/vigthoria/vigthoria-cli.git"

package/install.sh

@@ -26,7 +26,7 @@ else
 fi
 
 # Configuration
-CLI_VERSION="1.13.13"
+CLI_VERSION="1.13.18"
 INSTALL_DIR="$HOME/.vigthoria"
 REPO_URL="https://market.vigthoria.io/vigthoria/vigthoria-cli"
 GIT_PACKAGE_URL="git+https://market.vigthoria.io/vigthoria/vigthoria-cli.git"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.13.13",
+  "version": "1.13.18",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "type": "module",
   "main": "dist/index.js",
@@ -72,6 +72,7 @@
     "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:v3-workspace-path": "npm run build && node scripts/test-v3-workspace-path.js",
+    "test:v3-server-tool-execution": "npm run build && node scripts/test-v3-server-tool-execution.js",
     "test:session:project-match": "npm run build && node scripts/test-session-project-match.mjs",
     "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",

package/scripts/release/validate-no-go-gates.sh

@@ -5,6 +5,7 @@ ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
 cd "$ROOT"
 
 CLI="node dist/index.js"
+SERVICE_IDENTITY_MODE="${VIGTHORIA_TEST_SERVICE_IDENTITY:-0}"
 unset V3_SERVICE_KEY
 unset HYPERLOOP_SERVICE_KEY
 # Release validation runs against local model-router in this environment
@@ -27,6 +28,7 @@ printf '%s
 ' "$AUTH_JSON" > /tmp/vig-auth-preflight.json
 python3 - << 'PY'
 import json
+import re
 with open('/tmp/vig-auth-preflight.json','r',encoding='utf-8') as f:
     j=json.load(f)
 msg='Vigthoria Gate way user authentification failed. Please log out and login again.'
@@ -35,6 +37,15 @@ assert j.get('error') == msg, f"unexpected auth message: {j.get('error')}"
 print('[pass] auth preflight message')
 PY
 
+if [[ "$SERVICE_IDENTITY_MODE" == "1" ]]; then
+  # From this point onward the no-go suite exercises server-local model and
+  # tool routes without borrowing a human account session. The invalid-token
+  # gateway assertion above always runs against the canonical public boundary.
+  export VIGTHORIA_LOCAL_TEST_MODE=1
+  export VIGTHORIA_LOCAL_TEST_TOKEN="vigthoria-release-service-identity"
+  export VIGTHORIA_AUTH_TOKEN="$VIGTHORIA_LOCAL_TEST_TOKEN"
+fi
+
 echo "[1.1] ranker includes agent.py top10 for SSE prompt"
 node - << 'EOF2'
 import('./dist/utils/context-ranker.js').then((m)=>{
@@ -62,7 +73,17 @@ if (!tsc || !tsc.ran || !tsc.passed) process.exit(1);
 EOF2
 
 echo "[6.2] balanced-4b no-agent path"
-$CLI chat --no-agent --model balanced-4b --prompt "reply exactly: ok" --json >/tmp/vig-balanced.json
+for attempt in 1 2 3; do
+  if $CLI chat --no-agent --model balanced-4b --prompt "reply exactly: ok" --json >/tmp/vig-balanced.json; then
+    break
+  fi
+  if [[ "$attempt" == "3" ]]; then
+    echo "[fail] balanced-4b remained unavailable after 3 attempts"
+    exit 1
+  fi
+  echo "[retry] balanced-4b transient failure ($attempt/3)"
+  sleep 2
+done
 python3 - << 'PY'
 import json
 j=json.load(open('/tmp/vig-balanced.json'))
@@ -76,13 +97,17 @@ $CLI hyper-loop status >/tmp/vig-hyperloop.txt
 $CLI devtools connect >/tmp/vig-devtools.txt
 
 echo "[6.11] operator flow"
-$CLI operator --prompt "reply with exactly: OK" --json >/tmp/vig-operator.json
-python3 - << 'PY'
+if [[ "$SERVICE_IDENTITY_MODE" == "1" ]]; then
+  echo "[skip] paid-user operator probe (isolated release service identity)"
+else
+  $CLI operator --prompt "reply with exactly: OK" --json >/tmp/vig-operator.json
+  python3 - << 'PY'
 import json
 j=json.load(open('/tmp/vig-operator.json'))
 assert j.get('success') is True, j
 print('[pass] operator flow')
 PY
+fi
 
 echo "[7.1/7.3/7.4] local service health"
 for u in http://localhost:8030/health http://localhost:4009/health http://localhost:4011/health; do
@@ -95,6 +120,7 @@ echo "[7.2/7.8/12.3] models inventory"
 curl -s http://localhost:4009/v1/models >/tmp/vig-models.json
 python3 - << 'PY'
 import json
+import re
 ids={m.get('id','') for m in json.load(open('/tmp/vig-models.json')).get('data',[])}
 if ids:
   has_router = any(
@@ -110,7 +136,7 @@ if ids:
       'vigthoria-fast-9b', 'vigthoria-fast-9b:latest',
     )
   )
-  has_code = any('vigthoria-v3-code-35b' in i for i in ids)
+  has_code = any(re.search(r'^vigthoria-v3(?:\.\d+)?-code-35b(?:-|:|$)', i) for i in ids)
   assert has_router, f'missing router model in inventory: {sorted(ids)}'
   assert has_creative, f'missing creative/fast model in inventory: {sorted(ids)}'
   assert has_code, f'missing code model in inventory: {sorted(ids)}'
@@ -136,7 +162,17 @@ rg -n "coder.vigthoria.io/releases" install.ps1 install.sh README.md >/tmp/vig-r
 cat /tmp/vig-release-urls.txt
 
 echo "[12.1] no-agent governance fallback"
-$CLI chat --no-agent --model creative --prompt "say ok" --json >/tmp/vig-creative.json
+for attempt in 1 2 3; do
+  if $CLI chat --no-agent --model creative --prompt "say ok" --json >/tmp/vig-creative.json; then
+    break
+  fi
+  if [[ "$attempt" == "3" ]]; then
+    echo "[fail] governance fallback remained unavailable after 3 attempts"
+    exit 1
+  fi
+  echo "[retry] governance fallback transient failure ($attempt/3)"
+  sleep 2
+done
 python3 - << 'PY'
 import json
 j=json.load(open('/tmp/vig-creative.json'))