vigthoria-cli 1.13.22 → 1.13.23

package/dist/commands/doctor-registration.js

@@ -9,6 +9,7 @@ import { createAPIClient } from '../utils/api-client-factory.js';
 import { sanitizeUserFacingErrorText } from '../utils/api.js';
 import { getCliStateFile, isOfflineMode, isUpdateCheckSuppressed } from '../utils/cli-state.js';
 import { CliCommandError, formatSuccessJson } from '../utils/command-contract.js';
+import { runtimeTempStatus } from '../utils/runtime-temp.js';
 export function registerDoctorCommand(program, config, logger, version) {
     program
         .command('doctor')
@@ -76,6 +77,7 @@ export function registerDoctorCommand(program, config, logger, version) {
         const envToken = String(process.env.VIGTHORIA_AUTH_TOKEN || process.env.VIGTHORIA_TOKEN || '').trim();
         const configuredToken = envToken || String(config.get('authToken') || '').trim();
         const tokenSegments = configuredToken ? configuredToken.split('.').length : 0;
+        const tempStorage = runtimeTempStatus();
         const report = {
             cliVersion: version,
             nodeVersion: process.version,
@@ -102,6 +104,7 @@ export function registerDoctorCommand(program, config, logger, version) {
                 writable: sessionStorageWritable,
                 latestCheckpoint,
             },
+            tempStorage,
             subscriptionPlan: subscription.plan || null,
             subscriptionStatus: subscription.status || null,
             offlineMode: offline,
@@ -180,7 +183,11 @@ export function registerDoctorCommand(program, config, logger, version) {
                 console.log(chalk.gray('\nTip: pass --check-api to verify API reachability.'));
             }
         };
-        const requiredLocalChecksPassed = nodeCompatible && missingRuntimePackages.length === 0 && sessionStorageWritable;
+        const requiredLocalChecksPassed = nodeCompatible
+            && missingRuntimePackages.length === 0
+            && sessionStorageWritable
+            && tempStorage.writable
+            && !tempStorage.sharedSystemTemp;
         const coderReachable = !options.checkApi || offline || report.apiHealth === 'online';
         if (!requiredLocalChecksPassed || !coderReachable) {
             if (!options.json)

package/dist/commands/repo.js

@@ -15,14 +15,13 @@
 import chalk from 'chalk';
 import * as fs from 'fs';
 import * as path from 'path';
-import { createRequire } from 'node:module';
 import { guardedFetch } from '../utils/network-policy.js';
 import { createSpinner, CH } from '../utils/logger.js';
 import { createOperationId } from '../utils/mutation-journal.js';
 import { containsHighConfidenceSecret, isSensitivePath, safeChildProcessEnv } from '../utils/secret-policy.js';
 import { CliCommandError, commandFailure, formatSuccessJson } from '../utils/command-contract.js';
+import { createRuntimeTempDirectory, removeRuntimeTempDirectory } from '../utils/runtime-temp.js';
 import { assertSafeDestinationPath, assertSafeRelativePath, inspectZipArchive, mergeValidatedWorkspace, resolveWorkspacePath, validateExtractedWorkspace, } from '../utils/workspace-boundary.js';
-const require = createRequire(import.meta.url);
 import inquirer from 'inquirer';
 const MAX_REPOSITORY_CONTENT_BYTES = 100 * 1024 * 1024;
 const MAX_REPOSITORY_REQUEST_BYTES = 120 * 1024 * 1024;
@@ -570,14 +569,13 @@ export class RepoCommand {
                     throw new Error('Failed to download project archive');
                 const archiveBuffer = Buffer.from(await archiveResponse.arrayBuffer());
                 inspectZipArchive(archiveBuffer);
-                const os = require('os');
-                const stagingRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'vigthoria-pull-'));
+                const stagingRoot = createRuntimeTempDirectory('repo-pull-');
                 const tempArchive = path.join(stagingRoot, 'archive.zip');
                 const extractedPath = path.join(stagingRoot, 'extracted');
                 try {
                     fs.mkdirSync(extractedPath, { mode: 0o700 });
                     fs.writeFileSync(tempArchive, archiveBuffer, { mode: 0o600 });
-                    if (os.platform() === 'win32') {
+                    if (process.platform === 'win32') {
                         const { execFileSync } = await import('child_process');
                         execFileSync('powershell', [
                             '-NoProfile', '-NonInteractive', '-Command',
@@ -600,12 +598,11 @@ export class RepoCommand {
                     mergeValidatedWorkspace(extractedPath, outputPath);
                 }
                 finally {
-                    fs.rmSync(stagingRoot, { recursive: true, force: true });
+                    removeRuntimeTempDirectory(stagingRoot);
                 }
             }
             else if (data.files) {
-                const os = require('os');
-                const stagingRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'vigthoria-pull-inline-'));
+                const stagingRoot = createRuntimeTempDirectory('repo-inline-');
                 try {
                     for (const file of data.files) {
                         const filePath = resolveWorkspacePath(stagingRoot, file.path, { allowMissing: true });
@@ -616,7 +613,7 @@ export class RepoCommand {
                     mergeValidatedWorkspace(stagingRoot, outputPath);
                 }
                 finally {
-                    fs.rmSync(stagingRoot, { recursive: true, force: true });
+                    removeRuntimeTempDirectory(stagingRoot);
                 }
             }
             else {

package/dist/commands/update-registration.js

@@ -1,7 +1,6 @@
 import { createHash } from 'node:crypto';
 import { execFileSync as execFileSyncProcess } from 'node:child_process';
 import * as fs from 'node:fs';
-import * as os from 'node:os';
 import * as path from 'node:path';
 import axios from 'axios';
 import chalk from 'chalk';
@@ -13,6 +12,7 @@ import { CliCommandError, commandFailure } from '../utils/command-contract.js';
 import { compareSemanticVersions as compareVersions, resolveUpdateSource } from '../utils/update-policy.js';
 import { assertReleaseTransition, assertReleaseUrl, getReleasePolicy, parseReleaseManifestText, verifyReleaseSignature } from '../utils/release-policy.js';
 import { installReleaseTransaction } from '../utils/release-install.js';
+import { createRuntimeTempDirectory, removeRuntimeTempDirectory } from '../utils/runtime-temp.js';
 function maxVersion(...versions) {
     let best = null;
     for (const version of versions) {
@@ -42,6 +42,34 @@ async function fetchNpmLatestVersion() {
     }
 }
 const VIGTHORIA_DEFAULT_MANIFEST_URL = getReleasePolicy().origins.manifest;
+const MAX_RELEASE_ARCHIVE_BYTES = 256 * 1024 * 1024;
+async function readBoundedResponse(response, maximumBytes) {
+    const declaredLength = Number(response.headers.get('content-length') || 0);
+    if (declaredLength > maximumBytes)
+        throw new Error(`Release archive exceeds the ${maximumBytes}-byte download limit.`);
+    if (!response.body)
+        return Buffer.alloc(0);
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > maximumBytes) {
+                await reader.cancel('release archive size limit exceeded');
+                throw new Error(`Release archive exceeds the ${maximumBytes}-byte download limit.`);
+            }
+            chunks.push(Buffer.from(value));
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return Buffer.concat(chunks, total);
+}
 async function downloadFile(url, targetPath, explicitLocal = false) {
     let bytes;
     if (explicitLocal) {
@@ -49,6 +77,8 @@ async function downloadFile(url, targetPath, explicitLocal = false) {
             responseType: 'arraybuffer',
             timeout: 20000,
             maxRedirects: 0,
+            maxContentLength: MAX_RELEASE_ARCHIVE_BYTES,
+            maxBodyLength: MAX_RELEASE_ARCHIVE_BYTES,
             validateStatus: (status) => status >= 200 && status < 300,
         });
         bytes = Buffer.from(response.data);
@@ -57,7 +87,7 @@ async function downloadFile(url, targetPath, explicitLocal = false) {
         const response = await guardedFetch(url, {}, { audience: 'release' });
         if (!response.ok)
             throw new Error(`Release download returned HTTP ${response.status}`);
-        bytes = Buffer.from(await response.arrayBuffer());
+        bytes = await readBoundedResponse(response, MAX_RELEASE_ARCHIVE_BYTES);
     }
     fs.writeFileSync(targetPath, bytes, { mode: 0o600, flag: 'wx' });
 }
@@ -156,7 +186,7 @@ export function registerUpdateCommand(program, version) {
                 let updateTempDirectory = null;
                 try {
                     if (source.kind === 'remote') {
-                        updateTempDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'vigthoria-update-'));
+                        updateTempDirectory = createRuntimeTempDirectory('update-');
                         installTarget = path.join(updateTempDirectory, 'candidate.tgz');
                         await downloadFile(source.downloadUrl, installTarget);
                     }
@@ -186,7 +216,7 @@ export function registerUpdateCommand(program, version) {
                 }
                 finally {
                     if (updateTempDirectory)
-                        fs.rmSync(updateTempDirectory, { recursive: true, force: true });
+                        removeRuntimeTempDirectory(updateTempDirectory);
                 }
                 console.log(chalk.green('Update installed successfully'));
                 console.log(chalk.gray('Please restart the CLI to use the new version'));
@@ -273,7 +303,7 @@ export function registerUpdateCommand(program, version) {
             && compareVersions(manifestEntry.version, effectiveLatest) >= 0
             && compareVersions(manifestEntry.version, currentVersion) > 0);
         if (manifestIsAuthoritative && manifestEntry) {
-            const updateTempDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'vigthoria-update-'));
+            const updateTempDirectory = createRuntimeTempDirectory('update-');
             const tmpFile = path.join(updateTempDirectory, 'candidate.tgz');
             try {
                 console.log(chalk.cyan(`Downloading release package (${manifestEntry.version})...`));
@@ -306,7 +336,7 @@ export function registerUpdateCommand(program, version) {
                 return;
             }
             finally {
-                fs.rmSync(updateTempDirectory, { recursive: true, force: true });
+                removeRuntimeTempDirectory(updateTempDirectory);
             }
         }
         const npmSpec = npmVersion && compareVersions(npmVersion, currentVersion) > 0

package/dist/index.js

@@ -50,6 +50,8 @@ import { installAxiosNetworkPolicy, installGlobalFetchPolicy } from './utils/net
 import { installConsoleRedaction } from './utils/secret-policy.js';
 import { commandNameFromArgv, failureEnvelope, normalizeCommandError, CliCommandError, } from './utils/command-contract.js';
 import { commandAuthRequirement, commanderCommandPath } from './utils/command-policy.js';
+import { initializeRuntimeTempStorage } from './utils/runtime-temp.js';
+initializeRuntimeTempStorage();
 applyLocalTestfarmDefaults();
 if (process.env.VIGTHORIA_CAPTURE_RUNTIME_MODEL !== '1')
     installConsoleRedaction();

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

@@ -8,6 +8,8 @@ export interface PreviewScreenshotPort {
 export declare class OptionalPuppeteerScreenshotAdapter implements PreviewScreenshotPort {
     private readonly loadPuppeteer;
     private readonly environment;
-    constructor(loadPuppeteer?: () => Promise<unknown>, environment?: NodeJS.ProcessEnv);
+    private readonly allocateTemp;
+    private readonly releaseTemp;
+    constructor(loadPuppeteer?: () => Promise<unknown>, environment?: NodeJS.ProcessEnv, allocateTemp?: (prefix: string) => string, releaseTemp?: (directory: string) => void);
     capture(entryAbsolutePath: string, screenshotPath: string): Promise<PreviewScreenshotResult>;
 }

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

@@ -1,11 +1,16 @@
 import { pathToFileURL } from 'node:url';
 import { redactSensitiveText } from './secret-policy.js';
+import { createRuntimeTempDirectory, removeRuntimeTempDirectory } from './runtime-temp.js';
 export class OptionalPuppeteerScreenshotAdapter {
     loadPuppeteer;
     environment;
-    constructor(loadPuppeteer = () => import('puppeteer'), environment = process.env) {
+    allocateTemp;
+    releaseTemp;
+    constructor(loadPuppeteer = () => import('puppeteer'), environment = process.env, allocateTemp = createRuntimeTempDirectory, releaseTemp = removeRuntimeTempDirectory) {
         this.loadPuppeteer = loadPuppeteer;
         this.environment = environment;
+        this.allocateTemp = allocateTemp;
+        this.releaseTemp = releaseTemp;
     }
     async capture(entryAbsolutePath, screenshotPath) {
         if (this.environment.VIGTHORIA_DISABLE_PREVIEW_SCREENSHOT === '1') {
@@ -17,15 +22,25 @@ export class OptionalPuppeteerScreenshotAdapter {
             if (!puppeteer || typeof puppeteer.launch !== 'function') {
                 return { captured: false, error: 'puppeteer optional adapter is not installed' };
             }
-            const browser = await puppeteer.launch({ headless: true, args: ['--no-sandbox', '--disable-setuid-sandbox'] });
+            const browserProfile = this.allocateTemp('browser-');
             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 });
+                const browser = await puppeteer.launch({
+                    headless: true,
+                    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();
+                }
             }
             finally {
-                await browser.close();
+                this.releaseTemp(browserProfile);
             }
             return { captured: true };
         }

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

@@ -0,0 +1,76 @@
+export interface RuntimeTempOptions {
+    homeDirectory?: string;
+    environment?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    now?: () => number;
+    pid?: number;
+    isProcessAlive?: (pid: number) => boolean;
+    systemTempDirectory?: string;
+}
+export interface RuntimeTempCleanupResult {
+    removedEntries: number;
+    removedBytes: number;
+    skippedActiveEntries: number;
+    legacyRemovedEntries: number;
+    legacyRemovedBytes: number;
+}
+export interface RuntimeTempStatus extends RuntimeTempCleanupResult {
+    root: string;
+    source: 'per-user-default' | 'explicit-override';
+    writable: boolean;
+    sharedSystemTemp: boolean;
+    maxBytes: number;
+    minimumFreeBytes: number;
+    ttlHours: number;
+    usedBytes: number;
+    entryCount: number;
+    freeBytes: number | null;
+    error: string | null;
+}
+export declare class RuntimeTempError extends Error {
+    readonly code: string;
+    readonly details: Record<string, unknown>;
+    constructor(message: string, code: string, details?: Record<string, unknown>);
+}
+export declare function resolveRuntimeTempRoot(options?: RuntimeTempOptions): {
+    root: string;
+    source: RuntimeTempStatus['source'];
+};
+export declare class RuntimeTempManager {
+    private readonly environment;
+    private readonly platform;
+    private readonly homeDirectory;
+    private readonly now;
+    private readonly pid;
+    private readonly isProcessAlive;
+    private readonly systemTempRoot;
+    private readonly configuredRoot;
+    private readonly source;
+    private readonly maxBytes;
+    private readonly minimumFreeBytes;
+    private readonly ttlMs;
+    private initializedRoot;
+    private initializedIdentity;
+    private initializationError;
+    private lastCleanup;
+    constructor(options?: RuntimeTempOptions);
+    initialize(): RuntimeTempStatus;
+    createDirectory(prefix?: string): string;
+    removeDirectory(directory: string): void;
+    scavenge(options?: {
+        includeLegacy?: boolean;
+    }): RuntimeTempCleanupResult;
+    status(): RuntimeTempStatus;
+    private requireRoot;
+    private readEntries;
+    private entrySize;
+    private freeBytes;
+    private measure;
+    private removeEntry;
+    private cleanupLegacySystemTemp;
+}
+export declare function getRuntimeTempManager(): RuntimeTempManager;
+export declare function initializeRuntimeTempStorage(): RuntimeTempStatus;
+export declare function runtimeTempStatus(): RuntimeTempStatus;
+export declare function createRuntimeTempDirectory(prefix: string): string;
+export declare function removeRuntimeTempDirectory(directory: string): void;

package/dist/utils/runtime-temp.js

@@ -0,0 +1,492 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+const MIB = 1024 * 1024;
+const DEFAULT_MAX_BYTES = 1024 * MIB;
+const DEFAULT_MIN_FREE_BYTES = 128 * MIB;
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+const CLEANUP_LOCK_MAX_AGE_MS = 10 * 60 * 1000;
+const MAX_SCAN_ENTRIES = 100_000;
+const LEASE_FILE = '.vigthoria-temp-lease.json';
+const CLEANUP_LOCK = '.vigthoria-temp-cleanup.lock';
+const ROOT_MARKER = '.vigthoria-temp-root.json';
+const LEGACY_CLEANUP_MARKER = '.vigthoria-legacy-temp-cleanup-v1';
+const LEGACY_PREFIXES = [
+    'vigthoria-pull-',
+    'vigthoria-pull-inline-',
+    'vigthoria-update-',
+    'vigthoria-cli-install-',
+    'puppeteer_dev_chrome_profile-',
+];
+export class RuntimeTempError extends Error {
+    code;
+    details;
+    constructor(message, code, details = {}) {
+        super(message);
+        this.name = 'RuntimeTempError';
+        this.code = code;
+        this.details = details;
+    }
+}
+function numericSetting(name, value, fallback, minimum, maximum) {
+    if (!value)
+        return fallback;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < minimum || parsed > maximum) {
+        throw new RuntimeTempError(`${name} must be a number between ${minimum} and ${maximum}.`, 'TEMP_SETTING_INVALID', {
+            setting: name,
+        });
+    }
+    return Math.floor(parsed);
+}
+function pathIsContained(root, candidate, pathApi) {
+    const relative = pathApi.relative(root, candidate);
+    return relative === '' || (!relative.startsWith(`..${pathApi.sep}`) && relative !== '..' && !pathApi.isAbsolute(relative));
+}
+function rejectUnsafeWindowsPath(value) {
+    const normalized = value.replace(/\//g, '\\');
+    if (/^\\\\[?.]\\/i.test(normalized) || /^\\\\/.test(normalized)) {
+        throw new RuntimeTempError('VIGTHORIA_TEMP_DIR cannot use a UNC or Windows device path.', 'TEMP_ROOT_UNSAFE');
+    }
+}
+function isKnownSharedPosixTemp(value) {
+    const normalized = path.posix.resolve(value);
+    return normalized === '/tmp' || normalized === '/var/tmp' || normalized === '/usr/tmp';
+}
+function pathsEqual(left, right, platform) {
+    const pathApi = platform === 'win32' ? path.win32 : path.posix;
+    const normalize = (value) => {
+        const resolved = pathApi.resolve(value);
+        return platform === 'win32' ? resolved.toLocaleLowerCase('en-US') : resolved;
+    };
+    return normalize(left) === normalize(right);
+}
+export function resolveRuntimeTempRoot(options = {}) {
+    const environment = options.environment || process.env;
+    const platform = options.platform || process.platform;
+    const pathApi = platform === 'win32' ? path.win32 : path.posix;
+    const homeDirectory = options.homeDirectory || os.homedir();
+    const override = String(environment.VIGTHORIA_TEMP_DIR || '').trim();
+    if (override.includes('\0'))
+        throw new RuntimeTempError('VIGTHORIA_TEMP_DIR contains a null byte.', 'TEMP_ROOT_UNSAFE');
+    if (platform === 'win32' && override)
+        rejectUnsafeWindowsPath(override);
+    if (override && !pathApi.isAbsolute(override)) {
+        throw new RuntimeTempError('VIGTHORIA_TEMP_DIR must be an absolute local path.', 'TEMP_ROOT_UNSAFE');
+    }
+    const root = pathApi.resolve(override || pathApi.join(homeDirectory, '.vigthoria', 'tmp'));
+    if (root === pathApi.parse(root).root) {
+        throw new RuntimeTempError('The filesystem root cannot be used for Vigthoria temporary storage.', 'TEMP_ROOT_UNSAFE');
+    }
+    return { root, source: override ? 'explicit-override' : 'per-user-default' };
+}
+function defaultProcessAlive(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error?.code === 'EPERM';
+    }
+}
+export class RuntimeTempManager {
+    environment;
+    platform;
+    homeDirectory;
+    now;
+    pid;
+    isProcessAlive;
+    systemTempRoot;
+    configuredRoot;
+    source;
+    maxBytes;
+    minimumFreeBytes;
+    ttlMs;
+    initializedRoot = null;
+    initializedIdentity = null;
+    initializationError = null;
+    lastCleanup = {
+        removedEntries: 0,
+        removedBytes: 0,
+        skippedActiveEntries: 0,
+        legacyRemovedEntries: 0,
+        legacyRemovedBytes: 0,
+    };
+    constructor(options = {}) {
+        this.environment = options.environment || process.env;
+        this.platform = options.platform || process.platform;
+        this.homeDirectory = options.homeDirectory || os.homedir();
+        this.now = options.now || Date.now;
+        this.pid = options.pid || process.pid;
+        this.isProcessAlive = options.isProcessAlive || defaultProcessAlive;
+        this.systemTempRoot = options.systemTempDirectory || os.tmpdir();
+        const resolved = resolveRuntimeTempRoot({ ...options, environment: this.environment, platform: this.platform, homeDirectory: this.homeDirectory });
+        this.configuredRoot = resolved.root;
+        this.source = resolved.source;
+        this.maxBytes = numericSetting('VIGTHORIA_TEMP_MAX_BYTES', this.environment.VIGTHORIA_TEMP_MAX_BYTES, DEFAULT_MAX_BYTES, 64 * MIB, 64 * 1024 * MIB);
+        this.minimumFreeBytes = numericSetting('VIGTHORIA_TEMP_MIN_FREE_BYTES', this.environment.VIGTHORIA_TEMP_MIN_FREE_BYTES, DEFAULT_MIN_FREE_BYTES, 64 * MIB, 64 * 1024 * MIB);
+        const ttlHours = numericSetting('VIGTHORIA_TEMP_TTL_HOURS', this.environment.VIGTHORIA_TEMP_TTL_HOURS, DEFAULT_TTL_MS / 3_600_000, 1, 720);
+        this.ttlMs = ttlHours * 3_600_000;
+    }
+    initialize() {
+        if (this.initializedRoot || this.initializationError)
+            return this.status();
+        try {
+            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');
+            }
+            const existed = fs.existsSync(this.configuredRoot);
+            if (existed && fs.lstatSync(this.configuredRoot).isSymbolicLink()) {
+                throw new RuntimeTempError('Vigthoria temporary storage root cannot be a symbolic link or junction.', 'TEMP_ROOT_SYMLINK');
+            }
+            fs.mkdirSync(this.configuredRoot, { recursive: true, mode: 0o700 });
+            if (fs.lstatSync(this.configuredRoot).isSymbolicLink()) {
+                throw new RuntimeTempError('Vigthoria temporary storage root cannot be a symbolic link or junction.', 'TEMP_ROOT_SYMLINK');
+            }
+            const realRoot = fs.realpathSync(this.configuredRoot);
+            const markerPath = path.join(realRoot, ROOT_MARKER);
+            if (this.source === 'explicit-override' && existed && !fs.existsSync(markerPath)) {
+                const existingEntries = fs.readdirSync(realRoot);
+                if (existingEntries.length > 0) {
+                    throw new RuntimeTempError('Explicit temporary storage must be empty or already marked as Vigthoria-managed.', 'TEMP_ROOT_NOT_DEDICATED');
+                }
+            }
+            const pathApi = this.platform === 'win32' ? path.win32 : path.posix;
+            if (pathsEqual(realRoot, this.systemTempRoot, 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');
+            }
+            if (this.source === 'per-user-default') {
+                const realHome = fs.realpathSync(this.homeDirectory);
+                if (!pathIsContained(realHome, realRoot, pathApi)) {
+                    throw new RuntimeTempError('Default temporary storage escaped the user home through a link.', 'TEMP_ROOT_ESCAPE');
+                }
+            }
+            if (this.platform !== 'win32')
+                fs.chmodSync(realRoot, 0o700);
+            if (!fs.existsSync(markerPath)) {
+                try {
+                    fs.writeFileSync(markerPath, `${JSON.stringify({ schemaVersion: 1, owner: 'vigthoria-cli', createdAt: new Date(this.now()).toISOString() })}\n`, {
+                        flag: 'wx',
+                        mode: 0o600,
+                    });
+                }
+                catch (error) {
+                    if (error?.code !== 'EEXIST')
+                        throw error;
+                }
+            }
+            const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
+            if (marker.schemaVersion !== 1 || marker.owner !== 'vigthoria-cli') {
+                throw new RuntimeTempError('Temporary storage ownership marker is invalid.', 'TEMP_ROOT_MARKER_INVALID');
+            }
+            const rootStat = fs.statSync(realRoot, { bigint: true });
+            const probe = path.join(realRoot, `.write-probe-${this.pid}-${this.now()}`);
+            fs.writeFileSync(probe, '', { flag: 'wx', mode: 0o600 });
+            fs.unlinkSync(probe);
+            this.initializedRoot = realRoot;
+            this.initializedIdentity = { dev: rootStat.dev, ino: rootStat.ino };
+            this.environment.TMPDIR = realRoot;
+            this.environment.TMP = realRoot;
+            this.environment.TEMP = realRoot;
+            this.lastCleanup = this.scavenge({ includeLegacy: true });
+        }
+        catch (error) {
+            this.initializationError = error instanceof Error ? error.message : String(error);
+        }
+        return this.status();
+    }
+    createDirectory(prefix = 'run-') {
+        this.initialize();
+        const root = this.requireRoot();
+        if (!/^[a-z0-9][a-z0-9-]{0,47}-$/i.test(prefix)) {
+            throw new RuntimeTempError('Temporary directory prefix is invalid.', 'TEMP_PREFIX_INVALID');
+        }
+        this.lastCleanup = this.scavenge({ includeLegacy: false });
+        const before = this.measure(root);
+        if (before.usedBytes >= this.maxBytes || (before.freeBytes !== null && before.freeBytes < this.minimumFreeBytes)) {
+            throw new RuntimeTempError('Vigthoria temporary storage has insufficient capacity after cleanup.', 'TEMP_CAPACITY_EXHAUSTED', {
+                root,
+                usedBytes: before.usedBytes,
+                maxBytes: this.maxBytes,
+                freeBytes: before.freeBytes,
+                minimumFreeBytes: this.minimumFreeBytes,
+            });
+        }
+        const directory = fs.mkdtempSync(path.join(root, prefix));
+        if (this.platform !== 'win32')
+            fs.chmodSync(directory, 0o700);
+        fs.writeFileSync(path.join(directory, LEASE_FILE), `${JSON.stringify({ schemaVersion: 1, pid: this.pid, createdAt: new Date(this.now()).toISOString() })}\n`, {
+            flag: 'wx',
+            mode: 0o600,
+        });
+        return directory;
+    }
+    removeDirectory(directory) {
+        const root = this.requireRoot();
+        const absolute = path.resolve(directory);
+        if (path.dirname(absolute) !== root || absolute === root) {
+            throw new RuntimeTempError('Refusing to remove a path outside the Vigthoria temporary root.', 'TEMP_CLEANUP_ESCAPE');
+        }
+        fs.rmSync(absolute, { recursive: true, force: true });
+    }
+    scavenge(options = {}) {
+        const root = this.requireRoot();
+        const result = {
+            removedEntries: 0,
+            removedBytes: 0,
+            skippedActiveEntries: 0,
+            legacyRemovedEntries: 0,
+            legacyRemovedBytes: 0,
+        };
+        const lockPath = path.join(root, CLEANUP_LOCK);
+        let lock = null;
+        try {
+            for (let attempt = 0; attempt < 3 && lock === null; attempt += 1) {
+                try {
+                    lock = fs.openSync(lockPath, 'wx', 0o600);
+                }
+                catch (error) {
+                    if (error?.code !== 'EEXIST')
+                        throw error;
+                    let lockAge = 0;
+                    try {
+                        lockAge = this.now() - fs.statSync(lockPath).mtimeMs;
+                    }
+                    catch (statError) {
+                        if (statError?.code === 'ENOENT')
+                            continue;
+                        throw statError;
+                    }
+                    if (lockAge <= CLEANUP_LOCK_MAX_AGE_MS)
+                        return result;
+                    try {
+                        fs.unlinkSync(lockPath);
+                    }
+                    catch (unlinkError) {
+                        if (unlinkError?.code !== 'ENOENT')
+                            throw unlinkError;
+                    }
+                }
+            }
+            if (lock === null)
+                return result;
+            fs.writeFileSync(lock, `${this.pid}\n`);
+            let entries = this.readEntries(root);
+            for (const entry of entries) {
+                if (entry.active) {
+                    result.skippedActiveEntries += 1;
+                    continue;
+                }
+                if (this.now() - entry.modifiedAt > this.ttlMs)
+                    this.removeEntry(entry, result);
+            }
+            entries = this.readEntries(root);
+            let measurement = this.measure(root, entries);
+            for (const entry of entries.filter((candidate) => !candidate.active).sort((left, right) => left.modifiedAt - right.modifiedAt)) {
+                if (measurement.usedBytes <= this.maxBytes && (measurement.freeBytes === null || measurement.freeBytes >= this.minimumFreeBytes))
+                    break;
+                this.removeEntry(entry, result);
+                measurement = this.measure(root);
+            }
+            if (options.includeLegacy && !fs.existsSync(path.join(root, LEGACY_CLEANUP_MARKER))) {
+                this.cleanupLegacySystemTemp(result);
+                try {
+                    fs.writeFileSync(path.join(root, LEGACY_CLEANUP_MARKER), `${new Date(this.now()).toISOString()}\n`, { flag: 'wx', mode: 0o600 });
+                }
+                catch (error) {
+                    if (error?.code !== 'EEXIST')
+                        throw error;
+                }
+            }
+            return result;
+        }
+        finally {
+            if (lock !== null) {
+                fs.closeSync(lock);
+                try {
+                    fs.unlinkSync(lockPath);
+                }
+                catch { /* another process may have recovered a stale lock */ }
+            }
+        }
+    }
+    status() {
+        const root = this.initializedRoot || this.configuredRoot;
+        let measurement = { usedBytes: 0, entryCount: 0, freeBytes: null };
+        let runtimeError = this.initializationError;
+        if (this.initializedRoot) {
+            try {
+                measurement = this.measure(this.requireRoot());
+            }
+            catch (error) {
+                runtimeError = error instanceof Error ? error.message : String(error);
+            }
+        }
+        return {
+            root,
+            source: this.source,
+            writable: Boolean(this.initializedRoot) && !runtimeError,
+            sharedSystemTemp: this.initializedRoot ? pathsEqual(this.initializedRoot, this.systemTempRoot, this.platform) : false,
+            maxBytes: this.maxBytes,
+            minimumFreeBytes: this.minimumFreeBytes,
+            ttlHours: this.ttlMs / 3_600_000,
+            usedBytes: measurement.usedBytes,
+            entryCount: measurement.entryCount,
+            freeBytes: measurement.freeBytes,
+            error: runtimeError,
+            ...this.lastCleanup,
+        };
+    }
+    requireRoot() {
+        if (!this.initializedRoot) {
+            throw new RuntimeTempError(this.initializationError || 'Vigthoria temporary storage is unavailable.', 'TEMP_STORAGE_UNAVAILABLE', {
+                root: this.configuredRoot,
+            });
+        }
+        try {
+            const stat = fs.lstatSync(this.initializedRoot);
+            const identity = fs.statSync(this.initializedRoot, { bigint: true });
+            if (stat.isSymbolicLink()
+                || fs.realpathSync(this.initializedRoot) !== this.initializedRoot
+                || !this.initializedIdentity
+                || identity.dev !== this.initializedIdentity.dev
+                || identity.ino !== this.initializedIdentity.ino) {
+                throw new Error('root identity changed');
+            }
+        }
+        catch {
+            throw new RuntimeTempError('Vigthoria temporary storage root changed after initialization.', 'TEMP_ROOT_CHANGED', {
+                root: this.initializedRoot,
+            });
+        }
+        return this.initializedRoot;
+    }
+    readEntries(root) {
+        const entries = [];
+        for (const name of fs.readdirSync(root)) {
+            if (name === CLEANUP_LOCK || name === ROOT_MARKER || name === LEGACY_CLEANUP_MARKER)
+                continue;
+            const absolutePath = path.join(root, name);
+            let stat;
+            try {
+                stat = fs.lstatSync(absolutePath);
+            }
+            catch (error) {
+                if (error?.code === 'ENOENT')
+                    continue;
+                throw error;
+            }
+            let active = false;
+            if (stat.isDirectory() && !stat.isSymbolicLink()) {
+                const leasePath = path.join(absolutePath, LEASE_FILE);
+                try {
+                    const lease = JSON.parse(fs.readFileSync(leasePath, 'utf8'));
+                    active = typeof lease.pid === 'number' && this.isProcessAlive(lease.pid);
+                }
+                catch { /* third-party and abandoned directories have no live lease */ }
+            }
+            entries.push({ absolutePath, name, bytes: this.entrySize(absolutePath), modifiedAt: stat.mtimeMs, active });
+        }
+        return entries;
+    }
+    entrySize(entryPath) {
+        let bytes = 0;
+        let visited = 0;
+        const walk = (candidate) => {
+            visited += 1;
+            if (visited > MAX_SCAN_ENTRIES) {
+                bytes = Math.max(bytes, this.maxBytes + 1);
+                return;
+            }
+            const stat = fs.lstatSync(candidate);
+            bytes += stat.size;
+            if (!stat.isDirectory() || stat.isSymbolicLink())
+                return;
+            for (const name of fs.readdirSync(candidate))
+                walk(path.join(candidate, name));
+        };
+        try {
+            walk(entryPath);
+        }
+        catch {
+            return this.maxBytes + 1;
+        }
+        return bytes;
+    }
+    freeBytes(root) {
+        try {
+            const stat = fs.statfsSync(root);
+            return Number(stat.bavail) * Number(stat.bsize);
+        }
+        catch {
+            return null;
+        }
+    }
+    measure(root, entries = this.readEntries(root)) {
+        return {
+            usedBytes: entries.reduce((total, entry) => total + entry.bytes, 0),
+            entryCount: entries.length,
+            freeBytes: this.freeBytes(root),
+        };
+    }
+    removeEntry(entry, result) {
+        if (path.dirname(entry.absolutePath) !== this.requireRoot()) {
+            throw new RuntimeTempError('Temporary cleanup target escaped its root.', 'TEMP_CLEANUP_ESCAPE');
+        }
+        fs.rmSync(entry.absolutePath, { recursive: true, force: true });
+        result.removedEntries += 1;
+        result.removedBytes += entry.bytes;
+    }
+    cleanupLegacySystemTemp(result) {
+        const legacyRoot = this.systemTempRoot;
+        if (!fs.existsSync(legacyRoot) || path.resolve(legacyRoot) === this.requireRoot())
+            return;
+        const currentUid = typeof process.getuid === 'function' ? process.getuid() : null;
+        if (currentUid === null)
+            return;
+        let scanned = 0;
+        for (const name of fs.readdirSync(legacyRoot)) {
+            scanned += 1;
+            if (scanned > MAX_SCAN_ENTRIES)
+                break;
+            if (!LEGACY_PREFIXES.some((prefix) => name.startsWith(prefix)))
+                continue;
+            const candidate = path.join(legacyRoot, name);
+            let stat;
+            try {
+                stat = fs.lstatSync(candidate);
+            }
+            catch {
+                continue;
+            }
+            if (currentUid !== null && stat.uid !== currentUid)
+                continue;
+            if (this.now() - stat.mtimeMs <= this.ttlMs)
+                continue;
+            const bytes = this.entrySize(candidate);
+            fs.rmSync(candidate, { recursive: true, force: true });
+            result.legacyRemovedEntries += 1;
+            result.legacyRemovedBytes += bytes;
+        }
+    }
+}
+let defaultManager = null;
+export function getRuntimeTempManager() {
+    defaultManager ||= new RuntimeTempManager();
+    return defaultManager;
+}
+export function initializeRuntimeTempStorage() {
+    return getRuntimeTempManager().initialize();
+}
+export function runtimeTempStatus() {
+    return getRuntimeTempManager().initialize();
+}
+export function createRuntimeTempDirectory(prefix) {
+    return getRuntimeTempManager().createDirectory(prefix);
+}
+export function removeRuntimeTempDirectory(directory) {
+    getRuntimeTempManager().removeDirectory(directory);
+}

package/dist/utils/tools.js

@@ -28,6 +28,7 @@ import { assertContainedAbsolutePath } from './workspace-boundary.js';
 import { assertProcessNetworkAllowed, buildApprovalScope, hardenGitArguments, parseGitArguments, parseSupportedProcess, safeGitEnvironment, } from './process-policy.js';
 import { containsHighConfidenceSecret, isSensitivePath, safeChildProcessEnv } from './secret-policy.js';
 import { isOfflineNetworkMode } from './network-policy.js';
+import { createRuntimeTempDirectory, removeRuntimeTempDirectory } from './runtime-temp.js';
 import { ToolApprovalService } from './tool-approval-service.js';
 import { DelegationToolProvider, FilesystemToolProvider, NetworkBrowserToolProvider, ProcessToolProvider, RepositoryToolProvider, SearchToolProvider, SshToolProvider, ToolCapabilityRegistry, } from './tool-capability-providers.js';
 const STREAM_RESPONSE_MAX_YIELD_CHARS = 32 * 1024;
@@ -1341,7 +1342,14 @@ export class AgenticTools {
         return errors;
     }
     validateJavaScriptSyntax(source) {
-        const tempFile = path.join(this.cwd, `.vigthoria-temp-${Date.now()}.js`);
+        let tempDirectory;
+        try {
+            tempDirectory = createRuntimeTempDirectory('syntax-');
+        }
+        catch (error) {
+            return this.formatExternalToolError('syntax_check', 'allocate bounded temporary storage', error);
+        }
+        const tempFile = path.join(tempDirectory, 'candidate.js');
         try {
             try {
                 fs.writeFileSync(tempFile, source, 'utf-8');
@@ -1360,9 +1368,7 @@ export class AgenticTools {
         }
         finally {
             this.cleanupAfterToolError('syntax_check', `remove temporary file ${tempFile}`, () => {
-                if (fs.existsSync(tempFile)) {
-                    fs.unlinkSync(tempFile);
-                }
+                removeRuntimeTempDirectory(tempDirectory);
             });
         }
     }

package/install.ps1

@@ -129,12 +129,42 @@ function Test-Prerequisites {
     return $true
 }
 
+function Get-VigthoriaTempRoot {
+    $explicitRoot = $env:VIGTHORIA_TEMP_DIR
+    $candidate = if ($explicitRoot) { $explicitRoot } else { Join-Path $env:USERPROFILE ".vigthoria\tmp" }
+    if (-not [IO.Path]::IsPathRooted($candidate)) { throw "VIGTHORIA_TEMP_DIR must be an absolute local path" }
+    if ($candidate.StartsWith("\\") -or $candidate.StartsWith("\\?\") -or $candidate.StartsWith("\\.\")) {
+        throw "VIGTHORIA_TEMP_DIR cannot use a UNC or Windows device path"
+    }
+    $fullRoot = [IO.Path]::GetFullPath($candidate).TrimEnd([IO.Path]::DirectorySeparatorChar)
+    $volumeRoot = [IO.Path]::GetPathRoot($fullRoot).TrimEnd([IO.Path]::DirectorySeparatorChar)
+    if ($fullRoot -eq $volumeRoot -or $fullRoot -eq [IO.Path]::GetTempPath().TrimEnd([IO.Path]::DirectorySeparatorChar)) {
+        throw "Refusing shared or filesystem-root temporary storage"
+    }
+    New-Item -ItemType Directory -Path $fullRoot -Force -ErrorAction Stop | Out-Null
+    $cursor = Get-Item -LiteralPath $fullRoot -Force -ErrorAction Stop
+    while ($cursor) {
+        if (($cursor.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0) {
+            throw "Refusing a reparse-point temporary storage path"
+        }
+        if ($cursor.FullName -eq [IO.Path]::GetPathRoot($cursor.FullName)) { break }
+        $cursor = $cursor.Parent
+    }
+    if (-not $explicitRoot) {
+        $homeRoot = [IO.Path]::GetFullPath($env:USERPROFILE).TrimEnd([IO.Path]::DirectorySeparatorChar)
+        if (-not ($fullRoot.Equals($homeRoot, [StringComparison]::OrdinalIgnoreCase) -or $fullRoot.StartsWith($homeRoot + [IO.Path]::DirectorySeparatorChar, [StringComparison]::OrdinalIgnoreCase))) {
+            throw "Default temporary storage escaped the user profile"
+        }
+    }
+    return $fullRoot
+}
+
 function Install-VigthoriaCLI-NPM {
     Write-Host ""
     Write-Host "[INSTALL] Installing Vigthoria CLI..." -ForegroundColor Cyan
 
     if ($HOSTED_TARBALL_SHA256) {
-        $releaseTemp = Join-Path ([IO.Path]::GetTempPath()) ("vigthoria-cli-install-" + [Guid]::NewGuid().ToString("N"))
+        $releaseTemp = Join-Path (Get-VigthoriaTempRoot) ("install-" + [Guid]::NewGuid().ToString("N"))
         $releaseArchive = Join-Path $releaseTemp "candidate.tgz"
         try {
             New-Item -ItemType Directory -Path $releaseTemp -Force | Out-Null
@@ -178,7 +208,7 @@ function Install-VigthoriaCLI-NPM {
 function Install-VigthoriaCLI-Direct {
     Write-Host ""
     Write-Host "[INSTALL] Installing Vigthoria CLI (Direct Download)..." -ForegroundColor Cyan
-    $releaseTemp = Join-Path ([IO.Path]::GetTempPath()) ("vigthoria-cli-direct-" + [Guid]::NewGuid().ToString("N"))
+    $releaseTemp = Join-Path (Get-VigthoriaTempRoot) ("direct-" + [Guid]::NewGuid().ToString("N"))
     $tarballPath = Join-Path $releaseTemp "candidate.tgz"
     try {
         if (-not $HOSTED_TARBALL_SHA256) { throw "Direct installation requires a signed manifest SHA-256" }

package/install.sh

@@ -211,6 +211,41 @@ check_requirements() {
 }
 
 # Install CLI
+prepare_temp_root() {
+    local requested_root="${VIGTHORIA_TEMP_DIR:-$HOME/.vigthoria/tmp}"
+    case "$requested_root" in
+        /*) ;;
+        *) echo -e "${RED}VIGTHORIA_TEMP_DIR must be an absolute local path${NC}" >&2; return 1 ;;
+    esac
+    if [[ "$requested_root" == "/" || "$requested_root" == "${TMPDIR:-/tmp}" ]]; then
+        echo -e "${RED}Refusing shared or filesystem-root temporary storage${NC}" >&2
+        return 1
+    fi
+    mkdir -p "$requested_root"
+    local path_cursor="$requested_root"
+    while [[ "$path_cursor" != "/" ]]; do
+        if [[ -L "$path_cursor" ]]; then
+            echo -e "${RED}Refusing a symbolic-link temporary storage path${NC}" >&2
+            return 1
+        fi
+        path_cursor="$(dirname -- "$path_cursor")"
+    done
+    local resolved_root resolved_home
+    resolved_root="$(cd "$requested_root" && pwd -P)"
+    resolved_home="$(cd "$HOME" && pwd -P)"
+    case "$resolved_root" in
+        /tmp|/var/tmp|/usr/tmp) echo -e "${RED}Refusing shared temporary storage${NC}" >&2; return 1 ;;
+    esac
+    if [[ -z "${VIGTHORIA_TEMP_DIR:-}" ]]; then
+        case "$resolved_root/" in
+            "$resolved_home/"*) ;;
+            *) echo -e "${RED}Default temporary storage escaped the user home${NC}" >&2; return 1 ;;
+        esac
+    fi
+    chmod 700 "$resolved_root"
+    printf '%s\n' "$resolved_root"
+}
+
 install_cli() {
     echo -e "${CYAN}Installing Vigthoria CLI...${NC}"
     
@@ -220,7 +255,8 @@ install_cli() {
     # Option 1: Download and verify the exact hosted release package.
     if [[ -n "$HOSTED_TARBALL_SHA256" ]]; then
         echo "Downloading checksum-verified hosted release package..."
-        RELEASE_TMP_DIR="$(mktemp -d "${TMPDIR:-/tmp}/vigthoria-cli-install.XXXXXX")"
+        VIGTHORIA_INSTALL_TEMP_ROOT="$(prepare_temp_root)" || return 1
+        RELEASE_TMP_DIR="$(mktemp -d "$VIGTHORIA_INSTALL_TEMP_ROOT/install.XXXXXX")"
         RELEASE_ARCHIVE="$RELEASE_TMP_DIR/vigthoria-cli-${CLI_VERSION}.tgz"
         if ! validate_release_url "$HOSTED_TARBALL_URL"; then
             echo -e "${RED}Refusing untrusted release artifact URL${NC}"

package/package.json

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

package/scripts/release/test-balanced-model-live.sh

@@ -18,7 +18,10 @@ if ! curl --silent --show-error --fail --connect-timeout 5 --max-time 15 "$MODEL
   block "balanced-model infrastructure is unavailable at the configured endpoint"
 fi
 
-PROBE_TMP="$(mktemp -d "${TMPDIR:-/tmp}/vigthoria-balanced-live.XXXXXX")"
+PROBE_TEMP_ROOT="${VIGTHORIA_TEMP_DIR:-$HOME/.vigthoria/tmp}/live-tests"
+mkdir -p "$PROBE_TEMP_ROOT"
+chmod 700 "$PROBE_TEMP_ROOT"
+PROBE_TMP="$(mktemp -d "$PROBE_TEMP_ROOT/balanced.XXXXXX")"
 trap 'rm -rf "$PROBE_TMP"' EXIT
 
 for attempt in 1 2 3; do

package/scripts/release/validate-live-service-gates.sh

@@ -15,7 +15,10 @@ block() {
 [[ -n "${VIGTHORIA_TEMPLATE_SERVICE_URL:-}" ]] || block "the live Template Service endpoint is not configured"
 [[ -x dist/index.js ]] || block "dist/index.js is unavailable; build the candidate first"
 
-LIVE_TMP="$(mktemp -d "${TMPDIR:-/tmp}/vigthoria-live-services.XXXXXX")"
+LIVE_TEMP_ROOT="${VIGTHORIA_TEMP_DIR:-$HOME/.vigthoria/tmp}/live-tests"
+mkdir -p "$LIVE_TEMP_ROOT"
+chmod 700 "$LIVE_TEMP_ROOT"
+LIVE_TMP="$(mktemp -d "$LIVE_TEMP_ROOT/services.XXXXXX")"
 trap 'rm -rf "$LIVE_TMP"' EXIT
 export VIGTHORIA_NO_BANNER=1
 export VIGTHORIA_NO_UPDATE_CHECK=1

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

@@ -4,12 +4,21 @@ set -euo pipefail
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
 cd "$ROOT"
 
-VALIDATION_TMP="$(mktemp -d "${TMPDIR:-/tmp}/vigthoria-no-go.XXXXXX")"
+VALIDATION_TEMP_ROOT="${VIGTHORIA_VALIDATION_TEMP_DIR:-$(dirname "$ROOT")/.vigthoria-cli-validation}"
+mkdir -p "$VALIDATION_TEMP_ROOT"
+chmod 700 "$VALIDATION_TEMP_ROOT"
+find "$VALIDATION_TEMP_ROOT" -mindepth 1 -maxdepth 1 -type d -name 'run.*' -mmin +1440 -user "$(id -un)" -exec rm -rf -- {} +
+VALIDATION_TMP="$(mktemp -d "$VALIDATION_TEMP_ROOT/run.XXXXXX")"
 trap 'rm -rf "$VALIDATION_TMP"' EXIT
 mkdir -p "$VALIDATION_TMP/home"
+mkdir -p "$VALIDATION_TMP/runtime-tmp"
+chmod 700 "$VALIDATION_TMP/runtime-tmp"
 
 export HOME="$VALIDATION_TMP/home"
 export USERPROFILE="$HOME"
+export TMPDIR="$VALIDATION_TMP/runtime-tmp"
+export TMP="$TMPDIR"
+export TEMP="$TMPDIR"
 export npm_config_cache="$VALIDATION_TMP/npm-cache"
 export npm_config_update_notifier=false
 export VIGTHORIA_NO_BANNER=1
@@ -77,6 +86,7 @@ node scripts/test-chat-prompt-policy.mjs
 node scripts/test-tool-capability-providers.mjs
 node scripts/test-agent-stream-state.mjs
 node scripts/test-direct-output-policy.mjs
+node scripts/test-runtime-temp.mjs
 
 echo "[0.8] authoritative Phase 2 state/auth/session contracts"
 node scripts/test-durable-json-state.mjs