vigthoria-cli 1.13.25 → 1.13.29

package/dist/utils/runtime-temp.js

@@ -4,11 +4,14 @@ 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_ALLOCATION_MAX_BYTES = 64 * MIB;
 const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
 const CLEANUP_LOCK_MAX_AGE_MS = 10 * 60 * 1000;
+const LOCK_RETRY_WAIT_MS = 20;
 const MAX_SCAN_ENTRIES = 100_000;
 const LEASE_FILE = '.vigthoria-temp-lease.json';
 const CLEANUP_LOCK = '.vigthoria-temp-cleanup.lock';
+const ALLOCATION_LOCK = '.vigthoria-temp-allocation.lock';
 const ROOT_MARKER = '.vigthoria-temp-root.json';
 const LEGACY_CLEANUP_MARKER = '.vigthoria-legacy-temp-cleanup-v1';
 const LEGACY_PREFIXES = [
@@ -18,6 +21,12 @@ const LEGACY_PREFIXES = [
     'vigthoria-cli-install-',
     'puppeteer_dev_chrome_profile-',
 ];
+// Capture the operating-system temp root before CLI initialization rewrites
+// TMP/TEMP/TMPDIR to the managed per-user root.  `os.tmpdir()` is dynamic on
+// Node: after the rewrite it returns the managed root, which previously meant
+// a second public RuntimeTempManager instance could mistake the original
+// shared %TEMP% for a safe explicit override.
+const PROCESS_START_SYSTEM_TEMP = os.tmpdir();
 export class RuntimeTempError extends Error {
     code;
     details;
@@ -51,7 +60,15 @@ function rejectUnsafeWindowsPath(value) {
 }
 function isKnownSharedPosixTemp(value) {
     const normalized = path.posix.resolve(value);
-    return normalized === '/tmp' || normalized === '/var/tmp' || normalized === '/usr/tmp';
+    return ['/tmp', '/var/tmp', '/usr/tmp'].some((root) => pathIsContained(root, normalized, path.posix));
+}
+function isWithinSharedTemp(candidate, root, 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 pathIsContained(normalize(root), normalize(candidate), pathApi);
 }
 function pathsEqual(left, right, platform) {
     const pathApi = platform === 'win32' ? path.win32 : path.posix;
@@ -91,6 +108,10 @@ function defaultProcessAlive(pid) {
         return error?.code === 'EPERM';
     }
 }
+function synchronousWait(milliseconds) {
+    const signal = new Int32Array(new SharedArrayBuffer(4));
+    Atomics.wait(signal, 0, 0, milliseconds);
+}
 export class RuntimeTempManager {
     environment;
     platform;
@@ -99,10 +120,12 @@ export class RuntimeTempManager {
     pid;
     isProcessAlive;
     systemTempRoot;
+    sharedTempRoots;
     configuredRoot;
     source;
     maxBytes;
     minimumFreeBytes;
+    allocationMaxBytes;
     ttlMs;
     initializedRoot = null;
     initializedIdentity = null;
@@ -121,12 +144,24 @@ 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 || (this.platform === process.platform ? PROCESS_START_SYSTEM_TEMP : os.tmpdir());
+        this.sharedTempRoots = [
+            options.systemTempDirectory,
+            platformTemp,
+            this.environment.TEMP,
+            this.environment.TMP,
+            this.environment.TMPDIR,
+            this.platform === process.platform ? PROCESS_START_SYSTEM_TEMP : 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;
         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);
+        this.allocationMaxBytes = numericSetting('VIGTHORIA_TEMP_ALLOCATION_MAX_BYTES', this.environment.VIGTHORIA_TEMP_ALLOCATION_MAX_BYTES, DEFAULT_ALLOCATION_MAX_BYTES, MIB, this.maxBytes);
         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;
     }
@@ -134,6 +169,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) => isWithinSharedTemp(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 +197,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) => isWithinSharedTemp(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');
             }
@@ -198,31 +241,53 @@ export class RuntimeTempManager {
         }
         return this.status();
     }
-    createDirectory(prefix = 'run-') {
+    createDirectory(prefix = 'run-', requestedMaxBytes = this.allocationMaxBytes) {
         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');
         }
+        if (!Number.isSafeInteger(requestedMaxBytes) || requestedMaxBytes < MIB || requestedMaxBytes > this.maxBytes) {
+            throw new RuntimeTempError('Temporary allocation reservation is outside the managed root contract.', 'TEMP_RESERVATION_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 allocationLock = this.acquireLock(path.join(root, ALLOCATION_LOCK));
+        if (allocationLock === null) {
+            throw new RuntimeTempError('Temporary allocation admission is busy.', 'TEMP_ALLOCATION_BUSY');
+        }
+        try {
+            const entries = this.readEntries(root);
+            const before = this.measure(root, entries);
+            const reservedBytes = entries.reduce((total, entry) => total + Math.max(entry.bytes, entry.active ? entry.reservedBytes : 0), 0);
+            if (reservedBytes + requestedMaxBytes > this.maxBytes
+                || (before.freeBytes !== null && before.freeBytes - requestedMaxBytes < this.minimumFreeBytes)) {
+                throw new RuntimeTempError('Vigthoria temporary storage has insufficient reserved capacity after cleanup.', 'TEMP_CAPACITY_EXHAUSTED', {
+                    root,
+                    usedBytes: before.usedBytes,
+                    reservedBytes,
+                    requestedMaxBytes,
+                    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(),
+                reservedMaxBytes: requestedMaxBytes,
+            })}\n`, {
+                flag: 'wx',
+                mode: 0o600,
             });
+            return directory;
+        }
+        finally {
+            this.releaseLock(path.join(root, ALLOCATION_LOCK), allocationLock);
         }
-        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();
@@ -230,7 +295,7 @@ export class RuntimeTempManager {
         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 });
+        fs.rmSync(absolute, { recursive: true, force: true, maxRetries: 8, retryDelay: 100 });
     }
     scavenge(options = {}) {
         const root = this.requireRoot();
@@ -262,6 +327,13 @@ export class RuntimeTempManager {
                     }
                     if (lockAge <= CLEANUP_LOCK_MAX_AGE_MS)
                         return result;
+                    let ownerPid = 0;
+                    try {
+                        ownerPid = Number(fs.readFileSync(lockPath, 'utf8').trim());
+                    }
+                    catch { /* malformed stale lock */ }
+                    if (ownerPid > 0 && this.isProcessAlive(ownerPid))
+                        return result;
                     try {
                         fs.unlinkSync(lockPath);
                     }
@@ -367,7 +439,7 @@ export class RuntimeTempManager {
     readEntries(root) {
         const entries = [];
         for (const name of fs.readdirSync(root)) {
-            if (name === CLEANUP_LOCK || name === ROOT_MARKER || name === LEGACY_CLEANUP_MARKER)
+            if (name === CLEANUP_LOCK || name === ALLOCATION_LOCK || name === ROOT_MARKER || name === LEGACY_CLEANUP_MARKER)
                 continue;
             const absolutePath = path.join(root, name);
             let stat;
@@ -380,15 +452,19 @@ export class RuntimeTempManager {
                 throw error;
             }
             let active = false;
+            let reservedBytes = 0;
             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);
+                    if (Number.isSafeInteger(lease.reservedMaxBytes) && Number(lease.reservedMaxBytes) > 0) {
+                        reservedBytes = Number(lease.reservedMaxBytes);
+                    }
                 }
                 catch { /* third-party and abandoned directories have no live lease */ }
             }
-            entries.push({ absolutePath, name, bytes: this.entrySize(absolutePath), modifiedAt: stat.mtimeMs, active });
+            entries.push({ absolutePath, name, bytes: this.entrySize(absolutePath), reservedBytes, modifiedAt: stat.mtimeMs, active });
         }
         return entries;
     }
@@ -436,10 +512,50 @@ export class RuntimeTempManager {
         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 });
+        fs.rmSync(entry.absolutePath, { recursive: true, force: true, maxRetries: 8, retryDelay: 100 });
         result.removedEntries += 1;
         result.removedBytes += entry.bytes;
     }
+    acquireLock(lockPath) {
+        for (let attempt = 0; attempt < 100; attempt += 1) {
+            try {
+                const descriptor = fs.openSync(lockPath, 'wx', 0o600);
+                fs.writeFileSync(descriptor, `${this.pid}\n`);
+                return descriptor;
+            }
+            catch (error) {
+                if (error?.code !== 'EEXIST')
+                    throw error;
+                try {
+                    if (this.now() - fs.statSync(lockPath).mtimeMs > CLEANUP_LOCK_MAX_AGE_MS) {
+                        let ownerPid = 0;
+                        try {
+                            ownerPid = Number(fs.readFileSync(lockPath, 'utf8').trim());
+                        }
+                        catch { /* malformed stale lock */ }
+                        if (ownerPid <= 0 || !this.isProcessAlive(ownerPid)) {
+                            fs.unlinkSync(lockPath);
+                            continue;
+                        }
+                    }
+                }
+                catch (lockError) {
+                    if (lockError?.code === 'ENOENT')
+                        continue;
+                    throw lockError;
+                }
+                synchronousWait(LOCK_RETRY_WAIT_MS);
+            }
+        }
+        return null;
+    }
+    releaseLock(lockPath, descriptor) {
+        fs.closeSync(descriptor);
+        try {
+            fs.unlinkSync(lockPath);
+        }
+        catch { /* stale-lock recovery may have raced */ }
+    }
     cleanupLegacySystemTemp(result) {
         const legacyRoot = this.systemTempRoot;
         if (!fs.existsSync(legacyRoot) || path.resolve(legacyRoot) === this.requireRoot())
@@ -467,7 +583,7 @@ export class RuntimeTempManager {
             if (this.now() - stat.mtimeMs <= this.ttlMs)
                 continue;
             const bytes = this.entrySize(candidate);
-            fs.rmSync(candidate, { recursive: true, force: true });
+            fs.rmSync(candidate, { recursive: true, force: true, maxRetries: 8, retryDelay: 100 });
             result.legacyRemovedEntries += 1;
             result.legacyRemovedBytes += bytes;
         }
@@ -484,8 +600,8 @@ export function initializeRuntimeTempStorage() {
 export function runtimeTempStatus() {
     return getRuntimeTempManager().initialize();
 }
-export function createRuntimeTempDirectory(prefix) {
-    return getRuntimeTempManager().createDirectory(prefix);
+export function createRuntimeTempDirectory(prefix, requestedMaxBytes) {
+    return getRuntimeTempManager().createDirectory(prefix, requestedMaxBytes);
 }
 export function removeRuntimeTempDirectory(directory) {
     getRuntimeTempManager().removeDirectory(directory);

package/dist/utils/tools.js

@@ -1344,7 +1344,7 @@ export class AgenticTools {
     validateJavaScriptSyntax(source) {
         let tempDirectory;
         try {
-            tempDirectory = createRuntimeTempDirectory('syntax-');
+            tempDirectory = createRuntimeTempDirectory('syntax-', 16 * 1024 * 1024);
         }
         catch (error) {
             return this.formatExternalToolError('syntax_check', 'allocate bounded temporary storage', error);

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,73 @@ 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 === 'error' && record.code === 'AGENT_PLAN_INVALID') {
+        throw new AgentPlanContractError(String(record.message || 'Agent plan graph is invalid.'));
+    }
+    if (record.type !== 'plan')
+        return;
+    // Accept every server envelope used by V3/Operator integrations, while
+    // ignoring planning keepalives that intentionally have no task graph.
+    const taskCandidate = record.plan?.tasks ?? record.tasks ?? record.data?.tasks;
+    if (!Array.isArray(taskCandidate))
+        return;
+    const tasks = taskCandidate;
+    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/dist/utils/v3-workspace-service.d.ts

@@ -21,6 +21,7 @@ export declare class V3WorkspaceService {
         relativePath: string;
         absolutePath: string;
     } | null;
+    private resolveCaseInsensitiveWorkspacePath;
     writeFile(rootPath: string, rawPath: string, content: string, sourceRoot?: string): boolean;
     deleteFile(rootPath: string, rawPath: string): boolean;
     recover(context?: Record<string, any>, streamedFiles?: Record<string, string>, expectedFiles?: string[]): void;

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

@@ -133,6 +133,14 @@ export class V3WorkspaceService {
     }
     extractExpectedFiles(message = '', context = {}) {
         const candidates = new Set();
+        if (Array.isArray(context.expectedFiles)) {
+            for (const value of context.expectedFiles) {
+                const filePath = String(value || '').trim().replace(/^\.\//, '');
+                if (filePath && !/^https?:\/\//i.test(filePath) && !isSensitivePath(filePath)) {
+                    candidates.add(filePath);
+                }
+            }
+        }
         for (const value of [message, context.rawMessage, context.agentPrompt]) {
             const text = String(value || '');
             const extensions = 'c|cc|cpp|cxx|h|hpp|cs|css|go|html|htm|ini|java|js|jsx|json|kt|kts|md|mjs|cjs|php|ps1|py|rb|rs|scss|sh|sql|svelte|toml|ts|tsx|txt|vue|xml|yaml|yml';
@@ -208,15 +216,44 @@ export class V3WorkspaceService {
         if (relativePath && isSensitivePath(relativePath))
             return null;
         try {
-            const absolutePath = relativePath
+            let absolutePath = relativePath
                 ? resolveWorkspacePath(rootPath, relativePath, { allowMissing: true })
                 : fs.realpathSync(path.resolve(rootPath));
+            if (relativePath && !fs.existsSync(absolutePath)) {
+                const canonical = this.resolveCaseInsensitiveWorkspacePath(rootPath, relativePath);
+                relativePath = canonical.relativePath;
+                absolutePath = canonical.absolutePath;
+            }
             return { relativePath: relativePath || '.', absolutePath };
         }
         catch {
             return null;
         }
     }
+    resolveCaseInsensitiveWorkspacePath(rootPath, relativePath) {
+        const suppliedSegments = relativePath.split('/').filter(Boolean);
+        const canonicalSegments = [];
+        let current = fs.realpathSync(path.resolve(rootPath));
+        for (let index = 0; index < suppliedSegments.length; index += 1) {
+            const supplied = suppliedSegments[index];
+            let selected = supplied;
+            if (fs.existsSync(current) && fs.statSync(current).isDirectory()) {
+                const exact = path.join(current, supplied);
+                if (!fs.existsSync(exact)) {
+                    const foldedMatches = fs.readdirSync(current).filter((entry) => entry.toLowerCase() === supplied.toLowerCase());
+                    if (foldedMatches.length === 1)
+                        selected = foldedMatches[0];
+                }
+            }
+            canonicalSegments.push(selected);
+            current = path.join(current, selected);
+        }
+        const canonicalRelative = canonicalSegments.join('/');
+        return {
+            relativePath: canonicalRelative,
+            absolutePath: resolveWorkspacePath(rootPath, canonicalRelative, { allowMissing: true }),
+        };
+    }
     writeFile(rootPath, rawPath, content, sourceRoot) {
         const relativePath = this.normalizeRelativePath(rawPath, sourceRoot || rootPath);
         if (!relativePath || isSensitivePath(relativePath)) {

package/dist/utils/vigflow-client.d.ts

@@ -61,6 +61,9 @@ export interface VigFlowTransport {
     post<T>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<{
         data: T;
     }>;
+    delete<T>(url: string, config?: AxiosRequestConfig): Promise<{
+        data: T;
+    }>;
 }
 export interface VigFlowClientDependencies {
     getBaseUrls(): string[];
@@ -76,6 +79,7 @@ export declare class VigFlowClient {
     clearCredentials(): void;
     private accessToken;
     private withBackend;
+    private withMutationBackend;
     private endpoint;
     listTemplates(options?: {
         category?: string;
@@ -92,4 +96,9 @@ export declare class VigFlowClient {
         executionOptions?: Record<string, unknown>;
     }): Promise<VigFlowExecutionResult>;
     executionStatus(executionId: string): Promise<VigFlowExecutionStatus>;
+    deleteWorkflow(selector: string): Promise<{
+        id: string;
+        name?: string;
+        alreadyDeleted?: boolean;
+    }>;
 }

package/dist/utils/vigflow-client.js

@@ -37,6 +37,29 @@ export class VigFlowClient {
         }
         throw new Error(`No VigFlow backend available for ${operation}. The workflow service is not deployed or not reachable.`);
     }
+    async withMutationBackend(operation, action) {
+        const authenticationErrors = [];
+        for (const baseUrl of this.dependencies.getBaseUrls()) {
+            let token;
+            try {
+                token = await this.accessToken(baseUrl);
+            }
+            catch (error) {
+                authenticationErrors.push(`${baseUrl}: ${error instanceof Error ? error.message : String(error)}`);
+                this.dependencies.debug(`VigFlow ${operation} authentication via ${baseUrl} failed:`, error instanceof Error ? error.message : String(error));
+                continue;
+            }
+            // Once a mutation request is dispatched its outcome can be ambiguous.
+            // Never repeat it against a different backend; callers must reconcile
+            // the operation by its identifier before choosing to retry.
+            return action(baseUrl, {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                Authorization: `Bearer ${token}`,
+            });
+        }
+        throw new Error(`No VigFlow backend accepted authentication for ${operation}. ${authenticationErrors.join(' | ')}`.trim());
+    }
     endpoint(baseUrl, subPath) {
         return /\/api\/vigflow\/?$/i.test(baseUrl) ? `${baseUrl.replace(/\/$/, '')}${subPath}` : `${baseUrl}/api${subPath}`;
     }
@@ -79,7 +102,7 @@ export class VigFlowClient {
         throw new Error(`No VigFlow workflow matched "${normalized}".`);
     }
     useTemplate(templateId, options = {}) {
-        return this.withBackend('use template', async (baseUrl, headers) => {
+        return this.withMutationBackend('use template', async (baseUrl, headers) => {
             const response = await this.transport.post(this.endpoint(baseUrl, `/templates/${encodeURIComponent(templateId)}/use`), scanOutboundContext({ name: options.name, variables: options.variables || {} }).value, { headers, timeout: 30_000 });
             if (!response.data.workflow?.id)
                 throw new Error('VigFlow use-template response did not include a workflow id.');
@@ -87,7 +110,7 @@ export class VigFlowClient {
         });
     }
     runWorkflow(workflowId, options = {}) {
-        return this.withBackend('run workflow', async (baseUrl, headers) => {
+        return this.withMutationBackend('run workflow', async (baseUrl, headers) => {
             const response = await this.transport.post(this.endpoint(baseUrl, `/executions/run/${encodeURIComponent(workflowId)}`), scanOutboundContext({ data: options.data || {}, options: options.executionOptions || {} }).value, { headers, timeout: 60_000 });
             if (!response.data.executionId)
                 throw new Error('VigFlow run response did not include an execution id.');
@@ -102,4 +125,27 @@ export class VigFlowClient {
             return response.data.execution;
         });
     }
+    async deleteWorkflow(selector) {
+        const normalized = String(selector || '').trim();
+        if (!normalized)
+            throw new Error('Workflow selector is required. Provide a workflow id or name.');
+        // Native VigFlow IDs can be retried idempotently without first listing an
+        // object that may already be gone. Human-readable names remain resolved
+        // through the ownership-scoped list to avoid ambiguous deletion.
+        const target = /^(?:wf_[a-z0-9_-]+|[0-9]+|[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})$/i.test(normalized)
+            ? { id: normalized, name: undefined }
+            : await this.resolveWorkflow(normalized);
+        return this.withMutationBackend('delete workflow', async (baseUrl, headers) => {
+            try {
+                const response = await this.transport.delete(this.endpoint(baseUrl, `/workflows/${encodeURIComponent(target.id)}`), { headers, timeout: 30_000 });
+                return { id: target.id, name: target.name, alreadyDeleted: response.data.alreadyDeleted === true };
+            }
+            catch (error) {
+                if (Number(error?.response?.status) === 404) {
+                    return { id: target.id, name: target.name, alreadyDeleted: true };
+                }
+                throw error;
+            }
+        });
+    }
 }

package/dist/utils/workspace-reference.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Return a stable, non-filesystem workspace label for hosted history APIs.
+ *
+ * Client absolute paths are private machine metadata and must never be used as
+ * server workspace roots.  File access is provided separately by the
+ * authenticated client-tool bridge.
+ */
+export declare function buildLocalWorkspaceReference(workspacePath: string, accountNamespace?: string): string;

package/dist/utils/workspace-reference.js

@@ -0,0 +1,21 @@
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+/**
+ * Return a stable, non-filesystem workspace label for hosted history APIs.
+ *
+ * Client absolute paths are private machine metadata and must never be used as
+ * server workspace roots.  File access is provided separately by the
+ * authenticated client-tool bridge.
+ */
+export function buildLocalWorkspaceReference(workspacePath, accountNamespace = '') {
+    const normalized = String(workspacePath || 'workspace').replace(/\\/g, '/').replace(/\/+$/, '');
+    const displayName = path.posix.basename(normalized) || 'workspace';
+    const canonicalIdentity = process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+    const opaqueId = createHash('sha256')
+        .update(String(accountNamespace || 'anonymous'))
+        .update('\0')
+        .update(canonicalIdentity)
+        .digest('hex')
+        .slice(0, 24);
+    return `vigthoria://local-workspace/${encodeURIComponent(displayName)}?id=${opaqueId}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.13.25",
+  "version": "1.13.29",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "type": "module",
   "main": "dist/index.js",
@@ -84,13 +84,14 @@
     "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:workspace:reference": "npm run build && node scripts/test-workspace-reference.mjs",
     "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:external-client-resume": "npm run build && node scripts/test-external-client-resume.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",
     "test:v3-client-tool-quality": "npm run build && node scripts/test-v3-client-tool-quality.mjs",
-    "test:pitfall:context": "npm run build && node scripts/test-pitfall-context-smoke.js",
+    "test:pitfall:context": "npm run build && node scripts/test-pitfall-context-smoke.mjs",
     "test:game:command": "node scripts/test-game-command.mjs",
     "test:security:dependencies": "node scripts/test-dependency-security.mjs",
     "test:security:network": "npm run build && node scripts/test-network-policy.mjs && node scripts/test-installer-trust-policy.mjs && node scripts/test-local-security-service.mjs",
@@ -131,7 +132,6 @@
     "marked": "^11.0.0",
     "marked-terminal": "^6.2.0",
     "ora": "^7.0.1",
-    "puppeteer": "^24.40.0",
     "ws": "^8.14.2"
   },
   "devDependencies": {
@@ -148,8 +148,6 @@
   "overrides": {
     "glob": "^13.0.6",
     "brace-expansion": "5.0.9",
-    "fast-uri": "3.1.5",
-    "ip-address": "10.3.1",
-    "js-yaml": "4.3.1"
+    "fast-uri": "3.1.5"
   }
 }