@claude-flow/cli 3.29.0 → 3.30.1

package/.claude/helpers/.helpers-version

@@ -1 +1 @@
-3.25.6
+3.30.0

package/.claude/helpers/helpers.manifest.json

@@ -1,13 +1,13 @@
 {
   "manifest": {
-    "version": "3.29.0",
+    "version": "3.30.1",
     "files": {
       "auto-memory-hook.mjs": "e3e1033b24704992ddef6b31c7fa9dd7fcd9e1af7935dd77ef73402b916b31e6",
-      "hook-handler.cjs": "f51fb035d8a4110fdf763cee2913e285bcdbbaa618cbee980e032f89ffaf89d2",
+      "hook-handler.cjs": "dc926a1a585abac85941347894632a800a9c4394e99166726017643e5b3c5950",
       "intelligence.cjs": "5a55d979cb7ba5c8c4f27f3b2e6d686fbb1045d180023b803da672a37e05b915",
-      "statusline.cjs": "8416172e504b03f9ec2266a47bba048578c3b1e30c5c7c97a0a8261460cd601d"
+      "statusline.cjs": "7d7bdee732e1c75b863e409afb86ce0d712f4919245e990d806da6752015bffa"
     }
   },
-  "signature": "F0YZmNYCOnPOkf/kqbUoXtZ/jfYsX+Mn3QTGvtR6dafHx+oZ4uoobOKu/GYls+z+vHN2beL9c9GK53YKB1txBA==",
+  "signature": "6Dw13BYh3EAjBOefodVYha+5dpmcAxralqJIfT07xi9WUvhtDqwISpOVRWHMSdHM+XL1YGRh8I071X1XDB3zDw==",
   "algorithm": "ed25519"
 }

package/.claude/helpers/hook-handler.cjs

@@ -98,6 +98,105 @@ function spawnDetachedFunnelRefresh() {
   spawnDetachedHookRefresh('refresh-funnel');
 }
 
+// ADR-318/319: first-run auto-enable of spinner verbs (default ON) +
+// announcements (default OFF, explicit opt-in). Fires ONCE per install
+// (marker at ~/.ruflo/first-run-enabled.json), then never again —
+// subsequent sessions see the marker and skip.
+//
+// Split posture rationale:
+//   - Spinner verbs = low-intrusion (per-spin flash, append-mode mix
+//     with Claude Code defaults, moderate visibility over time). Default ON.
+//     Disclosure notification + one-command disable satisfies the ethical bar.
+//   - Announcements = higher-intrusion (prominent line at every Claude Code
+//     startup, more attention per view). Default OFF; opt-in via
+//     RUFLO_AUTO_ENABLE_ANNOUNCEMENTS=1 or explicit `ruflo announcements enable`.
+//
+// Gates (spinner is default-on unless any is TRUE):
+//   - RUFLO_NO_AUTO_ENABLE truthy (master opt-out — kills both)
+//   - RUFLO_NO_AUTO_ENABLE_SPINNER truthy (spinner-only opt-out)
+//   - CI / GITHUB_ACTIONS truthy
+//   - stdout is not a TTY (piped, non-interactive)
+//   - Marker file already exists
+//
+// Announcements needs the same gates PLUS RUFLO_AUTO_ENABLE_ANNOUNCEMENTS=1.
+//
+// Marker is written even if the spawns fail — auto-enable is a "we tried once"
+// contract, not "keep trying until success." Users can run enable manually.
+function firstRunAutoEnableIfEligible() {
+  try {
+    const path = require('path');
+    const fs = require('fs');
+    const os = require('os');
+    const truthy = (v) => v && !/^(0|false|off|no)$/i.test(String(v));
+    if (truthy(process.env.RUFLO_NO_AUTO_ENABLE)) return;
+    if (process.env.CI || process.env.GITHUB_ACTIONS) return;
+    if (process.stdout && process.stdout.isTTY === false) return;
+    const markerPath = path.join(os.homedir(), '.ruflo', 'first-run-enabled.json');
+    if (fs.existsSync(markerPath)) return;
+
+    const enableSpinner = !truthy(process.env.RUFLO_NO_AUTO_ENABLE_SPINNER);
+    const enableAnnouncements = truthy(process.env.RUFLO_AUTO_ENABLE_ANNOUNCEMENTS);
+
+    // Nothing to do — user opted out of both. Skip marker write so if they
+    // change their mind and re-enable env vars later, first-run still fires.
+    if (!enableSpinner && !enableAnnouncements) return;
+
+    // Spawn the enable commands detached + non-blocking. Any failure
+    // (missing CLI, refused state, etc.) is silent — auto-enable is
+    // best-effort and MUST NOT block session-restore. Uses execPath +
+    // resolved cli.js directly rather than spawnDetachedHookRefresh
+    // because that helper hardcodes 'hooks' as the top-level command.
+    const { spawn } = require('child_process');
+    const cliBin = resolveCliBinForHook();
+    const runDetached = (args) => {
+      try {
+        const spawnArgs = cliBin
+          ? [process.execPath, [cliBin, ...args]]
+          : [process.platform === 'win32' ? 'npx.cmd' : 'npx',
+             ['--prefer-offline', '@claude-flow/cli', ...args]];
+        const child = spawn(spawnArgs[0], spawnArgs[1], {
+          detached: true, stdio: 'ignore', env: process.env, windowsHide: true,
+        });
+        child.unref();
+      } catch { /* best-effort */ }
+    };
+    if (enableSpinner) runDetached(['spinner', 'enable', '--yes']);
+    if (enableAnnouncements) runDetached(['announcements', 'enable', '--yes']);
+
+    try {
+      fs.mkdirSync(path.dirname(markerPath), { recursive: true, mode: 0o700 });
+      fs.writeFileSync(
+        markerPath,
+        JSON.stringify({
+          _ts: Date.now(),
+          source: 'session-restore-hook',
+          enabled: { spinner: enableSpinner, announcements: enableAnnouncements },
+        }, null, 2),
+        { encoding: 'utf-8', mode: 0o600 }
+      );
+    } catch { /* ignore — best effort */ }
+
+    // Notification tells user exactly what happened. stderr so it doesn't
+    // corrupt any downstream JSON stdout consumer.
+    try {
+      const parts = [];
+      if (enableSpinner) parts.push('spinner verbs');
+      if (enableAnnouncements) parts.push('startup announcements');
+      const disableCmds = [];
+      if (enableSpinner) disableCmds.push('`ruflo spinner disable`');
+      if (enableAnnouncements) disableCmds.push('`ruflo announcements disable`');
+      process.stderr.write(
+        '[ruflo] First-run: enabled ' + parts.join(' + ') + '. ' +
+        'Disable anytime with ' + disableCmds.join(' / ') + '. ' +
+        (enableSpinner && !enableAnnouncements
+          ? 'Announcements stay opt-in — set RUFLO_AUTO_ENABLE_ANNOUNCEMENTS=1 to enable those too. '
+          : '') +
+        'Restart Claude Code once to see the changes take effect.\n'
+      );
+    } catch { /* ignore */ }
+  } catch { /* auto-enable must never break session-restore */ }
+}
+
 // Same fallback-aware pattern as spawnDetachedFunnelRefresh() above, for
 // ADR-316's co-pilot advisor tip. Safe to call on EVERY session-restore:
 // refresh-advisor's own action checks consent + a 24h TTL BEFORE spending
@@ -345,6 +444,11 @@ const handlers = {
   },
 
   'session-restore': async () => {
+    // ADR-318/319 first-run auto-enable — fire once per install, never
+    // re-fires after user disables. Respects RUFLO_NO_AUTO_ENABLE + CI.
+    // Fully non-blocking (detached spawn) so session-restore latency
+    // is unchanged.
+    firstRunAutoEnableIfEligible();
     if (session) {
       // Try restore first, fall back to start
       const existing = session.restore && session.restore();

package/.claude/helpers/statusline.cjs

@@ -42,12 +42,18 @@ const CONFIG = {
 const CWD = process.cwd();
 
 // ─── Delegation cache ───────────────────────────────────────────
-// Cache the CLI JSON result for 60s so rapid prompt re-renders
-// (Claude Code refreshes the statusline several times a second while
-// streaming) don't re-invoke the CLI each time. #2337: bumped 10s→60s
-// because 10s was far too short for how often Claude Code re-renders.
+// Cache the CLI JSON result so rapid prompt re-renders (Claude Code
+// refreshes the statusline several times a second while streaming) don't
+// re-invoke the CLI each time.
+// #2337 bumped 10s → 60s.
+// Followup for anthropics/claude-code#70200 (Windows console-flash bug —
+// claude.exe spawns hook/statusline subprocesses without CREATE_NO_WINDOW,
+// producing a visible cmd flash on every render): bumped 60s → 300s to
+// reduce the flash rate 5x on Windows until the upstream fix ships.
+// Tradeoff: stat/git counters update every 5min instead of every 1min;
+// promo/insight row still rotates on its own tighter 20s promoFresh clock.
 const CACHE_FILE = path.join(os.tmpdir(), 'ruflo-statusline-cache-' + require('crypto').createHash('md5').update(CWD).digest('hex').slice(0, 8) + '.json');
-const CACHE_TTL_MS = 60000;
+const CACHE_TTL_MS = 300000;
 
 // The promo/insight row is designed to rotate on a 20s cadence (funnel/
 // rotation.ts's ROTATION_SLOT_MS / funnel/promo.ts's insight-slot check —
@@ -229,7 +235,7 @@ function getStatuslineData() {
     try {
       const raw = execSync(
         cmd,
-        { encoding: 'utf-8', timeout: 8000, stdio: ['pipe', 'pipe', 'pipe'], cwd: CWD }
+        { encoding: 'utf-8', timeout: 8000, stdio: ['pipe', 'pipe', 'pipe'], cwd: CWD, windowsHide: true }
       ).trim();
       // The CLI may emit preamble lines before the JSON — find the first '{'.
       const jsonStart = raw.indexOf('{');
@@ -445,6 +451,11 @@ function safeExec(cmd, timeoutMs) {
       encoding: 'utf-8',
       timeout: timeoutMs || 2000,
       stdio: ['pipe', 'pipe', 'pipe'],
+      // Windows: without this, every execSync spawns cmd.exe /d /s /c which
+      // flashes a visible console window every render (~1/min via the 60s
+      // cache TTL). windowsHide runs the child in a hidden window instead.
+      // No-op on POSIX. Fix for #2XXX (user report: "cmd prompt keeps opening").
+      windowsHide: true,
     }).trim();
   } catch {
     return '';
@@ -868,12 +879,16 @@ function getPromoRow(d) {
     if (/^(0|false|off|no)$/i.test(String(process.env.RUFLO_FUNNEL || ''))) return null;
     const promo = d && d.promo;
     if (!promo || typeof promo.text !== 'string') return null;
-    // Strip control chars / ANSI / bidi overrides and hard-cap length —
-    // promo copy is data and must never emit its own terminal sequences.
-    const text = promo.text
+    // Strip control chars / ANSI / bidi overrides — promo copy is data and
+    // must never emit its own terminal sequences. Hard-cap length AFTER the
+    // strip; append an ellipsis when the cap fires so the row visibly reads
+    // as truncated instead of chopping a word mid-character (was: silent
+    // slice(0,100) that could produce output that looked like corrupt data).
+    const MAX_LEN = 100;
+    const sanitized = promo.text
       .replace(/[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/g, '')
-      .slice(0, 100)
-      .trim();
+      ;
+    const text = (sanitized.length > MAX_LEN ? sanitized.slice(0, MAX_LEN - 1).trimEnd() + '…' : sanitized).trim();
     if (text.length === 0) return null;
     // Split the label from the trailing "· manage: ruflo settings" instruction
     // so each part gets styling that matches what it actually IS:
@@ -896,9 +911,68 @@ function getPromoRow(d) {
     const DIM_OFF = '\u001b[22m';
     const BOLD_ON = '\u001b[1m';
     const BOLD_OFF = '\u001b[22m';
-    const linked = promo.url ? UL_ON + safeTerminalLink(label, promo.url) + UL_OFF : label;
-    if (!command) return linked;
-    return linked + DIM_ON + manageWord + DIM_OFF + BOLD_ON + command + BOLD_OFF;
+    const FG_BRIGHT_WHITE = '';
+    // Reset FG to default so the caller's row-color code resumes coloring the
+    // rest of the row after the command portion. Without this the row-color
+    // escape wouldn't visibly re-apply because we already emitted an explicit FG.
+    const FG_DEFAULT = '';
+    // Some hosts (Claude Code's Windows UI, cmd.exe, older mintty) don't
+    // render OSC 8 hyperlinks as clickable — the label just underlines and
+    // clicks do nothing. Append a "(domain)" suffix so the destination is
+    // visible/copyable everywhere. Wrap the suffix in OSC 8 too so terminals
+    // that DO support hyperlinks give users TWO click targets (label AND
+    // domain hint) instead of one — some Windows hosts render one but not
+    // the other depending on how the statusline row is parsed.
+    // Only for URLs (not educational tips), and only when the label doesn't
+    // already end in the domain to avoid duplication.
+    let visibleUrlHint = '';
+    if (promo.url) {
+      try {
+        const host = new URL(promo.url).hostname.replace(/^www\./, '');
+        // Strip the click-redirect wrapper so users see the FINAL destination,
+        // not funnel.ruv.io. If the URL is /v1/click/<id>?to=<encoded>, pull the target.
+        let displayHost = host;
+        try {
+          const to = new URL(promo.url).searchParams.get('to');
+          if (to) displayHost = new URL(to).hostname.replace(/^www\./, '');
+        } catch { /* not a click-redirect, keep the raw host */ }
+        if (displayHost && !label.toLowerCase().endsWith(displayHost.toLowerCase())) {
+          // safeTerminalLink returns the plain string if URL isn't allowlisted
+          // or the terminal can't do OSC 8 — either way the domain stays visible.
+          const clickableDomain = safeTerminalLink(displayHost, promo.url);
+          visibleUrlHint = DIM_ON + ' (' + clickableDomain + ')' + DIM_OFF;
+        }
+      } catch { /* malformed URL — omit hint, never break the row */ }
+    }
+    // "Entire row clickable" (user request) — wrap the whole assembled
+    // string in ONE OSC 8 hyperlink instead of just the label. The command
+    // portion keeps its bold + bright-white treatment (no underline) so it
+    // still VISUALLY reads as a shell command the user should type, not a
+    // link — but if the user clicks anywhere on the row (label, domain
+    // hint, connector, even the command text), the terminal opens the URL.
+    // Clicking DOES NOT execute the command; it just opens the target URL,
+    // which is safe. Terminals that ignore OSC 8 render the whole row as
+    // styled text and no click behavior — the previous fallback (visible
+    // domain suffix) still keeps the destination readable.
+    const wrapWholeRowInHyperlink = (assembled) => {
+      if (!promo.url) return assembled;
+      if (!terminalSupportsHyperlinks()) return assembled;
+      let parsed;
+      try { parsed = new URL(promo.url); } catch { return assembled; }
+      if (parsed.protocol !== 'https:') return assembled;
+      if (!PROMO_LINK_HOSTS.has(parsed.hostname)) return assembled;
+      const ESC = '';
+      return ESC + ']8;;' + parsed.href + ESC + '\\' + assembled + ESC + ']8;;' + ESC + '\\';
+    };
+    // Visual styling stays per-part. We only add the OSC 8 wrap around the
+    // combined string, so the whole row is one click target.
+    const labelStyled = promo.url ? UL_ON + label + UL_OFF : label;
+    if (!command) return wrapWholeRowInHyperlink(labelStyled + visibleUrlHint);
+    return wrapWholeRowInHyperlink(
+      labelStyled + visibleUrlHint
+      + DIM_ON + manageWord + DIM_OFF
+      + BOLD_ON + FG_BRIGHT_WHITE + command + FG_DEFAULT + BOLD_OFF
+    );
   } catch (e) {
     return null; // the promo row must never break the statusline
   }

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 1,
-  "generatedAt": "2026-07-14T16:52:03.409Z",
-  "gitSha": "0052b1b0",
+  "generatedAt": "2026-07-14T20:11:46.876Z",
+  "gitSha": "5fa2a3ce",
   "catalog": {
     "agents": 164,
     "tools": 387,

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

@@ -0,0 +1,17 @@
+/**
+ * `ruflo announcements` — manage ruflo entries in Claude Code's
+ * companyAnnouncements settings (ADR-319).
+ *
+ * Claude Code exposes `companyAnnouncements: string[]` in
+ * ~/.claude/settings.json. The array is shown at Claude Code startup,
+ * cycled at random if multiple entries exist. Higher-attention than
+ * the spinner row (once per session, prominently rendered) and
+ * lower-frequency (once per Claude Code launch vs. every processing pause).
+ *
+ * Same architectural guarantees as ADR-318 (spinner): append-only,
+ * backup-first, ZWJ-marker-tagged for clean removal.
+ */
+import type { Command } from '../types.js';
+export declare const announcementsCommand: Command;
+export default announcementsCommand;
+//# sourceMappingURL=announcements.d.ts.map

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

@@ -1,13 +1,16 @@
 /**
  * `ruflo funnel` — user control surface for the Cognitum lifecycle funnel
- * (ADR-301/305/309).
+ * (ADR-301/305/309/317).
  *
- *   funnel status    effective state and which precedence source decided it
- *   funnel disable   user-level opt-out (all surfaces) + delete funnel data
- *   funnel enable    re-enable at the user tier (cannot override env/enterprise)
- *   funnel accept    acknowledge the disclosure so rotation starts immediately
- *   funnel open      open the currently-shown promo URL in the default browser
- *   funnel id        print the pseudonymous funnel ID, if one exists
+ *   funnel status     effective state and which precedence source decided it
+ *   funnel disable    user-level opt-out (all surfaces) + delete funnel data
+ *   funnel enable     re-enable at the user tier (cannot override env/enterprise)
+ *   funnel accept     acknowledge the disclosure so rotation starts immediately
+ *   funnel open       open the currently-shown promo URL in the default browser
+ *   funnel enroll     opt in to the 50/50 revenue share on Cognitum sponsor spend (ADR-317)
+ *   funnel earnings   show accrued and paid revenue-share balance
+ *   funnel unenroll   revoke local enrollment (funnel itself stays enabled)
+ *   funnel id         print the pseudonymous funnel ID, if one exists
  */
 import type { Command } from '../types.js';
 export declare const funnelCommand: Command;

package/dist/src/commands/funnel.js

@@ -1,20 +1,24 @@
 /**
  * `ruflo funnel` — user control surface for the Cognitum lifecycle funnel
- * (ADR-301/305/309).
+ * (ADR-301/305/309/317).
  *
- *   funnel status    effective state and which precedence source decided it
- *   funnel disable   user-level opt-out (all surfaces) + delete funnel data
- *   funnel enable    re-enable at the user tier (cannot override env/enterprise)
- *   funnel accept    acknowledge the disclosure so rotation starts immediately
- *   funnel open      open the currently-shown promo URL in the default browser
- *   funnel id        print the pseudonymous funnel ID, if one exists
+ *   funnel status     effective state and which precedence source decided it
+ *   funnel disable    user-level opt-out (all surfaces) + delete funnel data
+ *   funnel enable     re-enable at the user tier (cannot override env/enterprise)
+ *   funnel accept     acknowledge the disclosure so rotation starts immediately
+ *   funnel open       open the currently-shown promo URL in the default browser
+ *   funnel enroll     opt in to the 50/50 revenue share on Cognitum sponsor spend (ADR-317)
+ *   funnel earnings   show accrued and paid revenue-share balance
+ *   funnel unenroll   revoke local enrollment (funnel itself stays enabled)
+ *   funnel id         print the pseudonymous funnel ID, if one exists
  */
 import { execFile } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { output } from '../output.js';
-import { deleteFunnelData, funnelStateDir, getDisclosure, getFunnelId, promoEligible, readConsents, recordDisclosureAccepted, recordDisclosureDeclined, recordDisclosureReenabled, resolveFunnelEnabled, } from '../funnel/index.js';
+import { deleteEnrollment, deleteFunnelData, funnelStateDir, getDisclosure, getEnrollment, getFunnelId, isEarningEligible, promoEligible, readConsents, recordDisclosureAccepted, recordDisclosureDeclined, recordDisclosureReenabled, resolveFunnelEnabled, } from '../funnel/index.js';
+import { hasConsent, recordConsent } from '../funnel/consent.js';
 import { readStateJson, writeStateJson } from '../funnel/state.js';
 function setUserConfigEnabled(enabled) {
     const cfg = readStateJson('funnel.json') ?? {};
@@ -181,6 +185,91 @@ const openSub = {
         }
     },
 };
+// ─── ADR-317: developer revenue-share subcommands ─────────────────────────
+const ENROLL_URL = 'https://funnel.ruv.io/enroll';
+const enrollSub = {
+    name: 'enroll',
+    description: 'Opt in to the 50/50 revenue share on Cognitum sponsor spend (ADR-317, Phase 0)',
+    action: async () => {
+        const decision = resolveFunnelEnabled();
+        if (!decision.enabled) {
+            output.printWarning(`Funnel is currently disabled by: ${decision.decidedBy}. Enable it (ruflo funnel enable) before enrolling — there's nothing to earn from until the funnel is on.`);
+            return { success: false, data: decision };
+        }
+        const disclosure = getDisclosure();
+        if (disclosure.state !== 'disclosed_enabled') {
+            output.printWarning("The Cognitum disclosure hasn't been shown/accepted yet. Run 'ruflo funnel accept' first, then re-run enroll.");
+            return { success: false, data: disclosure };
+        }
+        // Phase 0: record local consent so downstream attribution knows the user
+        // WANTS to enroll, but the backend endpoint that returns a real token is
+        // not live yet — this ADR ships in a version before the payout backend.
+        recordConsent('rev-share-payout', true, 'cli-funnel-enroll');
+        output.writeln('Consent recorded for rev-share-payout.');
+        output.writeln('');
+        output.writeln('The backend enrollment endpoint (Stripe Connect + KYC) is not yet live.');
+        output.writeln('When it ships, this command will open your browser to:');
+        output.writeln('');
+        output.writeln(`  ${ENROLL_URL}`);
+        output.writeln('');
+        output.writeln("Meanwhile, your consent is on file. Track the rollout at ADR-317 (v3/docs/adr/).");
+        return { success: true, data: { consent: 'granted', enrollment: 'pending-backend' } };
+    },
+};
+const earningsSub = {
+    name: 'earnings',
+    description: 'Show accrued and paid revenue-share balance (ADR-317)',
+    options: [
+        { name: 'json', description: 'Output as JSON', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        const consented = hasConsent('rev-share-payout');
+        const rec = getEnrollment();
+        const eligible = isEarningEligible();
+        const summary = {
+            consent: consented ? 'granted' : 'not-granted',
+            enrollment: rec ? { kyc_status: rec.kyc_status, enrolled_at: rec.enrolled_at, payout_account_last4: rec.payout_account_last4 } : null,
+            earning_eligible: eligible,
+            note: rec
+                ? 'Earnings endpoint (funnel.ruv.io/v1/earnings) is not yet live — see ADR-317 Phase 1.'
+                : 'Not enrolled. Run `ruflo funnel enroll` to opt in.',
+        };
+        if (ctx.flags.json) {
+            output.printJson(summary);
+        }
+        else {
+            output.writeln(`Consent: ${summary.consent}`);
+            output.writeln(`Enrolled: ${rec ? 'yes' : 'no'}`);
+            if (rec) {
+                output.writeln(`  KYC: ${rec.kyc_status}`);
+                output.writeln(`  Payout account: ****${rec.payout_account_last4}`);
+                output.writeln(`  Since: ${rec.enrolled_at}`);
+            }
+            output.writeln(`Earning: ${eligible ? 'yes' : 'no'}`);
+            output.writeln('');
+            output.writeln(summary.note);
+        }
+        return { success: true, data: summary };
+    },
+};
+const unenrollSub = {
+    name: 'unenroll',
+    description: 'Revoke rev-share enrollment locally (funnel itself stays enabled)',
+    action: async () => {
+        const hadEnrollment = !!getEnrollment();
+        const hadConsent = hasConsent('rev-share-payout');
+        recordConsent('rev-share-payout', false, 'cli-funnel-unenroll');
+        deleteEnrollment();
+        if (hadEnrollment || hadConsent) {
+            output.printSuccess('Unenrolled locally. Funnel messages still render; your install just no longer earns.');
+            output.writeln('Note: server-side revocation happens on next contact with funnel.ruv.io — the backend endpoint is not yet live (ADR-317 Phase 1).');
+        }
+        else {
+            output.writeln('Nothing to unenroll — no local enrollment record and no rev-share consent was set.');
+        }
+        return { success: true, data: { previouslyEnrolled: hadEnrollment, previouslyConsented: hadConsent } };
+    },
+};
 const idSub = {
     name: 'id',
     description: 'Print the pseudonymous funnel ID (exists only with telemetry consent)',
@@ -198,11 +287,13 @@ const idSub = {
 export const funnelCommand = {
     name: 'funnel',
     description: 'Control the Cognitum lifecycle funnel surfaces (tips, enrollment, notices)',
-    subcommands: [statusSub, disableSub, enableSub, acceptSub, openSub, idSub],
+    subcommands: [statusSub, disableSub, enableSub, acceptSub, openSub, enrollSub, earningsSub, unenrollSub, idSub],
     examples: [
         { command: 'ruflo funnel status', description: 'Effective state + deciding source' },
         { command: 'ruflo funnel accept', description: 'Skip the 24h grace so rotation starts now' },
         { command: 'ruflo funnel open', description: 'Open the current promo URL in the browser' },
+        { command: 'ruflo funnel enroll', description: 'Opt in to 50/50 rev share (ADR-317)' },
+        { command: 'ruflo funnel earnings', description: 'Show accrued and paid balance' },
         { command: 'ruflo funnel disable', description: 'Turn off every funnel surface' },
     ],
     action: statusSub.action,

package/dist/src/commands/index.js

@@ -83,6 +83,10 @@ const commandLoaders = {
     proxy: () => import('./proxy.js'),
     // Fable co-pilot advisor tip in the statusline insight ticker (ADR-316)
     advisor: () => import('./advisor.js'),
+    // Ruflo verbs in Claude Code's spinnerVerbs rotation (ADR-318)
+    spinner: () => import('./spinner.js'),
+    // Ruflo entries in Claude Code's companyAnnouncements startup rotation (ADR-319)
+    announcements: () => import('./announcements.js'),
 };
 // Cache for loaded commands
 const loadedCommands = new Map();

package/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