vigthoria-cli 1.13.31 → 1.13.42

package/dist/commands/update-registration.js

@@ -8,39 +8,11 @@ import { CH } from '../utils/logger.js';
 import { isOfflineMode, isUpdateCheckSuppressed, readCachedLatestVersion, writeCachedLatestVersion } from '../utils/cli-state.js';
 import { guardedFetch } from '../utils/network-policy.js';
 import { safeChildProcessEnv } from '../utils/secret-policy.js';
-import { CliCommandError, commandFailure } from '../utils/command-contract.js';
-import { compareSemanticVersions as compareVersions, resolveUpdateSource } from '../utils/update-policy.js';
+import { CliCommandError } from '../utils/command-contract.js';
+import { compareSemanticVersions as compareVersions } 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) {
-        if (!version)
-            continue;
-        if (!best || compareVersions(version, best) > 0)
-            best = version;
-    }
-    return best;
-}
-async function fetchNpmLatestVersion() {
-    try {
-        // Hard 5s timeout: a slow/blocked path to the public npm registry must
-        // never hang the caller (e.g. the Workbench's blocking `vigthoria update`
-        // invocation) indefinitely.
-        const latest = execFileSyncProcess(process.platform === 'win32' ? 'npm.cmd' : 'npm', ['view', 'vigthoria-cli', 'version'], {
-            encoding: 'utf8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-            windowsHide: true,
-            timeout: 5000,
-            env: safeChildProcessEnv(),
-        }).trim();
-        return latest || null;
-    }
-    catch {
-        return null;
-    }
-}
 const VIGTHORIA_DEFAULT_MANIFEST_URL = getReleasePolicy().origins.manifest;
 const MAX_RELEASE_ARCHIVE_BYTES = 256 * 1024 * 1024;
 async function readBoundedResponse(response, maximumBytes) {
@@ -114,15 +86,31 @@ function renderUpdateBanner(latestVersion, version) {
         console.log(chalk.red.bold(`\n${CH.warnEmoji}  SECURITY UPDATE AVAILABLE`));
         console.log(chalk.red(`   Version ${version} has security vulnerabilities.`));
         console.log(chalk.yellow(`   Please update to ${latestVersion} immediately:`));
-        console.log(chalk.white.bold('   npm install -g vigthoria-cli@latest\n'));
+        console.log(chalk.white.bold('   vigthoria update\n'));
     }
     else {
         console.log(chalk.yellow(`\n${CH.warnEmoji}  Update available: ${version} -> ${latestVersion}`));
         console.log(chalk.gray('   Run `vigthoria update` to install\n'));
     }
 }
-// Check for updates quietly on startup. Cached (24 h) so we never block
-// startup on `npm view`. Honours VIGTHORIA_OFFLINE / VIGTHORIA_NO_UPDATE_CHECK.
+async function fetchVerifiedManifestEntry(manifestUrl, channel) {
+    assertReleaseUrl(manifestUrl, 'manifest');
+    const response = await guardedFetch(manifestUrl, {
+        headers: { Accept: 'application/json' },
+    }, { audience: 'release', maxRedirects: getReleasePolicy().origins.maximumRedirects });
+    if (!response.ok)
+        throw new Error(`Manifest returned HTTP ${response.status}`);
+    const entry = parseReleaseManifestText(await response.text(), channel);
+    const signatureResponse = await guardedFetch(entry.signature.url, {
+        headers: { Accept: 'application/octet-stream' },
+    }, { audience: 'release', maxRedirects: getReleasePolicy().origins.maximumRedirects });
+    if (!signatureResponse.ok)
+        throw new Error(`Detached signature returned HTTP ${signatureResponse.status}`);
+    verifyReleaseSignature(channel, entry, await signatureResponse.text());
+    return entry;
+}
+// Check the signed extension manifest quietly on startup. Cached (24 h) so
+// startup does not repeatedly reach the network. No registry fallback exists.
 export async function checkForUpdatesQuietly(version) {
     if (isUpdateCheckSuppressed()) {
         return;
@@ -134,26 +122,15 @@ export async function checkForUpdatesQuietly(version) {
         }
         return;
     }
-    // Cache miss: probe npm registry in the background, with a hard 5 s
-    // timeout. Result is cached for 24 h so subsequent runs are instant.
     try {
-        const npmVersion = execFileSyncProcess(process.platform === 'win32' ? 'npm.cmd' : 'npm', ['view', 'vigthoria-cli', 'version'], {
-            encoding: 'utf8',
-            timeout: 5000,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            windowsHide: true,
-            env: safeChildProcessEnv(),
-        }).trim();
-        if (!npmVersion) {
-            return;
-        }
-        writeCachedLatestVersion(npmVersion);
-        if (compareVersions(npmVersion, version) > 0) {
-            renderUpdateBanner(npmVersion, version);
+        const entry = await fetchVerifiedManifestEntry(VIGTHORIA_DEFAULT_MANIFEST_URL, 'stable');
+        writeCachedLatestVersion(entry.version);
+        if (compareVersions(entry.version, version) > 0) {
+            renderUpdateBanner(entry.version, version);
         }
     }
     catch {
-        // Network or npm failure should never block CLI; do not cache failure.
+        // Network/signature failure never blocks startup and is never cached.
     }
 }
 export function registerUpdateCommand(program, version) {
@@ -163,72 +140,13 @@ export function registerUpdateCommand(program, version) {
         .alias('upgrade')
         .description('Check for updates and upgrade Vigthoria CLI. Default manifest: https://extension.vigthoria.io/downloads/manifest.json')
         .option('-c, --check', 'Only check for updates, don\'t install')
-        .option('-f, --from <target>', 'Install from exact vigthoria-cli@version, local .tgz, or trusted HTTPS .tgz')
-        .option('--sha256 <hex>', 'Required SHA-256 for HTTPS archives; optional verification for local archives')
         .option('-m, --manifest <url>', 'Update manifest URL for server-driven releases')
         .option('--channel <name>', 'Release channel to use from manifest (default: stable)', 'stable')
         .option('--allow-downgrade', 'Allow installing an older version from custom update source')
         .action(async (options) => {
-        const updateTarget = typeof options.from === 'string' ? options.from.trim() : '';
         const manifestUrl = typeof options.manifest === 'string' ? options.manifest.trim() : VIGTHORIA_DEFAULT_MANIFEST_URL.trim();
         const channel = typeof options.channel === 'string' ? options.channel.trim() : 'stable';
         const allowDowngrade = !!options.allowDowngrade;
-        if (updateTarget) {
-            const source = resolveUpdateSource(updateTarget, { sha256: options.sha256 });
-            try {
-                if (options.check) {
-                    console.log(chalk.cyan(`Update source validated (${source.kind}): ${updateTarget}`));
-                    console.log(chalk.gray('Run `vigthoria update --from <target>` to install from this source'));
-                    return;
-                }
-                console.log(chalk.cyan(`Installing update from ${updateTarget}...`));
-                let installTarget = source.kind === 'remote' ? '' : source.installTarget;
-                let updateTempDirectory = null;
-                try {
-                    if (source.kind === 'remote') {
-                        updateTempDirectory = createRuntimeTempDirectory('update-', 320 * 1024 * 1024);
-                        installTarget = path.join(updateTempDirectory, 'candidate.tgz');
-                        await downloadFile(source.downloadUrl, installTarget);
-                    }
-                    if (source.expectedSha256) {
-                        const actual = sha256File(installTarget).toLowerCase();
-                        if (actual !== source.expectedSha256) {
-                            throw new CliCommandError('Update archive checksum verification failed.', {
-                                code: 'UPDATE_CHECKSUM_MISMATCH',
-                                details: { expected: source.expectedSha256, actual },
-                            });
-                        }
-                    }
-                    const identity = source.kind === 'registry'
-                        ? { name: getReleasePolicy().packageName, version: installTarget.slice(installTarget.lastIndexOf('@') + 1) }
-                        : inspectReleaseArchive(installTarget);
-                    if (identity.name !== getReleasePolicy().packageName) {
-                        throw new CliCommandError('Update archive package identity is not vigthoria-cli.', { code: 'UPDATE_PACKAGE_IDENTITY_INVALID' });
-                    }
-                    if (!allowDowngrade && compareVersions(identity.version, version) < 0) {
-                        throw new CliCommandError(`Downgrade from ${version} to ${identity.version} requires --allow-downgrade.`, { code: 'UPDATE_DOWNGRADE_PROHIBITED' });
-                    }
-                    const installed = installReleaseTransaction(installTarget, identity.version, {
-                        ...(source.kind === 'registry' ? { npmRegistry: 'https://registry.npmjs.org/' } : {}),
-                    });
-                    console.log(chalk.gray(`Versioned installation: ${installed.versionDirectory}`));
-                    console.log(chalk.gray(`Active pointer: ${installed.currentLink}`));
-                }
-                finally {
-                    if (updateTempDirectory)
-                        removeRuntimeTempDirectory(updateTempDirectory);
-                }
-                console.log(chalk.green('Update installed successfully'));
-                console.log(chalk.gray('Please restart the CLI to use the new version'));
-                return;
-            }
-            catch (error) {
-                throw commandFailure(error, {
-                    code: 'UPDATE_INSTALL_FAILED',
-                    message: `Failed to install the validated ${source.kind} update source.`,
-                });
-            }
-        }
         if (isOfflineMode()) {
             console.log(chalk.yellow('Offline mode (VIGTHORIA_OFFLINE=1): skipping update check.'));
             return;
@@ -237,55 +155,25 @@ export function registerUpdateCommand(program, version) {
         let manifestEntry = null;
         if (manifestUrl) {
             try {
-                assertReleaseUrl(manifestUrl, 'manifest');
                 console.log(chalk.cyan(`Checking manifest channel ${channel}...`));
-                const response = await guardedFetch(manifestUrl, {
-                    headers: { Accept: 'application/json' },
-                }, { audience: 'release', maxRedirects: getReleasePolicy().origins.maximumRedirects });
-                if (!response.ok)
-                    throw new Error(`Manifest returned HTTP ${response.status}`);
-                const manifestText = await response.text();
-                manifestEntry = parseReleaseManifestText(manifestText, channel);
-                const signatureResponse = await guardedFetch(manifestEntry.signature.url, {
-                    headers: { Accept: 'application/octet-stream' },
-                }, { audience: 'release', maxRedirects: getReleasePolicy().origins.maximumRedirects });
-                if (!signatureResponse.ok)
-                    throw new Error(`Detached signature returned HTTP ${signatureResponse.status}`);
-                verifyReleaseSignature(channel, manifestEntry, await signatureResponse.text());
+                manifestEntry = await fetchVerifiedManifestEntry(manifestUrl, channel);
                 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)
                     throw error;
-                console.log(chalk.yellow(`Manifest check failed: ${error.message}`));
-                console.log(chalk.gray('Continuing with the exact-version npm registry fallback...'));
-            }
-        }
-        // The release manifest (server-curated, sha256-verified) is the
-        // authoritative source of truth for this private CLI. Only fall back
-        // to probing the public npm registry when the manifest itself has no
-        // usable entry - never let an npm version number override a valid,
-        // verified manifest entry (npm install -g against the public registry
-        // is slower, unverified, and has previously caused the Workbench's
-        // update button to hang for minutes).
-        let npmVersion = null;
-        if (manifestEntry?.version && manifestEntry?.url) {
-            console.log(chalk.gray('Release manifest has a valid entry; skipping public npm registry lookup.'));
-        }
-        else {
-            console.log(chalk.cyan('Checking npm registry...'));
-            npmVersion = await fetchNpmLatestVersion();
-            if (!npmVersion) {
-                console.log(chalk.yellow('Could not read latest version from npm registry.'));
+                throw new CliCommandError(`Signed extension release manifest is unavailable: ${error.message}`, {
+                    code: 'UPDATE_MANIFEST_UNAVAILABLE',
+                    category: 'network',
+                });
             }
         }
-        const effectiveLatest = maxVersion(manifestEntry?.version, npmVersion);
-        if (!effectiveLatest) {
-            throw new CliCommandError('Unable to determine the latest CLI version from manifest or npm.', {
-                code: 'UPDATE_VERSION_UNAVAILABLE',
+        if (!manifestEntry)
+            throw new CliCommandError('Signed extension release manifest is unavailable.', {
+                code: 'UPDATE_MANIFEST_UNAVAILABLE',
                 category: 'network',
             });
-        }
+        const effectiveLatest = manifestEntry.version;
         if (!allowDowngrade && compareVersions(effectiveLatest, currentVersion) <= 0) {
             console.log(chalk.green(`You are running the latest version (${currentVersion})`));
             return;
@@ -298,72 +186,41 @@ export function registerUpdateCommand(program, version) {
             console.log(chalk.gray('Run `vigthoria update` to install the update'));
             return;
         }
-        const manifestIsAuthoritative = Boolean(manifestEntry
-            && manifestEntry.url
-            && compareVersions(manifestEntry.version, effectiveLatest) >= 0
-            && compareVersions(manifestEntry.version, currentVersion) > 0);
-        if (manifestIsAuthoritative && manifestEntry) {
-            assertReleaseTransition(currentVersion, manifestEntry, channel, allowDowngrade);
-            const updateTempDirectory = createRuntimeTempDirectory('update-', 320 * 1024 * 1024);
-            const tmpFile = path.join(updateTempDirectory, 'candidate.tgz');
-            try {
-                console.log(chalk.cyan(`Downloading release package (${manifestEntry.version})...`));
-                await downloadFile(manifestEntry.url, tmpFile);
-                const expected = String(manifestEntry.sha256).toLowerCase();
-                const actual = sha256File(tmpFile).toLowerCase();
-                if (actual !== expected) {
-                    throw new CliCommandError('Release checksum verification failed.', {
-                        code: 'UPDATE_CHECKSUM_MISMATCH',
-                        details: { expected, actual },
-                    });
-                }
-                if (fs.statSync(tmpFile).size !== manifestEntry.size) {
-                    throw new CliCommandError('Release archive size does not match signed manifest metadata.', {
-                        code: 'UPDATE_SIZE_MISMATCH',
-                    });
-                }
-                console.log(chalk.green('Checksum verification passed'));
-                console.log(chalk.cyan('Installing update...'));
-                const identity = inspectReleaseArchive(tmpFile);
-                if (identity.name !== manifestEntry.packageName || identity.version !== manifestEntry.packageVersion) {
-                    throw new CliCommandError('Release archive package metadata conflicts with signed manifest identity.', {
-                        code: 'UPDATE_PACKAGE_IDENTITY_INVALID',
-                    });
-                }
-                const installed = installReleaseTransaction(tmpFile, manifestEntry.version);
-                console.log(chalk.gray(`Versioned installation: ${installed.versionDirectory}`));
-                console.log(chalk.green(`Updated to version ${manifestEntry.version}`));
-                console.log(chalk.gray('Please restart the CLI to use the new version'));
-                return;
+        assertReleaseTransition(currentVersion, manifestEntry, channel, allowDowngrade);
+        const updateTempDirectory = createRuntimeTempDirectory('update-', 320 * 1024 * 1024);
+        const tmpFile = path.join(updateTempDirectory, 'candidate.tgz');
+        try {
+            console.log(chalk.cyan(`Downloading release package (${manifestEntry.version})...`));
+            await downloadFile(manifestEntry.url, tmpFile);
+            const expected = String(manifestEntry.sha256).toLowerCase();
+            const actual = sha256File(tmpFile).toLowerCase();
+            if (actual !== expected) {
+                throw new CliCommandError('Release checksum verification failed.', {
+                    code: 'UPDATE_CHECKSUM_MISMATCH',
+                    details: { expected, actual },
+                });
             }
-            finally {
-                removeRuntimeTempDirectory(updateTempDirectory);
+            if (fs.statSync(tmpFile).size !== manifestEntry.size) {
+                throw new CliCommandError('Release archive size does not match signed manifest metadata.', {
+                    code: 'UPDATE_SIZE_MISMATCH',
+                });
             }
-        }
-        const npmSpec = npmVersion && compareVersions(npmVersion, currentVersion) > 0
-            ? `vigthoria-cli@${npmVersion}`
-            : `vigthoria-cli@${effectiveLatest}`;
-        try {
-            const registrySource = resolveUpdateSource(npmSpec);
-            if (registrySource.kind !== 'registry') {
-                throw new CliCommandError('Registry fallback did not resolve to an exact package version.', {
-                    code: 'UPDATE_REGISTRY_SOURCE_INVALID',
-                    category: 'configuration',
+            console.log(chalk.green('Checksum verification passed'));
+            console.log(chalk.cyan('Installing update...'));
+            const identity = inspectReleaseArchive(tmpFile);
+            if (identity.name !== manifestEntry.packageName || identity.version !== manifestEntry.packageVersion) {
+                throw new CliCommandError('Release archive package metadata conflicts with signed manifest identity.', {
+                    code: 'UPDATE_PACKAGE_IDENTITY_INVALID',
                 });
             }
-            console.log(chalk.cyan(`Installing update from npm registry (${npmSpec})...`));
-            const installed = installReleaseTransaction(registrySource.installTarget, effectiveLatest, {
-                npmRegistry: 'https://registry.npmjs.org/',
-            });
+            const installed = installReleaseTransaction(tmpFile, manifestEntry.version);
             console.log(chalk.gray(`Versioned installation: ${installed.versionDirectory}`));
-            console.log(chalk.green(`Updated to version ${effectiveLatest}`));
+            console.log(chalk.green(`Updated to version ${manifestEntry.version}`));
             console.log(chalk.gray('Please restart the CLI to use the new version'));
+            return;
         }
-        catch (error) {
-            throw commandFailure(error, {
-                code: 'UPDATE_REGISTRY_INSTALL_FAILED',
-                message: `Failed to install the exact registry package ${npmSpec}.`,
-            });
+        finally {
+            removeRuntimeTempDirectory(updateTempDirectory);
         }
     });
 }

package/dist/commands/v4-menu.d.ts

@@ -1,7 +1,6 @@
 export interface V4MenuOptions {
     defaultAgent?: string;
     defaultProvider?: string;
-    byokApiKey?: string;
     byokBaseUrl?: string;
     byokModel?: string;
     outFile: string;

package/dist/commands/v4-menu.js

@@ -18,7 +18,9 @@ function isCancelError(error) {
     return name === 'ExitPromptError' || name === 'ERR_CLOSED';
 }
 function writeResult(outFile, result) {
-    fs.writeFileSync(outFile, JSON.stringify(result), 'utf8');
+    fs.writeFileSync(outFile, JSON.stringify(result), { encoding: 'utf8', mode: 0o600 });
+    if (process.platform !== 'win32')
+        fs.chmodSync(outFile, 0o600);
 }
 export async function runV4Menu(options) {
     const defaultAgent = options.defaultAgent === 'v4' ? 'v4' : 'v3';
@@ -71,16 +73,16 @@ export async function runV4Menu(options) {
             writeResult(options.outFile, { agent: 'v4', provider });
             return;
         }
-        const existingApiKey = String(options.byokApiKey || '').trim();
+        const existingApiKey = String(process.env.VIGTHORIA_BYOK_API_KEY || '').trim();
         const existingBaseUrl = String(options.byokBaseUrl || '').trim();
         const existingModel = String(options.byokModel || '').trim();
-        const missing = !existingApiKey || !existingBaseUrl || !existingModel;
+        const missingDefaults = !existingBaseUrl || !existingModel;
         const questions = [];
         if (!existingApiKey) {
             questions.push({
                 type: 'password',
                 name: 'apiKey',
-                message: 'BYOK API key:',
+                message: 'BYOK API key (used for this session only):',
                 mask: '*',
                 validate: (value) => (String(value || '').trim() ? true : 'API key is required.'),
             });
@@ -106,12 +108,12 @@ export async function runV4Menu(options) {
         const baseUrl = String(answers.baseUrl || existingBaseUrl).trim();
         const model = String(answers.model || existingModel).trim();
         let save = false;
-        if (missing) {
+        if (missingDefaults) {
             const { saveLocally } = await inquirer.prompt([
                 {
                     type: 'confirm',
                     name: 'saveLocally',
-                    message: 'Store BYOK values locally in ~/.config/vigthoria/config.yaml?',
+                    message: 'Store the non-secret base URL and model locally? (The API key is never stored.)',
                     default: true,
                 },
             ]);

package/dist/commands/v4-registration.js

@@ -7,7 +7,6 @@ export function registerV4Commands(program, config, logger) {
         .description('Internal: interactive V3/V4 agent + provider picker used by the V4 Operating Agent launcher')
         .option('--default-agent <agent>', 'v3 | v4', 'v3')
         .option('--default-provider <provider>', 'cloud | v3_local | byok', 'cloud')
-        .option('--byok-api-key <key>', 'Existing BYOK api key', '')
         .option('--byok-base-url <url>', 'Existing BYOK base url', '')
         .option('--byok-model <name>', 'Existing BYOK model', '')
         .requiredOption('--out-file <path>', 'Write JSON selection result to this file')
@@ -15,7 +14,6 @@ export function registerV4Commands(program, config, logger) {
         await runV4Menu({
             defaultAgent: options.defaultAgent,
             defaultProvider: options.defaultProvider,
-            byokApiKey: options.byokApiKey,
             byokBaseUrl: options.byokBaseUrl,
             byokModel: options.byokModel,
             outFile: options.outFile,

package/dist/commands/v4.js

@@ -32,7 +32,7 @@ export class V4Command {
             .alias('v4-agent')
             .description('Launch Vigthoria V4 Operating Agent (DeerFlow 2.0 harness)')
             .option('--provider <provider>', 'Provider: cloud | v3_local | byok')
-            .option('--api-key <key>', 'BYOK API key for non-interactive mode')
+            .option('--api-key <key>', 'BYOK API key for compatibility; prefer VIGTHORIA_BYOK_API_KEY to avoid process-list exposure')
             .option('--base-url <url>', 'Provider base URL override')
             .option('--model <name>', 'Provider model override')
             .option('--transport <mode>', 'Bridge transport: auto | ws | sse', 'auto')
@@ -68,8 +68,13 @@ export class V4Command {
         if (options.provider) {
             args.push('--provider', String(options.provider));
         }
-        if (options.apiKey) {
-            args.push('--api-key', String(options.apiKey));
+        const childEnv = safeChildProcessEnv(process.env, { PYTHONUNBUFFERED: '1' });
+        const runtimeByokKey = options.apiKey || process.env.VIGTHORIA_BYOK_API_KEY;
+        if (runtimeByokKey) {
+            // Do not place provider secrets in the child process argument vector.
+            // The CLI option is retained for backwards compatibility, while the
+            // V4 process receives it through an ephemeral environment variable.
+            childEnv.VIGTHORIA_BYOK_API_KEY = String(runtimeByokKey);
         }
         if (options.baseUrl) {
             args.push('--base-url', String(options.baseUrl));
@@ -110,7 +115,7 @@ export class V4Command {
         const child = spawn(pythonBin, args, {
             cwd: v4Path,
             stdio: 'inherit',
-            env: safeChildProcessEnv(process.env, { PYTHONUNBUFFERED: '1' }),
+            env: childEnv,
         });
         const exitCode = await new Promise((resolve, reject) => {
             let interrupted = false;

package/dist/commands/wallet.d.ts

@@ -1,5 +1,5 @@
 /**
- * wallet.ts — VigCoin wallet management for Vigthoria CLI.
+ * wallet.ts — monetary Vigthoria Credits management for Vigthoria CLI.
  *
  *   vigthoria wallet balance          — show current balance
  *   vigthoria wallet history [--n 20] — recent transactions

package/dist/commands/wallet.js

@@ -1,5 +1,5 @@
 /**
- * wallet.ts — VigCoin wallet management for Vigthoria CLI.
+ * wallet.ts — monetary Vigthoria Credits management for Vigthoria CLI.
  *
  *   vigthoria wallet balance          — show current balance
  *   vigthoria wallet history [--n 20] — recent transactions
@@ -131,7 +131,7 @@ export class WalletCommand {
             }
             const txs = data.transactions || [];
             console.log('');
-            console.log(chalk.bold.cyan(`  VigCoin Transaction History (last ${txs.length})`));
+            console.log(chalk.bold.cyan(`  Vigthoria Credits Transaction History (last ${txs.length})`));
             console.log(chalk.gray('  ──────────────────────────────────────────────────────────'));
             if (txs.length === 0) {
                 console.log(chalk.gray('  No transactions found.'));
@@ -141,7 +141,7 @@ export class WalletCommand {
                     const sign = tx.amount >= 0 ? chalk.green(`+${tx.amount}`) : chalk.red(String(tx.amount));
                     const date = new Date(tx.created_at).toLocaleString();
                     const desc = tx.description || tx.action || tx.type;
-                    console.log(`  ${chalk.gray(date)}  ${sign.padStart(8)} ⓥ  ${chalk.gray(`→`)} ${chalk.yellow(tx.balance_after)} ⓥ  ${desc}`);
+                    console.log(`  ${chalk.gray(date)}  ${sign.padStart(8)} credits  ${chalk.gray(`→`)} ${chalk.yellow(tx.balance_after)} credits  ${desc}`);
                 }
             }
             console.log('');

package/dist/index.js

@@ -179,9 +179,8 @@ export function validateReleaseMetadata() {
         const readme = fs.readFileSync(readmePath, 'utf8');
         const bins = pkg.bin && typeof pkg.bin === 'object' ? pkg.bin : {};
         const requiredReadmePhrases = [
-            'npm install -g vigthoria-cli',
-            'curl -fsSL https://cli.vigthoria.io/install.sh | bash',
-            'irm https://cli.vigthoria.io/install.ps1 | iex',
+            'curl -fsSL https://extension.vigthoria.io/downloads/install.sh | bash',
+            'irm https://extension.vigthoria.io/downloads/install.ps1 | iex',
             'vigthoria login',
             'vigthoria chat',
             'vig c',

package/dist/utils/agent-stream-state.d.ts

@@ -3,6 +3,11 @@ export interface AgentStreamStateDependencies {
     isJsonOutput(): boolean;
     idleTimeoutMs(): number;
 }
+export type AgentToolResultPresentation = 'normal' | 'hidden' | 'correcting';
+/** Decode escaped line breaks without corrupting POSIX paths such as src/render.js. */
+export declare function normalizeAgentToolOutputForDisplay(output: string): string;
+/** Keep governed executor recovery details out of the normal user transcript. */
+export declare function classifyAgentToolResultPresentation(event: any): AgentToolResultPresentation;
 /** Owns the mutable lifecycle and deduplication state for one rendered agent stream. */
 export declare class AgentStreamState {
     private readonly dependencies;
@@ -18,9 +23,11 @@ export declare class AgentStreamState {
     readonly seenToolResults: Set<string>;
     private idleWatchInterval;
     private idleNoticeShown;
+    private lastCorrectionNoticeAt;
     constructor(dependencies: AgentStreamStateDependencies);
     reset(): void;
     noteActivity(): void;
+    shouldShowCorrectionNotice(now?: number, minimumIntervalMs?: number): boolean;
     startIdleWatch(spinner: Ora | null): void;
     stopIdleWatch(): void;
     sanitizeVisibleText(text: string): string;

package/dist/utils/agent-stream-state.js

@@ -1,4 +1,26 @@
 import chalk from 'chalk';
+/** Decode escaped line breaks without corrupting POSIX paths such as src/render.js. */
+export function normalizeAgentToolOutputForDisplay(output) {
+    return String(output || '')
+        .replace(/\\r\\n|\\n/g, '\n')
+        .replace(/\\r/g, '')
+        .replace(/\t/g, '  ');
+}
+/** Keep governed executor recovery details out of the normal user transcript. */
+export function classifyAgentToolResultPresentation(event) {
+    if (!event || event.type !== 'tool_result')
+        return 'normal';
+    if (event.user_visible === false || String(event.visibility || '').toLowerCase() === 'internal') {
+        return 'hidden';
+    }
+    if (event.success !== false)
+        return 'normal';
+    const detail = String(event.error || event.output || '');
+    if (/\b(?:deferred a second mutation|byte-identical source|duplicate reads are blocked|mutation recovery is active|was not offered for this atomic task|verification repair is pinned|blocked wrong-path|out-of-scope mutation|old_string found 0 times|mutation rejected before (?:write|edit)|degenerate mutation blocked before task acceptance|skipped (?:syntax|preview|runtime)_check[^.]*file does not exist yet|file not found in the local workspace)\b/i.test(detail)) {
+        return 'correcting';
+    }
+    return 'normal';
+}
 /** Owns the mutable lifecycle and deduplication state for one rendered agent stream. */
 export class AgentStreamState {
     dependencies;
@@ -14,6 +36,7 @@ export class AgentStreamState {
     seenToolResults = new Set();
     idleWatchInterval = null;
     idleNoticeShown = false;
+    lastCorrectionNoticeAt = 0;
     constructor(dependencies) {
         this.dependencies = dependencies;
     }
@@ -29,8 +52,16 @@ export class AgentStreamState {
         this.seenToolCalls.clear();
         this.seenToolResults.clear();
         this.idleNoticeShown = false;
+        this.lastCorrectionNoticeAt = 0;
     }
     noteActivity() { this.lastActivity = Date.now(); }
+    shouldShowCorrectionNotice(now = Date.now(), minimumIntervalMs = 5_000) {
+        if (this.lastCorrectionNoticeAt > 0 && now - this.lastCorrectionNoticeAt < minimumIntervalMs) {
+            return false;
+        }
+        this.lastCorrectionNoticeAt = now;
+        return true;
+    }
     startIdleWatch(spinner) {
         this.stopIdleWatch();
         if (this.dependencies.isJsonOutput() || !spinner)

package/dist/utils/agentRunOutcome.js

@@ -42,7 +42,11 @@ const LIST_ONLY_DISCOVERY_TOOLS = new Set([
     'glob',
     'dir',
 ]);
-const GENERIC_SUMMARY_RE = /^(completed the requested analysis|reviewed the workspace without writing changes|task completed|done|finished|analysis completed)([.\s]|$)/i;
+// Match only the complete placeholder. A real completion report commonly
+// starts with "Done" before listing verified work and the user's next step;
+// treating every such report as a stub discards the authoritative server
+// summary and leaves the CLI showing only a filename list.
+const GENERIC_SUMMARY_RE = /^(completed the requested analysis|reviewed the workspace without writing changes|task completed|done|finished|analysis completed)[.!]?$/i;
 /** Planner fallback / degraded inference — generic greeting unrelated to the user question. */
 const GENERIC_FALLBACK_GREETING_RE = /^(?:hello!?|hi!?|hey!?)\s*(?:how can i assist|how can i help|what would you like|whether you'?re looking to build)/i;
 /** System-prompt fragments leaked when the model falls back without real context. */