claude-flow 3.59.11 → 3.59.13

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

@@ -24,9 +24,10 @@ const helpersDir = __dirname;
 const helperRoot = path.resolve(helpersDir, '..', '..');
 
 // Resolve an installed @claude-flow/cli (or ruflo) bin — mirrors
-// statusline-generator.ts's resolveCliBin() candidate list. Used only to
-// spawn the detached funnel-refresh helper below; failures are silent (no
-// candidate found just means the refresh never fires this session).
+// statusline-generator.ts's resolveCliBin() candidate list, then looks for a
+// global install (resolveGlobalCliBin() below, #3368). Used only to spawn the
+// detached funnel-refresh helper below; failures are silent (no candidate
+// found just means the refresh falls back to npx).
 //
 // Verifies dist/src/index.js exists alongside bin/cli.js, not just the bin
 // itself — Claude Code's own plugin marketplace mechanism installs by
@@ -39,7 +40,17 @@ const helperRoot = path.resolve(helpersDir, '..', '..');
 // first every time and spawnDetachedFunnelRefresh() below had no fallback,
 // so the promo/disclosure row could never populate for any marketplace
 // install, on any OS.
+// session-restore asks up to three times (first-run enable, then the two
+// refreshes). The answer cannot change inside one short-lived hook process,
+// so resolve once: `undefined` means "not looked up yet", null means "no
+// local or global CLI — use npx".
+let cliBinCache;
 function resolveCliBinForHook() {
+  if (cliBinCache === undefined) cliBinCache = resolveCliBinUncached();
+  return cliBinCache;
+}
+
+function resolveCliBinUncached() {
   try {
     const home = os.homedir();
     const candidates = [
@@ -53,16 +64,219 @@ function resolveCliBinForHook() {
       path.join(helpersDir, '..', '..', 'bin', 'cli.js'),
     ];
     for (const p of candidates) {
-      try {
-        if (fs.existsSync(p) && fs.existsSync(path.join(path.dirname(p), '..', 'dist', 'src', 'index.js'))) {
-          return p;
-        }
-      } catch (e) { /* try next candidate */ }
+      if (isRunnableCli(p)) return p;
     }
+    return resolveGlobalCliBin();
   } catch (e) { /* ignore */ }
   return null;
 }
 
+function isRunnableCli(p) {
+  try {
+    return fs.existsSync(p) && fs.existsSync(path.join(path.dirname(p), '..', 'dist', 'src', 'index.js'));
+  } catch (e) { return false; }
+}
+
+// #3368: a global install — the README's `npm install -g ruflo@latest` — keeps
+// the CLI at <prefix>/lib/node_modules/ruflo/node_modules/@claude-flow/cli,
+// which none of the project-relative candidates above cover, so on those
+// machines every refresh fell back to npx: a second, separately cached copy
+// of the CLI that follows the registry's latest rather than the version the
+// user pinned (the same npx-cache skew as #3306), and that cannot start
+// offline on a cold cache.
+//
+// Three lookups, fs calls only (no child process), reached only after every
+// candidate above missed:
+//   1. npm's global prefix, resolved the way npm resolves it
+//      (npmGlobalPrefix() below). First because it does not depend on PATH:
+//      a hook inherits the host process's PATH, which need not contain the
+//      prefix's bin/ even when the user's interactive shell does (observed:
+//      the Claude Code process spawning hooks lacked ~/.npm-global/bin while
+//      a login zsh on the same machine had it).
+//   2. `ruflo`, then `claude-flow`, on PATH — the order plugins/ruflo-core/
+//      scripts/ruflo-hook.cjs uses — for globals npm did not install (yarn
+//      classic, bun). Only a symlinked bin counts, and only when it lands in
+//      a package that declares one of the three known names, so a wrapper
+//      script or a version-manager shim (Volta) is never mistaken for an
+//      install. The <dir>/node_modules/<name> layout npm uses on Windows,
+//      where ruflo.cmd sits beside node_modules\ruflo (what resolveNpmShim()
+//      in ruflo-hook.cjs maps), is only consulted on win32: on POSIX every
+//      manager symlinks, and probing it there would follow a Windows install
+//      exposed to WSL through the appended Windows PATH.
+//      Relative PATH entries (`.` or an empty entry) are skipped, so a bare
+//      `./ruflo` in the working directory is never picked up.
+//   3. ~/.npm-global, npm's documented no-sudo prefix, when 1 and 2 both
+//      missed: the prefix setting may live where this hook's node never
+//      reads it, and a wrapper script on PATH is skipped by 2.
+// `env`/`platform`/`execPath` are parameters so any layout is testable
+// from any OS.
+function resolveGlobalCliBin(env = process.env, platform = process.platform, execPath = process.execPath) {
+  const prefix = npmGlobalPrefix(env, platform, execPath);
+  if (prefix) {
+    const hit = cliUnderPrefix(prefix, platform);
+    if (hit) return hit;
+  }
+  const dirs = String(env.PATH || env.Path || '').split(platform === 'win32' ? ';' : ':');
+  const exts = platform === 'win32' ? ['.cmd', ''] : [''];
+  for (const name of ['ruflo', 'claude-flow']) {
+    for (const dir of dirs) {
+      if (!dir || !path.isAbsolute(dir)) continue;
+      for (const ext of exts) {
+        const shim = path.join(dir, name + ext);
+        if (!fs.existsSync(shim)) continue;
+        const roots = [];
+        try {
+          if (fs.lstatSync(shim).isSymbolicLink()) {
+            const root = path.dirname(path.dirname(fs.realpathSync(shim)));
+            if (isKnownPackageRoot(root)) roots.push(root);
+          }
+        } catch (e) { /* unreadable link — fall back to the layout roots */ }
+        if (platform === 'win32') {
+          roots.push(path.join(dir, 'node_modules', name));
+          if (name === 'claude-flow') roots.push(path.join(dir, 'node_modules', '@claude-flow', 'cli'));
+        }
+        for (const root of roots) {
+          const hit = cliInPackage(root);
+          if (hit) return hit;
+        }
+      }
+    }
+  }
+  // Last resort: ~/.npm-global, the prefix npm's own docs recommend for
+  // global installs without sudo ("Resolving EACCES permissions errors").
+  // The setting that points npm there can live where this hook's node never
+  // looks (another node's builtin npmrc, or a wrapper script that sets it
+  // per call), and a `ruflo` wrapper script on PATH is skipped above by
+  // design. Without this, such a machine fell back to npx @latest on every
+  // hook. Checked only after the configured prefix and PATH both miss, so it
+  // can never override either.
+  const home = env.HOME || env.USERPROFILE;
+  if (home && path.isAbsolute(home)) {
+    const hit = cliUnderPrefix(path.join(home, '.npm-global'), platform);
+    if (hit) return hit;
+  }
+  return null;
+}
+
+// The CLI of a global install under an npm prefix: <prefix>/lib/node_modules
+// on POSIX, <prefix>\node_modules on Windows, trying the three published
+// package names in order.
+function cliUnderPrefix(prefix, platform) {
+  const modules = platform === 'win32'
+    ? path.join(prefix, 'node_modules')
+    : path.join(prefix, 'lib', 'node_modules');
+  for (const pkg of ['ruflo', 'claude-flow', path.join('@claude-flow', 'cli')]) {
+    const hit = cliInPackage(path.join(modules, pkg));
+    if (hit) return hit;
+  }
+  return null;
+}
+
+// A bin on PATH only counts as an install when the package it points into
+// declares one of the three published names. This is a narrower check than
+// resolveNpmShim() in ruflo-hook.cjs, which never reads `name`: that one takes
+// the package name from the shim's own filename, then validates package.json's
+// `bin` entry and that its realpath stays inside the package. Here the bin has
+// already been resolved to a package root, so the manifest `name` is what
+// identifies it.
+function isKnownPackageRoot(root) {
+  try {
+    const name = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf-8')).name;
+    return name === 'ruflo' || name === 'claude-flow' || name === '@claude-flow/cli';
+  } catch (e) { return false; }
+}
+
+// Map an installed ruflo / claude-flow / @claude-flow/cli package root to the
+// CLI it runs: <root>/bin/cli.js (@claude-flow/cli itself),
+// <root>/v3/@claude-flow/cli/bin/cli.js (the claude-flow umbrella bundles
+// it), or @claude-flow/cli in the node_modules npm nests inside <root> —
+// or, for the flat layout yarn classic and bun use, in the node_modules
+// folder that holds <root> itself. That is the dependency edge
+// ruflo/bin/ruflo.js's findCliPath() follows. The search stops at that one
+// enclosing node_modules: walking further up would reach unrelated trees,
+// such as a stray ~/node_modules left by an `npm i` in a home directory.
+// Every hit must still pass isRunnableCli().
+function cliInPackage(root) {
+  if (!fs.existsSync(root)) return null;
+  const candidates = [
+    path.join(root, 'bin', 'cli.js'),
+    path.join(root, 'v3', '@claude-flow', 'cli', 'bin', 'cli.js'),
+    path.join(root, 'node_modules', '@claude-flow', 'cli', 'bin', 'cli.js'),
+  ];
+  for (let dir = path.dirname(root), i = 0; i < 4 && dir !== path.dirname(dir); i++, dir = path.dirname(dir)) {
+    if (path.basename(dir) === 'node_modules') {
+      candidates.push(path.join(dir, '@claude-flow', 'cli', 'bin', 'cli.js'));
+      break;
+    }
+  }
+  return candidates.find(isRunnableCli) || null;
+}
+
+// npm's global prefix without spawning npm (`npm prefix -g` measured 70-80 ms
+// per call, paid on every SessionStart that gets this far). Same precedence
+// npm applies:
+//   1. npm_config_prefix in the environment (npm accepts either case);
+//   2. `prefix=` in the user npmrc ($npm_config_userconfig, else ~/.npmrc),
+//      where `npm config set prefix ~/.npm-global` (the npm docs' fix for
+//      EACCES on global installs) writes it;
+//   3. `prefix=` in npm's builtin npmrc (<npm package>/npmrc), found through
+//      the `npm` link beside node: Homebrew writes `prefix = /opt/homebrew`
+//      there (its process.execPath is the Cellar path, so step 4 alone would
+//      be wrong), and the Node.js Windows installer ships
+//      `prefix=${APPDATA}\npm`;
+//   4. npm's default: $PREFIX, else the directory above node's bin/ (POSIX)
+//      or node.exe's own directory (Windows).
+// Values follow npm's ini handling for the cases that decide a path: a
+// quoted value is taken literally, an unquoted `;`/`#` starts a comment,
+// keys below a `[section]` header are ignored, `${VAR}` expands when the
+// variable is set (and `${VAR?}` to empty when it is not) but otherwise
+// stays literal like npm — which leaves the value relative, so the
+// isAbsolute() check below rejects it instead of pointing at the drive root.
+// Not emulated: escaped characters and npm's other ini corner cases; each of
+// those produces a miss, never a wrong CLI. The npmrc is read into memory,
+// but only the value of its last top-level `prefix =` line is kept: no other
+// line (an `_authToken`, say) is returned, stored or logged.
+function npmGlobalPrefix(env = process.env, platform = process.platform, execPath = process.execPath) {
+  const home = (platform === 'win32' ? env.USERPROFILE : env.HOME) || os.homedir();
+  const readPrefix = (file) => {
+    let value = null;
+    try {
+      for (const line of fs.readFileSync(file, 'utf-8').split(/\r?\n/)) {
+        if (/^\s*\[/.test(line)) break; // only the top-level section applies
+        const m = /^\s*prefix\s*=\s*(.*?)\s*$/.exec(line);
+        if (m) value = m[1]; // last one wins, as in npm's ini parser
+      }
+    } catch (e) { /* no such npmrc */ }
+    return value;
+  };
+  const nodeDir = path.dirname(execPath);
+  // npm's builtin npmrc sits in npm's own package dir. On Windows that is
+  // node_modules\npm beside node.exe; elsewhere follow the `npm` link beside
+  // node (<npm>/bin/npm-cli.js) — on Homebrew it points out of the node keg
+  // to /opt/homebrew/lib/node_modules/npm.
+  let builtinRc = path.join(nodeDir, 'node_modules', 'npm', 'npmrc');
+  if (platform !== 'win32') {
+    try {
+      builtinRc = path.join(path.dirname(path.dirname(fs.realpathSync(path.join(nodeDir, 'npm')))), 'npmrc');
+    } catch (e) { /* no npm beside node */ }
+  }
+  const raw = env.npm_config_prefix || env.NPM_CONFIG_PREFIX
+    || readPrefix(env.npm_config_userconfig || env.NPM_CONFIG_USERCONFIG || path.join(home, '.npmrc'))
+    || readPrefix(builtinRc)
+    || env.PREFIX
+    || (platform === 'win32' ? nodeDir : path.dirname(nodeDir));
+  let value = String(raw).trim();
+  const quoted = /^(["'])([\s\S]*)\1$/.exec(value);
+  if (quoted) value = quoted[2];
+  else value = value.replace(/(^|[^\\])[;#].*$/, '$1').trim();
+  value = value
+    .replace(/\$\{([^}?]+)(\?)?\}/g, (whole, name, optional) => (
+      env[name] !== undefined ? env[name] : (optional ? '' : whole)
+    ))
+    .replace(/^~(?=$|[\\/])/, home);
+  return path.isAbsolute(value) ? path.resolve(value) : null;
+}
+
 // Fire-and-forget doesn't work when the CALLER is itself a short-lived
 // subprocess (confirmed live: two consecutive statusline renders 5s apart
 // both saw an empty funnel-messages-cache, because the async HTTPS fetch
@@ -74,8 +288,8 @@ function resolveCliBinForHook() {
 // chance to write the cache. Never awaited here — must not add to
 // SessionStart's own timeout budget.
 //
-// No usable local candidate (resolveCliBinForHook() returned null) falls
-// back to npx: this call is detached/unref'd, so a slower npx cold-start
+// No usable local or global candidate (resolveCliBinForHook() returned null)
+// falls back to npx: this call is detached/unref'd, so a slower npx cold-start
 // costs nothing perceptible — unlike the statusline's own synchronous
 // render path, where local-first exists purely for per-render latency.
 // `--prefer-offline` avoids a registry round trip for the tarball when
@@ -1060,4 +1274,7 @@ if (require.main === module) {
 // Which sibling helpers loaded (all CommonJS, shipped as .cjs — #3555).
 const loadedHelpers = { router: !!router, session: !!session, memory: !!memory, intelligence: !!intelligence };
 
-module.exports = { runWithTimeout, INTELLIGENCE_TIMEOUT_MS, loadedHelpers, ownedByMod, MOD_OWNABLE_EVENTS, resolveCliBinForHook, cliSpawnArgs, helperRoot, scanSessionStartSettingsForRisk, srFormatRiskFindingsForAutomaticBoot, srScanSettingsForRisk, srScanCommandStringForRisk, srScanAllowRuleForRisk, SR_DANGEROUS_COMMAND_WORDS, SR_SHELL_EXEC_WORDS, SR_DOWNLOADER_WORDS, SR_STANDALONE_RISK_PATTERNS };
+// resolveGlobalCliBin/npmGlobalPrefix are exported for
+// hook-handler-global-cli.test.ts; resolveCliBinForHook for anyone checking
+// what a given machine resolves to without running a hook (#3368).
+module.exports = { runWithTimeout, INTELLIGENCE_TIMEOUT_MS, loadedHelpers, ownedByMod, MOD_OWNABLE_EVENTS, resolveCliBinForHook, resolveGlobalCliBin, npmGlobalPrefix, cliSpawnArgs, helperRoot, scanSessionStartSettingsForRisk, srFormatRiskFindingsForAutomaticBoot, srScanSettingsForRisk, srScanCommandStringForRisk, srScanAllowRuleForRisk, SR_DANGEROUS_COMMAND_WORDS, SR_SHELL_EXEC_WORDS, SR_DOWNLOADER_WORDS, SR_STANDALONE_RISK_PATTERNS };

package/.claude/proven-config.json

@@ -1,5 +1,5 @@
 {
-  "adoptedAt": 1792611332070,
+  "adoptedAt": 1792634570394,
   "championId": "sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319",
   "manifest": {
     "schema": "ruflo.proven-config/v1",

package/.claude/skills/pair-programming/SKILL.md

@@ -19,10 +19,21 @@ This skill provides professional pair programming capabilities with AI assistanc
 - **Code Review**: Security scanning, performance analysis, best practice enforcement
 - **Session Persistence**: Auto-save, recovery, export, and sharing
 
+## How Claude Code Uses This
+
+The CLI holds the session state; Claude Code reads it. There is no REPL to type into.
+
+1. At the start of every turn run `ruflo pair status --json`. If `active` is `false`, this skill is dormant.
+2. Follow `mode` and `aiRole`. As **driver** you write the code and the human reviews. As **navigator** you review and suggest and never edit unless asked. `tdd`, `review`, `mentor` and `debug` refine that behaviour as described below.
+3. When `switchDue` is `true`, run `ruflo pair switch`, announce the swap, and continue in the new role.
+4. Change mode mid-session with `ruflo pair mode <mode>`. The human can run the same commands from their shell.
+
+State lives in `.claude-flow/sessions/pair/current.json`. `ruflo pair end` archives it to `history.jsonl` next to it.
+
 ## Prerequisites
 
 **Required:**
-- Claude Flow CLI installed (`npm install -g claude-flow@alpha`)
+- Ruflo CLI installed (`npm install -g ruflo`), which provides the `ruflo pair` command
 - Git repository (optional but recommended)
 
 **Recommended:**
@@ -35,13 +46,13 @@ This skill provides professional pair programming capabilities with AI assistanc
 ### Basic Session
 ```bash
 # Start simple pair programming
-claude-flow pair --start
+ruflo pair start
 ```
 
 ### TDD Session
 ```bash
 # Test-driven development
-claude-flow pair --start \
+ruflo pair start \
   --mode tdd \
   --test-first \
   --coverage 90
@@ -56,23 +67,23 @@ claude-flow pair --start \
 #### Starting Sessions
 ```bash
 # Basic start
-claude-flow pair --start
+ruflo pair start
 
 # Expert refactoring session
-claude-flow pair --start \
+ruflo pair start \
   --agent senior-dev \
   --focus refactor \
   --verify \
   --threshold 0.98
 
 # Debugging session
-claude-flow pair --start \
+ruflo pair start \
   --agent debugger-expert \
   --focus debug \
   --review
 
 # Learning session
-claude-flow pair --start \
+ruflo pair start \
   --mode mentor \
   --pace slow \
   --examples
@@ -81,10 +92,10 @@ claude-flow pair --start \
 #### Session Management
 ```bash
 # Check status
-claude-flow pair --status
+ruflo pair status
 
 # View history
-claude-flow pair --history
+ruflo pair history
 
 # Pause session
 /pause [--reason <reason>]
@@ -93,7 +104,7 @@ claude-flow pair --history
 /resume
 
 # End session
-claude-flow pair --end [--save] [--report]
+ruflo pair end [--save] [--report]
 ```
 
 ### Available Modes
@@ -102,7 +113,7 @@ claude-flow pair --end [--save] [--report]
 You write code while AI provides guidance.
 
 ```bash
-claude-flow pair --start --mode driver
+ruflo pair start --mode driver
 ```
 
 **Your Responsibilities:**
@@ -137,7 +148,7 @@ claude-flow pair --start --mode driver
 AI writes code while you provide direction.
 
 ```bash
-claude-flow pair --start --mode navigator
+ruflo pair start --mode navigator
 ```
 
 **Your Responsibilities:**
@@ -173,13 +184,13 @@ Automatically alternates roles at intervals.
 
 ```bash
 # Default 10-minute intervals
-claude-flow pair --start --mode switch
+ruflo pair start --mode switch
 
 # 5-minute intervals (rapid)
-claude-flow pair --start --mode switch --interval 5m
+ruflo pair start --mode switch --interval 5m
 
 # 15-minute intervals (deep focus)
-claude-flow pair --start --mode switch --interval 15m
+ruflo pair start --mode switch --interval 15m
 ```
 
 **Handoff Process:**
@@ -199,7 +210,7 @@ claude-flow pair --start --mode switch --interval 15m
 
 **TDD Mode** - Test-Driven Development:
 ```bash
-claude-flow pair --start \
+ruflo pair start \
   --mode tdd \
   --test-first \
   --coverage 100
@@ -208,7 +219,7 @@ Workflow: Write failing test → Implement → Refactor → Repeat
 
 **Review Mode** - Continuous code review:
 ```bash
-claude-flow pair --start \
+ruflo pair start \
   --mode review \
   --strict \
   --security
@@ -217,7 +228,7 @@ Features: Real-time feedback, security scanning, performance analysis
 
 **Mentor Mode** - Learning-focused:
 ```bash
-claude-flow pair --start \
+ruflo pair start \
   --mode mentor \
   --explain-all \
   --pace slow
@@ -226,7 +237,7 @@ Features: Detailed explanations, step-by-step guidance, pattern teaching
 
 **Debug Mode** - Problem-solving:
 ```bash
-claude-flow pair --start \
+ruflo pair start \
   --mode debug \
   --verbose \
   --trace
@@ -559,19 +570,19 @@ Create `.claude-flow/pair-config.json`:
 #### CLI Configuration
 ```bash
 # Set configuration
-claude-flow pair config set defaultMode switch
-claude-flow pair config set verification.threshold 0.98
+ruflo pair config set defaultMode switch
+ruflo pair config set verification.threshold 0.98
 
 # Get configuration
-claude-flow pair config get
-claude-flow pair config get defaultMode
+ruflo pair config get
+ruflo pair config get defaultMode
 
 # Export/Import
-claude-flow pair config export > config.json
-claude-flow pair config import config.json
+ruflo pair config export > config.json
+ruflo pair config import config.json
 
 # Reset
-claude-flow pair config reset
+ruflo pair config reset
 ```
 
 #### Profile Management
@@ -580,17 +591,17 @@ Create reusable profiles:
 
 ```bash
 # Create profile
-claude-flow pair profile create refactoring \
+ruflo pair profile create refactoring \
   --mode driver \
   --verify true \
   --threshold 0.98 \
   --focus refactor
 
 # Use profile
-claude-flow pair --start --profile refactoring
+ruflo pair start --profile refactoring
 
 # List profiles
-claude-flow pair profile list
+ruflo pair profile list
 ```
 
 Profile configuration:
@@ -629,7 +640,7 @@ Implementing user authentication with JWT tokens:
 
 ```bash
 # Session setup
-claude-flow pair --start \
+ruflo pair start \
   --mode switch \
   --agent senior-dev \
   --focus implement \
@@ -676,7 +687,7 @@ Debugging a memory leak in Node.js:
 
 ```bash
 # Session setup
-claude-flow pair --start \
+ruflo pair start \
   --mode navigator \
   --agent debugger-expert \
   --focus debug \
@@ -717,7 +728,7 @@ Building shopping cart with test-driven development:
 
 ```bash
 # Session setup
-claude-flow pair --start \
+ruflo pair start \
   --mode tdd \
   --agent tdd-specialist \
   --test-first
@@ -759,7 +770,7 @@ Modernizing legacy code:
 
 ```bash
 # Session setup
-claude-flow pair --start \
+ruflo pair start \
   --mode driver \
   --focus refactor \
   --verify \
@@ -807,7 +818,7 @@ Optimizing slow React application:
 
 ```bash
 # Session setup
-claude-flow pair --start \
+ruflo pair start \
   --mode switch \
   --agent performance-expert \
   --focus optimize \
@@ -852,7 +863,7 @@ Building RESTful API with Express:
 
 ```bash
 # Session setup
-claude-flow pair --start \
+ruflo pair start \
   --mode navigator \
   --agent backend-expert \
   --focus implement \
@@ -897,28 +908,28 @@ claude-flow pair --start \
 
 ```bash
 # Refactoring template
-claude-flow pair --template refactor
+ruflo pair --template refactor
 # Focus: Code improvement
 # Verification: High (0.98)
 # Testing: After each change
 # Review: Continuous
 
 # Feature template
-claude-flow pair --template feature
+ruflo pair --template feature
 # Focus: Implementation
 # Verification: Standard (0.95)
 # Testing: On completion
 # Review: Pre-commit
 
 # Debug template
-claude-flow pair --template debug
+ruflo pair --template debug
 # Focus: Problem solving
 # Verification: Moderate (0.90)
 # Testing: Regression tests
 # Review: Root cause
 
 # Learning template
-claude-flow pair --template learn
+ruflo pair --template learn
 # Mode: Mentor
 # Pace: Slow
 # Explanations: Detailed
@@ -930,7 +941,7 @@ claude-flow pair --template learn
 #### Session Status
 
 ```bash
-claude-flow pair --status
+ruflo pair status
 ```
 
 **Output:**
@@ -962,7 +973,7 @@ Next Switch: in 3 minutes
 #### Session History
 
 ```bash
-claude-flow pair --history
+ruflo pair history
 ```
 
 **Output:**
@@ -993,32 +1004,32 @@ claude-flow pair --history
 
 ```bash
 # Save session
-claude-flow pair --save [--name <name>]
+ruflo pair --save [--name <name>]
 
 # Load session
-claude-flow pair --load <session-id>
+ruflo pair --load <session-id>
 
 # Export session
-claude-flow pair --export <session-id> [--format json|md]
+ruflo pair --export <session-id> [--format json|md]
 
 # Generate report
-claude-flow pair --report <session-id>
+ruflo pair --report <session-id>
 ```
 
 #### Background Sessions
 
 ```bash
 # Start in background
-claude-flow pair --start --background
+ruflo pair start --background
 
 # Monitor background session
-claude-flow pair --monitor
+ruflo pair --monitor
 
 # Attach to background session
-claude-flow pair --attach <session-id>
+ruflo pair --attach <session-id>
 
 # End background session
-claude-flow pair --end <session-id>
+ruflo pair end <session-id>
 ```
 
 ### Advanced Features
@@ -1054,30 +1065,30 @@ Use custom commands:
 
 ```bash
 # Start with recording
-claude-flow pair --start --record
+ruflo pair start --record
 
 # Replay session
-claude-flow pair --replay <session-id>
+ruflo pair --replay <session-id>
 
 # Session analytics
-claude-flow pair --analytics <session-id>
+ruflo pair --analytics <session-id>
 ```
 
 #### Integration Options
 
 **With Git:**
 ```bash
-claude-flow pair --start --git --auto-commit
+ruflo pair start --git --auto-commit
 ```
 
 **With CI/CD:**
 ```bash
-claude-flow pair --start --ci --non-interactive
+ruflo pair start --ci --non-interactive
 ```
 
 **With IDE:**
 ```bash
-claude-flow pair --start --ide vscode
+ruflo pair start --ide vscode
 ```
 
 ### Best Practices
@@ -1131,7 +1142,7 @@ claude-flow pair --start --ide vscode
 - Validate JSON syntax
 - Check file permissions
 - Review priority order (CLI > env > project > user > global)
-- Run `claude-flow pair config validate`
+- Run `ruflo pair config validate`
 
 ### Quality Metrics
 
@@ -1195,8 +1206,8 @@ Default shortcuts:
 
 ### Related Commands
 
-- `claude-flow pair --help` - Show help
-- `claude-flow pair config` - Manage configuration
-- `claude-flow pair profile` - Manage profiles
-- `claude-flow pair templates` - List templates
-- `claude-flow pair agents` - List available agents
+- `ruflo pair --help` - Show help
+- `ruflo pair config` - Manage configuration
+- `ruflo pair profile` - Manage profiles
+- `ruflo pair templates` - List templates
+- `ruflo pair agents` - List available agents

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.59.11",
+  "version": "3.59.13",
   "workspaces": [
     "v3/@claude-flow/codex",
     "v3/@claude-flow/mcp",

package/v3/@claude-flow/cli/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 7,
-  "generatedAt": "2026-10-21T19:36:12.729Z",
-  "gitSha": "0e7696e6",
+  "generatedAt": "2026-10-22T02:03:09.504Z",
+  "gitSha": "056a11ec",
   "catalog": {
     "agents": 176,
     "tools": 432,

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

@@ -46,6 +46,7 @@ export declare function getGuidanceCommand(): Promise<Command | undefined>;
 export declare function getApplianceCommand(): Promise<Command | undefined>;
 export declare function getCleanupCommand(): Promise<Command | undefined>;
 export declare function getAutopilotCommand(): Promise<Command | undefined>;
+export declare function getPairCommand(): Promise<Command | undefined>;
 export declare function getTransportCommand(): Promise<Command | undefined>;
 /**
  * Core commands loaded synchronously (available immediately)

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

@@ -70,6 +70,9 @@ const commandLoaders = {
     'transfer-store': () => import('./transfer-store.js'),
     cleanup: () => import('./cleanup.js'),
     autopilot: () => import('./autopilot.js'),
+    // Pair programming session state (restores the v2 `pair` command the
+    // bundled pair-programming skill depends on)
+    pair: () => import('./pair.js'),
     // GAIA Benchmark Harness (ADR-133)
     'gaia-bench': () => import('./gaia-bench.js'),
     // MetaHarness integration (ADR-150) — dispatcher over plugins/ruflo-metaharness/
@@ -203,6 +206,7 @@ export async function getGuidanceCommand() { return loadCommand('guidance'); }
 export async function getApplianceCommand() { return loadCommand('appliance'); }
 export async function getCleanupCommand() { return loadCommand('cleanup'); }
 export async function getAutopilotCommand() { return loadCommand('autopilot'); }
+export async function getPairCommand() { return loadCommand('pair'); }
 export async function getTransportCommand() { return loadCommand('transport'); }
 /**
  * Core commands loaded synchronously (available immediately)
@@ -249,14 +253,14 @@ export const commandsByCategory = {
  * Use this for help display and full command listings.
  */
 export async function getCommandsByCategory() {
-    const [daemonCmd, doctorCmd, embeddingsCmd, neuralCmd, performanceCmd, securityCmd, ruvectorCmd, hiveMindCmd, configCmd, completionsCmd, migrateCmd, workflowCmd, analyzeCmd, routeCmd, progressCmd, providersCmd, pluginsCmd, deploymentCmd, claimsCmd, issuesCmd, updateCmd, processCmd, guidanceCmd, applianceCmd, cleanupCmd, autopilotCmd, policyCmd,] = await Promise.all([
+    const [daemonCmd, doctorCmd, embeddingsCmd, neuralCmd, performanceCmd, securityCmd, ruvectorCmd, hiveMindCmd, configCmd, completionsCmd, migrateCmd, workflowCmd, analyzeCmd, routeCmd, progressCmd, providersCmd, pluginsCmd, deploymentCmd, claimsCmd, issuesCmd, updateCmd, processCmd, guidanceCmd, applianceCmd, cleanupCmd, autopilotCmd, policyCmd, pairCmd,] = await Promise.all([
         loadCommand('daemon'), loadCommand('doctor'), loadCommand('embeddings'), loadCommand('neural'),
         loadCommand('performance'), loadCommand('security'), loadCommand('ruvector'), loadCommand('hive-mind'),
         loadCommand('config'), loadCommand('completions'), loadCommand('migrate'), loadCommand('workflow'),
         loadCommand('analyze'), loadCommand('route'), loadCommand('progress'), loadCommand('providers'),
         loadCommand('plugins'), loadCommand('deployment'), loadCommand('claims'), loadCommand('issues'),
         loadCommand('update'), loadCommand('process'), loadCommand('guidance'), loadCommand('appliance'),
-        loadCommand('cleanup'), loadCommand('autopilot'), loadCommand('policy'),
+        loadCommand('cleanup'), loadCommand('autopilot'), loadCommand('policy'), loadCommand('pair'),
     ]);
     return {
         primary: [
@@ -270,7 +274,7 @@ export async function getCommandsByCategory() {
         ].filter(Boolean),
         utility: [
             configCmd, doctorCmd, daemonCmd, completionsCmd,
-            migrateCmd, workflowCmd,
+            migrateCmd, workflowCmd, pairCmd,
         ].filter(Boolean),
         analysis: [
             analyzeCmd, routeCmd, progressCmd,

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

@@ -0,0 +1,46 @@
+/**
+ * `ruflo pair` — pair programming session state.
+ *
+ * The bundled `pair-programming` skill has told Claude Code to run
+ * `claude-flow pair --start --mode tdd` since v2, but the v3 CLI never
+ * shipped the command, so the skill's modes could not be activated or
+ * switched. This restores a minimal, non-interactive version: the session
+ * (mode, who currently drives, when roles last swapped) lives in
+ * `.claude-flow/sessions/pair/current.json` in the project so both the human
+ * and the agent can read it between turns. There is no REPL — Claude Code
+ * cannot type into one — the agent reads `pair status --json` and behaves
+ * according to the recorded mode and role.
+ *
+ * Legacy v2 spellings (`pair --start`, `--status`, `--end`, `--history`)
+ * still work so existing skill docs and muscle memory keep functioning.
+ */
+import type { Command } from '../types.js';
+export declare const PAIR_MODES: {
+    readonly driver: "AI writes the code, human reviews and steers";
+    readonly navigator: "Human writes the code, AI reviews and suggests";
+    readonly switch: "Roles swap every --interval (default 10m)";
+    readonly tdd: "Red-green-refactor; AI writes failing tests first";
+    readonly review: "Read-only review of existing code, no edits without approval";
+    readonly mentor: "AI explains every step and asks before acting";
+    readonly debug: "Hypothesis-driven debugging; AI reproduces before fixing";
+};
+export type PairMode = keyof typeof PAIR_MODES;
+export type PairRole = 'driver' | 'navigator';
+export interface PairSession {
+    id: string;
+    mode: PairMode;
+    /** Who currently types. Always refers to the AI's role. */
+    aiRole: PairRole;
+    switchIntervalMinutes: number | null;
+    startedAt: string;
+    lastSwitchAt: string;
+    switches: number;
+    endedAt?: string;
+}
+export declare function readSession(cwd: string): PairSession | null;
+export declare function readHistory(cwd: string): PairSession[];
+/** Accepts `10`, `10m`, `1h`, `90s`; returns minutes or null when unparseable. */
+export declare function parseIntervalMinutes(raw: unknown): number | null;
+export declare const pairCommand: Command;
+export default pairCommand;
+//# sourceMappingURL=pair.d.ts.map

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

@@ -0,0 +1,303 @@
+/**
+ * `ruflo pair` — pair programming session state.
+ *
+ * The bundled `pair-programming` skill has told Claude Code to run
+ * `claude-flow pair --start --mode tdd` since v2, but the v3 CLI never
+ * shipped the command, so the skill's modes could not be activated or
+ * switched. This restores a minimal, non-interactive version: the session
+ * (mode, who currently drives, when roles last swapped) lives in
+ * `.claude-flow/sessions/pair/current.json` in the project so both the human
+ * and the agent can read it between turns. There is no REPL — Claude Code
+ * cannot type into one — the agent reads `pair status --json` and behaves
+ * according to the recorded mode and role.
+ *
+ * Legacy v2 spellings (`pair --start`, `--status`, `--end`, `--history`)
+ * still work so existing skill docs and muscle memory keep functioning.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { output } from '../output.js';
+export const PAIR_MODES = {
+    driver: 'AI writes the code, human reviews and steers',
+    navigator: 'Human writes the code, AI reviews and suggests',
+    switch: 'Roles swap every --interval (default 10m)',
+    tdd: 'Red-green-refactor; AI writes failing tests first',
+    review: 'Read-only review of existing code, no edits without approval',
+    mentor: 'AI explains every step and asks before acting',
+    debug: 'Hypothesis-driven debugging; AI reproduces before fixing',
+};
+const SESSION_DIR = ['.claude-flow', 'sessions', 'pair'];
+const DEFAULT_SWITCH_INTERVAL_MINUTES = 10;
+function sessionDir(cwd) {
+    return path.join(cwd, ...SESSION_DIR);
+}
+function currentPath(cwd) {
+    return path.join(sessionDir(cwd), 'current.json');
+}
+function historyPath(cwd) {
+    return path.join(sessionDir(cwd), 'history.jsonl');
+}
+export function readSession(cwd) {
+    try {
+        return JSON.parse(fs.readFileSync(currentPath(cwd), 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeSession(cwd, session) {
+    fs.mkdirSync(sessionDir(cwd), { recursive: true });
+    const tmp = currentPath(cwd) + '.tmp-' + process.pid;
+    fs.writeFileSync(tmp, JSON.stringify(session, null, 2) + '\n', 'utf-8');
+    fs.renameSync(tmp, currentPath(cwd));
+}
+export function readHistory(cwd) {
+    try {
+        return fs.readFileSync(historyPath(cwd), 'utf-8')
+            .split('\n')
+            .filter(Boolean)
+            .map(line => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}
+/** Accepts `10`, `10m`, `1h`, `90s`; returns minutes or null when unparseable. */
+export function parseIntervalMinutes(raw) {
+    if (raw === undefined || raw === null || raw === '')
+        return null;
+    if (typeof raw === 'number')
+        return raw > 0 ? raw : null;
+    const match = /^(\d+(?:\.\d+)?)\s*(s|m|h)?$/i.exec(String(raw).trim());
+    if (!match)
+        return null;
+    const value = parseFloat(match[1]);
+    const unit = (match[2] ?? 'm').toLowerCase();
+    const minutes = unit === 'h' ? value * 60 : unit === 's' ? value / 60 : value;
+    return minutes > 0 ? minutes : null;
+}
+function isMode(value) {
+    return typeof value === 'string' && value in PAIR_MODES;
+}
+function otherRole(role) {
+    return role === 'driver' ? 'navigator' : 'driver';
+}
+/** Default AI role implied by a mode, used when --role is not given. */
+function defaultRoleFor(mode) {
+    return mode === 'navigator' || mode === 'review' ? 'navigator' : 'driver';
+}
+function switchDue(session, now) {
+    if (session.mode !== 'switch' || !session.switchIntervalMinutes)
+        return false;
+    const elapsedMinutes = (now.getTime() - new Date(session.lastSwitchAt).getTime()) / 60_000;
+    return elapsedMinutes >= session.switchIntervalMinutes;
+}
+function describe(session, now) {
+    return {
+        ...session,
+        modeDescription: PAIR_MODES[session.mode],
+        humanRole: otherRole(session.aiRole),
+        switchDue: switchDue(session, now),
+    };
+}
+function printSession(session, now) {
+    output.writeln(`Session:   ${session.id}`);
+    output.writeln(`Mode:      ${session.mode} — ${PAIR_MODES[session.mode]}`);
+    output.writeln(`AI role:   ${session.aiRole}   (human: ${otherRole(session.aiRole)})`);
+    if (session.switchIntervalMinutes) {
+        output.writeln(`Interval:  every ${session.switchIntervalMinutes}m, ${session.switches} switch(es) so far`);
+        if (switchDue(session, now))
+            output.printWarning('Role switch is due — run `ruflo pair switch`.');
+    }
+    output.writeln(`Started:   ${session.startedAt}`);
+}
+function noSession(ctx) {
+    if (ctx.flags.json)
+        output.printJson({ active: false });
+    else
+        output.writeln('No active pair session. Start one with `ruflo pair start --mode <mode>`.');
+    return { success: true, data: { active: false } };
+}
+async function startAction(ctx) {
+    // `pair start tdd` and `pair start --mode tdd` both work; a bare word wins
+    // over the option default so it is never silently ignored.
+    const mode = ctx.args[0] ?? ctx.flags.mode ?? 'driver';
+    if (!isMode(mode)) {
+        output.printError(`Unknown mode "${String(mode)}". Choose one of: ${Object.keys(PAIR_MODES).join(', ')}`);
+        return { success: false, exitCode: 1 };
+    }
+    const existing = readSession(ctx.cwd);
+    if (existing) {
+        output.printError(`A pair session is already active (${existing.id}). End it first with \`ruflo pair end\`.`);
+        return { success: false, exitCode: 1, data: describe(existing, new Date()) };
+    }
+    const interval = ctx.flags.interval !== undefined ? parseIntervalMinutes(ctx.flags.interval) : null;
+    if (ctx.flags.interval !== undefined && interval === null) {
+        output.printError(`Invalid --interval "${String(ctx.flags.interval)}". Use e.g. 10m, 90s or 1h.`);
+        return { success: false, exitCode: 1 };
+    }
+    const role = ctx.flags.role;
+    const now = new Date();
+    const session = {
+        id: `pair_${now.getTime()}`,
+        mode,
+        aiRole: role === 'driver' || role === 'navigator' ? role : defaultRoleFor(mode),
+        switchIntervalMinutes: mode === 'switch' ? (interval ?? DEFAULT_SWITCH_INTERVAL_MINUTES) : interval,
+        startedAt: now.toISOString(),
+        lastSwitchAt: now.toISOString(),
+        switches: 0,
+    };
+    writeSession(ctx.cwd, session);
+    if (ctx.flags.json)
+        output.printJson(describe(session, now));
+    else {
+        output.printSuccess('Pair session started.');
+        printSession(session, now);
+    }
+    return { success: true, data: describe(session, now) };
+}
+const startSub = {
+    name: 'start',
+    description: 'Start a pair programming session',
+    options: [
+        { name: 'mode', short: 'm', description: 'Collaboration mode', type: 'string', default: 'driver', choices: Object.keys(PAIR_MODES) },
+        { name: 'role', description: "AI's starting role (defaults from mode)", type: 'string', choices: ['driver', 'navigator'] },
+        { name: 'interval', short: 'i', description: 'Role switch interval for switch mode (e.g. 10m, 1h)', type: 'string' },
+        { name: 'json', description: 'Output as JSON', type: 'boolean', default: false },
+    ],
+    action: startAction,
+};
+async function statusAction(ctx) {
+    const session = readSession(ctx.cwd);
+    if (!session)
+        return noSession(ctx);
+    const now = new Date();
+    if (ctx.flags.json)
+        output.printJson({ active: true, ...describe(session, now) });
+    else
+        printSession(session, now);
+    return { success: true, data: { active: true, ...describe(session, now) } };
+}
+const statusSub = {
+    name: 'status',
+    description: 'Show the active pair session',
+    options: [{ name: 'json', description: 'Output as JSON', type: 'boolean', default: false }],
+    action: statusAction,
+};
+async function switchAction(ctx) {
+    const session = readSession(ctx.cwd);
+    if (!session)
+        return noSession(ctx);
+    const now = new Date();
+    session.aiRole = otherRole(session.aiRole);
+    session.lastSwitchAt = now.toISOString();
+    session.switches += 1;
+    writeSession(ctx.cwd, session);
+    if (ctx.flags.json)
+        output.printJson(describe(session, now));
+    else
+        output.printSuccess(`Switched — AI is now ${session.aiRole}, human is ${otherRole(session.aiRole)}.`);
+    return { success: true, data: describe(session, now) };
+}
+const switchSub = {
+    name: 'switch',
+    description: 'Swap driver and navigator roles',
+    options: [{ name: 'json', description: 'Output as JSON', type: 'boolean', default: false }],
+    action: switchAction,
+};
+async function modeAction(ctx) {
+    const session = readSession(ctx.cwd);
+    if (!session)
+        return noSession(ctx);
+    const mode = ctx.args[0];
+    if (!isMode(mode)) {
+        output.printError(`Usage: ruflo pair mode <${Object.keys(PAIR_MODES).join('|')}>`);
+        return { success: false, exitCode: 1 };
+    }
+    const now = new Date();
+    session.mode = mode;
+    if (mode === 'switch' && !session.switchIntervalMinutes) {
+        session.switchIntervalMinutes = DEFAULT_SWITCH_INTERVAL_MINUTES;
+        session.lastSwitchAt = now.toISOString();
+    }
+    writeSession(ctx.cwd, session);
+    if (ctx.flags.json)
+        output.printJson(describe(session, now));
+    else
+        output.printSuccess(`Mode changed to ${mode} — ${PAIR_MODES[mode]}.`);
+    return { success: true, data: describe(session, now) };
+}
+const modeSub = {
+    name: 'mode',
+    description: 'Change the mode of the active session: ruflo pair mode <mode>',
+    options: [{ name: 'json', description: 'Output as JSON', type: 'boolean', default: false }],
+    action: modeAction,
+};
+async function endAction(ctx) {
+    const session = readSession(ctx.cwd);
+    if (!session)
+        return noSession(ctx);
+    session.endedAt = new Date().toISOString();
+    fs.appendFileSync(historyPath(ctx.cwd), JSON.stringify(session) + '\n', 'utf-8');
+    fs.rmSync(currentPath(ctx.cwd), { force: true });
+    if (ctx.flags.json)
+        output.printJson(session);
+    else
+        output.printSuccess(`Pair session ${session.id} ended after ${session.switches} role switch(es).`);
+    return { success: true, data: session };
+}
+const endSub = {
+    name: 'end',
+    description: 'End the active session and append it to the history',
+    options: [{ name: 'json', description: 'Output as JSON', type: 'boolean', default: false }],
+    action: endAction,
+};
+async function historyAction(ctx) {
+    const history = readHistory(ctx.cwd);
+    if (ctx.flags.json)
+        output.printJson(history);
+    else if (history.length === 0)
+        output.writeln('No past pair sessions.');
+    else
+        for (const s of history)
+            output.writeln(`${s.id}  ${s.mode.padEnd(9)}  ${s.startedAt} → ${s.endedAt ?? '?'}  (${s.switches} switches)`);
+    return { success: true, data: history };
+}
+const historySub = {
+    name: 'history',
+    description: 'List past pair sessions',
+    options: [{ name: 'json', description: 'Output as JSON', type: 'boolean', default: false }],
+    action: historyAction,
+};
+export const pairCommand = {
+    name: 'pair',
+    description: 'Pair programming session: modes, driver/navigator roles, switching',
+    subcommands: [startSub, statusSub, switchSub, modeSub, endSub, historySub],
+    // Top-level flags kept for the v2 spelling used throughout the skill docs.
+    options: [
+        { name: 'start', description: 'Alias for `pair start`', type: 'boolean', default: false },
+        { name: 'status', description: 'Alias for `pair status`', type: 'boolean', default: false },
+        { name: 'end', description: 'Alias for `pair end`', type: 'boolean', default: false },
+        { name: 'history', description: 'Alias for `pair history`', type: 'boolean', default: false },
+        ...(startSub.options ?? []),
+    ],
+    examples: [
+        { command: 'ruflo pair start --mode tdd', description: 'Start a test-first session with the AI driving' },
+        { command: 'ruflo pair start --mode switch --interval 15m', description: 'Swap roles every 15 minutes' },
+        { command: 'ruflo pair status --json', description: 'Machine-readable state for the agent to read each turn' },
+        { command: 'ruflo pair switch', description: 'Swap driver and navigator now' },
+        { command: 'ruflo pair mode review', description: 'Change mode mid-session' },
+        { command: 'ruflo pair end', description: 'End the session and record it in the history' },
+    ],
+    action: async (ctx) => {
+        if (ctx.flags.start)
+            return startAction(ctx);
+        if (ctx.flags.end)
+            return endAction(ctx);
+        if (ctx.flags.history)
+            return historyAction(ctx);
+        return statusAction(ctx);
+    },
+};
+export default pairCommand;
+//# sourceMappingURL=pair.js.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/claims-tools.d.ts

@@ -6,7 +6,7 @@
  *
  * @module @claude-flow/cli/mcp-tools/claims
  */
-import type { MCPTool } from './types.js';
+import { type MCPTool } from './types.js';
 export declare const claimsTools: MCPTool[];
 export default claimsTools;
 //# sourceMappingURL=claims-tools.d.ts.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/claims-tools.js

@@ -6,19 +6,20 @@
  *
  * @module @claude-flow/cli/mcp-tools/claims
  */
+import { getProjectCwd } from './types.js';
 import { readClaimsStore } from '../services/claims-store.js';
 import { validateIdentifier, validateText } from './validate-input.js';
 // File-based persistence
 import { existsSync, writeFileSync, mkdirSync } from 'fs';
-import { join, resolve } from 'path';
+import { resolve } from 'path';
 const CLAIMS_DIR = '.claude-flow/claims';
 const CLAIMS_FILE = 'claims.json';
 const DEFAULT_MAX_CLAIMS = 5;
 function getClaimsPath() {
-    return resolve(join(CLAIMS_DIR, CLAIMS_FILE));
+    return resolve(getProjectCwd(), CLAIMS_DIR, CLAIMS_FILE);
 }
 function ensureClaimsDir() {
-    const dir = resolve(CLAIMS_DIR);
+    const dir = resolve(getProjectCwd(), CLAIMS_DIR);
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.59.11",
+  "version": "3.59.13",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",