claude-flow 3.28.0 → 3.30.0

package/v3/@claude-flow/cli/dist/src/commands/ruvector/status.js

@@ -177,8 +177,8 @@ export const statusCommand = {
                 spinner.setText('Checking vector extension...');
             spinner.start();
             // Check for ruvector first
-            const ruvectorResult = await client.query(`
-        SELECT extname, extversion FROM pg_extension WHERE extname = 'ruvector'
+            const ruvectorResult = await client.query(`
+        SELECT extname, extversion FROM pg_extension WHERE extname = 'ruvector'
       `);
             if (ruvectorResult.rows.length > 0) {
                 statusData.pgvector = {
@@ -192,8 +192,8 @@ export const statusCommand = {
             }
             else {
                 // Fall back to pgvector
-                const pgvectorResult = await client.query(`
-          SELECT extname, extversion FROM pg_extension WHERE extname = 'vector'
+                const pgvectorResult = await client.query(`
+          SELECT extname, extversion FROM pg_extension WHERE extname = 'vector'
         `);
                 if (pgvectorResult.rows.length > 0) {
                     statusData.pgvector = {
@@ -216,8 +216,8 @@ export const statusCommand = {
             if (!jsonOutput)
                 spinner.setText(`Checking schema "${config.schema}"...`);
             spinner.start();
-            const schemaResult = await client.query(`
-        SELECT schema_name FROM information_schema.schemata WHERE schema_name = $1
+            const schemaResult = await client.query(`
+        SELECT schema_name FROM information_schema.schemata WHERE schema_name = $1
       `, [config.schema]);
             if (schemaResult.rows.length === 0) {
                 statusData.ruvector = { initialized: false };
@@ -238,8 +238,8 @@ export const statusCommand = {
                 spinner.setText('Loading RuVector metadata...');
             spinner.start();
             try {
-                const metadataResult = await client.query(`
-          SELECT key, value FROM ${config.schema}.metadata
+                const metadataResult = await client.query(`
+          SELECT key, value FROM ${config.schema}.metadata
         `);
                 const metadata = {};
                 for (const row of metadataResult.rows) {
@@ -263,23 +263,23 @@ export const statusCommand = {
             if (!jsonOutput)
                 spinner.setText('Gathering table statistics...');
             spinner.start();
-            const tablesResult = await client.query(`
-        SELECT
-          t.table_name,
-          pg_relation_size(quote_ident(t.table_schema) || '.' || quote_ident(t.table_name)) as table_size,
-          pg_total_relation_size(quote_ident(t.table_schema) || '.' || quote_ident(t.table_name)) as total_size,
-          (SELECT count(*) FROM ${config.schema}.embeddings) as row_count
-        FROM information_schema.tables t
-        WHERE t.table_schema = $1
-        ORDER BY t.table_name
+            const tablesResult = await client.query(`
+        SELECT
+          t.table_name,
+          pg_relation_size(quote_ident(t.table_schema) || '.' || quote_ident(t.table_name)) as table_size,
+          pg_total_relation_size(quote_ident(t.table_schema) || '.' || quote_ident(t.table_name)) as total_size,
+          (SELECT count(*) FROM ${config.schema}.embeddings) as row_count
+        FROM information_schema.tables t
+        WHERE t.table_schema = $1
+        ORDER BY t.table_name
       `, [config.schema]);
             const tableStats = [];
             for (const row of tablesResult.rows) {
                 // Get row count for each table
                 let rowCount = 0;
                 try {
-                    const countResult = await client.query(`
-            SELECT count(*) as cnt FROM ${config.schema}.${row.table_name}
+                    const countResult = await client.query(`
+            SELECT count(*) as cnt FROM ${config.schema}.${row.table_name}
           `);
                     rowCount = parseInt(countResult.rows[0].cnt, 10);
                 }
@@ -301,21 +301,21 @@ export const statusCommand = {
                 if (!jsonOutput)
                     spinner.setText('Gathering index information...');
                 spinner.start();
-                const indexResult = await client.query(`
-          SELECT
-            i.relname as index_name,
-            t.relname as table_name,
-            am.amname as index_type,
-            pg_relation_size(i.oid) as index_size,
-            idx.indisvalid as is_valid,
-            idx.indisunique as is_unique
-          FROM pg_index idx
-          JOIN pg_class i ON i.oid = idx.indexrelid
-          JOIN pg_class t ON t.oid = idx.indrelid
-          JOIN pg_namespace n ON n.oid = t.relnamespace
-          JOIN pg_am am ON am.oid = i.relam
-          WHERE n.nspname = $1
-          ORDER BY t.relname, i.relname
+                const indexResult = await client.query(`
+          SELECT
+            i.relname as index_name,
+            t.relname as table_name,
+            am.amname as index_type,
+            pg_relation_size(i.oid) as index_size,
+            idx.indisvalid as is_valid,
+            idx.indisunique as is_unique
+          FROM pg_index idx
+          JOIN pg_class i ON i.oid = idx.indexrelid
+          JOIN pg_class t ON t.oid = idx.indrelid
+          JOIN pg_namespace n ON n.oid = t.relnamespace
+          JOIN pg_am am ON am.oid = i.relam
+          WHERE n.nspname = $1
+          ORDER BY t.relname, i.relname
         `, [config.schema]);
                 statusData.indexes = indexResult.rows.map(row => ({
                     name: row.index_name,
@@ -333,10 +333,10 @@ export const statusCommand = {
                 spinner.setText('Checking migration status...');
             spinner.start();
             try {
-                const migrationsResult = await client.query(`
-          SELECT version, name, applied_at
-          FROM ${config.schema}.migrations
-          ORDER BY version ASC
+                const migrationsResult = await client.query(`
+          SELECT version, name, applied_at
+          FROM ${config.schema}.migrations
+          ORDER BY version ASC
         `);
                 statusData.migrations = migrationsResult.rows.map(row => ({
                     version: row.version,

package/v3/@claude-flow/cli/dist/src/commands/spinner.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `ruflo spinner` — manage ruflo verbs in Claude Code's spinnerVerbs
+ * settings (ADR-318).
+ *
+ * Claude Code exposes `spinnerVerbs.mode` + `spinnerVerbs.verbs[]` in
+ * ~/.claude/settings.json. This command appends a curated ruflo pool to
+ * that array, tagged with a zero-width joiner marker so `disable` can
+ * strip only ruflo verbs without touching user-authored ones.
+ *
+ * NEVER replaces — always appends (see ADR-318 §Guarantees). Always backs
+ * up ~/.claude/settings.json before write.
+ */
+import type { Command } from '../types.js';
+export declare const spinnerCommand: Command;
+export default spinnerCommand;
+//# sourceMappingURL=spinner.d.ts.map

package/v3/@claude-flow/cli/dist/src/commands/spinner.js

@@ -0,0 +1,329 @@
+/**
+ * `ruflo spinner` — manage ruflo verbs in Claude Code's spinnerVerbs
+ * settings (ADR-318).
+ *
+ * Claude Code exposes `spinnerVerbs.mode` + `spinnerVerbs.verbs[]` in
+ * ~/.claude/settings.json. This command appends a curated ruflo pool to
+ * that array, tagged with a zero-width joiner marker so `disable` can
+ * strip only ruflo verbs without touching user-authored ones.
+ *
+ * NEVER replaces — always appends (see ADR-318 §Guarantees). Always backs
+ * up ~/.claude/settings.json before write.
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { output } from '../output.js';
+import { hasConsent, recordConsent, revokeConsent } from '../funnel/consent.js';
+// Zero-width joiner triple — invisible in every terminal that renders it,
+// takes zero display cells, and is exceedingly unlikely to appear in a
+// user-authored verb. Used to tag ruflo-managed entries so `disable`
+// removes ONLY ours.
+const RUFLO_MARKER = '‍‍‍';
+const SETTINGS_PATH = path.join(os.homedir(), '.claude', 'settings.json');
+// v0 baked pool (see ADR-318 for the v1 remote-served plan). Mix of neutral
+// and Cognitum-tagged verbs, all validated (some word ends in -ing, ≤ 30 chars).
+//
+// Ratio target: ~15% Cognitum-tagged, ~85% neutral — sponsor is visible but
+// doesn't dominate. With append mode + ~50 Claude Code default verbs, this
+// gives roughly a 40% chance any spin is a ruflo verb, and ~6% of ALL spins
+// show a Cognitum-tagged verb.
+const RUFLO_VERB_POOL_V0 = [
+    // Memory & retrieval (7)
+    'Consulting the memory graph',
+    'Warming the HNSW index',
+    'Recalling similar patterns',
+    'Searching semantic memory',
+    'Reranking with MMR',
+    'Traversing knowledge graph',
+    'Loading trajectory context',
+    // Optimization (6)
+    'Optimizing your prompt',
+    'Sharpening the plan',
+    'Compacting the context',
+    'Distilling the trajectory',
+    'Reducing token spend',
+    'Compressing the working set',
+    // Learning & intelligence (6)
+    'Learning from the trajectory',
+    'Training the router',
+    'Judging past verdicts',
+    'Consolidating memories',
+    'Reasoning through the graph',
+    'Predicting the next step',
+    // Security & audit (4)
+    'Auditing for CVEs',
+    'Scanning dependencies',
+    'Verifying signatures',
+    'Guarding against injection',
+    // Agents & swarm (4)
+    'Spawning subagents',
+    'Coordinating the swarm',
+    'Reaching consensus',
+    'Balancing the workload',
+    // Workflow (4)
+    'Routing to the best model',
+    'Warming background workers',
+    'Analyzing the diff',
+    'Sharpening the review',
+    // Cognitum-tagged (6)
+    'Consulting Cognitum',
+    'Checking Cognitum credits',
+    'Routing via Cognitum',
+    'Fetching a Cognitum tip',
+    'Warming Cognitum cache',
+    'Weighing Cognitum options',
+];
+// Reject anything that violates the ADR-318 §Guarantees ingest rules.
+function isValidVerb(v) {
+    if (typeof v !== 'string')
+        return false;
+    const stripped = v.replace(RUFLO_MARKER, '');
+    if (stripped.length === 0 || stripped.length > 30)
+        return false;
+    // Claude Code's spinnerVerbs takes present participles. Traditionally
+    // one word ("Thinking"), but multi-word phrases work too as long as
+    // some word ends in "-ing". Was `/ing$/i.test(stripped)` which required
+    // the whole STRING end in "ing" — that rejected every multi-word verb
+    // in the pool ("Optimizing your prompt" ends in "prompt", not "ing").
+    const words = stripped.split(/\s+/).filter(Boolean);
+    if (!words.some(w => /ing$/i.test(w)))
+        return false;
+    // Per-code-point iteration (not regex) — a naive `/[…]/` char class
+    // parsed as raw UTF-8 bytes matches bytes INSIDE multi-byte sequences
+    // of legit emoji. Today's pool is pure ASCII so the old regex worked
+    // by accident; this is the defensive fix ahead of any future emoji verb.
+    // Same pattern as commands/announcements.ts.
+    for (const ch of stripped) {
+        const cp = ch.codePointAt(0);
+        if (cp < 0x20)
+            return false;
+        if (cp === 0x7f)
+            return false;
+        if (cp >= 0x80 && cp <= 0x9f)
+            return false;
+        if (cp >= 0x202a && cp <= 0x202e)
+            return false;
+        if (cp >= 0x2066 && cp <= 0x2069)
+            return false;
+    }
+    if (/https?:\/\//i.test(stripped))
+        return false;
+    return true;
+}
+function markVerb(v) {
+    return v + RUFLO_MARKER;
+}
+function isRufloVerb(v) {
+    return typeof v === 'string' && v.includes(RUFLO_MARKER);
+}
+function readSettings() {
+    try {
+        const raw = fs.readFileSync(SETTINGS_PATH, 'utf-8');
+        return { data: JSON.parse(raw), raw };
+    }
+    catch {
+        return { data: {}, raw: null };
+    }
+}
+function backupSettings(raw) {
+    const ts = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupPath = SETTINGS_PATH + '.bak-' + ts;
+    fs.writeFileSync(backupPath, raw, 'utf-8');
+    return backupPath;
+}
+function findMostRecentBackup() {
+    try {
+        const dir = path.dirname(SETTINGS_PATH);
+        const base = path.basename(SETTINGS_PATH);
+        const entries = fs.readdirSync(dir)
+            .filter(f => f.startsWith(base + '.bak-'))
+            .sort()
+            .reverse();
+        return entries.length > 0 ? path.join(dir, entries[0]) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeSettings(data) {
+    // Ensure the .claude directory exists (fresh install case).
+    fs.mkdirSync(path.dirname(SETTINGS_PATH), { recursive: true });
+    // Atomic write: write to sibling temp file, rename over.
+    const tmp = SETTINGS_PATH + '.tmp-' + process.pid;
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+    fs.renameSync(tmp, SETTINGS_PATH);
+}
+const enableSub = {
+    name: 'enable',
+    description: "Add ruflo's curated verb pool to Claude Code's spinner rotation",
+    options: [
+        { name: 'yes', description: 'Skip the confirmation prompt', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        const validVerbs = RUFLO_VERB_POOL_V0.filter(isValidVerb);
+        if (validVerbs.length === 0) {
+            output.printError('Verb pool is empty after validation — refusing to write nothing.');
+            return { success: false };
+        }
+        // Disclosure moment (per ADR-318 §Full mix). Print the pool including
+        // Cognitum-tagged entries so the user sees what they're opting in to.
+        output.writeln('The following verbs will be appended to Claude Code\'s spinner rotation:');
+        output.writeln('');
+        for (const v of validVerbs)
+            output.writeln('  • ' + v);
+        output.writeln('');
+        output.writeln('Some verbs mention Cognitum, Ruflo\'s sponsor. This is opt-in and reversible via');
+        output.writeln("`ruflo spinner disable`. Claude Code's default verbs are preserved (append-only).");
+        if (!ctx.flags.yes) {
+            output.writeln('');
+            output.printWarning('Re-run with --yes to confirm.');
+            return { success: false, data: { previewedVerbs: validVerbs.length } };
+        }
+        // Read current settings, back up, merge.
+        const { data, raw } = readSettings();
+        let backupPath = null;
+        if (raw)
+            backupPath = backupSettings(raw);
+        const currentBlock = data.spinnerVerbs ?? {};
+        if (currentBlock.mode === 'replace') {
+            output.printError('settings.json has spinnerVerbs.mode = "replace" — refusing to append (would silently be inert). ' +
+                'Either change your mode to "append" manually and re-run, or accept ruflo\'s pool as your entire set via manual edit.');
+            return { success: false, data: { currentMode: 'replace' } };
+        }
+        const currentVerbs = Array.isArray(currentBlock.verbs) ? currentBlock.verbs : [];
+        // Strip any prior ruflo entries so re-running enable is idempotent
+        // instead of duplicating our pool every time.
+        const preservedUserVerbs = currentVerbs.filter(v => !isRufloVerb(v));
+        const newVerbs = validVerbs.map(markVerb);
+        data.spinnerVerbs = {
+            mode: 'append',
+            verbs: [...preservedUserVerbs, ...newVerbs],
+        };
+        writeSettings(data);
+        recordConsent('spinner-verbs', true, 'cli-spinner-enable');
+        output.printSuccess(`Enabled — appended ${newVerbs.length} verbs to spinnerVerbs.`);
+        if (backupPath)
+            output.writeln(`Backup: ${backupPath}`);
+        return {
+            success: true,
+            data: {
+                appended: newVerbs.length,
+                preservedUserVerbs: preservedUserVerbs.length,
+                backup: backupPath,
+            },
+        };
+    },
+};
+const disableSub = {
+    name: 'disable',
+    description: 'Remove ruflo verbs from Claude Code\'s spinner rotation (user-authored verbs preserved)',
+    action: async () => {
+        const { data, raw } = readSettings();
+        if (!raw || !data.spinnerVerbs?.verbs?.length) {
+            revokeConsent('spinner-verbs', 'cli-spinner-disable');
+            output.writeln('Nothing to disable — no spinnerVerbs block found in settings.json.');
+            return { success: true, data: { removed: 0 } };
+        }
+        const backupPath = backupSettings(raw);
+        const before = data.spinnerVerbs.verbs.length;
+        data.spinnerVerbs.verbs = data.spinnerVerbs.verbs.filter(v => !isRufloVerb(v));
+        const after = data.spinnerVerbs.verbs.length;
+        // If we removed everything and the block is now empty, drop the block
+        // entirely so Claude Code falls straight back to its defaults.
+        if (data.spinnerVerbs.verbs.length === 0)
+            delete data.spinnerVerbs;
+        writeSettings(data);
+        revokeConsent('spinner-verbs', 'cli-spinner-disable');
+        output.printSuccess(`Disabled — removed ${before - after} ruflo verbs (kept ${after} user-authored).`);
+        output.writeln(`Backup: ${backupPath}`);
+        return { success: true, data: { removed: before - after, kept: after, backup: backupPath } };
+    },
+};
+const listSub = {
+    name: 'list',
+    description: 'Show ruflo\'s verb pool and which verbs are currently installed',
+    options: [
+        { name: 'json', description: 'Output as JSON', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        const { data } = readSettings();
+        const installed = data.spinnerVerbs?.verbs ?? [];
+        const installedRuflo = installed.filter(isRufloVerb).map(v => v.replace(RUFLO_MARKER, ''));
+        const installedUser = installed.filter(v => !isRufloVerb(v));
+        const pool = RUFLO_VERB_POOL_V0.filter(isValidVerb);
+        const summary = {
+            consent: hasConsent('spinner-verbs') ? 'granted' : 'not-granted',
+            mode: data.spinnerVerbs?.mode ?? '(none)',
+            pool_available: pool,
+            installed_ruflo: installedRuflo,
+            installed_user_authored: installedUser,
+        };
+        if (ctx.flags.json) {
+            output.printJson(summary);
+        }
+        else {
+            output.writeln(`Consent: ${summary.consent}`);
+            output.writeln(`spinnerVerbs.mode in settings.json: ${summary.mode}`);
+            output.writeln('');
+            output.writeln(`Ruflo pool (${pool.length} verbs, available):`);
+            for (const v of pool)
+                output.writeln('  • ' + v);
+            output.writeln('');
+            output.writeln(`Currently installed ruflo verbs (${installedRuflo.length}):`);
+            if (installedRuflo.length === 0)
+                output.writeln('  (none — run `ruflo spinner enable --yes` to install)');
+            else
+                for (const v of installedRuflo)
+                    output.writeln('  • ' + v);
+            output.writeln('');
+            output.writeln(`User-authored verbs (${installedUser.length}, untouched by ruflo):`);
+            for (const v of installedUser)
+                output.writeln('  • ' + v);
+        }
+        return { success: true, data: summary };
+    },
+};
+const resetSub = {
+    name: 'reset',
+    description: 'Restore the most recent settings.json backup (destructive)',
+    options: [
+        { name: 'yes', description: 'Skip the confirmation prompt', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        const backup = findMostRecentBackup();
+        if (!backup) {
+            output.printWarning('No settings.json backup found — nothing to restore.');
+            return { success: false };
+        }
+        if (!ctx.flags.yes) {
+            output.writeln(`Would restore: ${backup}`);
+            output.writeln(`Over:          ${SETTINGS_PATH}`);
+            output.writeln('');
+            output.printWarning('Re-run with --yes to confirm.');
+            return { success: false, data: { wouldRestore: backup } };
+        }
+        // Backup the CURRENT file too before overwriting, so reset is itself reversible.
+        const { raw } = readSettings();
+        if (raw)
+            backupSettings(raw);
+        fs.copyFileSync(backup, SETTINGS_PATH);
+        revokeConsent('spinner-verbs', 'cli-spinner-reset');
+        output.printSuccess(`Restored settings.json from ${backup}`);
+        return { success: true, data: { restoredFrom: backup } };
+    },
+};
+export const spinnerCommand = {
+    name: 'spinner',
+    description: 'Manage ruflo verbs in Claude Code\'s spinnerVerbs rotation (ADR-318)',
+    subcommands: [enableSub, disableSub, listSub, resetSub],
+    examples: [
+        { command: 'ruflo spinner list', description: 'Show the ruflo pool + what\'s currently installed' },
+        { command: 'ruflo spinner enable --yes', description: 'Append ruflo\'s verb pool to settings.json' },
+        { command: 'ruflo spinner disable', description: 'Remove ruflo verbs, keep user-authored ones' },
+        { command: 'ruflo spinner reset --yes', description: 'Restore the most recent settings.json backup' },
+    ],
+    action: listSub.action,
+};
+export default spinnerCommand;
+//# sourceMappingURL=spinner.js.map

package/v3/@claude-flow/cli/dist/src/config/proven-config.js

@@ -20,8 +20,8 @@
  */
 import { createHash, verify as edVerify, sign as edSign } from 'crypto';
 /** Ruflo config-signing PUBLIC key (safe to commit). Private half in GCP Secret Manager (ruflo-config-signing-key). */
-export const RUFLO_CONFIG_PUBKEY = `-----BEGIN PUBLIC KEY-----
-MCowBQYDK2VwAyEA3zr3BLCFKyrjvjZg9BXxchXIuGYwYwq21FYCjTpQO6A=
+export const RUFLO_CONFIG_PUBKEY = `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEA3zr3BLCFKyrjvjZg9BXxchXIuGYwYwq21FYCjTpQO6A=
 -----END PUBLIC KEY-----`;
 export function sha256Hex(content) {
     return createHash('sha256').update(content).digest('hex');

package/v3/@claude-flow/cli/dist/src/funnel/consent.js

@@ -20,6 +20,9 @@ export const CONSENT_DOMAINS = [
     'power-saver',
     'training-data-sharing',
     'advisor-tips',
+    'rev-share-payout',
+    'spinner-verbs',
+    'company-announcements',
 ];
 export function readConsents() {
     return readStateJson(CONSENT_FILE) ?? {};

package/v3/@claude-flow/cli/dist/src/funnel/disclosure.d.ts

@@ -37,6 +37,7 @@ export declare function recordDisclosureShown(now?: Date): DisclosureRecord;
 export declare function recordDisclosureDeclined(now?: Date): DisclosureRecord;
 /** Re-enable after a prior decline (explicit user action only). */
 export declare function recordDisclosureReenabled(now?: Date): DisclosureRecord;
+export declare function recordDisclosureAccepted(now?: Date): DisclosureRecord;
 /**
  * Whether promotional/educational messages may render. True only after the
  * disclosure was shown AND its grace window has elapsed. While the window is

package/v3/@claude-flow/cli/dist/src/funnel/disclosure.js

@@ -80,6 +80,18 @@ export function recordDisclosureReenabled(now = new Date()) {
     writeStateJson(DISCLOSURE_FILE, rec);
     return rec;
 }
+// Explicit user acknowledgement — bypasses the 24h grace so rotation starts
+// on the next render. The grace window's purpose is anti-flash (a single
+// glance can't count as "the user was told"); an explicit CLI action IS the
+// user saying they were told, so backdating firstShownAt past the window is
+// the correct semantics — not a policy hole. Stamps 1s past grace to avoid
+// clock-skew edge cases where now-grace lands exactly on the boundary.
+export function recordDisclosureAccepted(now = new Date()) {
+    const backdated = new Date(now.getTime() - DISCLOSURE_GRACE_MS - 1000);
+    const rec = { state: 'disclosed_enabled', firstShownAt: backdated.toISOString() };
+    writeStateJson(DISCLOSURE_FILE, rec);
+    return rec;
+}
 /**
  * Whether promotional/educational messages may render. True only after the
  * disclosure was shown AND its grace window has elapsed. While the window is

package/v3/@claude-flow/cli/dist/src/funnel/index.d.ts

@@ -7,13 +7,14 @@ export { funnelStateDir } from './state.js';
 export { isCI, isInteractive, reducedMotion } from './environment.js';
 export { resolveFunnelEnabled } from './precedence.js';
 export { CONSENT_DOMAINS, getConsent, hasConsent, readConsents, recordConsent, revokeConsent, } from './consent.js';
-export { DISCLOSURE_GRACE_MS, DISCLOSURE_ROTATION_SLOT_MS, getDisclosure, promoEligible, recordDisclosureDeclined, recordDisclosureReenabled, recordDisclosureShown, selectDisclosureMessage, } from './disclosure.js';
+export { DISCLOSURE_GRACE_MS, DISCLOSURE_ROTATION_SLOT_MS, getDisclosure, promoEligible, recordDisclosureAccepted, recordDisclosureDeclined, recordDisclosureReenabled, recordDisclosureShown, selectDisclosureMessage, } from './disclosure.js';
 export { MAX_MESSAGE_COLUMNS, MESSAGES, containsForbiddenSequences, displayWidth, eligibleMessages, eligibleMessagesFromPools, isAllowedUrl, isValidMessage, } from './messages.js';
 export { DEFAULT_MESSAGES_ENDPOINT, getRemoteMessages, refreshRemoteMessages, } from './message-transport.js';
 export { PROMO_REPEAT_CAP_MS, PROMO_SLOT_MODULO, ROTATION_SLOT_MS, selectMessage, } from './rotation.js';
 export { CREDIT_RECOVERY_HINT, classifyCreditError, renderCreditRecovery, shouldShowCreditRecovery, type CreditPromptSession, type ProviderErrorLike, } from './credit-errors.js';
 export { deleteFunnelData, getFunnelId, lastRecordedEvent, recordFunnelEvent } from './events.js';
 export { getFunnelPromo, type PromoContext } from './promo.js';
+export { PAYOUT_POLICY_VERSION, deleteEnrollment, getAttributionToken, getEnrollment, isEarningEligible, recordEnrollment, } from './payout.js';
 export { RATE_LIMIT_TTL_MS, clearRateLimitStatus, markRateLimited, rateLimitNotice, readRateLimitStatus, type RateLimitStatus, } from './rate-limit-notifier.js';
 export { QUOTA_LOW_TTL_MS, clearQuotaLowStatus, markQuotaLow, quotaLowNotice, readQuotaLowStatus, type QuotaLowStatus, } from './power-saver-notifier.js';
 export { TOGGLE_COOLDOWN_MS, cooldownActive, cooldownRemainingMin } from './toggle-cooldown.js';

package/v3/@claude-flow/cli/dist/src/funnel/index.js

@@ -7,13 +7,14 @@ export { funnelStateDir } from './state.js';
 export { isCI, isInteractive, reducedMotion } from './environment.js';
 export { resolveFunnelEnabled } from './precedence.js';
 export { CONSENT_DOMAINS, getConsent, hasConsent, readConsents, recordConsent, revokeConsent, } from './consent.js';
-export { DISCLOSURE_GRACE_MS, DISCLOSURE_ROTATION_SLOT_MS, getDisclosure, promoEligible, recordDisclosureDeclined, recordDisclosureReenabled, recordDisclosureShown, selectDisclosureMessage, } from './disclosure.js';
+export { DISCLOSURE_GRACE_MS, DISCLOSURE_ROTATION_SLOT_MS, getDisclosure, promoEligible, recordDisclosureAccepted, recordDisclosureDeclined, recordDisclosureReenabled, recordDisclosureShown, selectDisclosureMessage, } from './disclosure.js';
 export { MAX_MESSAGE_COLUMNS, MESSAGES, containsForbiddenSequences, displayWidth, eligibleMessages, eligibleMessagesFromPools, isAllowedUrl, isValidMessage, } from './messages.js';
 export { DEFAULT_MESSAGES_ENDPOINT, getRemoteMessages, refreshRemoteMessages, } from './message-transport.js';
 export { PROMO_REPEAT_CAP_MS, PROMO_SLOT_MODULO, ROTATION_SLOT_MS, selectMessage, } from './rotation.js';
 export { CREDIT_RECOVERY_HINT, classifyCreditError, renderCreditRecovery, shouldShowCreditRecovery, } from './credit-errors.js';
 export { deleteFunnelData, getFunnelId, lastRecordedEvent, recordFunnelEvent } from './events.js';
 export { getFunnelPromo } from './promo.js';
+export { PAYOUT_POLICY_VERSION, deleteEnrollment, getAttributionToken, getEnrollment, isEarningEligible, recordEnrollment, } from './payout.js';
 export { RATE_LIMIT_TTL_MS, clearRateLimitStatus, markRateLimited, rateLimitNotice, readRateLimitStatus, } from './rate-limit-notifier.js';
 export { QUOTA_LOW_TTL_MS, clearQuotaLowStatus, markQuotaLow, quotaLowNotice, readQuotaLowStatus, } from './power-saver-notifier.js';
 export { TOGGLE_COOLDOWN_MS, cooldownActive, cooldownRemainingMin } from './toggle-cooldown.js';

package/v3/@claude-flow/cli/dist/src/funnel/payout.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Developer revenue-share enrollment state — ADR-317, Phase 0.
+ *
+ * Stores an opaque enrollment token issued by the funnel.ruv.io backend
+ * after the user completes browser-side KYC + Stripe Connect. The client
+ * never introspects the token; it just includes it in attribution events
+ * so the backend can credit the correct payout account.
+ *
+ * Consent for the `rev-share-payout` domain is a PRECONDITION for
+ * enrollment (see ADR-317 §1). Consent alone does not mean earning —
+ * an enrollment token is also required, and KYC can fail after consent
+ * is granted for reasons outside the user's control. Callers should
+ * check both when deciding whether to enrich attribution.
+ */
+import type { PayoutEnrollment, PayoutEnrollmentPolicyVersion } from './types.js';
+/** Bump when the payout policy changes materially (e.g., 50/50 → other split). */
+export declare const PAYOUT_POLICY_VERSION: PayoutEnrollmentPolicyVersion;
+export declare function getEnrollment(): PayoutEnrollment | null;
+/**
+ * Whether attribution events should be enriched with the user's enrollment
+ * token. True only when BOTH consent is granted AND a verified token exists —
+ * either alone means "not yet earning."
+ */
+export declare function isEarningEligible(): boolean;
+/** Opaque token safe to include in attribution events. Null when not eligible. */
+export declare function getAttributionToken(): string | null;
+/**
+ * Record a successful enrollment (called by the CLI subcommand after the
+ * browser-side flow returns via device-code callback). Never called from
+ * hot paths — this is a rare, user-initiated write.
+ */
+export declare function recordEnrollment(rec: Omit<PayoutEnrollment, 'policy_version'>): PayoutEnrollment;
+/**
+ * Delete local enrollment state. Called by `ruflo funnel unenroll`. The
+ * server-side revoke is separate — this only removes the local token so
+ * subsequent attribution events stop being enriched. Idempotent — deleting
+ * a missing enrollment is a no-op success.
+ */
+export declare function deleteEnrollment(): boolean;
+//# sourceMappingURL=payout.d.ts.map

package/v3/@claude-flow/cli/dist/src/funnel/payout.js

@@ -0,0 +1,60 @@
+/**
+ * Developer revenue-share enrollment state — ADR-317, Phase 0.
+ *
+ * Stores an opaque enrollment token issued by the funnel.ruv.io backend
+ * after the user completes browser-side KYC + Stripe Connect. The client
+ * never introspects the token; it just includes it in attribution events
+ * so the backend can credit the correct payout account.
+ *
+ * Consent for the `rev-share-payout` domain is a PRECONDITION for
+ * enrollment (see ADR-317 §1). Consent alone does not mean earning —
+ * an enrollment token is also required, and KYC can fail after consent
+ * is granted for reasons outside the user's control. Callers should
+ * check both when deciding whether to enrich attribution.
+ */
+import { readStateJson, writeStateJson } from './state.js';
+import { hasConsent } from './consent.js';
+const PAYOUT_FILE = 'funnel-payout.json';
+/** Bump when the payout policy changes materially (e.g., 50/50 → other split). */
+export const PAYOUT_POLICY_VERSION = 1;
+export function getEnrollment() {
+    return readStateJson(PAYOUT_FILE);
+}
+/**
+ * Whether attribution events should be enriched with the user's enrollment
+ * token. True only when BOTH consent is granted AND a verified token exists —
+ * either alone means "not yet earning."
+ */
+export function isEarningEligible() {
+    if (!hasConsent('rev-share-payout'))
+        return false;
+    const rec = getEnrollment();
+    return !!rec && rec.kyc_status === 'verified' && !!rec.enrollment_token;
+}
+/** Opaque token safe to include in attribution events. Null when not eligible. */
+export function getAttributionToken() {
+    if (!isEarningEligible())
+        return null;
+    const rec = getEnrollment();
+    return rec?.enrollment_token ?? null;
+}
+/**
+ * Record a successful enrollment (called by the CLI subcommand after the
+ * browser-side flow returns via device-code callback). Never called from
+ * hot paths — this is a rare, user-initiated write.
+ */
+export function recordEnrollment(rec) {
+    const full = { ...rec, policy_version: PAYOUT_POLICY_VERSION };
+    writeStateJson(PAYOUT_FILE, full);
+    return full;
+}
+/**
+ * Delete local enrollment state. Called by `ruflo funnel unenroll`. The
+ * server-side revoke is separate — this only removes the local token so
+ * subsequent attribution events stop being enriched. Idempotent — deleting
+ * a missing enrollment is a no-op success.
+ */
+export function deleteEnrollment() {
+    return writeStateJson(PAYOUT_FILE, null);
+}
+//# sourceMappingURL=payout.js.map