@claude-flow/cli 3.32.3 → 3.32.4

package/dist/src/commands/proxy-lifecycle.js

@@ -0,0 +1,232 @@
+/**
+ * `ruflo proxy install|start|stop|status|logs|update|uninstall` (ADR-307) —
+ * the full lifecycle command set, kept in its own file so
+ * src/commands/proxy.ts (the ADR-313/314/315 consent subcommands) stays
+ * under the repo's 500-line-per-file convention. Merged into one
+ * `proxyCommand` in proxy.ts.
+ */
+import { output } from '../output.js';
+import { hasConsent, recordConsent, revokeConsent } from '../funnel/index.js';
+import { installProxy, uninstallProxy } from '../proxy/install.js';
+import { startForeground, startBackground, stopProxy, getProxyStatus, readProxyLogTail, watchProxyLog, ProxyNotInstalledError, ProxyAlreadyRunningError, } from '../proxy/lifecycle.js';
+import { proxyTokenPath } from '../proxy/paths.js';
+import { removeInjectedToken, startTokenRefreshPump } from '../proxy/token-bridge.js';
+/** Pinned and reviewed; later upgrades remain explicit commands. */
+export const DEFAULT_PROXY_RELEASE = '0.4.0';
+const INSTALL_DISCLOSURE = [
+    'Installing the Meta LLM Proxy (ADR-304/307).',
+    '',
+    'This downloads a separately-released Rust binary (Ed25519-signature and',
+    'checksum verified before anything is written to disk) and runs it as a',
+    'local process bound to 127.0.0.1 only. The proxy routes to LOCAL',
+    'backends by default — no prompt leaves this machine. Cloud routing is a',
+    'separate, explicit opt-in (`ruflo proxy config --cloud`), never enabled',
+    'by install alone.',
+    '',
+    'Uninstall anytime: ruflo proxy uninstall',
+].join('\n');
+const installSub = {
+    name: 'install',
+    description: 'Download, verify, and install the meta-proxy binary (ADR-307)',
+    options: [
+        // NOT named 'version' — index.ts:107 globally intercepts any --version/-v
+        // anywhere in argv (`if (flags.version || flags.V) { showVersion(); return; }`)
+        // BEFORE subcommand dispatch, regardless of which command defines it. A
+        // subcommand-local --version is silently swallowed by the CLI's own
+        // `ruflo --version` handling — confirmed the hard way in E2E testing.
+        { name: 'release', description: `Release version to install (default: ${DEFAULT_PROXY_RELEASE})`, type: 'string' },
+        { name: 'yes', description: 'Skip the confirmation prompt', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        // Resolve the reviewed default before the consent gate. An explicit empty
+        // override still fails below without recording a consent receipt.
+        const version = typeof ctx.flags.release === 'string' ? ctx.flags.release : DEFAULT_PROXY_RELEASE;
+        if (!version) {
+            output.printError('ruflo proxy install requires --release <x.y.z> — there is no version-discovery ' +
+                'endpoint yet (see the plan doc for the tracked follow-up). Find the latest at ' +
+                'the release channel and pass it explicitly.');
+            return { success: false, exitCode: 1 };
+        }
+        if (!hasConsent('proxy-install')) {
+            output.writeln(INSTALL_DISCLOSURE);
+            output.writeln('');
+            const confirmed = Boolean(ctx.flags.yes);
+            if (!confirmed) {
+                output.writeln(`Re-run with --yes to confirm: ruflo proxy install --yes (installs ${version})`);
+                return { success: true, data: { confirmed: false } };
+            }
+            recordConsent('proxy-install', true, 'proxy-install');
+        }
+        try {
+            const spinner = output.createSpinner({ text: `Installing meta-proxy ${version}...`, spinner: 'dots' });
+            spinner.start();
+            const result = await installProxy({ version, log: (line) => spinner.setText(line) });
+            spinner.succeed(`meta-proxy ${version} installed`);
+            output.writeln(`  binary: ${result.binaryPath}`);
+            output.writeln(`  sha256: ${result.sha256}`);
+            return { success: true, data: result };
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            output.printError('Install failed', message);
+            return { success: false, message, exitCode: 1 };
+        }
+    },
+};
+const updateSub = {
+    name: 'update',
+    description: 'Re-verify and replace the installed binary with a specific version (never automatic)',
+    options: [{ name: 'release', description: 'Release version to install', type: 'string', required: true }],
+    action: async (ctx) => {
+        const version = typeof ctx.flags.release === 'string' ? ctx.flags.release : undefined;
+        if (!version) {
+            output.printError('ruflo proxy update requires --release <x.y.z>');
+            return { success: false, exitCode: 1 };
+        }
+        try {
+            const spinner = output.createSpinner({ text: `Updating meta-proxy to ${version}...`, spinner: 'dots' });
+            spinner.start();
+            const result = await installProxy({ version, log: (line) => spinner.setText(line) });
+            spinner.succeed(`meta-proxy updated to ${version}`);
+            output.writeln(`  binary: ${result.binaryPath}`);
+            return { success: true, data: result };
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            output.printError('Update failed', message);
+            return { success: false, message, exitCode: 1 };
+        }
+    },
+};
+const startSub = {
+    name: 'start',
+    description: 'Start meta-proxy (foreground by default; --service to detach)',
+    options: [
+        { name: 'service', description: 'Run detached (background), survives terminal close but not a reboot — full OS-service registration is not yet implemented', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        const service = Boolean(ctx.flags.service);
+        try {
+            if (service) {
+                const { pid } = await startBackground();
+                output.printSuccess(`meta-proxy started in the background (pid ${pid})`);
+                output.writeln('  Note: survives this terminal closing, but not a reboot — OS-service registration is not yet implemented.');
+                output.writeln('  Logs: ruflo proxy logs');
+                return { success: true, data: { pid } };
+            }
+            output.writeln('Starting meta-proxy in the foreground — press Ctrl+C to stop.');
+            await startTokenRefreshPump();
+            await startForeground(); // never returns normally
+            return { success: true };
+        }
+        catch (e) {
+            if (e instanceof ProxyNotInstalledError || e instanceof ProxyAlreadyRunningError) {
+                output.printError(e.message);
+                return { success: false, message: e.message, exitCode: 1 };
+            }
+            const message = e instanceof Error ? e.message : String(e);
+            output.printError('Failed to start meta-proxy', message);
+            return { success: false, message, exitCode: 1 };
+        }
+    },
+};
+const superviseSub = {
+    name: 'supervise',
+    description: 'Internal detached supervisor for token refresh and meta-proxy lifecycle',
+    action: async () => {
+        await startTokenRefreshPump();
+        await startForeground(true);
+        return { success: true };
+    },
+};
+const stopSub = {
+    name: 'stop',
+    description: 'Stop a running meta-proxy process',
+    action: async () => {
+        const result = await stopProxy();
+        removeInjectedToken();
+        if (!result.wasRunning) {
+            output.writeln('meta-proxy was not running.');
+            return { success: true, data: result };
+        }
+        output.printSuccess(`meta-proxy stopped (was pid ${result.pid})`);
+        return { success: true, data: result };
+    },
+};
+const statusSub = {
+    name: 'status',
+    description: 'Show meta-proxy install + process status',
+    options: [{ name: 'json', description: 'Machine-readable output', type: 'boolean', default: false }],
+    action: async (ctx) => {
+        const status = getProxyStatus();
+        if (ctx.flags.json) {
+            output.printJson(status);
+            return { success: true, data: status };
+        }
+        output.writeln(`Installed: ${status.installed ? 'yes' : 'no'}`);
+        output.writeln(`Running: ${status.running ? `yes (pid ${status.pid})` : 'no'}`);
+        if (status.stalePidFile)
+            output.writeln('  (a stale PID file was found and will be cleared on next start)');
+        if (!status.installed)
+            output.writeln(`Run: ruflo proxy install --yes (installs ${DEFAULT_PROXY_RELEASE})`);
+        else if (!status.running)
+            output.writeln('Run: ruflo proxy start');
+        return { success: true, data: status };
+    },
+};
+const logsSub = {
+    name: 'logs',
+    description: 'Show meta-proxy --service logs',
+    options: [
+        { name: 'follow', short: 'f', description: 'Stream new log lines as they arrive', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        if (ctx.flags.follow) {
+            output.writeln('Following meta-proxy logs — press Ctrl+C to stop.');
+            try {
+                const watcher = watchProxyLog((line) => output.writeln(line));
+                await new Promise((resolve) => {
+                    process.on('SIGINT', () => {
+                        watcher.close();
+                        resolve();
+                    });
+                });
+                return { success: true };
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                output.printError(message);
+                return { success: false, message, exitCode: 1 };
+            }
+        }
+        const tail = readProxyLogTail();
+        if (!tail) {
+            output.writeln('No log content yet — meta-proxy has never been started in --service mode.');
+            return { success: true, data: { empty: true } };
+        }
+        output.writeln(tail);
+        return { success: true };
+    },
+};
+const uninstallSub = {
+    name: 'uninstall',
+    description: 'Stop the proxy (if running), remove the binary, token, and consent receipt',
+    action: async () => {
+        const status = getProxyStatus();
+        if (status.running) {
+            await stopProxy();
+            output.writeln('Stopped the running meta-proxy process.');
+        }
+        const removed = await uninstallProxy();
+        const { existsSync, unlinkSync } = await import('node:fs');
+        const tokenPath = proxyTokenPath();
+        if (existsSync(tokenPath))
+            unlinkSync(tokenPath);
+        removeInjectedToken();
+        revokeConsent('proxy-install', 'proxy-uninstall');
+        output.printSuccess(removed ? 'meta-proxy uninstalled.' : 'Nothing was installed — cleaned up any leftover state.');
+        return { success: true, data: { removed } };
+    },
+};
+export const proxyLifecycleSubcommands = [installSub, updateSub, startSub, superviseSub, stopSub, statusSub, logsSub, uninstallSub];
+//# sourceMappingURL=proxy-lifecycle.js.map

package/dist/src/commands/proxy.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `ruflo proxy` — Meta LLM Proxy control surface (ADR-304/307/313).
+ *
+ * This command currently implements the ADR-313 sponsored-downtime
+ * subcommands only (`sponsor-enable` / `sponsor-disable` / `sponsor-status`).
+ * The full lifecycle command set ADR-307 specifies
+ * (`install|start|stop|status|logs|update|uninstall`) manages the proxy
+ * *process* itself and is out of scope here — this surface only manages
+ * the consent-gated sponsored-mode flag the already-running proxy reads
+ * from its config mirror.
+ *
+ * Consent (ADR-302/313): granting `sponsored-downtime` consent here writes
+ * BOTH the ruflo-side consent receipt (source of truth) AND a mirror flag
+ * into ~/.ruflo/proxy-config.toml (the file the Rust proxy binary reads).
+ * The proxy never writes this file — ruflo does, exactly once per
+ * enable/disable action.
+ */
+import type { Command } from '../types.js';
+export declare const proxyCommand: Command;
+export default proxyCommand;
+//# sourceMappingURL=proxy.d.ts.map

package/dist/src/commands/proxy.js

@@ -0,0 +1,398 @@
+/**
+ * `ruflo proxy` — Meta LLM Proxy control surface (ADR-304/307/313).
+ *
+ * This command currently implements the ADR-313 sponsored-downtime
+ * subcommands only (`sponsor-enable` / `sponsor-disable` / `sponsor-status`).
+ * The full lifecycle command set ADR-307 specifies
+ * (`install|start|stop|status|logs|update|uninstall`) manages the proxy
+ * *process* itself and is out of scope here — this surface only manages
+ * the consent-gated sponsored-mode flag the already-running proxy reads
+ * from its config mirror.
+ *
+ * Consent (ADR-302/313): granting `sponsored-downtime` consent here writes
+ * BOTH the ruflo-side consent receipt (source of truth) AND a mirror flag
+ * into ~/.ruflo/proxy-config.toml (the file the Rust proxy binary reads).
+ * The proxy never writes this file — ruflo does, exactly once per
+ * enable/disable action.
+ */
+import * as fs from 'fs';
+import { output } from '../output.js';
+import { hasConsent, recordConsent, revokeConsent, funnelStateDir } from '../funnel/index.js';
+import { recordFunnelEvent } from '../funnel/events.js';
+import { clearRateLimitStatus, readRateLimitStatus } from '../funnel/rate-limit-notifier.js';
+import { clearQuotaLowStatus, readQuotaLowStatus } from '../funnel/power-saver-notifier.js';
+import { getInstalledCliVersion } from '../init/helper-refresh.js';
+import * as path from 'path';
+import { proxyLifecycleSubcommands } from './proxy-lifecycle.js';
+const PROXY_CONFIG_FILE = 'proxy-config.toml';
+/**
+ * Minimal hand-rolled TOML writer — this config has exactly one boolean
+ * field ruflo needs to set (`sponsored_consent_granted`); every other field
+ * the proxy binary defaults itself (ADR-307 "a malformed config must never
+ * crash the proxy — it degrades to safe defaults"). We read-modify-write
+ * the raw text so a user's own bind/backend customizations survive, only
+ * ever touching this one line. No TOML parser dependency needed for this.
+ */
+function readProxyConfigRaw() {
+    try {
+        return fs.readFileSync(path.join(funnelStateDir(), PROXY_CONFIG_FILE), 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+function writeConfigLine(field, rawValue) {
+    const dir = funnelStateDir();
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const target = path.join(dir, PROXY_CONFIG_FILE);
+    const raw = readProxyConfigRaw();
+    const line = `${field} = ${rawValue}`;
+    const pattern = new RegExp(`^${field}\\s*=.*$`, 'm');
+    let next;
+    if (pattern.test(raw)) {
+        next = raw.replace(pattern, line);
+    }
+    else {
+        next = raw.length > 0 ? `${raw.trimEnd()}\n${line}\n` : `${line}\n`;
+    }
+    const tmp = `${target}.tmp`;
+    fs.writeFileSync(tmp, next, { encoding: 'utf-8', mode: 0o600 });
+    fs.renameSync(tmp, target);
+}
+function writeConsentMirrorLine(field, value) {
+    writeConfigLine(field, String(value));
+}
+function writeSponsoredConsentMirror(granted) {
+    writeConsentMirrorLine('sponsored_consent_granted', granted);
+}
+function writePowerSaverConsentMirror(granted) {
+    writeConsentMirrorLine('power_saver_consent_granted', granted);
+}
+function writeTrainingShareConsentMirror(granted) {
+    writeConsentMirrorLine('training_share_consent_granted', granted);
+}
+/**
+ * `default_data_plane` — the ADR-304 cloud-routing toggle. Values confirmed
+ * against meta-proxy's actual `DataPlane` enum (`src/config.rs`,
+ * `#[serde(rename_all = "snake_case")]`): "local" | "cloud" | "sponsored" |
+ * "passthrough" (the last two are not written by this command — sponsored
+ * is ADR-313's own consent flag, passthrough is the proxy's own default).
+ */
+function readDataPlane() {
+    const raw = readProxyConfigRaw();
+    const match = raw.match(/^default_data_plane\s*=\s*"([^"]*)"/m);
+    return match ? match[1] : 'passthrough'; // matches the Rust struct's own default
+}
+function writeDataPlane(plane) {
+    writeConfigLine('default_data_plane', `"${plane}"`);
+}
+const CLOUD_ROUTING_DISCLOSURE = [
+    'Enabling cloud routing.',
+    '',
+    'With cloud routing ON, prompts for cloud-tier requests are sent to',
+    'api.cognitum.one and forwarded to the selected provider',
+    '(Claude / GPT / Gemini / DeepSeek / OpenRouter).',
+    '',
+    'Requests routed to local backends never leave this machine.',
+    '',
+    'Disable anytime: ruflo proxy config --local-only',
+].join('\n');
+const configSub = {
+    name: 'config',
+    description: 'Toggle cloud routing (ADR-304) — local backends only by default',
+    options: [
+        { name: 'cloud', description: 'Enable cloud routing (requires cloud-routing consent)', type: 'boolean', default: false },
+        { name: 'local-only', description: 'Disable cloud routing, revert to local-only routing', type: 'boolean', default: false },
+        { name: 'yes', description: 'Skip the confirmation prompt', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        const wantCloud = Boolean(ctx.flags.cloud);
+        const wantLocalOnly = Boolean(ctx.flags.localOnly ?? ctx.flags['local-only']);
+        if (wantCloud && wantLocalOnly) {
+            output.printError('Pass either --cloud or --local-only, not both.');
+            return { success: false, exitCode: 1 };
+        }
+        if (!wantCloud && !wantLocalOnly) {
+            const plane = readDataPlane();
+            output.writeln(`Current data plane: ${plane}`);
+            output.writeln(plane === 'cloud'
+                ? 'Cloud routing is ON — cloud-tier requests go to api.cognitum.one.'
+                : 'Cloud routing is OFF — requests never leave this machine (or use your own Claude subscription on Passthrough).');
+            return { success: true, data: { plane } };
+        }
+        if (wantLocalOnly) {
+            writeDataPlane('local');
+            revokeConsent('cloud-routing', 'proxy-config-local-only');
+            output.printSuccess('Cloud routing disabled — reverted to local-only routing.');
+            return { success: true, data: { plane: 'local' } };
+        }
+        // wantCloud
+        if (!hasConsent('cloud-routing')) {
+            output.writeln(CLOUD_ROUTING_DISCLOSURE);
+            output.writeln('');
+            if (!ctx.flags.yes) {
+                output.writeln('Re-run with --yes to confirm: ruflo proxy config --cloud --yes');
+                return { success: true, data: { confirmed: false } };
+            }
+            recordConsent('cloud-routing', true, 'proxy-config-cloud');
+        }
+        writeDataPlane('cloud');
+        output.printSuccess('Cloud routing enabled.');
+        output.writeln('  Requests routed to local backends still never leave this machine.');
+        output.writeln('  Disable anytime: ruflo proxy config --local-only');
+        return { success: true, data: { plane: 'cloud' } };
+    },
+};
+const SPONSOR_DISCLOSURE = [
+    'Enabling sponsored downtime mode.',
+    '',
+    "While your Claude usage limit resets, requests can be routed through",
+    "Cognitum's own model capacity, sponsored at no cost to you. This is a",
+    'separate data plane from your own cloud-routing config — Cognitum sees',
+    'these prompts (server-side, same handling as any api.cognitum.one',
+    'request), never your own Claude account.',
+    '',
+    'Sponsored capacity is rate-limited and best-effort — Cognitum may',
+    'throttle or decline requests under load. Disable anytime:',
+    '  ruflo proxy sponsor-disable',
+].join('\n');
+const sponsorEnableSub = {
+    name: 'sponsor-enable',
+    description: "Opt into Cognitum-sponsored downtime capacity (ADR-313)",
+    options: [
+        { name: 'yes', description: 'Skip the confirmation prompt', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        if (hasConsent('sponsored-downtime')) {
+            output.writeln('Sponsored downtime mode is already enabled.');
+            return { success: true, data: { alreadyEnabled: true } };
+        }
+        output.writeln(SPONSOR_DISCLOSURE);
+        output.writeln('');
+        if (!ctx.flags.yes) {
+            output.writeln('Re-run with --yes to confirm: ruflo proxy sponsor-enable --yes');
+            return { success: true, data: { confirmed: false } };
+        }
+        recordConsent('sponsored-downtime', true, 'proxy-sponsor-enable');
+        writeSponsoredConsentMirror(true);
+        recordFunnelEvent('sponsor_mode_enabled', 'statusline', getInstalledCliVersion());
+        output.printSuccess('Sponsored downtime mode enabled.');
+        output.writeln('The proxy will use it automatically while ruflo settings notices');
+        output.writeln('rate-limited is flagged. Disable anytime: ruflo proxy sponsor-disable');
+        return { success: true, data: { confirmed: true } };
+    },
+};
+const sponsorDisableSub = {
+    name: 'sponsor-disable',
+    description: 'Revoke sponsored-downtime consent and stop using sponsored capacity',
+    action: async () => {
+        revokeConsent('sponsored-downtime', 'proxy-sponsor-disable');
+        writeSponsoredConsentMirror(false);
+        recordFunnelEvent('sponsor_mode_disabled', 'statusline', getInstalledCliVersion());
+        output.printSuccess('Sponsored downtime mode disabled.');
+        return { success: true };
+    },
+};
+const sponsorStatusSub = {
+    name: 'sponsor-status',
+    description: 'Show sponsored-downtime consent + rate-limit flag state',
+    action: async () => {
+        const consented = hasConsent('sponsored-downtime');
+        const rateLimited = readRateLimitStatus();
+        output.writeln(`Sponsored downtime consent: ${consented ? 'granted' : 'not granted'}`);
+        output.writeln(`Rate-limit flag: ${rateLimited.limited ? `set (since ${rateLimited.since})` : 'not set'}`);
+        if (rateLimited.limited && !consented) {
+            output.writeln('');
+            output.writeln('You are flagged as rate-limited but have not enabled sponsored');
+            output.writeln('capacity. Enable it with: ruflo proxy sponsor-enable --yes');
+        }
+        return { success: true, data: { consented, rateLimited } };
+    },
+};
+/** Convenience: clear the rate-limited flag once you're back to normal. */
+const sponsorClearSub = {
+    name: 'sponsor-clear',
+    description: 'Clear the rate-limited flag (your Claude limit has reset)',
+    action: async () => {
+        const changed = clearRateLimitStatus();
+        if (!changed) {
+            output.printError('Rate-limit flag was just toggled — try again in a few minutes (ADR-314 anti-abuse cooldown).');
+            return { success: false };
+        }
+        output.printSuccess('Rate-limit flag cleared.');
+        return { success: true };
+    },
+};
+const POWER_SAVER_DISCLOSURE = [
+    'Enabling power saver mode.',
+    '',
+    "Everyday requests will route through Cognitum's own difficulty-based",
+    'router (cognitum-auto) instead of your Claude subscription directly —',
+    'simple messages stay cheap, genuinely hard reasoning still escalates to',
+    'a comparable frontier model. This is billed to YOUR OWN Cognitum',
+    'account (cloud-routing), not sponsored/free capacity — a separate',
+    'decision from sponsored downtime mode.',
+    '',
+    'Disable anytime: ruflo proxy power-saver-disable',
+].join('\n');
+const powerSaverEnableSub = {
+    name: 'power-saver-enable',
+    description: 'Opt into power saver mode — route everyday requests through your own Cognitum account (ADR-314)',
+    options: [
+        { name: 'yes', description: 'Skip the confirmation prompt', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        if (hasConsent('power-saver')) {
+            output.writeln('Power saver mode is already enabled.');
+            return { success: true, data: { alreadyEnabled: true } };
+        }
+        output.writeln(POWER_SAVER_DISCLOSURE);
+        output.writeln('');
+        if (!ctx.flags.yes) {
+            output.writeln('Re-run with --yes to confirm: ruflo proxy power-saver-enable --yes');
+            return { success: true, data: { confirmed: false } };
+        }
+        recordConsent('power-saver', true, 'proxy-power-saver-enable');
+        writePowerSaverConsentMirror(true);
+        recordFunnelEvent('power_saver_enabled', 'statusline', getInstalledCliVersion());
+        output.printSuccess('Power saver mode enabled.');
+        output.writeln('Flag it active with: ruflo settings notices quota-low');
+        output.writeln('Disable anytime: ruflo proxy power-saver-disable');
+        return { success: true, data: { confirmed: true } };
+    },
+};
+const powerSaverDisableSub = {
+    name: 'power-saver-disable',
+    description: 'Revoke power-saver consent and stop routing through Cognitum for cost savings',
+    action: async () => {
+        revokeConsent('power-saver', 'proxy-power-saver-disable');
+        writePowerSaverConsentMirror(false);
+        recordFunnelEvent('power_saver_disabled', 'statusline', getInstalledCliVersion());
+        output.printSuccess('Power saver mode disabled.');
+        return { success: true };
+    },
+};
+const powerSaverStatusSub = {
+    name: 'power-saver-status',
+    description: 'Show power-saver consent + quota-low flag state',
+    action: async () => {
+        const consented = hasConsent('power-saver');
+        const quotaLow = readQuotaLowStatus();
+        output.writeln(`Power saver consent: ${consented ? 'granted' : 'not granted'}`);
+        output.writeln(`Quota-low flag: ${quotaLow.low ? `set (since ${quotaLow.since})` : 'not set'}`);
+        if (quotaLow.low && !consented) {
+            output.writeln('');
+            output.writeln('You are flagged as running low but have not enabled power saver');
+            output.writeln('mode. Enable it with: ruflo proxy power-saver-enable --yes');
+        }
+        return { success: true, data: { consented, quotaLow } };
+    },
+};
+/** Convenience: clear the quota-low flag once you're back to normal. */
+const powerSaverClearSub = {
+    name: 'power-saver-clear',
+    description: 'Clear the quota-low flag',
+    action: async () => {
+        const changed = clearQuotaLowStatus();
+        if (!changed) {
+            output.printError('Quota-low flag was just toggled — try again in a few minutes (ADR-314 anti-abuse cooldown).');
+            return { success: false };
+        }
+        output.printSuccess('Quota-low flag cleared.');
+        return { success: true };
+    },
+};
+const TRAINING_SHARE_DISCLOSURE = [
+    'Enabling training-data sharing.',
+    '',
+    'When a request runs on the sponsored plane, the proxy will attach a',
+    'consent header telling Cognitum it may retain that interaction —',
+    '(post safety-scan) — as input to its MicroLoRA training pipeline',
+    '(meta-llm ADR-251), gated through its existing SHADOW/promotion-rule',
+    'safety net; adaptations are never auto-served. This is content, not',
+    'just metadata, and is entirely separate from sponsored-downtime',
+    'consent — using free capacity never implicitly means this is on.',
+    '',
+    'Declining has zero effect on sponsored-capacity access.',
+    '',
+    'Disable anytime: ruflo proxy training-share-disable',
+].join('\n');
+const trainingShareEnableSub = {
+    name: 'training-share-enable',
+    description: 'Opt into sharing sponsored-plane interaction content for meta-llm training (ADR-315)',
+    options: [
+        { name: 'yes', description: 'Skip the confirmation prompt', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        if (hasConsent('training-data-sharing')) {
+            output.writeln('Training-data sharing is already enabled.');
+            return { success: true, data: { alreadyEnabled: true } };
+        }
+        output.writeln(TRAINING_SHARE_DISCLOSURE);
+        output.writeln('');
+        if (!ctx.flags.yes) {
+            output.writeln('Re-run with --yes to confirm: ruflo proxy training-share-enable --yes');
+            return { success: true, data: { confirmed: false } };
+        }
+        recordConsent('training-data-sharing', true, 'proxy-training-share-enable');
+        writeTrainingShareConsentMirror(true);
+        recordFunnelEvent('training_share_enabled', 'statusline', getInstalledCliVersion());
+        output.printSuccess('Training-data sharing enabled.');
+        output.writeln('Only sponsored-plane requests carry the consent header. Disable anytime:');
+        output.writeln('  ruflo proxy training-share-disable');
+        return { success: true, data: { confirmed: true } };
+    },
+};
+const trainingShareDisableSub = {
+    name: 'training-share-disable',
+    description: 'Revoke training-data-sharing consent — stop sending the training consent header',
+    action: async () => {
+        revokeConsent('training-data-sharing', 'proxy-training-share-disable');
+        writeTrainingShareConsentMirror(false);
+        recordFunnelEvent('training_share_disabled', 'statusline', getInstalledCliVersion());
+        output.printSuccess('Training-data sharing disabled.');
+        return { success: true };
+    },
+};
+const trainingShareStatusSub = {
+    name: 'training-share-status',
+    description: 'Show training-data-sharing consent state',
+    action: async () => {
+        const consented = hasConsent('training-data-sharing');
+        output.writeln(`Training-data sharing consent: ${consented ? 'granted' : 'not granted'}`);
+        if (consented) {
+            output.writeln('Sponsored-plane requests carry X-Cognitum-Training-Consent: true.');
+        }
+        return { success: true, data: { consented } };
+    },
+};
+export const proxyCommand = {
+    name: 'proxy',
+    description: 'Meta LLM Proxy — install/lifecycle + sponsored downtime + power saver + training-data sharing (ADR-304/307/313/314/315)',
+    subcommands: [
+        ...proxyLifecycleSubcommands,
+        configSub,
+        sponsorEnableSub, sponsorDisableSub, sponsorStatusSub, sponsorClearSub,
+        powerSaverEnableSub, powerSaverDisableSub, powerSaverStatusSub, powerSaverClearSub,
+        trainingShareEnableSub, trainingShareDisableSub, trainingShareStatusSub,
+    ],
+    examples: [
+        { command: 'ruflo proxy install --yes', description: 'Install the signed Meta-Proxy v0.4.0 binary' },
+        { command: 'ruflo proxy start', description: 'Start meta-proxy in the foreground' },
+        { command: 'ruflo proxy status', description: 'Show install + process status' },
+        { command: 'ruflo proxy config --cloud --yes', description: 'Enable cloud routing (ADR-304)' },
+        { command: 'ruflo proxy config --local-only', description: 'Revert to local-only routing' },
+        { command: 'ruflo proxy sponsor-status', description: 'Show current sponsored-mode state' },
+        { command: 'ruflo proxy sponsor-enable --yes', description: 'Opt into sponsored downtime capacity' },
+        { command: 'ruflo proxy power-saver-enable --yes', description: 'Opt into power saver mode' },
+        { command: 'ruflo proxy training-share-enable --yes', description: 'Opt into training-data sharing (ADR-315)' },
+    ],
+    action: async (ctx) => {
+        const { getProxyStatus } = await import('../proxy/lifecycle.js');
+        const status = getProxyStatus();
+        output.writeln(`Installed: ${status.installed ? 'yes' : 'no'}; Running: ${status.running ? `yes (pid ${status.pid})` : 'no'}`);
+        return sponsorStatusSub.action(ctx);
+    },
+};
+export default proxyCommand;
+//# sourceMappingURL=proxy.js.map

package/dist/src/commands/route.d.ts

@@ -0,0 +1,16 @@
+/**
+ * V3 CLI Route Command
+ * Intelligent task-to-agent routing using Q-Learning
+ *
+ * Features:
+ * - Q-Learning based agent selection
+ * - Semantic task understanding
+ * - Confidence scoring
+ * - Learning from feedback
+ *
+ * Created with love by ruv.io
+ */
+import type { Command } from '../types.js';
+export declare const routeCommand: Command;
+export default routeCommand;
+//# sourceMappingURL=route.d.ts.map