claude-flow 3.49.0 → 3.50.0

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

@@ -286,6 +286,17 @@ async function readStdin() {
   });
 }
 
+// ADR-404: the ruflo mod (plugins/ruflo-mods) runs these events in-process
+// inside Claude Code and sets RUFLO_MODS_OWNS on the process, which every hook
+// started after inherits. An event named there is the mod's; returning here
+// keeps it from firing twice. Only side-effect events can be handed over:
+// guards such as pre-bash always run, whatever the variable says.
+const MOD_OWNABLE_EVENTS = new Set(['route', 'post-edit']);
+function ownedByMod(cmd, env = process.env) {
+  if (!MOD_OWNABLE_EVENTS.has(cmd)) return false;
+  return String(env.RUFLO_MODS_OWNS || '').split(',').some((owned) => owned.trim() === cmd);
+}
+
 function claimSideEffectEvent(family, stdinData, event) {
   if (/^(1|true|yes|on)$/i.test(process.env.RUFLO_DISABLE_HOOK_DEDUP || '')) return true;
   try {
@@ -312,6 +323,8 @@ function claimSideEffectEvent(family, stdinData, event) {
 }
 
 async function main() {
+  if (ownedByMod(command)) return;
+
   // Global safety timeout: hooks must NEVER hang (#1530, #1531)
   const safetyTimer = setTimeout(() => {
     process.stderr.write("[WARN] Hook handler global timeout (5s), forcing exit\n");
@@ -606,4 +619,4 @@ 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 };
+module.exports = { runWithTimeout, INTELLIGENCE_TIMEOUT_MS, loadedHelpers, ownedByMod, MOD_OWNABLE_EVENTS };

package/.claude/proven-config.json

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

package/.claude-plugin/marketplace.json

@@ -215,6 +215,16 @@
       "name": "ruflo-music",
       "source": "./plugins/ruflo-music",
       "description": "AI music generation via Cognitum Music (cogmusic MCP) \u2014 compose lyrics/prompts, generate tracks, separate stems, extract MIDI, and master through your own music.cognitum.one account"
+    },
+    {
+      "name": "ruflo-mods",
+      "source": "./plugins/ruflo-mods",
+      "description": "Early access (ADR-404): ruflo as a Claude Code mod (function hooks) \u2014 in-process routing, edit learning signals, tighten-only tool checks from ruflo policy, and the cost budget ladder. Opt-in via `ruflo mods install`; classic hooks stay the fallback"
+    },
+    {
+      "name": "ruflo-ruos",
+      "source": "./plugins/ruflo-ruos",
+      "description": "Run ruflo swarm agents on your own ruOS cloud desktops via the tenant-authenticated fleet MCP or per-tenant SSH; optional, removable"
     }
   ]
 }

package/package.json

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

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

@@ -1,10 +1,10 @@
 {
   "schemaVersion": 1,
   "generation": 7,
-  "generatedAt": "2026-10-01T00:04:08.841Z",
-  "gitSha": "0bd8e314",
+  "generatedAt": "2026-10-02T00:19:27.102Z",
+  "gitSha": "27982983",
   "catalog": {
-    "agents": 175,
+    "agents": 176,
     "tools": 418,
     "skills": 34
   },

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

@@ -2306,6 +2306,22 @@ async function checkMetaharness() {
         };
     }
 }
+// ADR-404 — ruflo as a Claude Code mod (function hooks, early access). One
+// line in a bare `doctor`: whether the mod is enabled, can load (function
+// hooks on, not refused by allowManagedModsOnly) and has started; never a
+// failure, since the classic hooks are the default and the fallback.
+// `ruflo mods doctor` prints every finding.
+async function checkMods() {
+    const { probeMods } = await import('../mods/probe.js');
+    const findings = probeMods({ projectRoot: process.cwd() });
+    const enabled = findings.find((f) => f.name === 'ruflo-mods plugin')?.status === 'pass';
+    if (!enabled)
+        return { name: 'ruflo mods (ADR-404)', status: 'pass', message: 'not enabled; classic hooks handle every event' };
+    const warnings = findings.filter((f) => f.status !== 'pass');
+    return warnings.length === 0
+        ? { name: 'ruflo mods (ADR-404)', status: 'pass', message: findings.find((f) => f.name === 'last mod start')?.message ?? 'enabled' }
+        : { name: 'ruflo mods (ADR-404)', status: 'warn', message: warnings.map((f) => `${f.name}: ${f.message}`).join('; '), fix: 'ruflo mods doctor' };
+}
 // Opt-in @ruvector/typesafe task router (optional peer). `--component typesafe` only.
 async function checkTypesafeRouter() {
     const name = '@ruvector/typesafe router';
@@ -2519,7 +2535,7 @@ export const doctorCommand = {
         {
             name: 'component',
             short: 'c',
-            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, mcp-overhead, claude, browser, disk, typescript, agentic-flow, encryption, federation, funnel, proxy, auth, typesafe, metaharness)',
+            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, mcp-overhead, claude, browser, disk, typescript, agentic-flow, encryption, federation, funnel, proxy, auth, typesafe, mods, metaharness)',
             type: 'string'
         },
         {
@@ -2661,6 +2677,7 @@ export const doctorCommand = {
             checkFunnel, // ADR-305 — effective funnel state + deciding precedence source
             checkProxySponsoredConsent, // ADR-313 — Meta LLM Proxy sponsored-downtime health
             checkAuth, // ADR-306 — Cognitum identity (warn-only; never fails bare `ruflo doctor`)
+            checkMods, // ADR-404 — Claude Code mod path (warn-only)
         ];
         // #2677: `--component memory` now runs the whole memory-health suite,
         // not just the existence check. Values can be a single check or an
@@ -2714,6 +2731,7 @@ export const doctorCommand = {
             'proxy': [checkProxySponsoredConsent, checkProxyBinary, checkProxyProcess, checkProxyBindAddress],
             'auth': checkAuth, // ADR-306
             'typesafe': checkTypesafeRouter, // opt-in @ruvector/typesafe task router
+            'mods': checkMods, // ADR-404 — ruflo as a Claude Code mod
         };
         let checksToRun = allChecks;
         if (component && componentMap[component]) {

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

@@ -88,6 +88,8 @@ const commandLoaders = {
     advisor: () => import('./advisor.js'),
     // Ruflo verbs in Claude Code's spinnerVerbs rotation (ADR-318)
     spinner: () => import('./spinner.js'),
+    // ruflo as a Claude Code mod: function hooks, early access (ADR-404)
+    mods: () => import('./mods.js'),
     // Ruflo entries in Claude Code's companyAnnouncements startup rotation (ADR-319)
     announcements: () => import('./announcements.js'),
     // AGNTCY/Outshift runtime transport selection (ADR-324 §2) — optional,

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

@@ -775,6 +775,19 @@ const initClaudeAction = async (ctx) => {
                 output.writeln(output.warning('  Embedding initialization skipped (run manually)'));
             }
         }
+        // ADR-404 — opt into the Claude Code mod path. Additive: the classic
+        // hooks just written stay the default and the fallback.
+        if (ctx.flags.mods === true) {
+            output.writeln();
+            try {
+                const { installMod } = await import('../mods/install.js');
+                const installed = installMod(ctx.cwd, 'local');
+                output.writeln(output.success(`  ✓ ruflo-mods enabled in ${installed.settingsFile} (early access; run "ruflo mods doctor")`));
+            }
+            catch (err) {
+                output.writeln(output.warning(`  ruflo-mods not enabled: ${err instanceof Error ? err.message : String(err)}`));
+            }
+        }
         if (!startDaemon && !startAll) {
             const bin = (process.argv[1] || '').includes('ruflo') ? 'ruflo' : 'claude-flow';
             output.writeln(output.bold('Next steps:'));
@@ -1500,6 +1513,13 @@ export const initCommand = {
             type: 'boolean',
             default: false,
         },
+        {
+            // ADR-404 — Claude Code function hooks are early access; opt-in only.
+            name: 'mods',
+            description: 'Also enable the ruflo Claude Code mod (function hooks, early access); classic hooks stay as fallback',
+            type: 'boolean',
+            default: false,
+        },
         {
             name: 'with-embeddings',
             description: 'Initialize ONNX embedding subsystem with hyperbolic support',

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

@@ -0,0 +1,13 @@
+/**
+ * `ruflo mods` — opt into running ruflo as a Claude Code mod (ADR-404,
+ * Claude Code function hooks, early access).
+ *
+ * install/uninstall edit one settings file and record what they added;
+ * status/doctor report what can be known from outside a session; sync-policy
+ * rewrites the policy projection the mod's tool check reads. Classic hooks
+ * are never removed: they stay the default and the fallback.
+ */
+import type { Command } from '../types.js';
+export declare const modsCommand: Command;
+export default modsCommand;
+//# sourceMappingURL=mods.d.ts.map

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

@@ -0,0 +1,126 @@
+/**
+ * `ruflo mods` — opt into running ruflo as a Claude Code mod (ADR-404,
+ * Claude Code function hooks, early access).
+ *
+ * install/uninstall edit one settings file and record what they added;
+ * status/doctor report what can be known from outside a session; sync-policy
+ * rewrites the policy projection the mod's tool check reads. Classic hooks
+ * are never removed: they stay the default and the fallback.
+ */
+import { output } from '../output.js';
+import { installMod, uninstallMod } from '../mods/install.js';
+import { probeMods } from '../mods/probe.js';
+function projectRoot(ctx) {
+    return ctx.flags.projectRoot ?? ctx.flags['project-root'] ?? ctx.cwd ?? process.cwd();
+}
+function printFindings(findings) {
+    for (const f of findings) {
+        const mark = f.status === 'pass' ? output.success('✓') : f.status === 'warn' ? output.warning('!') : output.error('✗');
+        output.writeln(`${mark} ${f.name}: ${f.message}`);
+        if (f.fix && f.status !== 'pass')
+            output.writeln(output.dim(`    fix: ${f.fix}`));
+    }
+}
+const rootOption = { name: 'project-root', description: 'Project root (default: current directory)', type: 'string' };
+const installSub = {
+    name: 'install',
+    description: 'Enable the ruflo-mods plugin for this project (opt-in; classic hooks stay as fallback)',
+    options: [
+        rootOption,
+        { name: 'scope', description: 'local (.claude/settings.local.json, default) | project (.claude/settings.json)', type: 'string', default: 'local' },
+        { name: 'dry-run', description: 'Show the settings that would be written', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        const scope = ctx.flags.scope ?? 'local';
+        if (scope !== 'local' && scope !== 'project') {
+            output.printError(`--scope must be local or project, got ${scope}`);
+            return { success: false, exitCode: 1 };
+        }
+        const root = projectRoot(ctx);
+        const result = installMod(root, scope, (ctx.flags.dryRun === true || ctx.flags['dry-run'] === true));
+        if (result.dryRun) {
+            output.writeln(`Would write ${result.settingsFile}:`);
+            output.printJson(result.next);
+            return { success: true, data: result };
+        }
+        await syncPolicy(root, true);
+        output.printSuccess(`ruflo-mods enabled in ${result.settingsFile}${result.backup ? ` (backup: ${result.backup})` : ''}`);
+        output.writeln('Restart Claude Code, then run /ruflo-mods in a session to see what the mod owns.');
+        output.writeln(output.dim('Early access: Claude Code loads it only where function hooks are on. Run `ruflo mods doctor`.'));
+        return { success: true, data: result };
+    },
+};
+const uninstallSub = {
+    name: 'uninstall',
+    description: 'Remove what `ruflo mods install` added (classic hooks take every event back)',
+    options: [rootOption, { name: 'dry-run', description: 'Show what would be removed', type: 'boolean', default: false }],
+    action: async (ctx) => {
+        const result = uninstallMod(projectRoot(ctx), (ctx.flags.dryRun === true || ctx.flags['dry-run'] === true));
+        if (!result.removed) {
+            output.printWarning('No install record (.claude-flow/mods/install.json): nothing ruflo added to remove.');
+            return { success: true, data: result };
+        }
+        output.printSuccess(`${result.dryRun ? 'Would remove' : 'Removed'} ruflo-mods from ${result.settingsFile}`);
+        return { success: true, data: result };
+    },
+};
+function findingsCommand(name, description) {
+    return {
+        name,
+        description,
+        options: [rootOption, { name: 'json', description: 'Output as JSON', type: 'boolean', default: false }],
+        action: async (ctx) => {
+            const findings = probeMods({ projectRoot: projectRoot(ctx) });
+            if (ctx.flags.json)
+                output.printJson(findings);
+            else
+                printFindings(findings);
+            const failed = findings.some((f) => f.status === 'fail');
+            // status reports; doctor gates (warnings are expected while early access is off).
+            return { success: !failed, exitCode: name === 'doctor' && failed ? 1 : 0, data: findings };
+        },
+    };
+}
+async function syncPolicy(root, quiet) {
+    try {
+        const { loadPolicyState } = await import('../services/policy-runtime.js');
+        const { syncPolicyProjection } = await import('../mods/policy-projection.js');
+        const result = syncPolicyProjection(root, loadPolicyState(root));
+        if (!quiet || result.action !== 'unchanged')
+            output.writeln(`policy projection: ${result.action} (${result.path})`);
+        return true;
+    }
+    catch (error) {
+        output.printWarning(`policy projection not synced: ${error.message}`);
+        return false;
+    }
+}
+const syncPolicySub = {
+    name: 'sync-policy',
+    description: 'Rewrite the Claude Code policy projection from .claude-flow/policy/state.json',
+    options: [rootOption],
+    action: async (ctx) => {
+        const ok = await syncPolicy(projectRoot(ctx), false);
+        return { success: ok, exitCode: ok ? 0 : 1 };
+    },
+};
+const statusSub = findingsCommand('status', 'Show whether the mod is enabled, can load, and what it owns');
+export const modsCommand = {
+    name: 'mods',
+    description: 'Run ruflo as a Claude Code mod (function hooks, early access, ADR-404)',
+    subcommands: [
+        installSub,
+        uninstallSub,
+        statusSub,
+        findingsCommand('doctor', 'Check the mod path; exits 1 only on a failure'),
+        syncPolicySub,
+    ],
+    examples: [
+        { command: 'ruflo mods install', description: 'Enable for this project (settings.local.json)' },
+        { command: 'ruflo mods doctor', description: 'Function hooks on? Refused by policy? Handshake supported?' },
+        { command: 'ruflo mods uninstall', description: 'Remove only what install added' },
+    ],
+    action: statusSub.action,
+};
+export default modsCommand;
+//# sourceMappingURL=mods.js.map

package/v3/@claude-flow/cli/dist/src/init/helpers-generator.js

@@ -530,7 +530,19 @@ export function generateHookHandler() {
         '  });',
         '}',
         '',
+        // ADR-404: same handshake as the shipped hook-handler.cjs, so a helper
+        // regenerated by the refresh fallback still hands route/post-edit to the mod.
+        '// ADR-404: the ruflo mod names the events it runs in-process in',
+        '// RUFLO_MODS_OWNS; only side-effect events hand over, guards always run.',
+        "const MOD_OWNABLE_EVENTS = new Set(['route', 'post-edit']);",
+        'function ownedByMod(cmd, env) {',
+        '  env = env || process.env;',
+        '  if (!MOD_OWNABLE_EVENTS.has(cmd)) return false;',
+        "  return String(env.RUFLO_MODS_OWNS || '').split(',').some(function (owned) { return owned.trim() === cmd; });",
+        '}',
+        '',
         'async function main() {',
+        '  if (ownedByMod(command)) return;',
         '  let stdinData = "";',
         '  try { stdinData = await readStdin(); } catch (e) { /* ignore */ }',
         '  let hookInput = {};',

package/v3/@claude-flow/cli/dist/src/mods/claude-installs.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Which Claude Code binaries a shell would find, and whether the one it runs
+ * can load mods (ADR-404). Mods are on by default from Claude Code 2.1.287;
+ * from 2.1.277 they load with CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1; older
+ * builds predate them. A server-side rollout switch can still hold them off
+ * on any version (reported separately). A stale install earlier on PATH
+ * (a 2.1.107 npm-global beside a current native one, say) silently decides.
+ */
+export declare const MODS_DEFAULT_ON = "2.1.287";
+export declare const MODS_FIRST = "2.1.277";
+export interface ClaudeInstall {
+    path: string;
+    version: string | null;
+}
+export type VersionOf = (path: string) => string | null;
+/** a < b for dotted numeric versions. */
+export declare function versionLess(a: string, b: string): boolean;
+/** `claude --version` of one binary, bounded; null when it cannot say. */
+export declare const defaultVersionOf: VersionOf;
+/** Every `claude` on PATH, in PATH order (the first is what runs), plus ~/.local/bin. */
+export declare function findClaudeInstalls(env: NodeJS.ProcessEnv, home: string, versionOf?: VersionOf): ClaudeInstall[];
+export interface InstallsFinding {
+    status: 'pass' | 'warn';
+    message: string;
+    fix?: string;
+}
+/** The doctor's reading of what `claude` resolves to and what else is installed. */
+export declare function judgeInstalls(installs: readonly ClaudeInstall[], enableEnvSet: boolean): InstallsFinding;
+//# sourceMappingURL=claude-installs.d.ts.map

package/v3/@claude-flow/cli/dist/src/mods/claude-installs.js

@@ -0,0 +1,83 @@
+/**
+ * Which Claude Code binaries a shell would find, and whether the one it runs
+ * can load mods (ADR-404). Mods are on by default from Claude Code 2.1.287;
+ * from 2.1.277 they load with CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1; older
+ * builds predate them. A server-side rollout switch can still hold them off
+ * on any version (reported separately). A stale install earlier on PATH
+ * (a 2.1.107 npm-global beside a current native one, say) silently decides.
+ */
+import { execFileSync } from 'node:child_process';
+import { existsSync, realpathSync, statSync } from 'node:fs';
+import { delimiter, join } from 'node:path';
+export const MODS_DEFAULT_ON = '2.1.287';
+export const MODS_FIRST = '2.1.277';
+const parse = (v) => v.split('.').map((n) => Number(n));
+/** a < b for dotted numeric versions. */
+export function versionLess(a, b) {
+    const x = parse(a);
+    const y = parse(b);
+    for (let i = 0; i < Math.max(x.length, y.length); i++) {
+        if ((x[i] ?? 0) !== (y[i] ?? 0))
+            return (x[i] ?? 0) < (y[i] ?? 0);
+    }
+    return false;
+}
+/** `claude --version` of one binary, bounded; null when it cannot say. */
+export const defaultVersionOf = (path) => {
+    try {
+        const out = execFileSync(path, ['--version'], { encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] });
+        return out.match(/\d+\.\d+\.\d+/)?.[0] ?? null;
+    }
+    catch {
+        return null;
+    }
+};
+/** Every `claude` on PATH, in PATH order (the first is what runs), plus ~/.local/bin. */
+export function findClaudeInstalls(env, home, versionOf = defaultVersionOf) {
+    const names = process.platform === 'win32' ? ['claude.exe', 'claude.cmd', 'claude'] : ['claude'];
+    const dirs = [...(env.PATH ?? '').split(delimiter).filter(Boolean), join(home, '.local', 'bin')];
+    const seen = new Set();
+    const installs = [];
+    for (const dir of dirs) {
+        for (const name of names) {
+            const path = join(dir, name);
+            let real;
+            try {
+                if (!existsSync(path) || !statSync(path).isFile())
+                    continue;
+                real = realpathSync(path);
+            }
+            catch {
+                continue;
+            }
+            if (seen.has(real))
+                continue;
+            seen.add(real);
+            installs.push({ path, version: versionOf(path) });
+        }
+    }
+    return installs;
+}
+/** The doctor's reading of what `claude` resolves to and what else is installed. */
+export function judgeInstalls(installs, enableEnvSet) {
+    if (installs.length === 0)
+        return { status: 'warn', message: 'no claude binary on PATH', fix: 'install Claude Code >= 2.1.287' };
+    const [first] = installs;
+    const others = installs.slice(1).filter((i) => i.version !== first.version);
+    const mixed = others.length
+        ? `; also installed: ${others.map((i) => `${i.path} (${i.version ?? 'unknown'})`).join(', ')}. The first on PATH runs; a stale one can shadow a current one.`
+        : '';
+    const runs = `${first.path} (${first.version ?? 'version unknown'})`;
+    if (!first.version)
+        return { status: 'warn', message: `claude resolves to ${runs}${mixed}` };
+    if (!versionLess(first.version, MODS_DEFAULT_ON)) {
+        return { status: others.length ? 'warn' : 'pass', message: `claude resolves to ${runs}: mods on by default${mixed}` };
+    }
+    if (!versionLess(first.version, MODS_FIRST)) {
+        return enableEnvSet
+            ? { status: others.length ? 'warn' : 'pass', message: `claude resolves to ${runs}: mods load with CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1 (set)${mixed}` }
+            : { status: 'warn', message: `claude resolves to ${runs}: below ${MODS_DEFAULT_ON}, mods need CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1 (not set)${mixed}`, fix: `upgrade to >= ${MODS_DEFAULT_ON}, or export CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1` };
+    }
+    return { status: 'warn', message: `claude resolves to ${runs}: predates mods (< ${MODS_FIRST}); classic hooks handle every event${mixed}`, fix: `upgrade to >= ${MODS_DEFAULT_ON} and remove the stale install from PATH` };
+}
+//# sourceMappingURL=claude-installs.js.map

package/v3/@claude-flow/cli/dist/src/mods/install.d.ts

@@ -0,0 +1,64 @@
+/**
+ * `ruflo mods install|uninstall` (ADR-404): enable the ruflo-mods plugin for
+ * one project, opt-in, and take back exactly what was added.
+ *
+ * Writes three keys of a Claude Code settings file (`.claude/settings.local.json`
+ * by default, so the early-access feature is one person's choice, not the
+ * repository's): `enabledPlugins["ruflo-mods@ruflo"]`, the `ruflo` entry of
+ * `extraKnownMarketplaces` when absent, and `env.CLAUDE_CODE_ENABLE_FUNCTION_HOOKS`.
+ * What was added is recorded in `.claude-flow/mods/install.json`, so uninstall
+ * removes those and nothing a person set themselves. Classic hooks are never
+ * touched: they stay the fallback (the mod takes an event over at runtime only).
+ */
+export declare const MOD_PLUGIN_ID = "ruflo-mods@ruflo";
+export declare const MARKETPLACE_NAME = "ruflo";
+export declare const MARKETPLACE_SOURCE: {
+    readonly source: {
+        readonly source: "github";
+        readonly repo: "ruvnet/ruflo";
+    };
+};
+export declare const ENABLE_ENV = "CLAUDE_CODE_ENABLE_FUNCTION_HOOKS";
+export declare const INSTALL_RECORD: string;
+export type Scope = 'local' | 'project';
+export interface InstallRecord {
+    version: 1;
+    settingsFile: string;
+    installedAt: string;
+    added: {
+        plugin: boolean;
+        marketplace: boolean;
+        env: boolean;
+    };
+}
+type Settings = Record<string, unknown> & {
+    enabledPlugins?: Record<string, unknown>;
+    extraKnownMarketplaces?: Record<string, unknown>;
+    env?: Record<string, unknown>;
+};
+export declare function settingsFileFor(projectRoot: string, scope: Scope): string;
+/** Reads a settings file; absent is `{}`, anything unparseable throws (never overwritten). */
+export declare function readSettingsFile(path: string): Settings;
+/** The settings after install, and what install added (pure). */
+export declare function withModEnabled(settings: Settings): {
+    next: Settings;
+    added: InstallRecord['added'];
+};
+/** The settings after uninstall: only what the record says install added (pure). */
+export declare function withModRemoved(settings: Settings, added: InstallRecord['added']): Settings;
+export interface InstallResult {
+    settingsFile: string;
+    backup?: string;
+    added: InstallRecord['added'];
+    dryRun: boolean;
+    next: Settings;
+}
+export declare function installMod(projectRoot: string, scope: Scope, dryRun?: boolean): InstallResult;
+export declare function readRecord(projectRoot: string): InstallRecord | null;
+export declare function uninstallMod(projectRoot: string, dryRun?: boolean): {
+    settingsFile?: string;
+    removed: boolean;
+    dryRun: boolean;
+};
+export {};
+//# sourceMappingURL=install.d.ts.map

package/v3/@claude-flow/cli/dist/src/mods/install.js

@@ -0,0 +1,135 @@
+/**
+ * `ruflo mods install|uninstall` (ADR-404): enable the ruflo-mods plugin for
+ * one project, opt-in, and take back exactly what was added.
+ *
+ * Writes three keys of a Claude Code settings file (`.claude/settings.local.json`
+ * by default, so the early-access feature is one person's choice, not the
+ * repository's): `enabledPlugins["ruflo-mods@ruflo"]`, the `ruflo` entry of
+ * `extraKnownMarketplaces` when absent, and `env.CLAUDE_CODE_ENABLE_FUNCTION_HOOKS`.
+ * What was added is recorded in `.claude-flow/mods/install.json`, so uninstall
+ * removes those and nothing a person set themselves. Classic hooks are never
+ * touched: they stay the fallback (the mod takes an event over at runtime only).
+ */
+import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve, sep } from 'node:path';
+export const MOD_PLUGIN_ID = 'ruflo-mods@ruflo';
+export const MARKETPLACE_NAME = 'ruflo';
+export const MARKETPLACE_SOURCE = { source: { source: 'github', repo: 'ruvnet/ruflo' } };
+export const ENABLE_ENV = 'CLAUDE_CODE_ENABLE_FUNCTION_HOOKS';
+export const INSTALL_RECORD = join('.claude-flow', 'mods', 'install.json');
+export function settingsFileFor(projectRoot, scope) {
+    return join(resolve(projectRoot), '.claude', scope === 'local' ? 'settings.local.json' : 'settings.json');
+}
+function isRecord(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+/** Reads a settings file; absent is `{}`, anything unparseable throws (never overwritten). */
+export function readSettingsFile(path) {
+    if (!existsSync(path))
+        return {};
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (!isRecord(parsed))
+        throw new Error(`${path} is not a JSON object`);
+    return parsed;
+}
+function writeJson(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+    renameSync(tmp, path);
+}
+/** The settings after install, and what install added (pure). */
+export function withModEnabled(settings) {
+    const next = { ...settings };
+    const plugins = isRecord(settings.enabledPlugins) ? { ...settings.enabledPlugins } : {};
+    const markets = isRecord(settings.extraKnownMarketplaces) ? { ...settings.extraKnownMarketplaces } : {};
+    const env = isRecord(settings.env) ? { ...settings.env } : {};
+    const added = {
+        plugin: plugins[MOD_PLUGIN_ID] !== true,
+        marketplace: !(MARKETPLACE_NAME in markets),
+        env: env[ENABLE_ENV] !== '1',
+    };
+    plugins[MOD_PLUGIN_ID] = true;
+    if (added.marketplace)
+        markets[MARKETPLACE_NAME] = MARKETPLACE_SOURCE;
+    env[ENABLE_ENV] = '1';
+    next.enabledPlugins = plugins;
+    next.extraKnownMarketplaces = markets;
+    next.env = env;
+    return { next, added };
+}
+/** The settings after uninstall: only what the record says install added (pure). */
+export function withModRemoved(settings, added) {
+    const next = { ...settings };
+    const drop = (key, name) => {
+        const section = next[key];
+        if (!isRecord(section))
+            return;
+        const copy = { ...section };
+        delete copy[name];
+        if (Object.keys(copy).length === 0)
+            delete next[key];
+        else
+            next[key] = copy;
+    };
+    if (added.plugin)
+        drop('enabledPlugins', MOD_PLUGIN_ID);
+    if (added.marketplace)
+        drop('extraKnownMarketplaces', MARKETPLACE_NAME);
+    if (added.env)
+        drop('env', ENABLE_ENV);
+    return next;
+}
+export function installMod(projectRoot, scope, dryRun = false) {
+    const settingsFile = settingsFileFor(projectRoot, scope);
+    const current = readSettingsFile(settingsFile);
+    const { next, added } = withModEnabled(current);
+    if (dryRun)
+        return { settingsFile, added, dryRun, next };
+    let backup;
+    if (existsSync(settingsFile)) {
+        backup = `${settingsFile}.bak-ruflo-mods-${Date.now()}`;
+        copyFileSync(settingsFile, backup);
+    }
+    writeJson(settingsFile, next);
+    const recordPath = join(resolve(projectRoot), INSTALL_RECORD);
+    const previous = readRecord(projectRoot);
+    // A second install keeps the first record's claims: what ruflo added once
+    // is still ruflo's to remove.
+    const merged = previous && previous.settingsFile === settingsFile
+        ? { plugin: previous.added.plugin || added.plugin, marketplace: previous.added.marketplace || added.marketplace, env: previous.added.env || added.env }
+        : added;
+    const record = { version: 1, settingsFile, installedAt: new Date().toISOString(), added: merged };
+    writeJson(recordPath, record);
+    return { settingsFile, backup, added: merged, dryRun, next };
+}
+export function readRecord(projectRoot) {
+    const path = join(resolve(projectRoot), INSTALL_RECORD);
+    if (!existsSync(path))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        return parsed && parsed.version === 1 && typeof parsed.settingsFile === 'string' && isRecord(parsed.added) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function uninstallMod(projectRoot, dryRun = false) {
+    const record = readRecord(projectRoot);
+    if (!record)
+        return { removed: false, dryRun };
+    // The record names the file; never follow it outside this project.
+    const root = resolve(projectRoot);
+    if (!resolve(record.settingsFile).startsWith(join(root, '.claude') + sep)) {
+        throw new Error(`install record names a settings file outside ${root}/.claude: ${record.settingsFile}`);
+    }
+    if (dryRun)
+        return { settingsFile: record.settingsFile, removed: true, dryRun };
+    if (existsSync(record.settingsFile)) {
+        writeJson(record.settingsFile, withModRemoved(readSettingsFile(record.settingsFile), record.added));
+    }
+    unlinkSync(join(root, INSTALL_RECORD));
+    return { settingsFile: record.settingsFile, removed: true, dryRun };
+}
+//# sourceMappingURL=install.js.map

package/v3/@claude-flow/cli/dist/src/mods/policy-projection.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The policy projection the ruflo mod reads (ADR-404).
+ *
+ * A hooks module may read at most 4 MiB and cannot import @claude-flow/security,
+ * while `.claude-flow/policy/state.json` carries the whole receipt ledger
+ * (tens of MB on a busy project). So every policy state write also writes a
+ * small file holding only what the mod's `tool.check` needs: the mode and the
+ * rules that name a `claude-code.` action explicitly. Legacy mode, or no such
+ * rule, removes the file, and the mod then adds no policy of its own.
+ *
+ * The projection never authorizes anything: the mod only tightens Claude
+ * Code's own verdict with it, so a deleted or stale projection returns to the
+ * no-mod baseline and can never loosen a call. It is not a ledger and holds
+ * no receipts; issue #3602 (the ledger anchor) is untouched by it.
+ */
+import type { PolicyRule, PolicyState } from '@claude-flow/security';
+export declare const PROJECTION_RELATIVE: string;
+export declare const CLAUDE_CODE_ACTION_PREFIX = "claude-code.";
+export interface PolicyProjection {
+    version: 1;
+    mode: PolicyState['mode'];
+    generatedAt: number;
+    rules: PolicyRule[];
+}
+/** Whether a rule names Claude Code tool calls explicitly (never via `*` or no actions). */
+export declare function targetsClaudeCode(rule: Pick<PolicyRule, 'actions'>): boolean;
+/** The projection of a state, or null when there is nothing to project. */
+export declare function projectionOf(state: Pick<PolicyState, 'mode' | 'rules'>, now?: number): PolicyProjection | null;
+export type ProjectionSync = {
+    action: 'written' | 'removed' | 'unchanged';
+    path: string;
+};
+/**
+ * Writes (atomically, owner-only) or removes the projection for a state.
+ * Throws on I/O failure; policy-runtime calls it after the state is safely
+ * written and keeps the state write's own result whatever happens here.
+ */
+export declare function syncPolicyProjection(projectRoot: string, state: Pick<PolicyState, 'mode' | 'rules'>): ProjectionSync;
+//# sourceMappingURL=policy-projection.d.ts.map

package/v3/@claude-flow/cli/dist/src/mods/policy-projection.js

@@ -0,0 +1,65 @@
+/**
+ * The policy projection the ruflo mod reads (ADR-404).
+ *
+ * A hooks module may read at most 4 MiB and cannot import @claude-flow/security,
+ * while `.claude-flow/policy/state.json` carries the whole receipt ledger
+ * (tens of MB on a busy project). So every policy state write also writes a
+ * small file holding only what the mod's `tool.check` needs: the mode and the
+ * rules that name a `claude-code.` action explicitly. Legacy mode, or no such
+ * rule, removes the file, and the mod then adds no policy of its own.
+ *
+ * The projection never authorizes anything: the mod only tightens Claude
+ * Code's own verdict with it, so a deleted or stale projection returns to the
+ * no-mod baseline and can never loosen a call. It is not a ledger and holds
+ * no receipts; issue #3602 (the ledger anchor) is untouched by it.
+ */
+import { existsSync, mkdirSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+export const PROJECTION_RELATIVE = join('.claude-flow', 'policy', 'claude-code.json');
+export const CLAUDE_CODE_ACTION_PREFIX = 'claude-code.';
+/** Whether a rule names Claude Code tool calls explicitly (never via `*` or no actions). */
+export function targetsClaudeCode(rule) {
+    return Array.isArray(rule.actions) && rule.actions.some((a) => typeof a === 'string' && a.startsWith(CLAUDE_CODE_ACTION_PREFIX));
+}
+/** The projection of a state, or null when there is nothing to project. */
+export function projectionOf(state, now = Date.now()) {
+    if (state.mode === 'legacy')
+        return null;
+    const rules = (Array.isArray(state.rules) ? state.rules : []).filter(targetsClaudeCode).map((rule) => ({
+        id: rule.id,
+        effect: rule.effect,
+        actions: [...rule.actions],
+        ...(rule.enabled !== undefined ? { enabled: rule.enabled } : {}),
+        ...(rule.priority !== undefined ? { priority: rule.priority } : {}),
+        ...(rule.resources ? { resources: [...rule.resources] } : {}),
+        ...(rule.principals ? { principals: [...rule.principals] } : {}),
+        ...(rule.identityTypes ? { identityTypes: [...rule.identityTypes] } : {}),
+        ...(rule.roles ? { roles: [...rule.roles] } : {}),
+        ...(rule.environments ? { environments: [...rule.environments] } : {}),
+        ...(rule.constraints ? { constraints: { ...rule.constraints } } : {}),
+    }));
+    if (rules.length === 0)
+        return null;
+    return { version: 1, mode: state.mode, generatedAt: now, rules };
+}
+/**
+ * Writes (atomically, owner-only) or removes the projection for a state.
+ * Throws on I/O failure; policy-runtime calls it after the state is safely
+ * written and keeps the state write's own result whatever happens here.
+ */
+export function syncPolicyProjection(projectRoot, state) {
+    const path = join(resolve(projectRoot), PROJECTION_RELATIVE);
+    const projection = projectionOf(state);
+    if (!projection) {
+        if (!existsSync(path))
+            return { action: 'unchanged', path };
+        unlinkSync(path);
+        return { action: 'removed', path };
+    }
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(projection, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    renameSync(tmp, path);
+    return { action: 'written', path };
+}
+//# sourceMappingURL=policy-projection.js.map

package/v3/@claude-flow/cli/dist/src/mods/probe.d.ts

@@ -0,0 +1,28 @@
+/**
+ * What can be known, from outside a Claude Code session, about whether the
+ * ruflo mod will load and what it will own (ADR-404). Every finding names its
+ * source; nothing here claims a live load it did not see. The one direct
+ * evidence of a load is the heartbeat the mod writes at session start.
+ */
+import { type ClaudeInstall } from './claude-installs.js';
+export declare const HANDSHAKE_MARKER = "RUFLO_MODS_OWNS";
+export declare const HEARTBEAT_RELATIVE: string;
+export type Status = 'pass' | 'warn' | 'fail';
+export interface Finding {
+    name: string;
+    status: Status;
+    message: string;
+    fix?: string;
+}
+/** Managed settings, where an organization sets sec-default's options. */
+export declare function managedSettingsPath(os?: NodeJS.Platform): string;
+export interface ProbeInputs {
+    projectRoot: string;
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    managedPath?: string;
+    /** Claude Code binaries on PATH; discovered (each `--version` run) when absent. */
+    installs?: ClaudeInstall[];
+}
+export declare function probeMods(inputs: ProbeInputs): Finding[];
+//# sourceMappingURL=probe.d.ts.map

package/v3/@claude-flow/cli/dist/src/mods/probe.js

@@ -0,0 +1,118 @@
+/**
+ * What can be known, from outside a Claude Code session, about whether the
+ * ruflo mod will load and what it will own (ADR-404). Every finding names its
+ * source; nothing here claims a live load it did not see. The one direct
+ * evidence of a load is the heartbeat the mod writes at session start.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { join, resolve } from 'node:path';
+import { findClaudeInstalls, judgeInstalls } from './claude-installs.js';
+import { ENABLE_ENV, MOD_PLUGIN_ID, readRecord, readSettingsFile, settingsFileFor } from './install.js';
+import { PROJECTION_RELATIVE } from './policy-projection.js';
+export const HANDSHAKE_MARKER = 'RUFLO_MODS_OWNS';
+export const HEARTBEAT_RELATIVE = join('.claude-flow', 'mods', 'session.json');
+const SEC_DEFAULT_ID = 'cc-plugin-sec-default@builtin';
+function readJson(path) {
+    try {
+        return existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function get(obj, ...keys) {
+    return keys.reduce((o, k) => (o !== null && typeof o === 'object' ? o[k] : undefined), obj);
+}
+/** Managed settings, where an organization sets sec-default's options. */
+export function managedSettingsPath(os = platform()) {
+    if (os === 'darwin')
+        return '/Library/Application Support/ClaudeCode/managed-settings.json';
+    if (os === 'win32')
+        return 'C:\\ProgramData\\ClaudeCode\\managed-settings.json';
+    return '/etc/claude-code/managed-settings.json';
+}
+export function probeMods(inputs) {
+    const root = resolve(inputs.projectRoot);
+    const home = inputs.home ?? homedir();
+    const env = inputs.env ?? process.env;
+    const findings = [];
+    // 1. Enabled for this project?
+    const files = [settingsFileFor(root, 'local'), settingsFileFor(root, 'project'), join(home, '.claude', 'settings.json')];
+    const enabledIn = files.find((f) => {
+        try {
+            return get(readSettingsFile(f), 'enabledPlugins', MOD_PLUGIN_ID) === true;
+        }
+        catch {
+            return false;
+        }
+    });
+    findings.push(enabledIn
+        ? { name: 'ruflo-mods plugin', status: 'pass', message: `enabled in ${enabledIn}` }
+        : { name: 'ruflo-mods plugin', status: 'warn', message: 'not enabled; classic hooks handle every event', fix: 'ruflo mods install' });
+    // 2. Function hooks switched on for installed plugins (early access).
+    const envOn = env[ENABLE_ENV] === '1';
+    const settingsOn = files.some((f) => {
+        try {
+            return get(readSettingsFile(f), 'env', ENABLE_ENV) === '1';
+        }
+        catch {
+            return false;
+        }
+    });
+    // 2a. Which Claude Code runs, and whether a stale install shadows it.
+    findings.push({ name: 'claude installs', ...judgeInstalls(inputs.installs ?? findClaudeInstalls(env, home), envOn || settingsOn) });
+    // Observed live (ADR-404): 2.1.287 loads mods with ENABLE_ENV unset;
+    // 2.1.282 refuses them without it ("not turned on for installed plugins");
+    // on either, a server-side rollout switch served off holds them off, the
+    // variable notwithstanding. Which binary runs is the 'claude installs' finding.
+    const rollout = get(readJson(join(home, '.claude.json')), 'cachedGrowthBookFeatures', 'tengu_plugin_hooks_modules');
+    const enableMsg = `${ENABLE_ENV} ${envOn ? 'set in this environment' : settingsOn ? 'set in settings env' : 'not set'}`;
+    findings.push(rollout === true
+        ? { name: 'function hooks', status: 'pass', message: `Claude Code rollout switch cached on; ${enableMsg}` }
+        : rollout === false
+            ? { name: 'function hooks', status: 'warn', message: `Claude Code serves function hooks OFF for this account (cached); the mod will not load and classic hooks keep every event; ${enableMsg}` }
+            : { name: 'function hooks', status: 'warn', message: `rollout switch not cached (unverified whether the mod can load); ${enableMsg}`, fix: `export ${ENABLE_ENV}=1 and start Claude Code once` });
+    // 3. Refused by policy?
+    const managed = readJson(inputs.managedPath ?? managedSettingsPath());
+    const managedOnly = get(managed, 'pluginConfigs', SEC_DEFAULT_ID, 'options', 'allowManagedModsOnly');
+    findings.push(managedOnly !== undefined && managedOnly !== false
+        ? { name: 'managed policy', status: 'warn', message: 'allowManagedModsOnly is set: Claude Code refuses user mods; classic hooks stay in charge' }
+        : { name: 'managed policy', status: 'pass', message: managed === undefined ? 'no managed settings' : 'user mods allowed (allowManagedModsOnly not set)' });
+    // 4. Every classic helper a hook could run honours the handshake (the mod's
+    // own rule, plugins/ruflo-mods/hooks/session.ts); else the mod stands down.
+    const helpers = [...new Set([join(root, '.claude', 'helpers', 'hook-handler.cjs'), join(home, '.claude', 'helpers', 'hook-handler.cjs')])].filter(existsSync);
+    const stale = helpers.filter((h) => {
+        try {
+            return !readFileSync(h, 'utf8').includes(HANDSHAKE_MARKER);
+        }
+        catch {
+            return true;
+        }
+    });
+    findings.push(helpers.length === 0
+        ? { name: 'classic handshake', status: 'pass', message: 'no hook-handler.cjs: the mod owns route and post-edit outright' }
+        : stale.length === 0
+            ? { name: 'classic handshake', status: 'pass', message: `${helpers.join(', ')} hand route and post-edit to the mod while it runs` }
+            : { name: 'classic handshake', status: 'warn', message: `${stale.join(', ')} predate${stale.length === 1 ? 's' : ''} the handshake: the mod stands down and classic hooks keep route/post-edit`, fix: 'ruflo init --upgrade (refresh helpers in the project and in ~/.claude)' });
+    // 5. Policy projection.
+    const projectionPath = join(root, PROJECTION_RELATIVE);
+    const projection = readJson(projectionPath);
+    const stateMode = get(readJson(join(root, '.claude-flow', 'policy', 'state.json')), 'mode');
+    findings.push(projection !== undefined
+        ? { name: 'policy projection', status: 'pass', message: `${get(projection, 'mode')} mode, ${get(projection, 'rules')?.length ?? 0} claude-code rule(s)` }
+        : stateMode === 'enforce' || stateMode === 'observe'
+            ? { name: 'policy projection', status: 'warn', message: `policy is ${String(stateMode)} but no projection exists (no claude-code.* rules, or state written by an older CLI)`, fix: 'ruflo mods sync-policy' }
+            : { name: 'policy projection', status: 'pass', message: 'none (no ruflo policy for Claude Code tools)' });
+    // 6. Evidence of a load.
+    const beat = readJson(join(root, HEARTBEAT_RELATIVE));
+    const startedAt = get(beat, 'startedAt');
+    const owned = get(beat, 'owned');
+    findings.push(typeof startedAt === 'string'
+        ? { name: 'last mod start', status: 'pass', message: `${startedAt}, owning ${Array.isArray(owned) && owned.length ? owned.join(', ') : 'nothing'}` }
+        : { name: 'last mod start', status: enabledIn ? 'warn' : 'pass', message: 'the mod has not started in this project' + (enabledIn ? ' (restart Claude Code; check function hooks above)' : '') });
+    if (readRecord(root))
+        findings.push({ name: 'install record', status: 'pass', message: join(root, '.claude-flow', 'mods', 'install.json') });
+    return findings;
+}
+//# sourceMappingURL=probe.js.map

package/v3/@claude-flow/cli/dist/src/services/policy-runtime.js

@@ -4,6 +4,7 @@ import { execFileSync } from 'node:child_process';
 import { closeSync, constants as fsConstants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readlinkSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { hostname, userInfo } from 'node:os';
+import { syncPolicyProjection } from '../mods/policy-projection.js';
 const POLICY_DIR = join('.claude-flow', 'policy');
 const POLICY_FILE = 'state.json';
 const LOCK_FILE = 'state.lock';
@@ -227,6 +228,20 @@ function verifyStateAnchor(projectRoot, state) {
     }
 }
 async function writePolicyState(projectRoot, statePath, state) {
+    await writePolicyStateFiles(projectRoot, statePath, state);
+    // ADR-404: the ruflo mod reads Claude Code tool rules from a small
+    // projection, never from state.json. Written only after the state and its
+    // anchor are safely down; a failure here never fails the state write. A
+    // projection left stale by such a failure can only tighten, never loosen,
+    // a Claude Code verdict (the mod merges with `stricter`).
+    try {
+        syncPolicyProjection(projectRoot, state);
+    }
+    catch (error) {
+        process.stderr.write(`[policy] claude-code projection not written: ${error.message}\n`);
+    }
+}
+async function writePolicyStateFiles(projectRoot, statePath, state) {
     const anchorPath = trustPaths(projectRoot).anchor;
     if (state.mode === 'enforce' || existsSync(anchorPath)) {
         const key = trustKey(projectRoot, true);

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.49.0",
+  "version": "3.50.0",
   "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",