vigthoria-cli 1.13.25 → 1.13.26

package/dist/commands/chat.js

@@ -2931,15 +2931,24 @@ export class ChatCommand {
             if (this.streamState.streamingStarted && !this.streamState.streamedAnswerDisplayed) {
                 this.displayV3StreamedAnswer();
             }
-            const previewGate = (response.metadata?.previewGate || null);
+            const serverPreviewGate = (response.metadata?.previewGate || null);
             const workspaceHasOutput = this.api.hasAgentWorkspaceOutput(workspaceContext);
             const changedFileCount = response.changedFiles ? Object.keys(response.changedFiles).length : 0;
             const requiresWorkspaceChanges = taskRequiresWorkspaceChangesWithContext(contextualPrompt, intentContext);
+            const previewGate = requiresWorkspaceChanges
+                ? serverPreviewGate
+                : { required: false, passed: true, skipped: false };
             const answerContent = normalizeAgentAnswerContent(response.content, this.streamState.streamedAnswerBuffer);
             liveOutcome.changedFileCount = changedFileCount;
             liveOutcome.requiresWorkspaceChanges = requiresWorkspaceChanges;
             liveOutcome.workspaceHasOutput = requiresWorkspaceChanges ? workspaceHasOutput : false;
             liveOutcome.answerContent = answerContent;
+            const workflowError = response.metadata?.workflowError;
+            if (workflowError && !liveOutcome.executorError) {
+                liveOutcome.executorError = typeof workflowError === 'string'
+                    ? workflowError
+                    : String(workflowError.message || 'Agent execution failed.');
+            }
             const success = previewGate?.required === true
                 ? previewGate?.passed === true && previewGate?.skipped !== true
                 : true;

package/dist/commands/game.js

@@ -39,7 +39,11 @@ export function gameProcessInvocation(pm, args, platform = process.platform, com
             category: 'usage',
         });
     }
-    const command = [executable, ...args].map((token) => `"${token}"`).join(' ');
+    // Every token is already restricted to an inert alphabet above. Passing the
+    // tokens without embedded quotes is important: on Windows, cmd.exe can hand
+    // the quote characters to the .cmd shim as part of argv[0], producing the
+    // observed literal `"npm.cmd"` launch failure.
+    const command = [executable, ...args].join(' ');
     return { executable: comSpec, args: ['/d', '/s', '/c', command] };
 }
 const run = (pm, args, cwd, timeoutMs = 10 * 60_000) => new Promise((resolve, reject) => { const invocation = gameProcessInvocation(pm, args); const child = spawn(invocation.executable, invocation.args, { cwd, stdio: 'inherit', windowsHide: true, env: safeChildProcessEnv() }); let interrupted = false; const onInterrupt = () => { interrupted = true; child.kill('SIGINT'); }; process.once('SIGINT', onInterrupt); const timer = timeoutMs > 0 ? setTimeout(() => { child.kill('SIGTERM'); reject(new CliCommandError(`${pm} command timed out after ${timeoutMs}ms`, { code: 'GAME_PROCESS_TIMEOUT' })); }, timeoutMs) : null; const finish = () => { if (timer)

package/dist/commands/preview.d.ts

@@ -20,6 +20,7 @@ interface PreviewOptions {
     proof?: boolean;
     screenshot?: boolean;
 }
+export declare function isPreviewProofRequested(options: Pick<PreviewOptions, 'proof' | 'screenshot'>): boolean;
 export declare class PreviewCommand {
     private logger;
     private api;

package/dist/commands/preview.js

@@ -51,6 +51,9 @@ const MIME_TYPES = {
     '.txt': 'text/plain',
     '.map': 'application/json',
 };
+export function isPreviewProofRequested(options) {
+    return options.proof === true || options.screenshot === true;
+}
 export class PreviewCommand {
     logger;
     api;
@@ -76,11 +79,17 @@ export class PreviewCommand {
             await this.showConsolidatedDiff(projectPath);
         }
         // Run Template Service preview proof gate
-        if (options.proof) {
-            await this.runProofGate(projectPath, options.screenshot);
+        if (isPreviewProofRequested(options)) {
+            try {
+                await this.runProofGate(projectPath, options.screenshot);
+            }
+            catch (error) {
+                this.api.destroy();
+                throw error;
+            }
         }
         // If only --diff or --proof was requested (no explicit entry/port), just exit
-        if (options.diff || options.proof) {
+        if (options.diff || isPreviewProofRequested(options)) {
             if (!options.entry && !options.port) {
                 this.api.destroy();
                 return;
@@ -90,7 +99,7 @@ export class PreviewCommand {
         const entryFile = this.detectEntryFile(projectPath, options.entry);
         if (!entryFile) {
             this.logger.warn('No HTML entry file found. Use --entry <file> to specify one.');
-            if (!options.diff && !options.proof) {
+            if (!options.diff && !options.proof && !options.screenshot) {
                 this.api.destroy();
                 throw new CliCommandError('No HTML entry file found. Use --entry <file> to specify one.', {
                     code: 'PREVIEW_ENTRY_NOT_FOUND', category: 'configuration',
@@ -162,7 +171,7 @@ export class PreviewCommand {
      * Start a local HTTP server for preview
      */
     async startServer(projectPath, entryFile, port, autoOpen) {
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
             this.server = http.createServer((req, res) => {
                 let filePath;
                 try {
@@ -210,6 +219,20 @@ export class PreviewCommand {
                     res.end('Internal server error');
                 }
             });
+            const finish = (error) => {
+                process.removeListener('SIGINT', shutdown);
+                process.removeListener('SIGTERM', shutdown);
+                this.api.destroy();
+                this.server = null;
+                error ? reject(error) : resolve();
+            };
+            const shutdown = () => {
+                console.log(chalk.gray('\n  Stopping preview server...'));
+                if (!this.server)
+                    return finish();
+                this.server.close((error) => finish(error || undefined));
+            };
+            this.server.once('error', finish);
             this.server.listen(port, () => {
                 const url = `http://localhost:${port}/${entryFile}`;
                 console.log(chalk.green(`  ${CH.success} Preview server running`));
@@ -221,15 +244,8 @@ export class PreviewCommand {
                     this.openBrowser(url);
                 }
             });
-            // Handle graceful shutdown
-            const shutdown = () => {
-                console.log(chalk.gray('\n  Stopping preview server...'));
-                this.server?.close();
-                this.api.destroy();
-                resolve();
-            };
-            process.on('SIGINT', shutdown);
-            process.on('SIGTERM', shutdown);
+            process.once('SIGINT', shutdown);
+            process.once('SIGTERM', shutdown);
         });
     }
     /**

package/dist/commands/repo.d.ts

@@ -14,6 +14,22 @@
  */
 import { Config } from '../utils/config.js';
 import { Logger } from '../utils/logger.js';
+interface Project {
+    id: number;
+    project_name: string;
+    project_path: string;
+    description: string;
+    tech_stack: string;
+    visibility: 'public' | 'private' | 'restricted';
+    is_public: boolean;
+    demo_url: string | null;
+    repo_url: string | null;
+    status: string;
+    storage_usage_mb: number;
+    created_at: string;
+    updated_at: string;
+    last_synced_at: string | null;
+}
 interface PushOptions {
     path?: string;
     name?: string;
@@ -34,6 +50,25 @@ interface ListOptions {
 interface ShareOptions {
     expires?: string;
 }
+interface RepositoryMaterialization {
+    project?: Project;
+    projectName?: string;
+    description?: string;
+    downloadUrl?: string;
+    inlineComplete?: boolean;
+    files?: Array<{
+        path: string;
+        content?: string;
+        encoding?: 'utf8' | 'base64';
+        size?: number;
+        binary?: boolean;
+    }>;
+}
+export declare function isCompleteRepositoryInlinePayload(data: RepositoryMaterialization): boolean;
+export declare function resolveRepositoryDownloadRoute(rawUrl: string, coderApiBase: string, publicDownload?: boolean): {
+    url: string;
+    audience: 'coder' | 'community';
+};
 export declare class RepositoryMutationAmbiguousError extends Error {
     readonly operationId: string;
     readonly mutationOutcome = "unknown";
@@ -48,8 +83,6 @@ export declare class RepoCommand {
     private communityToken;
     constructor(config: Config, _logger: Logger);
     private getAuthHeaders;
-    private getRepositoryAudienceForUrl;
-    private getAuthHeadersForUrl;
     private ensureCommunityAuth;
     private repoFetch;
     private collectProjectFiles;

package/dist/commands/repo.js

@@ -23,6 +23,35 @@ import { CliCommandError, commandFailure, formatSuccessJson } from '../utils/com
 import { createRuntimeTempDirectory, removeRuntimeTempDirectory } from '../utils/runtime-temp.js';
 import { assertSafeDestinationPath, assertSafeRelativePath, inspectZipArchive, mergeValidatedWorkspace, resolveWorkspacePath, validateExtractedWorkspace, } from '../utils/workspace-boundary.js';
 import inquirer from 'inquirer';
+export function isCompleteRepositoryInlinePayload(data) {
+    if (!Array.isArray(data.files) || data.files.length === 0 || data.inlineComplete === false)
+        return false;
+    return data.files.every((file) => typeof file?.path === 'string'
+        && typeof file?.content === 'string'
+        && (file.encoding === undefined || file.encoding === 'utf8' || file.encoding === 'base64')
+        && file.binary !== true);
+}
+export function resolveRepositoryDownloadRoute(rawUrl, coderApiBase, publicDownload = false) {
+    const parsed = new URL(rawUrl);
+    if (parsed.protocol !== 'https:' || parsed.username || parsed.password || parsed.port) {
+        throw new Error('Repository download URL is not an exact trusted HTTPS origin');
+    }
+    if (parsed.hostname.toLowerCase() === 'coder.vigthoria.io')
+        return { url: parsed.href, audience: 'coder' };
+    if (parsed.hostname.toLowerCase() !== 'community.vigthoria.io') {
+        throw new Error('Repository download URL is outside the Coder and Community trust boundary');
+    }
+    if (publicDownload)
+        return { url: parsed.href, audience: 'community' };
+    const match = parsed.pathname.match(/^\/api\/showcase\/(\d+)\/download$/);
+    if (!match || parsed.search || parsed.hash) {
+        throw new Error('Authenticated repository archive URL has an unsupported path');
+    }
+    return {
+        url: `${coderApiBase.replace(/\/$/, '')}/api/community-repo/archive/${encodeURIComponent(match[1])}`,
+        audience: 'coder',
+    };
+}
 const MAX_REPOSITORY_CONTENT_BYTES = 100 * 1024 * 1024;
 const MAX_REPOSITORY_REQUEST_BYTES = 120 * 1024 * 1024;
 class RepositoryApiError extends Error {
@@ -87,17 +116,6 @@ export class RepoCommand {
             'Content-Type': 'application/json',
         };
     }
-    getRepositoryAudienceForUrl(rawUrl) {
-        const hostname = new URL(rawUrl).hostname.toLowerCase();
-        if (hostname === 'coder.vigthoria.io')
-            return 'coder';
-        if (hostname === 'community.vigthoria.io')
-            return 'community';
-        throw new Error('Repository download URL is outside the Coder and Community trust boundary');
-    }
-    getAuthHeadersForUrl(rawUrl) {
-        return this.getAuthHeaders(this.getRepositoryAudienceForUrl(rawUrl));
-    }
     async ensureCommunityAuth() {
         if (this.communityToken) {
             return;
@@ -596,12 +614,38 @@ export class RepoCommand {
         try {
             if (fs.existsSync(outputPath))
                 validateExtractedWorkspace(outputPath);
-            if (data.downloadUrl) {
-                const archiveResponse = await guardedFetch(data.downloadUrl, {
+            if (isCompleteRepositoryInlinePayload(data)) {
+                const stagingRoot = createRuntimeTempDirectory('repo-inline-');
+                try {
+                    let totalBytes = 0;
+                    for (const file of data.files) {
+                        const filePath = resolveWorkspacePath(stagingRoot, file.path, { allowMissing: true });
+                        const content = file.encoding === 'base64'
+                            ? Buffer.from(file.content, 'base64')
+                            : Buffer.from(file.content, 'utf8');
+                        if (typeof file.size === 'number' && file.size !== content.byteLength) {
+                            throw new Error(`Repository file size mismatch: ${file.path}`);
+                        }
+                        totalBytes += content.byteLength;
+                        if (totalBytes > MAX_REPOSITORY_CONTENT_BYTES)
+                            throw new Error('Repository inline payload exceeds the materialization limit');
+                        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+                        fs.writeFileSync(filePath, content, { mode: 0o600 });
+                    }
+                    validateExtractedWorkspace(stagingRoot);
+                    mergeValidatedWorkspace(stagingRoot, outputPath);
+                }
+                finally {
+                    removeRuntimeTempDirectory(stagingRoot);
+                }
+            }
+            else if (data.downloadUrl) {
+                const route = resolveRepositoryDownloadRoute(data.downloadUrl, this.apiBase, publicDownload);
+                const archiveResponse = await guardedFetch(route.url, {
                     headers: publicDownload
                         ? { 'Content-Type': 'application/json' }
-                        : this.getAuthHeadersForUrl(data.downloadUrl)
-                }, { audience: this.getRepositoryAudienceForUrl(data.downloadUrl) });
+                        : this.getAuthHeaders(route.audience)
+                }, { audience: route.audience });
                 if (!archiveResponse.ok)
                     throw new Error('Failed to download project archive');
                 const archiveBuffer = Buffer.from(await archiveResponse.arrayBuffer());
@@ -638,23 +682,8 @@ export class RepoCommand {
                     removeRuntimeTempDirectory(stagingRoot);
                 }
             }
-            else if (data.files) {
-                const stagingRoot = createRuntimeTempDirectory('repo-inline-');
-                try {
-                    for (const file of data.files) {
-                        const filePath = resolveWorkspacePath(stagingRoot, file.path, { allowMissing: true });
-                        fs.mkdirSync(path.dirname(filePath), { recursive: true });
-                        fs.writeFileSync(filePath, file.content, { mode: 0o600 });
-                    }
-                    validateExtractedWorkspace(stagingRoot);
-                    mergeValidatedWorkspace(stagingRoot, outputPath);
-                }
-                finally {
-                    removeRuntimeTempDirectory(stagingRoot);
-                }
-            }
             else {
-                throw new Error('Repository response contained neither an archive nor inline files');
+                throw new Error('Repository response contained neither a complete inline payload nor an archive');
             }
             downloadSpinner.succeed(chalk.green('Project materialized successfully!'));
             console.log(chalk.cyan('\n📁 Project extracted to:'));
@@ -891,7 +920,8 @@ export class RepoCommand {
         const spinner = createSpinner('Deleting project...').start();
         try {
             const operationId = createOperationId();
-            const response = await this.repoFetch(`/api/repo/projects/${encodeURIComponent(projectName)}`, {
+            const repo = await this.resolveRepoByName(projectName);
+            const response = await this.repoFetch(`/api/repo/projects/${encodeURIComponent(String(repo.id))}`, {
                 method: 'DELETE',
                 headers: { 'X-Vigthoria-Operation-Id': operationId },
             }, { operationId });

package/dist/commands/update-registration.js

@@ -252,7 +252,7 @@ export function registerUpdateCommand(program, version) {
                 if (!signatureResponse.ok)
                     throw new Error(`Detached signature returned HTTP ${signatureResponse.status}`);
                 verifyReleaseSignature(channel, manifestEntry, await signatureResponse.text());
-                assertReleaseTransition(currentVersion, manifestEntry, channel, allowDowngrade);
+                console.log(chalk.gray(`Verified ${channel} manifest: version=${manifestEntry.version} package=${manifestEntry.packageName}@${manifestEntry.packageVersion} size=${manifestEntry.size} sha256=${manifestEntry.sha256}`));
             }
             catch (error) {
                 if (error instanceof CliCommandError)
@@ -303,6 +303,7 @@ export function registerUpdateCommand(program, version) {
             && compareVersions(manifestEntry.version, effectiveLatest) >= 0
             && compareVersions(manifestEntry.version, currentVersion) > 0);
         if (manifestIsAuthoritative && manifestEntry) {
+            assertReleaseTransition(currentVersion, manifestEntry, channel, allowDowngrade);
             const updateTempDirectory = createRuntimeTempDirectory('update-');
             const tmpFile = path.join(updateTempDirectory, 'candidate.tgz');
             try {

package/dist/utils/api.js

@@ -15,7 +15,7 @@ import { buildSemanticContext } from './context-ranker.js';
 import { getChangedFiles } from './workspace-cache.js';
 import { isSubstantiveAgentAnswer, isToolEvidenceStubAnswer } from './agentRunOutcome.js';
 import { buildExecutionHints, isPlannerBuildTask, resolvePlannerAgentTimeoutMs } from './requestIntent.js';
-import { isV3StreamKeepaliveEvent } from './v3-stream-events.js';
+import { assertValidAgentPlanEvent, isV3StreamKeepaliveEvent } from './v3-stream-events.js';
 import { resolveV3ContextCharLimit, WORKSPACE_FILE_CHAR_CAP, } from './contextBudget.js';
 import { isLocalTestfarmMode, fetchWithServiceTimeout } from './localTestMode.js';
 import { buildClientManifest } from './clientManifest.js';
@@ -710,13 +710,10 @@ export class APIClient {
         return this.v3AgentClient.approvalUrl(baseUrl);
     }
     getOperatorBaseUrls() {
-        const configuredModelsApiUrl = String(this.config.get('modelsApiUrl') || 'https://api.vigthoria.io').replace(/\/$/, '');
         const urls = [
             process.env.VIGTHORIA_OPERATOR_URL,
             process.env.OPERATOR_URL,
-            'http://127.0.0.1:4009',
-            configuredModelsApiUrl,
-            'https://api.vigthoria.io',
+            'https://agent.vigthoria.io',
         ].filter(Boolean).map((url) => String(url).replace(/\/$/, ''));
         return [...new Set(urls)];
     }
@@ -3109,6 +3106,7 @@ document.addEventListener('DOMContentLoaded', () => {
                     if (explicitEventType && (!event.type || event.type === 'message')) {
                         event.type = explicitEventType;
                     }
+                    assertValidAgentPlanEvent(event);
                     const userEvent = this.sanitizeV3AgentEventForUser(event);
                     events.push(userEvent);
                     if (!contextId && typeof event.context_id === 'string' && event.context_id.trim()) {
@@ -3360,12 +3358,15 @@ document.addEventListener('DOMContentLoaded', () => {
                             // A pre-existing local project is not proof that this run produced
                             // valid output. A terminal planner/executor error fails proof and
                             // causes the operation journal to roll back streamed mutations.
-                            const failedPreviewGate = {
-                                required: true,
-                                passed: false,
-                                skipped: true,
-                                error: 'Agent execution failed before preview validation.',
-                            };
+                            const analysisOnly = this.isAnalysisOnlyTask(message, executionContext);
+                            const failedPreviewGate = analysisOnly
+                                ? { required: false, passed: true, skipped: false }
+                                : {
+                                    required: true,
+                                    passed: false,
+                                    skipped: true,
+                                    error: 'Agent execution failed before preview validation.',
+                                };
                             return this.finalizeV3AgentWorkflowResponse(data, {
                                 content: '',
                                 taskId: data.task_id || null,

package/dist/utils/network-policy.js

@@ -3,7 +3,7 @@ export { redactSensitiveText } from './secret-policy.js';
 const AUDIENCE_HOSTS = {
     coder: new Set(['coder.vigthoria.io']),
     models: new Set(['api.vigthoria.io']),
-    operator: new Set(['api.vigthoria.io', 'operator.vigthoria.io']),
+    operator: new Set(['agent.vigthoria.io', 'operator.vigthoria.io']),
     hub: new Set(['hub.vigthoria.io']),
     community: new Set(['community.vigthoria.io']),
     music: new Set(['music.vigthoria.io']),

package/dist/utils/preview-screenshot-adapter.d.ts

@@ -5,11 +5,52 @@ export type PreviewScreenshotResult = {
 export interface PreviewScreenshotPort {
     capture(entryAbsolutePath: string, screenshotPath: string): Promise<PreviewScreenshotResult>;
 }
+type BrowserPage = {
+    setViewport(options: {
+        width: number;
+        height: number;
+        deviceScaleFactor: number;
+    }): Promise<void>;
+    goto(url: string, options: {
+        waitUntil: string;
+        timeout: number;
+    }): Promise<void>;
+    screenshot(options: {
+        path: string;
+        fullPage: boolean;
+    }): Promise<unknown>;
+};
+type Browser = {
+    newPage(): Promise<BrowserPage>;
+    close(): Promise<void>;
+    process?(): {
+        kill(signal?: NodeJS.Signals): boolean;
+    } | null;
+};
+type PuppeteerLike = {
+    executablePath?(): string;
+    launch(options: {
+        headless: true | 'shell';
+        args: string[];
+        userDataDir: string;
+        executablePath?: string;
+        timeout: number;
+        protocolTimeout: number;
+    }): Promise<Browser>;
+};
+export type PreviewBrowserResolution = {
+    executablePath?: string;
+    headless: true | 'shell';
+    source: 'packaged' | 'system' | 'injected';
+};
+export declare function resolvePreviewBrowserExecutable(puppeteer: PuppeteerLike, environment?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, exists?: (candidate: string) => boolean): PreviewBrowserResolution | null;
 export declare class OptionalPuppeteerScreenshotAdapter implements PreviewScreenshotPort {
     private readonly loadPuppeteer;
     private readonly environment;
     private readonly allocateTemp;
     private readonly releaseTemp;
-    constructor(loadPuppeteer?: () => Promise<unknown>, environment?: NodeJS.ProcessEnv, allocateTemp?: (prefix: string) => string, releaseTemp?: (directory: string) => void);
+    private readonly platform;
+    constructor(loadPuppeteer?: () => Promise<unknown>, environment?: NodeJS.ProcessEnv, allocateTemp?: (prefix: string) => string, releaseTemp?: (directory: string) => void, platform?: NodeJS.Platform);
     capture(entryAbsolutePath: string, screenshotPath: string): Promise<PreviewScreenshotResult>;
 }
+export {};

package/dist/utils/preview-screenshot-adapter.js

@@ -1,16 +1,54 @@
 import { pathToFileURL } from 'node:url';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { redactSensitiveText } from './secret-policy.js';
 import { createRuntimeTempDirectory, removeRuntimeTempDirectory } from './runtime-temp.js';
+export function resolvePreviewBrowserExecutable(puppeteer, environment = process.env, platform = process.platform, exists = fs.existsSync) {
+    if (typeof puppeteer.executablePath !== 'function')
+        return { headless: 'shell', source: 'injected' };
+    try {
+        const packaged = puppeteer.executablePath();
+        if (packaged && exists(packaged))
+            return { executablePath: packaged, headless: 'shell', source: 'packaged' };
+    }
+    catch {
+        // Continue to trusted platform browser locations.
+    }
+    if (platform !== 'win32')
+        return null;
+    const bases = [environment['PROGRAMFILES(X86)'], environment.ProgramFiles, environment.LOCALAPPDATA]
+        .filter((value) => typeof value === 'string' && value.length > 0);
+    const relatives = [
+        ['Microsoft', 'Edge', 'Application', 'msedge.exe'],
+        ['Google', 'Chrome', 'Application', 'chrome.exe'],
+    ];
+    for (const base of bases) {
+        for (const relative of relatives) {
+            const candidate = path.win32.join(base, ...relative);
+            if (exists(candidate))
+                return { executablePath: candidate, headless: true, source: 'system' };
+        }
+    }
+    return null;
+}
+function withTimeout(promise, timeoutMs, label) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+        promise.then((value) => { clearTimeout(timer); resolve(value); }, (error) => { clearTimeout(timer); reject(error); });
+    });
+}
 export class OptionalPuppeteerScreenshotAdapter {
     loadPuppeteer;
     environment;
     allocateTemp;
     releaseTemp;
-    constructor(loadPuppeteer = () => import('puppeteer'), environment = process.env, allocateTemp = createRuntimeTempDirectory, releaseTemp = removeRuntimeTempDirectory) {
+    platform;
+    constructor(loadPuppeteer = () => import('puppeteer'), environment = process.env, allocateTemp = createRuntimeTempDirectory, releaseTemp = removeRuntimeTempDirectory, platform = process.platform) {
         this.loadPuppeteer = loadPuppeteer;
         this.environment = environment;
         this.allocateTemp = allocateTemp;
         this.releaseTemp = releaseTemp;
+        this.platform = platform;
     }
     async capture(entryAbsolutePath, screenshotPath) {
         if (this.environment.VIGTHORIA_DISABLE_PREVIEW_SCREENSHOT === '1') {
@@ -22,24 +60,38 @@ export class OptionalPuppeteerScreenshotAdapter {
             if (!puppeteer || typeof puppeteer.launch !== 'function') {
                 return { captured: false, error: 'required Puppeteer screenshot runtime is not installed' };
             }
+            const browserResolution = resolvePreviewBrowserExecutable(puppeteer, this.environment, this.platform);
+            if (!browserResolution) {
+                return { captured: false, error: 'required browser executable is unavailable; install Chrome/Edge or the packaged Puppeteer browser' };
+            }
             const browserProfile = this.allocateTemp('browser-');
+            let browser = null;
             try {
-                const browser = await puppeteer.launch({
-                    headless: 'shell',
+                browser = await withTimeout(puppeteer.launch({
+                    headless: browserResolution.headless,
                     args: ['--no-sandbox', '--disable-setuid-sandbox'],
                     userDataDir: browserProfile,
-                });
-                try {
-                    const page = await browser.newPage();
-                    await page.setViewport({ width: 1440, height: 960, deviceScaleFactor: 1 });
-                    await page.goto(pathToFileURL(entryAbsolutePath).toString(), { waitUntil: 'networkidle0', timeout: 20_000 });
-                    await page.screenshot({ path: screenshotPath, fullPage: true });
-                }
-                finally {
-                    await browser.close();
-                }
+                    executablePath: browserResolution.executablePath,
+                    timeout: 20_000,
+                    protocolTimeout: 20_000,
+                }), 25_000, 'browser launch');
+                const page = await withTimeout(browser.newPage(), 10_000, 'browser page creation');
+                await withTimeout(page.setViewport({ width: 800, height: 600, deviceScaleFactor: 1 }), 10_000, 'browser viewport setup');
+                await page.goto(pathToFileURL(entryAbsolutePath).toString(), { waitUntil: 'networkidle0', timeout: 20_000 });
+                await withTimeout(page.screenshot({ path: screenshotPath, fullPage: false }), 20_000, 'screenshot capture');
             }
             finally {
+                if (browser) {
+                    try {
+                        await withTimeout(browser.close(), 5_000, 'browser shutdown');
+                    }
+                    catch {
+                        try {
+                            browser.process?.()?.kill('SIGKILL');
+                        }
+                        catch { /* exact owned browser only */ }
+                    }
+                }
                 this.releaseTemp(browserProfile);
             }
             return { captured: true };

package/dist/utils/runtime-temp.d.ts

@@ -44,6 +44,7 @@ export declare class RuntimeTempManager {
     private readonly pid;
     private readonly isProcessAlive;
     private readonly systemTempRoot;
+    private readonly sharedTempRoots;
     private readonly configuredRoot;
     private readonly source;
     private readonly maxBytes;

package/dist/utils/runtime-temp.js

@@ -99,6 +99,7 @@ export class RuntimeTempManager {
     pid;
     isProcessAlive;
     systemTempRoot;
+    sharedTempRoots;
     configuredRoot;
     source;
     maxBytes;
@@ -121,7 +122,18 @@ export class RuntimeTempManager {
         this.now = options.now || Date.now;
         this.pid = options.pid || process.pid;
         this.isProcessAlive = options.isProcessAlive || defaultProcessAlive;
-        this.systemTempRoot = options.systemTempDirectory || os.tmpdir();
+        const platformTemp = this.platform === 'win32'
+            ? String(this.environment.TEMP || this.environment.TMP || '').trim()
+            : String(this.environment.TMPDIR || '').trim();
+        this.systemTempRoot = options.systemTempDirectory || platformTemp || os.tmpdir();
+        this.sharedTempRoots = [
+            options.systemTempDirectory,
+            platformTemp,
+            this.environment.TEMP,
+            this.environment.TMP,
+            this.environment.TMPDIR,
+            this.platform === process.platform ? os.tmpdir() : undefined,
+        ].filter((value) => typeof value === 'string' && value.trim().length > 0);
         const resolved = resolveRuntimeTempRoot({ ...options, environment: this.environment, platform: this.platform, homeDirectory: this.homeDirectory });
         this.configuredRoot = resolved.root;
         this.source = resolved.source;
@@ -134,6 +146,14 @@ export class RuntimeTempManager {
         if (this.initializedRoot || this.initializationError)
             return this.status();
         try {
+            // Reject the shared OS temp path before touching the filesystem. This is
+            // also what makes cross-platform policy probes deterministic: a Windows
+            // policy instance running in a non-Windows test host must not attempt to
+            // create a drive-letter path before it can reject `%TEMP%`.
+            if (this.sharedTempRoots.some((root) => pathsEqual(this.configuredRoot, root, this.platform))
+                || (this.platform !== 'win32' && isKnownSharedPosixTemp(this.configuredRoot))) {
+                throw new RuntimeTempError('The shared operating-system temporary directory cannot be used for Vigthoria runtime storage.', 'TEMP_ROOT_SHARED');
+            }
             if (this.source === 'per-user-default' && !fs.existsSync(this.homeDirectory)) {
                 throw new RuntimeTempError('The user home directory does not exist; managed temporary storage cannot be initialized.', 'TEMP_HOME_UNAVAILABLE');
             }
@@ -154,7 +174,7 @@ export class RuntimeTempManager {
                 }
             }
             const pathApi = this.platform === 'win32' ? path.win32 : path.posix;
-            if (pathsEqual(realRoot, this.systemTempRoot, this.platform)
+            if (this.sharedTempRoots.some((root) => pathsEqual(realRoot, root, this.platform))
                 || (this.platform !== 'win32' && isKnownSharedPosixTemp(realRoot))) {
                 throw new RuntimeTempError('The shared operating-system temporary directory cannot be used for Vigthoria runtime storage.', 'TEMP_ROOT_SHARED');
             }

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

@@ -3,3 +3,11 @@
  * connections alive — not substantive work the CLI should surface as progress.
  */
 export declare function isV3StreamKeepaliveEvent(event: unknown): boolean;
+export declare class AgentPlanContractError extends Error {
+    readonly code = "AGENT_PLAN_INVALID";
+    constructor(message: string);
+}
+/** Validate a server-authored execution graph before any task can be credited.
+ * A cyclic, duplicate, self-referencing, or dangling graph is never runnable
+ * and must not reach the UI callback where it could later be counted as 2/2. */
+export declare function assertValidAgentPlanEvent(event: unknown): void;

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

@@ -39,3 +39,65 @@ export function isV3StreamKeepaliveEvent(event) {
     }
     return false;
 }
+export class AgentPlanContractError extends Error {
+    code = 'AGENT_PLAN_INVALID';
+    constructor(message) {
+        super(message);
+        this.name = 'AgentPlanContractError';
+    }
+}
+function dependencyId(value) {
+    if (typeof value === 'string' || typeof value === 'number')
+        return String(value).trim();
+    if (!value || typeof value !== 'object')
+        return '';
+    const record = value;
+    return String(record.id || record.task_id || record.taskId || '').trim();
+}
+/** Validate a server-authored execution graph before any task can be credited.
+ * A cyclic, duplicate, self-referencing, or dangling graph is never runnable
+ * and must not reach the UI callback where it could later be counted as 2/2. */
+export function assertValidAgentPlanEvent(event) {
+    if (!event || typeof event !== 'object')
+        return;
+    const record = event;
+    if (record.type !== 'plan' || !Array.isArray(record.plan?.tasks))
+        return;
+    const tasks = record.plan.tasks;
+    const ids = tasks.map((task, index) => {
+        const id = dependencyId(task.id ?? task.task_id ?? task.taskId);
+        if (!id)
+            throw new AgentPlanContractError(`Agent plan task at index ${index} has no stable ID.`);
+        return id;
+    });
+    if (new Set(ids).size !== ids.length)
+        throw new AgentPlanContractError('Agent plan contains duplicate task IDs.');
+    const idSet = new Set(ids);
+    const graph = new Map();
+    tasks.forEach((task, index) => {
+        const raw = task.depends_on ?? task.dependsOn ?? task.dependencies ?? [];
+        const dependencies = (Array.isArray(raw) ? raw : [raw]).map(dependencyId).filter(Boolean);
+        for (const dependency of dependencies) {
+            if (dependency === ids[index])
+                throw new AgentPlanContractError(`Agent plan task ${ids[index]} depends on itself.`);
+            if (!idSet.has(dependency))
+                throw new AgentPlanContractError(`Agent plan task ${ids[index]} depends on missing task ${dependency}.`);
+        }
+        graph.set(ids[index], dependencies);
+    });
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (id, trail) => {
+        if (visiting.has(id))
+            throw new AgentPlanContractError(`Agent plan contains a dependency cycle: ${[...trail, id].join(' -> ')}.`);
+        if (visited.has(id))
+            return;
+        visiting.add(id);
+        for (const dependency of graph.get(id) || [])
+            visit(dependency, [...trail, id]);
+        visiting.delete(id);
+        visited.add(id);
+    };
+    for (const id of ids)
+        visit(id, []);
+}

package/package.json

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