@solarains/va-cli 0.1.4 → 0.1.6

package/README.md

@@ -12,7 +12,9 @@ npm install -g @solarains/va-cli
 
 ```bash
 vaone --help
+vaone --version
 vaone init
+vaone update
 ```
 
 Use `vaone ...` to access the CLI command surface.

package/dist/cli/help-copy.js

@@ -9,11 +9,20 @@ const HELP_COPY = {
         globalFlagsHeading: 'Global flags:',
         helpFlag: 'Show help',
         debugFlag: 'Enable debug logging',
+        versionFlag: 'Show CLI version',
         commandHelp: {
             '': {
-                summary: 'VAOne CLI with guided init, auth, assets, usage, daily reports, intelligence queries, and diagnostics.',
+                summary: 'VAOne CLI with versioning, self-update, guided init, auth, assets, usage, daily reports, intelligence queries, and diagnostics.',
                 usage: 'vaone <command> [subcommand] [options]',
             },
+            'version': {
+                summary: 'Show the current VAOne CLI version.',
+                usage: 'vaone version',
+            },
+            'update': {
+                summary: 'Check for a newer packaged CLI release and sync VA-managed skill packs.',
+                usage: 'vaone update',
+            },
             'init': {
                 summary: 'Install VisionAlpha operator skills with branded onboarding and optional browser login.',
                 usage: 'vaone init [.] [--agents codex,claude,openclaw] [--scope project|user] [--lang en|zh-CN] [--skip-login] [--force] [--yes]',
@@ -50,11 +59,20 @@ const HELP_COPY = {
         globalFlagsHeading: '全局参数：',
         helpFlag: '显示帮助',
         debugFlag: '启用调试日志',
+        versionFlag: '显示 CLI 版本',
         commandHelp: {
             '': {
-                summary: 'VAOne CLI，提供引导式 init、认证、资产、usage、日报、intelligence 查询与诊断能力。',
+                summary: 'VAOne CLI，提供版本查看、自更新、引导式 init、认证、资产、usage、日报、intelligence 查询与诊断能力。',
                 usage: 'vaone <命令> [子命令] [参数]',
             },
+            'version': {
+                summary: '显示当前 VAOne CLI 版本。',
+                usage: 'vaone version',
+            },
+            'update': {
+                summary: '检查新版 CLI，并同步所有 VA 受管 skill pack。',
+                usage: 'vaone update',
+            },
             'init': {
                 summary: '通过带品牌感的引导流程安装 VisionAlpha operator skills，并可选串联浏览器登录。',
                 usage: 'vaone init [.] [--agents codex,claude,openclaw] [--scope project|user] [--lang en|zh-CN] [--skip-login] [--force] [--yes]',

package/dist/cli/help.js

@@ -25,5 +25,7 @@ function renderHelp(command, pathSegments = [], locale = 'en') {
     lines.push(copy.globalFlagsHeading);
     lines.push(`  --help, -h   ${copy.helpFlag}`);
     lines.push(`  --debug      ${copy.debugFlag}`);
+    lines.push(`  --version    ${copy.versionFlag}`);
+    lines.push(`  -V, -v       ${copy.versionFlag}`);
     return lines.join('\n');
 }

package/dist/cli/root-command.js

@@ -7,13 +7,17 @@ const doctor_command_1 = require("../commands/doctor/doctor-command");
 const init_command_1 = require("../commands/init/init-command");
 const intelligence_command_1 = require("../commands/intelligence/intelligence-command");
 const reports_command_1 = require("../commands/reports/reports-command");
+const update_command_1 = require("../commands/update/update-command");
 const uninstall_command_1 = require("../commands/uninstall/uninstall-command");
 const usage_command_1 = require("../commands/usage/usage-command");
+const version_command_1 = require("../commands/version/version-command");
 exports.rootCommand = {
     name: 'vaone',
-    summary: 'VAOne CLI with guided init, auth, assets, usage, daily reports, intelligence queries, and diagnostics.',
+    summary: 'VAOne CLI with versioning, self-update, guided init, auth, assets, usage, daily reports, intelligence queries, and diagnostics.',
     usage: 'vaone <command> [subcommand] [options]',
     children: [
+        version_command_1.versionCommand,
+        update_command_1.updateCommand,
         init_command_1.initCommand,
         uninstall_command_1.uninstallCommand,
         auth_command_1.authCommand,

package/dist/cli/run-cli.js

@@ -11,10 +11,12 @@ const logger_1 = require("../shared/logger");
 const help_1 = require("./help");
 const help_copy_1 = require("./help-copy");
 const root_command_1 = require("./root-command");
+const version_command_1 = require("../commands/version/version-command");
 function parseArgv(argv) {
     const tokens = [];
     let debug = false;
     let help = false;
+    let version = false;
     for (const token of argv) {
         if (token === '--') {
             continue;
@@ -27,6 +29,10 @@ function parseArgv(argv) {
             help = true;
             continue;
         }
+        if (token === '--version' || token === '-V' || token === '-v') {
+            version = true;
+            continue;
+        }
         tokens.push(token);
     }
     if (tokens[0] === 'help') {
@@ -36,6 +42,7 @@ function parseArgv(argv) {
     return {
         debug,
         help,
+        version,
         tokens,
     };
 }
@@ -67,12 +74,24 @@ function printUnknownCommand(logger, command, path, token, locale) {
 async function runCli(argv, env, deps = {}) {
     const parsedArgv = parseArgv(argv);
     const logger = new logger_1.Logger(parsedArgv.debug || env.VAONE_DEBUG === 'true');
+    if (parsedArgv.version) {
+        return (0, version_command_1.printCliVersion)(logger);
+    }
+    const resolvedCommand = resolveCommand(parsedArgv.tokens);
+    if (!parsedArgv.help && resolvedCommand.path[0] === 'version') {
+        try {
+            return await (0, version_command_1.printCliVersion)(logger, resolvedCommand.remainingArgs);
+        }
+        catch (error) {
+            logger.error(error instanceof Error ? error.message : 'Unknown CLI failure.');
+            return 1;
+        }
+    }
     const paths = (0, paths_1.createCliPaths)(env);
     const runtimeConfig = await (0, runtime_config_1.loadRuntimeConfig)(env, paths);
     logger.setDebugMode(parsedArgv.debug || runtimeConfig.debug);
     const tokenStore = new token_store_1.TokenStore(paths.authStateFile);
     const installationStore = new installation_store_1.InstallationStore(paths.installationStateFile);
-    const resolvedCommand = resolveCommand(parsedArgv.tokens);
     const unknownToken = resolvedCommand.remainingArgs[0];
     const canTraverseFurther = Boolean(resolvedCommand.command.children?.length && unknownToken);
     const locale = runtimeConfig.locale;
@@ -96,19 +115,22 @@ async function runCli(argv, env, deps = {}) {
         logger.plain((0, help_1.renderHelp)(resolvedCommand.command, resolvedCommand.path, locale));
         return 0;
     }
-    await (0, paths_1.ensureCliDirectories)(paths);
-    const preflightExitCode = await (deps.runStartupPreflight ?? preflight_1.runStartupPreflight)({
-        argv,
-        env,
-        logger,
-        paths,
-        runtimeConfig,
-        commandPath: resolvedCommand.path,
-        cwd: process.cwd(),
-        homeDir: (0, node_os_1.homedir)(),
-    });
-    if (typeof preflightExitCode === 'number') {
-        return preflightExitCode;
+    if (!((0, preflight_1.shouldSkipManagedSync)(resolvedCommand.path) &&
+        (0, preflight_1.shouldSkipCliUpdate)(resolvedCommand.path))) {
+        await (0, paths_1.ensureCliDirectories)(paths);
+        const preflightExitCode = await (deps.runStartupPreflight ?? preflight_1.runStartupPreflight)({
+            argv,
+            env,
+            logger,
+            paths,
+            runtimeConfig,
+            commandPath: resolvedCommand.path,
+            cwd: process.cwd(),
+            homeDir: (0, node_os_1.homedir)(),
+        });
+        if (typeof preflightExitCode === 'number') {
+            return preflightExitCode;
+        }
     }
     try {
         return await resolvedCommand.command.run(context, resolvedCommand.remainingArgs);

package/dist/commands/intelligence/query-command.js

@@ -95,10 +95,6 @@ exports.intelligenceQueryCommand = {
                 error.code === 'ASSET_INTELLIGENCE_ACCESS_DENIED') {
                 throw new Error('This account does not currently have paid asset-intelligence access.');
             }
-            if (error instanceof authenticated_api_client_1.CliApiError &&
-                error.code === 'ASSET_INTELLIGENCE_QUOTA_EXCEEDED') {
-                throw new Error('The current intelligence query would exceed the daily paid usage quota.');
-            }
             if (error instanceof authenticated_api_client_1.CliApiError && error.code === 'INVALID_CURSOR') {
                 await stateStore.clear();
                 throw new Error('The saved or provided query cursor is no longer valid. Restart the query without `--next`.');

package/dist/commands/reports/get-command.js

@@ -13,16 +13,10 @@ function resolveAssetId(positionals, optionAssetId) {
     return optionAssetId ?? positionals[0] ?? '';
 }
 function getSelectionMessage(input) {
-    if (input.previousSelectedReportKey === input.requestedReportKey) {
-        return 'This report is already the locked daily selection for the current product day.';
-    }
-    if (!input.previousSelectedReportKey && input.detailSelectedToday) {
-        return 'This read locked the account daily-report selection for the current product day.';
-    }
     if (input.detailSelectedToday) {
-        return 'This report is currently the selected daily report for the current product day.';
+        return 'This report is included in the current product day usage state. Repeat reads today do not consume another unit.';
     }
-    return 'Selection state is available but no new lock was created.';
+    return 'This report did not consume a new daily-report unit.';
 }
 exports.reportsGetCommand = {
     name: 'get',
@@ -38,10 +32,7 @@ exports.reportsGetCommand = {
         const usageSummary = await (0, usage_api_client_1.getUsageSummary)(context);
         try {
             const report = await (0, daily_reports_api_client_1.getDailyReportDetail)(context, assetId, { date });
-            const requestedReportKey = `${report.assetId}:${report.date}`;
             (0, daily_reports_output_1.renderDailyReportDetail)(context.logger, report, getSelectionMessage({
-                previousSelectedReportKey: usageSummary.dailyReport.selectedReportKey,
-                requestedReportKey,
                 detailSelectedToday: report.selectedToday,
             }));
             return 0;
@@ -49,10 +40,7 @@ exports.reportsGetCommand = {
         catch (error) {
             if (error instanceof authenticated_api_client_1.CliApiError &&
                 error.code === 'DAILY_REPORT_SELECTION_LIMIT_REACHED') {
-                const selectedReportKey = usageSummary.dailyReport.selectedReportKey;
-                throw new Error(selectedReportKey
-                    ? `Daily report selection is already locked for ${selectedReportKey}. Free accounts can only keep one report selection per product day.`
-                    : 'Daily report selection is already locked for the current product day.');
+                throw new Error(`Daily report limit reached for the current product day. Remaining quota: ${usageSummary.dailyReport.remainingToday ?? 0}.`);
             }
             if (error instanceof authenticated_api_client_1.CliApiError &&
                 error.code === 'DAILY_REPORT_NOT_FOUND') {

package/dist/commands/reports/list-command.js

@@ -7,7 +7,7 @@ const daily_reports_output_1 = require("../../features/daily-reports/daily-repor
 const usage_api_client_1 = require("../../features/usage/usage-api-client");
 exports.reportsListCommand = {
     name: 'list',
-    summary: 'List normalized daily reports with current selection state.',
+    summary: 'List normalized daily reports with current usage state.',
     usage: 'vaone reports list [--asset-id <id>] [--category <category>] [--date-from <yyyy-mm-dd>] [--date-to <yyyy-mm-dd>] [--limit <n>]',
     async run(context, args) {
         const parsed = (0, argv_1.parseCommandArgs)(args);
@@ -26,7 +26,6 @@ exports.reportsListCommand = {
         ]);
         (0, daily_reports_output_1.renderDailyReportList)(context.logger, reports, {
             statusLabel: usageSummary.dailyReport.statusLabel,
-            selectedReportKey: usageSummary.dailyReport.selectedReportKey,
         });
         return 0;
     },

package/dist/commands/update/update-command.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateCommand = void 0;
+const node_os_1 = require("node:os");
+const preflight_1 = require("../../features/update/preflight");
+const argv_1 = require("../../shared/argv");
+exports.updateCommand = {
+    name: 'update',
+    summary: 'Check for a newer packaged CLI release and sync VA-managed skill packs.',
+    usage: 'vaone update',
+    async run(context, args) {
+        const parsed = (0, argv_1.parseCommandArgs)(args);
+        if (parsed.positionals.length > 0) {
+            throw new Error('`vaone update` does not accept positional arguments.');
+        }
+        return (0, preflight_1.runExplicitUpdate)({
+            argv: context.argv,
+            env: process.env,
+            logger: context.logger,
+            paths: context.paths,
+            runtimeConfig: context.runtimeConfig,
+            cwd: process.cwd(),
+            homeDir: (0, node_os_1.homedir)(),
+        });
+    },
+};

package/dist/commands/version/version-command.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionCommand = void 0;
+exports.printCliVersion = printCliVersion;
+const package_metadata_1 = require("../../features/runtime/package-metadata");
+async function printCliVersion(logger, args = []) {
+    if (args.length > 0) {
+        throw new Error('`vaone version` does not accept positional arguments.');
+    }
+    const runtimePackage = await (0, package_metadata_1.resolveRuntimePackageInfo)();
+    logger.plain(runtimePackage.version);
+    return 0;
+}
+exports.versionCommand = {
+    name: 'version',
+    summary: 'Show the current VAOne CLI version.',
+    usage: 'vaone version',
+    async run(context, args) {
+        return printCliVersion(context.logger, args);
+    },
+};

package/dist/features/daily-reports/daily-reports-output.js

@@ -6,12 +6,9 @@ const output_1 = require("../../shared/output");
 function formatAssetName(report) {
     return report.assetNameZh || report.assetNameEn || report.assetId;
 }
-function renderDailyReportList(logger, reports, selectionSummary) {
-    (0, output_1.printSection)(logger, 'Daily report selection');
-    (0, output_1.printKeyValue)(logger, 'Status', selectionSummary.statusLabel);
-    if (selectionSummary.selectedReportKey) {
-        (0, output_1.printKeyValue)(logger, 'Locked report', selectionSummary.selectedReportKey);
-    }
+function renderDailyReportList(logger, reports, usageSummary) {
+    (0, output_1.printSection)(logger, 'Daily report usage');
+    (0, output_1.printKeyValue)(logger, 'Status', usageSummary.statusLabel);
     (0, output_1.printSection)(logger, 'Available reports');
     if (!reports.length) {
         logger.info('No reports matched the current filters.');
@@ -28,12 +25,12 @@ function renderDailyReportList(logger, reports, selectionSummary) {
         (0, output_1.printList)(logger, [report.summary || 'No summary available.']);
     });
 }
-function renderDailyReportDetail(logger, report, selectionMessage) {
+function renderDailyReportDetail(logger, report, usageMessage) {
     (0, output_1.printSection)(logger, 'Daily report');
     (0, output_1.printKeyValue)(logger, 'Asset', `${formatAssetName(report)} (${report.assetId})`);
     (0, output_1.printKeyValue)(logger, 'Date', report.date);
     (0, output_1.printKeyValue)(logger, 'Category', report.category || 'unknown');
-    (0, output_1.printKeyValue)(logger, 'Selection', selectionMessage);
+    (0, output_1.printKeyValue)(logger, 'Usage', usageMessage);
     (0, output_1.printSection)(logger, 'Summary');
     (0, output_1.printList)(logger, [report.summary || 'No summary available.']);
     (0, output_1.printSection)(logger, 'Content');

package/dist/features/init/init-copy.js

@@ -163,11 +163,8 @@ function getInitCopy(locale) {
                 summaryDailyReport(value) {
                     return `日报状态: ${value}`;
                 },
-                summaryLockedReport(value) {
-                    return `锁定日报: ${value}`;
-                },
-                summaryIntelligence(value) {
-                    return `情报额度: ${value}`;
+                summaryDailyReportUsed(value) {
+                    return `今日日报已用: ${value}`;
                 },
                 summaryResetCadence(value) {
                     return `重置周期: ${value}`;
@@ -324,11 +321,8 @@ function getInitCopy(locale) {
             summaryDailyReport(value) {
                 return `Daily report: ${value}`;
             },
-            summaryLockedReport(value) {
-                return `Locked report: ${value}`;
-            },
-            summaryIntelligence(value) {
-                return `Intelligence quota: ${value}`;
+            summaryDailyReportUsed(value) {
+                return `Daily report used today: ${value}`;
             },
             summaryResetCadence(value) {
                 return `Reset cadence: ${value}`;

package/dist/features/init/init-flow.js

@@ -155,8 +155,7 @@ function extractUsageSummary(lines, copy) {
             continue;
         }
         if (line === 'Plan' ||
-            line === 'Daily report' ||
-            line === 'Intelligence quota') {
+            line === 'Daily report') {
             section = line;
             continue;
         }
@@ -173,19 +172,12 @@ function extractUsageSummary(lines, copy) {
         }
         if (section === 'Daily report') {
             const status = extractValue([line], 'Status');
-            const lockedReport = extractValue([line], 'Locked report');
+            const usedToday = extractValue([line], 'Used today');
             if (status) {
                 summary.push(copy.messages.summaryDailyReport(status));
             }
-            if (lockedReport) {
-                summary.push(copy.messages.summaryLockedReport(lockedReport));
-            }
-            continue;
-        }
-        if (section === 'Intelligence quota') {
-            const status = extractValue([line], 'Status');
-            if (status) {
-                summary.push(copy.messages.summaryIntelligence(status));
+            if (usedToday) {
+                summary.push(copy.messages.summaryDailyReportUsed(usedToday));
                 continue;
             }
             const normalized = line.replace(/^- /, '');

package/dist/features/update/preflight.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPLICIT_UPDATE_TARGET_VERSION_ENV = exports.EXPLICIT_UPDATE_REEXEC_ENV = exports.PREFLIGHT_GUARD_ENV = void 0;
+exports.shouldSkipManagedSync = shouldSkipManagedSync;
+exports.shouldSkipCliUpdate = shouldSkipCliUpdate;
+exports.canPromptForUpdate = canPromptForUpdate;
+exports.fetchLatestPublishedVersion = fetchLatestPublishedVersion;
+exports.performSelfUpdate = performSelfUpdate;
+exports.reexecCommand = reexecCommand;
 exports.resolveUpdateAction = resolveUpdateAction;
+exports.runExplicitUpdate = runExplicitUpdate;
 exports.runStartupPreflight = runStartupPreflight;
 const node_child_process_1 = require("node:child_process");
 const paths_1 = require("../../state/paths");
@@ -11,9 +19,11 @@ const managed_pack_1 = require("../init/managed-pack");
 const package_metadata_1 = require("../runtime/package-metadata");
 const version_1 = require("./version");
 const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
-const PREFLIGHT_GUARD_ENV = 'VAONE_SKIP_PREFLIGHT';
+exports.PREFLIGHT_GUARD_ENV = 'VAONE_SKIP_PREFLIGHT';
+exports.EXPLICIT_UPDATE_REEXEC_ENV = 'VAONE_EXPLICIT_UPDATE_REEXEC';
+exports.EXPLICIT_UPDATE_TARGET_VERSION_ENV = 'VAONE_EXPLICIT_UPDATE_TARGET_VERSION';
 const UPDATE_COPY = {
-    en: {
+    'en': {
         promptTitle(currentVersion, latestVersion) {
             return `A newer VAOne CLI is available (${currentVersion} -> ${latestVersion}).`;
         },
@@ -57,10 +67,14 @@ function shouldSkipManagedSync(commandPath) {
     return (commandPath.length === 0 ||
         commandPath[0] === 'init' ||
         commandPath[0] === 'doctor' ||
-        commandPath[0] === 'uninstall');
+        commandPath[0] === 'uninstall' ||
+        commandPath[0] === 'update' ||
+        commandPath[0] === 'version');
 }
 function shouldSkipCliUpdate(commandPath) {
-    return commandPath[0] === 'doctor';
+    return (commandPath[0] === 'doctor' ||
+        commandPath[0] === 'update' ||
+        commandPath[0] === 'version');
 }
 function canPromptForUpdate(env) {
     return (process.stdin.isTTY === true &&
@@ -101,7 +115,7 @@ async function performSelfUpdate(packageName, version) {
         failureMessage: result.stderr?.trim() || result.stdout?.trim() || 'npm update failed.',
     };
 }
-async function reexecCommand(argv) {
+async function reexecCommand(argv, extraEnv) {
     if (!process.argv[1]) {
         return null;
     }
@@ -109,7 +123,8 @@ async function reexecCommand(argv) {
         stdio: 'inherit',
         env: {
             ...process.env,
-            [PREFLIGHT_GUARD_ENV]: '1',
+            [exports.PREFLIGHT_GUARD_ENV]: '1',
+            ...extraEnv,
         },
     });
     if (typeof result.status === 'number') {
@@ -144,14 +159,17 @@ async function resolveUpdateAction(input) {
         ],
     })
         .then((choice) => ({ kind: 'choice', choice }), (error) => ({ kind: 'error', error }));
-    const timeoutMs = input.timeoutMs ?? 5_000;
-    const timeoutPromise = new Promise((resolve) => {
-        setTimeout(() => {
-            void prompt.close().catch(() => undefined);
-            resolve({ kind: 'timeout' });
-        }, timeoutMs);
-    });
-    const result = await Promise.race([selectionPromise, timeoutPromise]);
+    const result = input.timeoutMs === null
+        ? await selectionPromise
+        : await Promise.race([
+            selectionPromise,
+            new Promise((resolve) => {
+                setTimeout(() => {
+                    void prompt.close().catch(() => undefined);
+                    resolve({ kind: 'timeout' });
+                }, input.timeoutMs ?? 5_000);
+            }),
+        ]);
     if (result.kind === 'timeout') {
         input.logger.info(copy.timeoutNotice(input.latestVersion));
         return 'update';
@@ -161,25 +179,211 @@ async function resolveUpdateAction(input) {
     }
     return result.choice;
 }
+function createUpdateStateStore(paths) {
+    return new update_state_store_1.UpdateStateStore((0, paths_1.resolveUpdateStateFile)(paths));
+}
+function formatManagedPackRefreshSummary(refreshed) {
+    return refreshed
+        .map((entry) => `${entry.target.displayName} (${entry.scope})`)
+        .join(', ');
+}
+async function syncManagedPacksForVersion(input) {
+    const refreshed = await (input.syncManagedPacksImpl ?? managed_pack_1.syncManagedPacks)({
+        cwd: input.cwd,
+        homeDir: input.homeDir,
+        currentVersion: input.currentVersion,
+    });
+    if (refreshed.length > 0) {
+        input.logger.info(`Refreshed stale managed skill packs: ${formatManagedPackRefreshSummary(refreshed)}.`);
+    }
+    return refreshed;
+}
+async function resolvePublishedUpdate(input) {
+    const updateStateStore = createUpdateStateStore(input.paths);
+    const updateState = (await updateStateStore.read()) ?? {};
+    try {
+        const latestVersion = await (input.fetchLatestVersionImpl ?? fetchLatestPublishedVersion)(input.packageName);
+        return {
+            latestVersion,
+            updateStateStore,
+            updateState,
+            nextState: {
+                ...updateState,
+                lastCheckedAt: new Date(input.now()).toISOString(),
+                lastKnownLatestVersion: latestVersion,
+            },
+        };
+    }
+    catch (error) {
+        await updateStateStore.save({
+            ...updateState,
+            lastCheckedAt: new Date(input.now()).toISOString(),
+            lastFailureCode: 'version_check_failed',
+            lastFailureMessage: error instanceof Error ? error.message : 'Version check failed.',
+        });
+        throw error;
+    }
+}
+function createExplicitRestartEnv(latestVersion) {
+    return {
+        [exports.EXPLICIT_UPDATE_REEXEC_ENV]: '1',
+        [exports.EXPLICIT_UPDATE_TARGET_VERSION_ENV]: latestVersion,
+    };
+}
+async function runExplicitUpdate(input, deps = {}) {
+    const runtimePackage = (await deps.resolvePackageInfo?.()) ?? (await (0, package_metadata_1.resolveRuntimePackageInfo)());
+    if (input.env[exports.EXPLICIT_UPDATE_REEXEC_ENV] === '1') {
+        const updatedVersion = input.env[exports.EXPLICIT_UPDATE_TARGET_VERSION_ENV] ?? runtimePackage.version;
+        input.logger.info(`VAOne CLI updated to ${updatedVersion}.`);
+        try {
+            const refreshed = await syncManagedPacksForVersion({
+                logger: input.logger,
+                cwd: input.cwd,
+                homeDir: input.homeDir,
+                currentVersion: runtimePackage.version,
+                syncManagedPacksImpl: deps.syncManagedPacks,
+            });
+            if (refreshed.length === 0) {
+                input.logger.info('No stale VA-managed skill packs were found.');
+            }
+            return 0;
+        }
+        catch (error) {
+            input.logger.error(`Managed skill-pack sync failed after CLI update: ${error instanceof Error ? error.message : 'unknown error'}`);
+            return 1;
+        }
+    }
+    if (!runtimePackage.isPackagedInstall) {
+        input.logger.error('`vaone update` only works from the packaged npm install. Local repository runs must update dependencies manually.');
+        return 1;
+    }
+    const now = deps.now ?? Date.now;
+    let publishedUpdate;
+    try {
+        publishedUpdate = await resolvePublishedUpdate({
+            now,
+            logger: input.logger,
+            paths: input.paths,
+            packageName: runtimePackage.name,
+            fetchLatestVersionImpl: deps.fetchLatestVersion,
+        });
+    }
+    catch (error) {
+        input.logger.error(`CLI update check failed: ${error instanceof Error ? error.message : 'unknown error'}`);
+        return 1;
+    }
+    const { latestVersion, nextState, updateStateStore } = publishedUpdate;
+    if ((0, version_1.isVersionNewer)(latestVersion, runtimePackage.version)) {
+        const interactive = canPromptForUpdate(input.env);
+        const action = interactive
+            ? await resolveUpdateAction({
+                currentVersion: runtimePackage.version,
+                latestVersion,
+                locale: input.runtimeConfig.locale,
+                logger: input.logger,
+                promptFactory: deps.promptFactory,
+                timeoutMs: null,
+            })
+            : 'update';
+        if (!interactive) {
+            input.logger.info(`No interactive terminal detected. Updating VAOne CLI to ${latestVersion}.`);
+        }
+        if (action === 'defer') {
+            await (0, runtime_config_1.saveRuntimeConfig)(input.paths, {
+                updateDeferredUntilVersion: latestVersion,
+            });
+            input.runtimeConfig.updateDeferredUntilVersion = latestVersion;
+            await updateStateStore.save({
+                ...nextState,
+                lastFailureCode: undefined,
+                lastFailureMessage: undefined,
+            });
+            input.logger.info(`Deferred CLI self-update until a version newer than ${latestVersion} is published.`);
+        }
+        else if (action === 'skip') {
+            await updateStateStore.save({
+                ...nextState,
+                lastFailureCode: undefined,
+                lastFailureMessage: undefined,
+            });
+            input.logger.info('Skipped CLI self-update for this run.');
+        }
+        else {
+            const copy = UPDATE_COPY[input.runtimeConfig.locale];
+            input.logger.info(copy.updatingNotice(latestVersion));
+            const result = await (deps.performSelfUpdate ?? performSelfUpdate)(runtimePackage.name, latestVersion);
+            if (!result.success) {
+                await updateStateStore.save({
+                    ...nextState,
+                    lastAttemptedUpdateAt: new Date(now()).toISOString(),
+                    lastAttemptedTargetVersion: latestVersion,
+                    lastFailureCode: result.failureCode,
+                    lastFailureMessage: result.failureMessage,
+                });
+                input.logger.error(result.failureMessage ?? 'CLI update failed.');
+                return 1;
+            }
+            await (0, runtime_config_1.saveRuntimeConfig)(input.paths, {
+                updateDeferredUntilVersion: undefined,
+            });
+            input.runtimeConfig.updateDeferredUntilVersion = undefined;
+            await updateStateStore.save({
+                ...nextState,
+                lastAttemptedUpdateAt: new Date(now()).toISOString(),
+                lastAttemptedTargetVersion: latestVersion,
+                lastFailureCode: undefined,
+                lastFailureMessage: undefined,
+            });
+            input.logger.info(copy.restartingNotice);
+            const exitCode = await (deps.reexecCommand ?? reexecCommand)(input.argv, createExplicitRestartEnv(latestVersion));
+            if (typeof exitCode === 'number') {
+                return exitCode;
+            }
+            input.logger.error('CLI update completed, but restarting `vaone update` did not return an exit code.');
+            return 1;
+        }
+    }
+    else {
+        await updateStateStore.save({
+            ...nextState,
+            lastFailureCode: undefined,
+            lastFailureMessage: undefined,
+        });
+        input.logger.info(`VAOne CLI is already up to date (${runtimePackage.version}).`);
+    }
+    try {
+        const refreshed = await syncManagedPacksForVersion({
+            logger: input.logger,
+            cwd: input.cwd,
+            homeDir: input.homeDir,
+            currentVersion: runtimePackage.version,
+            syncManagedPacksImpl: deps.syncManagedPacks,
+        });
+        if (refreshed.length === 0) {
+            input.logger.info('No stale VA-managed skill packs were found.');
+        }
+        return 0;
+    }
+    catch (error) {
+        input.logger.error(`Managed skill-pack sync failed: ${error instanceof Error ? error.message : 'unknown error'}`);
+        return 1;
+    }
+}
 async function runStartupPreflight(input, deps = {}) {
-    if (input.env[PREFLIGHT_GUARD_ENV] === '1') {
+    if (input.env[exports.PREFLIGHT_GUARD_ENV] === '1') {
         return null;
     }
     const now = deps.now ?? Date.now;
     const runtimePackage = (await deps.resolvePackageInfo?.()) ?? (await (0, package_metadata_1.resolveRuntimePackageInfo)());
     if (!shouldSkipManagedSync(input.commandPath)) {
         try {
-            const refreshed = await (deps.syncManagedPacks ?? managed_pack_1.syncManagedPacks)({
+            await syncManagedPacksForVersion({
+                logger: input.logger,
                 cwd: input.cwd,
                 homeDir: input.homeDir,
                 currentVersion: runtimePackage.version,
+                syncManagedPacksImpl: deps.syncManagedPacks,
             });
-            if (refreshed.length > 0) {
-                const summary = refreshed
-                    .map((entry) => `${entry.target.displayName} (${entry.scope})`)
-                    .join(', ');
-                input.logger.info(`Refreshed stale managed skill packs: ${summary}.`);
-            }
         }
         catch (error) {
             input.logger.warn(`Managed skill-pack sync failed: ${error instanceof Error ? error.message : 'unknown error'}`);
@@ -191,7 +395,7 @@ async function runStartupPreflight(input, deps = {}) {
     if (!runtimePackage.isPackagedInstall || !canPromptForUpdate(input.env)) {
         return null;
     }
-    const updateStateStore = new update_state_store_1.UpdateStateStore((0, paths_1.resolveUpdateStateFile)(input.paths));
+    const updateStateStore = createUpdateStateStore(input.paths);
     const updateState = (await updateStateStore.read()) ?? {};
     const lastCheckedAt = updateState.lastCheckedAt
         ? Date.parse(updateState.lastCheckedAt)
@@ -202,15 +406,15 @@ async function runStartupPreflight(input, deps = {}) {
     }
     let latestVersion;
     try {
-        latestVersion = await (deps.fetchLatestVersion ?? fetchLatestPublishedVersion)(runtimePackage.name);
+        latestVersion = (await resolvePublishedUpdate({
+            now,
+            logger: input.logger,
+            paths: input.paths,
+            packageName: runtimePackage.name,
+            fetchLatestVersionImpl: deps.fetchLatestVersion,
+        })).latestVersion;
     }
     catch (error) {
-        await updateStateStore.save({
-            ...updateState,
-            lastCheckedAt: new Date(now()).toISOString(),
-            lastFailureCode: 'version_check_failed',
-            lastFailureMessage: error instanceof Error ? error.message : 'Version check failed.',
-        });
         input.logger.warn(`CLI update check failed: ${error instanceof Error ? error.message : 'unknown error'}`);
         return null;
     }
@@ -228,8 +432,7 @@ async function runStartupPreflight(input, deps = {}) {
         return null;
     }
     const deferredBoundary = input.runtimeConfig.updateDeferredUntilVersion;
-    if (deferredBoundary &&
-        !(0, version_1.isVersionNewer)(latestVersion, deferredBoundary)) {
+    if (deferredBoundary && !(0, version_1.isVersionNewer)(latestVersion, deferredBoundary)) {
         await updateStateStore.save(nextState);
         return null;
     }

package/dist/features/usage/usage-output.js

@@ -2,22 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderUsageSummary = renderUsageSummary;
 const output_1 = require("../../shared/output");
-function formatQuotaLine(label, quota) {
-    if (!quota) {
-        return `${label}: not enabled`;
-    }
-    return `${label}: ${quota.used}/${quota.limit} used, ${quota.remaining} remaining`;
-}
-function formatSelectedReportKey(key) {
-    if (!key) {
-        return undefined;
-    }
-    const [assetId, date] = key.split(':');
-    if (!assetId || !date) {
-        return key;
-    }
-    return `${assetId} on ${date}`;
-}
 function renderUsageSummary(logger, summary) {
     (0, output_1.printSection)(logger, 'Plan');
     (0, output_1.printKeyValue)(logger, 'Current plan', summary.plan.name);
@@ -38,15 +22,8 @@ function renderUsageSummary(logger, summary) {
     (0, output_1.printKeyValue)(logger, 'Remaining selections today', summary.dailyReport.remainingToday === null
         ? 'not limited'
         : String(summary.dailyReport.remainingToday));
-    const selectedReport = formatSelectedReportKey(summary.dailyReport.selectedReportKey);
-    if (selectedReport) {
-        (0, output_1.printKeyValue)(logger, 'Locked report', selectedReport);
-    }
-    (0, output_1.printSection)(logger, 'Intelligence quota');
-    (0, output_1.printKeyValue)(logger, 'Status', summary.intelligence.statusLabel);
+    (0, output_1.printKeyValue)(logger, 'Used today', String(summary.dailyReport.usedToday));
     (0, output_1.printList)(logger, [
-        formatQuotaLine('Calls', summary.intelligence.calls),
-        formatQuotaLine('Rows', summary.intelligence.rows),
-        `Reset cadence: ${summary.intelligence.resetCadence} (${summary.intelligence.resetTimezone})`,
+        `Reset cadence: ${summary.dailyReport.resetCadence} (${summary.dailyReport.resetTimezone})`,
     ]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solarains/va-cli",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Bootstrap CLI for the VAOne product.",
   "bin": {
     "vaone": "dist/main.js"

package/skills/visionalpha-operator/references/daily-reports.md

@@ -26,5 +26,6 @@ Use this reference when the user wants a report list, a specific report, or "tod
 ## Recovery notes
 
 - If the CLI says login is required, run `vaone auth login`.
-- If the CLI reports the daily report selection is already locked, explain that free accounts can keep only one report selection for the current product day.
-
+- If the CLI reports that the daily report limit is reached, explain that free
+  accounts can access one unique report per product day and paid accounts can
+  access one hundred unique reports per product day.