@claude-flow/cli 3.25.5 → 3.26.0

package/dist/src/commands/hooks.js

@@ -8,6 +8,7 @@ import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { storeCommand } from './transfer-store.js';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
+import { getSecurityStatus as sharedGetSecurityStatus, getSwarmStatus as sharedGetSwarmStatus, getGitUncommittedCount as sharedGetGitUncommittedCount, } from '../funnel/local-signals.js';
 /**
  * #1686 — `?? 0` only defaults null/undefined; NaN slips through and
  * surfaces as `"NaN"` (or earlier crashed `.toFixed`) in the metrics
@@ -3412,52 +3413,11 @@ const statuslineCommand = {
             const dddProgress = Math.min(100, Math.floor((domainsCompleted / totalDomains) * 100));
             return { domainsCompleted, totalDomains, dddProgress, patternsLearned: learning.patterns, sessionsCompleted: learning.sessions };
         }
-        // Get security status
-        function getSecurityStatus() {
-            const scanResultsPath = path.join(process.cwd(), '.claude', 'security-scans');
-            let cvesFixed = 0;
-            const totalCves = 3;
-            if (fs.existsSync(scanResultsPath)) {
-                try {
-                    const scans = fs.readdirSync(scanResultsPath).filter((f) => f.endsWith('.json'));
-                    cvesFixed = Math.min(totalCves, scans.length);
-                }
-                catch {
-                    // Ignore
-                }
-            }
-            const auditPath = path.join(process.cwd(), '.swarm', 'security');
-            if (fs.existsSync(auditPath)) {
-                try {
-                    const audits = fs.readdirSync(auditPath).filter((f) => f.includes('audit'));
-                    cvesFixed = Math.min(totalCves, Math.max(cvesFixed, audits.length));
-                }
-                catch {
-                    // Ignore
-                }
-            }
-            const status = cvesFixed >= totalCves ? 'CLEAN' : cvesFixed > 0 ? 'IN_PROGRESS' : 'PENDING';
-            return { status, cvesFixed, totalCves };
-        }
-        // Get swarm status
-        function getSwarmStatus() {
-            let activeAgents = 0;
-            let coordinationActive = false;
-            const maxAgents = 15;
-            const isWindows = process.platform === 'win32';
-            try {
-                const psCmd = isWindows
-                    ? 'tasklist /FI "IMAGENAME eq node.exe" /NH 2>NUL | find /c /v "" 2>NUL || echo 0'
-                    : 'ps aux 2>/dev/null | grep -c agentic-flow || echo "0"';
-                const ps = execSync(psCmd, { encoding: 'utf-8', timeout: 3000 });
-                activeAgents = Math.max(0, parseInt(ps.trim()) - 1);
-                coordinationActive = activeAgents > 0;
-            }
-            catch {
-                // ps/tasklist unavailable or timed out — report zero
-            }
-            return { activeAgents, maxAgents, coordinationActive };
-        }
+        // Security/swarm status — shared with the advisor-tip refresh (ADR-316)
+        // via funnel/local-signals.ts, a single source of truth so the two call
+        // sites can never silently drift on what these signals mean.
+        const getSecurityStatus = sharedGetSecurityStatus;
+        const getSwarmStatus = sharedGetSwarmStatus;
         // Get system metrics
         function getSystemMetrics() {
             let memoryMB = 0;
@@ -3554,12 +3514,30 @@ const statuslineCommand = {
         const swarm = getSwarmStatus();
         const system = getSystemMetrics();
         const user = getUserInfo();
+        const getGitUncommittedCount = sharedGetGitUncommittedCount;
+        // Funnel promo row (ADR-301). The statusline is spawned with piped stdio
+        // by an interactive host, so interactivity is asserted here; all other
+        // gates (RUFLO_FUNNEL, enterprise policy, config, CI, disclosure,
+        // rotation ratio) are enforced inside getFunnelPromo. Never allowed to
+        // break the statusline.
+        let promo = null;
+        try {
+            const { getFunnelPromo } = await import('../funnel/index.js');
+            promo = getFunnelPromo({
+                interactive: true,
+                localInsights: { security, swarm, gitUncommittedCount: getGitUncommittedCount() },
+            });
+        }
+        catch {
+            promo = null;
+        }
         const statusData = {
             user,
             v3Progress: progress,
             security,
             swarm,
             system,
+            promo,
             timestamp: new Date().toISOString()
         };
         // JSON output
@@ -4418,6 +4396,90 @@ const notifyCommand = {
         return { success: true, data: { timestamp, level, message } };
     }
 };
+// Refresh-funnel subcommand — the fix for "promo doesn't load right away".
+//
+// refreshRemoteMessages() (funnel/message-transport.ts) is fire-and-forget
+// by design so the STATUSLINE's own per-render invocation never blocks on
+// a network call. But the statusline is spawned as a short-lived subprocess
+// per render (execSync from statusline-generator.ts) — a fire-and-forget
+// promise kicked off there has no "later" to run in; the process exits
+// before the HTTPS fetch can complete, so the local message cache never
+// actually gets written and the promo row never appears (confirmed live:
+// two consecutive cold-cache statusline renders, 5s apart, both returned
+// promo:null and the cache file was never created).
+//
+// This command exists to be invoked from a LONGER-LIVED context — the
+// SessionStart hook (see hook-handler.cjs's 'session-restore' handler,
+// which spawns this detached so it isn't killed when the hook's own
+// process exits, and isn't awaited so it doesn't add to the hook's own
+// timeout budget). One real, properly-awaited refresh attempt here, once
+// per session, is what actually gives refreshRemoteMessages() a chance to
+// finish before anything needs the cache.
+const refreshFunnelCommand = {
+    name: 'refresh-funnel',
+    description: 'Best-effort background refresh of the funnel message cache (internal — see hook-handler.cjs session-restore)',
+    options: [
+        { name: 'quiet', description: 'Suppress output (used when spawned detached from a hook)', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        try {
+            const { refreshRemoteMessages } = await import('../funnel/index.js');
+            const result = await refreshRemoteMessages();
+            if (!ctx.flags.quiet) {
+                output.writeln(JSON.stringify(result));
+            }
+            return { success: true, data: result };
+        }
+        catch (error) {
+            // Fail silent by design (matches message-transport.ts's own "fail
+            // silent" discipline) — a broken refresh must never surface as a
+            // hook error, only ever as "no promo this session."
+            if (!ctx.flags.quiet) {
+                output.printError(`refresh-funnel failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return { success: true, data: { refreshed: false, skipped: 'error' } };
+        }
+    }
+};
+// Refresh-advisor subcommand — ADR-316's co-pilot tip. Mirrors
+// refreshFunnelCommand exactly: a properly-awaited CLI subcommand meant to
+// be spawned DETACHED from hook-handler.cjs's session-restore handler, so a
+// real (potentially multi-second, real-money) `claude -p` call gets a
+// chance to finish without ever blocking or being awaited by the hook's own
+// process. refreshAdvisorTipIfStale() itself is the safety net that makes
+// this cheap to call on every session-restore: it checks consent + a 24h
+// TTL BEFORE spending anything, so most invocations are a no-op file read.
+const refreshAdvisorCommand = {
+    name: 'refresh-advisor',
+    description: 'Best-effort background refresh of the co-pilot advisor tip (internal — see hook-handler.cjs session-restore; ADR-316)',
+    options: [
+        { name: 'quiet', description: 'Suppress output (used when spawned detached from a hook)', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        try {
+            const { refreshAdvisorTipIfStale } = await import('../funnel/advisor-tip.js');
+            const { getSecurityStatus, getSwarmStatus, getGitUncommittedCount } = await import('../funnel/local-signals.js');
+            const result = await refreshAdvisorTipIfStale({
+                security: getSecurityStatus(),
+                swarm: getSwarmStatus(),
+                gitUncommittedCount: getGitUncommittedCount(),
+            });
+            if (!ctx.flags.quiet) {
+                output.writeln(JSON.stringify(result));
+            }
+            return { success: true, data: result };
+        }
+        catch (error) {
+            // Fail silent by design (matches refresh-funnel's own discipline) — a
+            // broken advisor refresh must never surface as a hook error, only
+            // ever as "no tip this window."
+            if (!ctx.flags.quiet) {
+                output.printError(`refresh-advisor failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return { success: true, data: { refreshed: false, reason: 'error' } };
+        }
+    }
+};
 // Main hooks command
 export const hooksCommand = {
     name: 'hooks',
@@ -4461,6 +4523,10 @@ export const hooksCommand = {
         // Agent Teams integration
         teammateIdleCommand,
         taskCompletedCommand,
+        // Funnel background refresh — see refreshFunnelCommand's own doc comment
+        refreshFunnelCommand,
+        // Advisor co-pilot tip background refresh — ADR-316
+        refreshAdvisorCommand,
     ],
     options: [],
     examples: [

package/dist/src/commands/index.js

@@ -31,6 +31,7 @@ const commandLoaders = {
     'hive-mind': () => import('./hive-mind.js'),
     process: () => import('./process.js'),
     daemon: () => import('./daemon.js'),
+    version: () => import('./version.js'),
     // V3 Advanced Commands (less frequently used - lazy load)
     neural: () => import('./neural.js'),
     security: () => import('./security.js'),
@@ -73,6 +74,15 @@ const commandLoaders = {
     metaharness: () => import('./metaharness.js'),
     // Eject (ADR-150 Phase 2) — lift ruflo project into a renamed standalone harness
     eject: () => import('./eject.js'),
+    // Cognitum lifecycle funnel controls (ADR-301/305/309)
+    funnel: () => import('./funnel.js'),
+    // User-facing preferences wrapper (ADR-311 copy discipline — no "funnel" in
+    // the user surface). Forwards to the funnel primitives internally.
+    settings: () => import('./settings.js'),
+    // Meta LLM Proxy — sponsored downtime capacity (ADR-304/307/313)
+    proxy: () => import('./proxy.js'),
+    // Fable co-pilot advisor tip in the statusline insight ticker (ADR-316)
+    advisor: () => import('./advisor.js'),
 };
 // Cache for loaded commands
 const loadedCommands = new Map();

package/dist/src/commands/init.js

@@ -7,6 +7,41 @@ import { confirm, select, multiSelect, input } from '../prompt.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { executeInit, executeUpgrade, executeUpgradeWithMissing, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, } from '../init/index.js';
+import { ENROLLMENT_SCREEN, recordEnrollmentOutcome, shouldOfferEnrollment, } from '../funnel/enrollment.js';
+/**
+ * ADR-302 post-init capability enrollment. One-time, interactive-TTY-only,
+ * skippable with --no-signup, auto-skipped in CI/automation. Never throws
+ * and never affects init's exit code. Accepting records the `account`
+ * consent receipt only — no other capability is enabled by this prompt.
+ */
+async function offerCapabilityEnrollment(ctx) {
+    try {
+        const noSignup = Boolean(ctx.flags['no-signup'] || ctx.flags.noSignup);
+        if (ctx.flags.format === 'json')
+            return; // scripted output stays pure
+        if (!shouldOfferEnrollment({ noSignup, cwd: ctx.cwd }))
+            return;
+        output.writeln();
+        output.writeln(ENROLLMENT_SCREEN);
+        output.writeln();
+        const accepted = await confirm({
+            message: 'Create a free Cognitum account now?',
+            default: false,
+        });
+        recordEnrollmentOutcome(Boolean(accepted));
+        output.writeln();
+        if (accepted) {
+            output.printInfo('Create your free account at https://cognitum.one');
+            output.writeln(output.dim('  CLI sign-in (`ruflo auth login`) ships with the ADR-306 auth release.'));
+        }
+        else {
+            output.writeln(output.dim('You can enable later at https://cognitum.one — this prompt will not repeat.'));
+        }
+    }
+    catch {
+        // Enrollment is optional; init success is never affected.
+    }
+}
 // Codex initialization action
 async function initCodexAction(ctx, options) {
     const { force, minimal, full, dualMode } = options;
@@ -445,6 +480,7 @@ const initAction = async (ctx) => {
         if (ctx.flags.format === 'json') {
             output.printJson(result);
         }
+        await offerCapabilityEnrollment(ctx);
         return { success: true, data: result };
     }
     catch (error) {
@@ -686,6 +722,7 @@ const wizardCommand = {
                     { setting: 'Hooks', value: `${result.summary.hooksEnabled} enabled` },
                 ],
             });
+            await offerCapabilityEnrollment(ctx);
             return { success: true, data: result };
         }
         catch (error) {
@@ -1017,6 +1054,13 @@ export const initCommand = {
             type: 'boolean',
             default: false,
         },
+        {
+            // ADR-302 — skip the one-time post-init capability enrollment prompt.
+            name: 'no-signup',
+            description: 'Skip the post-init Cognitum capability enrollment prompt',
+            type: 'boolean',
+            default: false,
+        },
         {
             name: 'only-claude',
             description: 'Only create .claude/ directory (skip runtime)',

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,310 @@
+/**
+ * `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';
+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 writeConsentMirrorLine(field, value) {
+    const dir = funnelStateDir();
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const target = path.join(dir, PROXY_CONFIG_FILE);
+    const raw = readProxyConfigRaw();
+    const line = `${field} = ${value}`;
+    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 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);
+}
+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 — sponsored downtime + power saver + training-data sharing (ADR-304/307/313/314/315)',
+    subcommands: [
+        sponsorEnableSub, sponsorDisableSub, sponsorStatusSub, sponsorClearSub,
+        powerSaverEnableSub, powerSaverDisableSub, powerSaverStatusSub, powerSaverClearSub,
+        trainingShareEnableSub, trainingShareDisableSub, trainingShareStatusSub,
+    ],
+    examples: [
+        { 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: sponsorStatusSub.action,
+};
+export default proxyCommand;
+//# sourceMappingURL=proxy.js.map

package/dist/src/commands/security.js

@@ -218,6 +218,35 @@ const scanCommand = {
                 `Critical: ${criticalCount}  High: ${highCount}  Medium: ${mediumCount}  Low: ${lowCount}`,
                 `Total Issues: ${findings.length}`,
             ].join('\n'), 'Scan Summary');
+            // Persist the scan result so downstream consumers (the statusline's
+            // getSecurityStatus in funnel/local-signals.ts, which reads
+            // `.claude/security-scans/*.json`) reflect real scan state. Best-effort:
+            // a failed write must never fail the scan itself.
+            try {
+                const scanDirOut = path.join(path.resolve(target), '.claude', 'security-scans');
+                fs.mkdirSync(scanDirOut, { recursive: true });
+                const record = {
+                    timestamp: new Date().toISOString(),
+                    target,
+                    depth,
+                    type: scanType,
+                    summary: {
+                        critical: criticalCount,
+                        high: highCount,
+                        medium: mediumCount,
+                        low: lowCount,
+                        total: findings.length,
+                    },
+                    findings,
+                };
+                // Deterministic name keyed on scan config so repeated runs overwrite
+                // rather than accumulate stale reports.
+                const outFile = path.join(scanDirOut, `scan-${scanType}-${depth}.json`);
+                fs.writeFileSync(outFile, JSON.stringify(record, null, 2));
+            }
+            catch {
+                // Persistence is advisory only — ignore write failures.
+            }
             // Auto-fix if requested
             if (fix && criticalCount + highCount > 0) {
                 output.writeln();