@claude-flow/cli 3.25.6 → 3.26.0

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();

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

@@ -0,0 +1,19 @@
+/**
+ * `ruflo settings` — user-facing preferences router (ADR-311 amendment).
+ *
+ * The name change from `ruflo funnel …` is deliberate copy discipline:
+ * "funnel" is internal analytics terminology; it should not appear in the
+ * command surface end users see. Every subcommand here forwards to the
+ * existing `ruflo funnel` primitives so behavior stays identical — this
+ * is a friendlier wrapper, not a re-implementation.
+ *
+ * Subcommands:
+ *   ruflo settings                     Show effective settings + how to change them
+ *   ruflo settings notices status      Show whether the notices row is on
+ *   ruflo settings notices off         Turn off the notices row (persistent)
+ *   ruflo settings notices on          Re-enable the notices row
+ *   ruflo settings notices id          Show the pseudonymous notices id
+ */
+import type { Command } from '../types.js';
+export declare const settingsCommand: Command;
+//# sourceMappingURL=settings.d.ts.map

package/dist/src/commands/settings.js

@@ -0,0 +1,180 @@
+/**
+ * `ruflo settings` — user-facing preferences router (ADR-311 amendment).
+ *
+ * The name change from `ruflo funnel …` is deliberate copy discipline:
+ * "funnel" is internal analytics terminology; it should not appear in the
+ * command surface end users see. Every subcommand here forwards to the
+ * existing `ruflo funnel` primitives so behavior stays identical — this
+ * is a friendlier wrapper, not a re-implementation.
+ *
+ * Subcommands:
+ *   ruflo settings                     Show effective settings + how to change them
+ *   ruflo settings notices status      Show whether the notices row is on
+ *   ruflo settings notices off         Turn off the notices row (persistent)
+ *   ruflo settings notices on          Re-enable the notices row
+ *   ruflo settings notices id          Show the pseudonymous notices id
+ */
+import { output } from '../output.js';
+import { deleteFunnelData, funnelStateDir, getDisclosure, getFunnelId, hasConsent, readConsents, recordDisclosureDeclined, recordDisclosureReenabled, resolveFunnelEnabled, } from '../funnel/index.js';
+import { readStateJson, writeStateJson } from '../funnel/state.js';
+import { clearRateLimitStatus, markRateLimited, rateLimitNotice, readRateLimitStatus, } from '../funnel/rate-limit-notifier.js';
+import { clearQuotaLowStatus, markQuotaLow, quotaLowNotice, readQuotaLowStatus, } from '../funnel/power-saver-notifier.js';
+function setUserConfigEnabled(enabled) {
+    const cfg = readStateJson('funnel.json') ?? {};
+    cfg.enabled = enabled;
+    writeStateJson('funnel.json', cfg);
+}
+const noticesStatusSub = {
+    name: 'status',
+    description: 'Show whether notices are on and which source decided it',
+    action: async () => {
+        const decision = resolveFunnelEnabled();
+        const disclosure = getDisclosure();
+        output.writeln(`Notices: ${decision.enabled ? 'enabled' : 'disabled'} (decided by: ${decision.decidedBy})`);
+        output.writeln(`Disclosure: ${disclosure.state}`);
+        output.writeln(`Telemetry: ${hasConsent('telemetry') ? 'consent granted' : 'no consent'}`);
+        return { success: true, data: { decision, disclosure: disclosure.state } };
+    },
+};
+const noticesOffSub = {
+    name: 'off',
+    description: 'Turn off statusline notices (persistent, user-level)',
+    action: async () => {
+        setUserConfigEnabled(false);
+        recordDisclosureDeclined();
+        deleteFunnelData();
+        output.printSuccess('Notices disabled. Local notice data deleted.');
+        return { success: true };
+    },
+};
+const noticesOnSub = {
+    name: 'on',
+    description: 'Re-enable statusline notices',
+    action: async () => {
+        setUserConfigEnabled(true);
+        recordDisclosureReenabled();
+        const decision = resolveFunnelEnabled();
+        if (decision.enabled) {
+            output.printSuccess('Notices enabled.');
+        }
+        else {
+            output.printWarning(`User preference recorded, but notices stay off (decided by: ${decision.decidedBy})`);
+        }
+        return { success: true, data: decision };
+    },
+};
+const noticesIdSub = {
+    name: 'id',
+    description: 'Print the pseudonymous notices ID (telemetry consent required)',
+    action: async () => {
+        const id = getFunnelId();
+        output.writeln(id ?? '(no id — telemetry consent not granted, or notices are off)');
+        return { success: true, data: { id } };
+    },
+};
+const rateLimitedSub = {
+    name: 'rate-limited',
+    description: 'Manually flag that you have hit a Claude usage limit (ADR-312 Phase 0)',
+    options: [
+        { name: 'clear', description: 'Clear the flag', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        if (ctx.flags.clear) {
+            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 changed = markRateLimited();
+        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 set.');
+        output.writeln('');
+        output.writeln('This is a manual, self-reported flag — ruflo cannot detect Claude\'s');
+        output.writeln('usage-limit state automatically today (see ADR-312). While flagged,');
+        output.writeln('the notices row may suggest sponsored Cognitum capacity as a bridge');
+        output.writeln('until your own limit resets: ruflo proxy sponsor-enable');
+        output.writeln('');
+        output.writeln('Clear it any time: ruflo settings notices rate-limited --clear');
+        const notice = rateLimitNotice();
+        return { success: true, data: { notice, status: readRateLimitStatus() } };
+    },
+};
+const quotaLowSub = {
+    name: 'quota-low',
+    description: 'Manually flag that your Claude quota is running low (ADR-314 power saver)',
+    options: [
+        { name: 'clear', description: 'Clear the flag', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        if (ctx.flags.clear) {
+            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 changed = markQuotaLow();
+        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 set.');
+        output.writeln('');
+        output.writeln('This is a manual, self-reported flag — ruflo cannot read your actual');
+        output.writeln('quota percentage today (see ADR-312/314). While flagged, and once you');
+        output.writeln('enable power saver mode, everyday requests route through Cognitum\'s');
+        output.writeln('own difficulty-based router (billed to your own Cognitum account):');
+        output.writeln('  ruflo proxy power-saver-enable');
+        output.writeln('');
+        output.writeln('Clear it any time: ruflo settings notices quota-low --clear');
+        const notice = quotaLowNotice();
+        return { success: true, data: { notice, status: readQuotaLowStatus() } };
+    },
+};
+const noticesCommand = {
+    name: 'notices',
+    description: 'Control the statusline notices row',
+    subcommands: [noticesStatusSub, noticesOffSub, noticesOnSub, noticesIdSub, rateLimitedSub, quotaLowSub],
+    action: noticesStatusSub.action,
+};
+const overviewAction = async () => {
+    const decision = resolveFunnelEnabled();
+    const disclosure = getDisclosure();
+    const consents = readConsents();
+    output.writeln('ruflo settings — user preferences');
+    output.writeln('');
+    output.writeln('Notices (statusline tips + product updates)');
+    output.writeln('  ruflo settings notices status    Show current state');
+    output.writeln('  ruflo settings notices off       Turn off all notices');
+    output.writeln('  ruflo settings notices on        Re-enable');
+    output.writeln('  ruflo settings notices id        Show pseudonymous notices id');
+    output.writeln('');
+    output.writeln(`  current: ${decision.enabled ? 'enabled' : 'disabled'} (${decision.decidedBy})`);
+    output.writeln(`  disclosure: ${disclosure.state}`);
+    const domains = Object.keys(consents);
+    if (domains.length) {
+        output.writeln(`  consents: ${domains.join(', ')}`);
+    }
+    output.writeln(`  state dir: ${funnelStateDir()}`);
+    return { success: true, data: { decision, disclosure: disclosure.state, consents } };
+};
+export const settingsCommand = {
+    name: 'settings',
+    description: 'View and change user preferences (notices, consents)',
+    subcommands: [noticesCommand],
+    examples: [
+        { command: 'ruflo settings', description: 'Overview + current state' },
+        { command: 'ruflo settings notices off', description: 'Turn off statusline notices' },
+        { command: 'ruflo settings notices status', description: 'Show current notices state' },
+    ],
+    action: overviewAction,
+};
+//# sourceMappingURL=settings.js.map