@claude-flow/cli 3.33.0 → 3.35.0

package/dist/src/commands/agntcy/swarm-join.js

@@ -0,0 +1,85 @@
+/**
+ * V3 CLI `ruflo swarm join <namespace>` — ADR-380 §2.
+ *
+ * Joins a SLIM group-membership channel scoped to a Cognitum tenant/project
+ * namespace (e.g. `cognitum/research/security`). This is an AGNTCY/SLIM
+ * concept layered on top of — never a replacement for — this repo's own
+ * `swarm_init`/`hive-mind_*` MCP-tool coordination, which remains the
+ * default for single-host swarms per ADR-380 §2.
+ *
+ * NOT WIRED INTO THE MAIN CLI ROUTER YET. This file is exported for a
+ * later integration pass to attach as a new subcommand of the existing
+ * `swarm` command (`v3/@claude-flow/cli/src/commands/swarm.ts`).
+ */
+import { output } from '../../output.js';
+import { AGNTCY_NOT_CONFIGURED_MESSAGE, AGNTCY_PACKAGE_NAME, detectAgntcyRuntime, } from './runtime.js';
+/**
+ * SLIM group-membership namespaces are slash-delimited (e.g.
+ * `cognitum/research/security`), matching the ADR-380 §2 example. Validate
+ * the shape locally — deterministic, no SDK required — before ever
+ * attempting a network join.
+ */
+export function validateNamespace(namespace) {
+    if (!namespace || namespace.trim().length === 0) {
+        return { valid: false, error: 'namespace must be a non-empty string' };
+    }
+    // Deliberately NOT filtering empty segments — a leading/trailing/double
+    // slash (e.g. "cognitum//security") is a malformed namespace, not a
+    // cosmetic one, and should be rejected rather than silently repaired.
+    const segments = namespace.split('/');
+    if (segments.length === 0) {
+        return { valid: false, error: 'namespace must contain at least one segment' };
+    }
+    const validSegment = /^[a-zA-Z0-9_-]+$/;
+    const bad = segments.find((s) => !validSegment.test(s));
+    if (bad !== undefined) {
+        return { valid: false, error: `invalid namespace segment "${bad}" — only [a-zA-Z0-9_-] allowed per segment` };
+    }
+    return { valid: true };
+}
+const joinCommand = {
+    name: 'join',
+    description: 'Join a SLIM group-membership channel scoped to a namespace (ADR-380 §2)',
+    examples: [
+        { command: 'ruflo swarm join cognitum/research/security', description: 'Join the SLIM group-membership channel for a tenant namespace' },
+    ],
+    action: async (ctx) => {
+        const namespace = (ctx.args[0] || ctx.flags.namespace || '').trim();
+        if (!namespace) {
+            output.printError('Namespace is required. Usage: ruflo swarm join <namespace> (e.g. cognitum/research/security)');
+            return { success: false, exitCode: 1 };
+        }
+        const nsCheck = validateNamespace(namespace);
+        if (!nsCheck.valid) {
+            output.printError(`Invalid namespace "${namespace}": ${nsCheck.error}`);
+            return { success: false, exitCode: 1 };
+        }
+        const status = await detectAgntcyRuntime();
+        if (!status.configured) {
+            output.printInfo(AGNTCY_NOT_CONFIGURED_MESSAGE);
+            output.printInfo(`Namespace "${namespace}" was not joined via SLIM. Local swarm/hive-mind coordination ` +
+                '(swarm_init / hive-mind_* MCP tools) remains available and unaffected.');
+            return {
+                success: true,
+                data: { joined: false, namespace, configured: false, reason: status.reason },
+            };
+        }
+        try {
+            const mod = (await import(AGNTCY_PACKAGE_NAME));
+            if (typeof mod.joinGroup !== 'function') {
+                throw new Error(`"${AGNTCY_PACKAGE_NAME}" is installed but does not export joinGroup()`);
+            }
+            const result = await mod.joinGroup({ endpoint: status.endpoint, namespace });
+            output.printSuccess(`Joined SLIM group "${namespace}"${typeof result?.members === 'number' ? ` (${result.members} members)` : ''}.`);
+            return { success: true, data: { joined: true, namespace, members: result?.members } };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            output.printError(`SLIM group join failed: ${message}`);
+            return { success: true, data: { joined: false, namespace, error: message } };
+        }
+    },
+};
+export { joinCommand as swarmJoinCommand };
+export default joinCommand;
+//# sourceMappingURL=swarm-join.js.map

package/dist/src/commands/agntcy/transport.d.ts

@@ -0,0 +1,24 @@
+/**
+ * V3 CLI `ruflo transport use slim` — ADR-380 §2.
+ *
+ * Switches the active swarm/hive-mind coordination transport from today's
+ * in-process/local-hooks routing to SLIM (secure messaging for MCP/A2A,
+ * hierarchical routing, group membership, MLS encryption) for agents
+ * coordinating across hosts or across a tenant boundary.
+ *
+ * Local transport stays the default. This command is a NO-OP on the local
+ * path unless an operator has both set {@link AGNTCY_ENDPOINT_ENV} AND
+ * installed the (not-yet-published) optional runtime package — see
+ * runtime.ts for the full graceful-degradation contract.
+ *
+ * NOT WIRED INTO THE MAIN CLI ROUTER YET. This file is exported for a
+ * later integration pass to attach as a new top-level `transport` command
+ * (or a subcommand of one, per the open question in ADR-380 §"Open
+ * Questions" about per-swarm vs. global scope).
+ */
+import type { Command } from '../../types.js';
+declare const useCommand: Command;
+export declare const transportCommand: Command;
+export { useCommand };
+export default transportCommand;
+//# sourceMappingURL=transport.d.ts.map

package/dist/src/commands/agntcy/transport.js

@@ -0,0 +1,95 @@
+/**
+ * V3 CLI `ruflo transport use slim` — ADR-380 §2.
+ *
+ * Switches the active swarm/hive-mind coordination transport from today's
+ * in-process/local-hooks routing to SLIM (secure messaging for MCP/A2A,
+ * hierarchical routing, group membership, MLS encryption) for agents
+ * coordinating across hosts or across a tenant boundary.
+ *
+ * Local transport stays the default. This command is a NO-OP on the local
+ * path unless an operator has both set {@link AGNTCY_ENDPOINT_ENV} AND
+ * installed the (not-yet-published) optional runtime package — see
+ * runtime.ts for the full graceful-degradation contract.
+ *
+ * NOT WIRED INTO THE MAIN CLI ROUTER YET. This file is exported for a
+ * later integration pass to attach as a new top-level `transport` command
+ * (or a subcommand of one, per the open question in ADR-380 §"Open
+ * Questions" about per-swarm vs. global scope).
+ */
+import { output } from '../../output.js';
+import { AGNTCY_NOT_CONFIGURED_MESSAGE, AGNTCY_PACKAGE_NAME, detectAgntcyRuntime, } from './runtime.js';
+/** Transport names this command currently recognizes. Only 'slim' per ADR-380 §2. */
+const SUPPORTED_TRANSPORTS = new Set(['slim']);
+const useCommand = {
+    name: 'use',
+    description: 'Switch the active swarm/hive-mind transport (e.g. slim) — ADR-380 §2',
+    examples: [
+        { command: 'ruflo transport use slim', description: 'Switch coordination transport to SLIM (opt-in, degrades to local)' },
+    ],
+    action: async (ctx) => {
+        const requested = (ctx.args[0] || ctx.flags.transport || '').trim().toLowerCase();
+        if (!requested) {
+            output.printError('Transport name required. Usage: ruflo transport use <name> (e.g. slim)');
+            return { success: false, exitCode: 1 };
+        }
+        if (!SUPPORTED_TRANSPORTS.has(requested)) {
+            output.printError(`Unknown transport "${requested}". Supported: ${Array.from(SUPPORTED_TRANSPORTS).join(', ')}.`);
+            output.printInfo('Local transport remains the default and needs no explicit "use".');
+            return { success: false, exitCode: 1 };
+        }
+        const status = await detectAgntcyRuntime();
+        if (!status.configured) {
+            output.printInfo(AGNTCY_NOT_CONFIGURED_MESSAGE);
+            output.printInfo('Active transport remains: local (in-process hooks routing).');
+            return {
+                success: true,
+                data: { transport: 'local', requested, configured: false, reason: status.reason },
+            };
+        }
+        // Reachable only once the optional package is actually installed AND
+        // an endpoint is configured — not possible today (package unpublished).
+        try {
+            const mod = (await import(AGNTCY_PACKAGE_NAME));
+            if (typeof mod.createSlimTransport !== 'function') {
+                throw new Error(`"${AGNTCY_PACKAGE_NAME}" is installed but does not export createSlimTransport()`);
+            }
+            await mod.createSlimTransport({ endpoint: status.endpoint });
+            output.printSuccess(`Active transport switched to: slim (${status.endpoint})`);
+            return { success: true, data: { transport: 'slim', endpoint: status.endpoint, configured: true } };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            output.printError(`Failed to activate SLIM transport: ${message}`);
+            output.printInfo('Falling back to local transport.');
+            return { success: true, data: { transport: 'local', requested, configured: false, error: message } };
+        }
+    },
+};
+export const transportCommand = {
+    name: 'transport',
+    description: 'Manage the active swarm/hive-mind coordination transport (ADR-380 §2)',
+    subcommands: [useCommand],
+    examples: [
+        { command: 'ruflo transport use slim', description: 'Switch coordination transport to SLIM' },
+    ],
+    action: async () => {
+        output.writeln();
+        output.writeln(output.bold('AGNTCY/SLIM Transport'));
+        output.writeln(output.dim('='.repeat(60)));
+        output.writeln();
+        output.printBox([
+            'Local transport (in-process hooks routing) is the default.',
+            '',
+            'Subcommands:',
+            '',
+            '  use <name>   Switch the active transport (currently: slim)',
+            '',
+            `See ADR-380 for setup: v3/docs/adr/ADR-380-agntcy-outshift-runtime-integration.md`,
+        ].join('\n'), 'AGNTCY/SLIM Transport');
+        output.writeln();
+        return { success: true };
+    },
+};
+export { useCommand };
+export default transportCommand;
+//# sourceMappingURL=transport.js.map

package/dist/src/commands/daemon.js

@@ -4,6 +4,7 @@
  */
 import { output } from '../output.js';
 import { getDaemon, startDaemon, stopDaemon } from '../services/worker-daemon.js';
+import { resolveDaemonProjectRoot } from '../services/daemon-autostart.js';
 import { fork } from 'child_process';
 import { fileURLToPath } from 'url';
 import { dirname, join, resolve } from 'path';
@@ -61,7 +62,11 @@ const startCommand = {
         }
         // #1914: a forked daemon child receives --workspace <root>; the launcher
         // and interactive invocations have no flag and fall back to cwd.
-        const projectRoot = resolveWorkspaceFlag(ctx.flags.workspace) ?? process.cwd();
+        // #2877: that cwd fallback is normalized to the owning project root, so
+        // `daemon start` from a subdirectory contends for the SAME lock/PID file
+        // as one from the root instead of silently keying its own pair.
+        const projectRoot = resolveWorkspaceFlag(ctx.flags.workspace)
+            ?? resolveDaemonProjectRoot(process.cwd());
         const isDaemonProcess = process.env.CLAUDE_FLOW_DAEMON === '1';
         // Parse resource threshold overrides from CLI flags
         const config = {};
@@ -605,7 +610,7 @@ const stopCommand = {
     ],
     action: async (ctx) => {
         const quiet = ctx.flags.quiet;
-        const projectRoot = process.cwd();
+        const projectRoot = resolveDaemonProjectRoot(process.cwd());
         // #2661: `stop --all` — the containment lever for daemon fanout across
         // Git worktrees. Only processes positively identified as ruflo daemons
         // (via their self-identifying argv) are touched; each receives SIGTERM
@@ -657,7 +662,7 @@ async function stopAllDaemons(quiet) {
         await stopDaemon();
     }
     catch { /* not running in-process */ }
-    await killBackgroundDaemon(process.cwd());
+    await killBackgroundDaemon(resolveDaemonProjectRoot(process.cwd()));
     const daemons = await scanRunningDaemons();
     if (daemons.length === 0) {
         if (!quiet) {
@@ -1160,7 +1165,7 @@ const statusCommand = {
         if (ctx.flags.all) {
             return renderAllDaemonsStatus();
         }
-        const projectRoot = process.cwd();
+        const projectRoot = resolveDaemonProjectRoot(process.cwd());
         try {
             const daemon = getDaemon(projectRoot);
             const status = daemon.getStatus();
@@ -1304,7 +1309,7 @@ const triggerCommand = {
             // #2661: an explicit `trigger --headless` is user consent for AI
             // execution of THIS run (still governed by the global AI budget).
             // Without the flag, config.json / env opt-in still applies.
-            const daemon = getDaemon(process.cwd(), ctx.flags.headless === true ? { aiWorkersEnabled: true } : undefined);
+            const daemon = getDaemon(resolveDaemonProjectRoot(process.cwd()), ctx.flags.headless === true ? { aiWorkersEnabled: true } : undefined);
             const spinner = output.createSpinner({ text: `Running ${workerType} worker...`, spinner: 'dots' });
             spinner.start();
             const result = await daemon.triggerWorker(workerType);
@@ -1347,7 +1352,7 @@ const enableCommand = {
             return { success: false, exitCode: 1 };
         }
         try {
-            const daemon = getDaemon(process.cwd());
+            const daemon = getDaemon(resolveDaemonProjectRoot(process.cwd()));
             daemon.setWorkerEnabled(workerType, !disable);
             output.printSuccess(`Worker ${workerType} ${disable ? 'disabled' : 'enabled'}`);
             return { success: true };
@@ -1402,7 +1407,7 @@ const installSupervisorCommand = {
         const force = ctx.flags.force === true;
         const load = ctx.flags.load !== false;
         const dryRun = ctx.flags['dry-run'] === true || ctx.flags.dryRun === true;
-        const projectRoot = process.cwd();
+        const projectRoot = resolveDaemonProjectRoot(process.cwd());
         const platform = process.platform;
         if (platform === 'win32') {
             output.printError('Windows scheduled-task installer is not yet implemented.');

package/dist/src/commands/doctor.js

@@ -1766,6 +1766,76 @@ async function checkMetaharnessIntegration() {
         };
     }
 }
+/**
+ * Dependency-contract check: every `@metaharness/*` package this CLI DECLARES
+ * in its own optionalDependencies must actually resolve at runtime. Declared
+ * packages are advertised integration surfaces (`ruflo metaharness evolve`,
+ * flywheel receipt interop, radio coordination) — a declared-but-absent
+ * package means the install dropped an optional dep (or the declaration
+ * regressed to peer-only), so the advertised integration silently degrades.
+ * That is a FAIL, not a warn: warn is reserved for surfaces that were never
+ * advertised as installed (the `npx metaharness` umbrella path above).
+ */
+async function checkMetaharnessDeclaredPackages() {
+    const NAME = 'MetaHarness declared packages (ADR-150)';
+    try {
+        // Walk up from this module to the CLI package root (works for npx cache,
+        // global install, project-local install, and monorepo dev alike).
+        let root = null;
+        let q = dirname(fileURLToPath(import.meta.url));
+        for (let i = 0; i < 8; i++) {
+            const pj = join(q, 'package.json');
+            if (existsSync(pj)) {
+                try {
+                    if (JSON.parse(readFileSync(pj, 'utf-8')).name === '@claude-flow/cli') {
+                        root = q;
+                        break;
+                    }
+                }
+                catch { /* keep walking */ }
+            }
+            q = dirname(q);
+        }
+        if (!root)
+            return { name: NAME, status: 'warn', message: 'could not locate the @claude-flow/cli package root' };
+        const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf-8'));
+        const declared = Object.keys(pkg.optionalDependencies ?? {}).filter((n) => n === 'metaharness' || n.startsWith('@metaharness/'));
+        if (declared.length === 0) {
+            return {
+                name: NAME,
+                status: 'fail',
+                message: 'no @metaharness/* packages declared in optionalDependencies — the dependency contract regressed (peer-only declarations are never installed)',
+                fix: 'Restore @metaharness/darwin, @metaharness/flywheel, @metaharness/radio to optionalDependencies in @claude-flow/cli',
+            };
+        }
+        // Node resolution: nearest node_modules wins, walking upward from the CLI root.
+        const resolves = (name) => {
+            let d = root;
+            for (let i = 0; i < 10; i++) {
+                if (existsSync(join(d, 'node_modules', name, 'package.json')))
+                    return true;
+                const parent = dirname(d);
+                if (parent === d)
+                    break;
+                d = parent;
+            }
+            return false;
+        };
+        const missing = declared.filter((n) => !resolves(n));
+        if (missing.length > 0) {
+            return {
+                name: NAME,
+                status: 'fail',
+                message: `declared but not installed: ${missing.join(', ')} — advertised MetaHarness surfaces are degraded`,
+                fix: 'npm install --include=optional  # optional deps were skipped or pruned',
+            };
+        }
+        return { name: NAME, status: 'pass', message: `${declared.length} declared package(s) resolve: ${declared.join(', ')}` };
+    }
+    catch (err) {
+        return { name: NAME, status: 'warn', message: `check failed: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
 async function checkMetaharness() {
     try {
         const version = await runCommand('npx -y metaharness@latest --version 2>&1', 15000);
@@ -2116,6 +2186,7 @@ export const doctorCommand = {
             checkEncryptionAtRest, // ADR-096 Phase 5
             checkFederationBreaker, // ADR-097 Phase 4
             checkMetaharness, // ADR-150 — MetaHarness upstream package
+            checkMetaharnessDeclaredPackages, // dependency contract — declared optional deps must resolve
             checkMetaharnessIntegration, // iter 45 — ruflo-side integration layer
             checkFunnel, // ADR-305 — effective funnel state + deciding precedence source
             checkProxySponsoredConsent, // ADR-313 — Meta LLM Proxy sponsored-downtime health
@@ -2158,7 +2229,7 @@ export const doctorCommand = {
             'agentic-flow': checkAgenticFlow,
             'encryption': checkEncryptionAtRest, // ADR-096 Phase 5
             'federation': checkFederationBreaker, // ADR-097 Phase 4
-            'metaharness': checkMetaharness, // ADR-150 — upstream package
+            'metaharness': [checkMetaharness, checkMetaharnessDeclaredPackages, checkMetaharnessIntegration], // ADR-150 — upstream + declared deps + ruflo-side
             'metaharness-integration': checkMetaharnessIntegration, // iter 45 — ruflo-side
             'funnel': checkFunnel, // ADR-305
             // ADR-307 — deep-dive array, same pattern as 'memory' above: the cheap

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

@@ -45,6 +45,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 getTransportCommand(): Promise<Command | undefined>;
 /**
  * Core commands loaded synchronously (available immediately)
  * Advanced commands loaded on-demand for faster startup

package/dist/src/commands/index.js

@@ -90,6 +90,10 @@ const commandLoaders = {
     spinner: () => import('./spinner.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,
+    // removable augmentation; no-ops to local transport when AGNTCY/SLIM is
+    // not configured (RUFLO_AGNTCY_SLIM_ENDPOINT unset).
+    transport: () => import('./agntcy/transport.js'),
 };
 // Cache for loaded commands
 const loadedCommands = new Map();
@@ -188,6 +192,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 getTransportCommand() { return loadCommand('transport'); }
 /**
  * Core commands loaded synchronously (available immediately)
  * Advanced commands loaded on-demand for faster startup

package/dist/src/commands/metaharness.js

@@ -39,7 +39,7 @@ import { existsSync, readFileSync } from 'fs';
 import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { runFlywheelWorker } from '../services/harness-flywheel-runtime.js';
-import { listFlywheelReceipts, promoteFlywheelCandidate, readFlywheelTransactionState, verifyFlywheelLedger, } from '../services/flywheel-transaction.js';
+import { listFlywheelReceipts, promoteFlywheelCandidate, readFlywheelTransactionState, resetSequentialEvidence, verifyFlywheelLedger, } from '../services/flywheel-transaction.js';
 import { evaluatePolicyRequest } from '../services/policy-runtime.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // Subcommand → plugin script filename
@@ -124,6 +124,37 @@ async function dispatchFlywheel(operation, positional, flags) {
         const state = readFlywheelTransactionState(projectRoot);
         data = { ledgerHead: state.ledgerHead, commits: state.commits };
     }
+    else if (operation === 'evidence-reset') {
+        // ADR-381 §2 — start a new evidence epoch. Same policy gate as promote:
+        // this reopens the family-wise alpha budget, so it is a governance action.
+        const reason = String(flywheelFlag(flags, 'reason', '')).trim();
+        if (!reason) {
+            data = { success: false, reason: 'evidence-reset requires --reason "<why>" — the reset audit trail records intent' };
+        }
+        else {
+            const policy = await evaluatePolicyRequest({
+                identity: { id: process.env.CLAUDE_FLOW_PRINCIPAL_ID ?? 'metaharness-local', type: 'agent', roles: ['optimizer'] },
+                action: {
+                    type: 'metaharness.evidence.reset',
+                    resource: projectRoot,
+                    environment: 'production',
+                    destructive: true,
+                },
+                context: {
+                    approvalIds: String(flywheelFlag(flags, 'approvalId', '')).split(',').filter(Boolean),
+                },
+            }, projectRoot);
+            if (policy.enforcedOutcome !== 'allowed') {
+                data = { success: false, reason: `policy-${policy.enforcedOutcome}:${policy.reason}`, policyReceiptId: policy.receiptId };
+            }
+            else {
+                data = await resetSequentialEvidence(projectRoot, {
+                    confirm: flywheelFlag(flags, 'confirm', false) === true,
+                    reason,
+                });
+            }
+        }
+    }
     else if (operation === 'promote') {
         const receiptId = positional[0];
         const publicKeyPath = flywheelFlag(flags, 'publicKey');
@@ -151,6 +182,10 @@ async function dispatchFlywheel(operation, positional, flags) {
                 data = await promoteFlywheelCandidate(projectRoot, receiptId, {
                     confirm: flywheelFlag(flags, 'confirm', false) === true,
                     trustedPublicKeys: new Set([publicKey]),
+                    // --allow-aggregate-evidence: explicit migration escape hatch for
+                    // pre-upgrade receipts without task-level pairedOutcomes. Default
+                    // is strict — aggregate-only evidence is refused.
+                    requirePairedEvidence: flywheelFlag(flags, 'allowAggregateEvidence', false) !== true,
                 });
             }
         }
@@ -288,7 +323,7 @@ export const metaharnessCommand = {
             output.writeln('  redblue       adversarial red/blue LLM testing (init|run|patch|attack|report)');
             output.writeln('  evolve        Darwin candidate evolution');
             output.writeln('  bench         create or verify a stable benchmark suite');
-            output.writeln('  flywheel      receipt loop: run | status | receipts | history | promote');
+            output.writeln('  flywheel      receipt loop: run | status | receipts | history | promote | evidence-reset');
             output.writeln('');
             output.writeln('Each subcommand accepts --format json|table and --help.');
             output.writeln('');

package/dist/src/commands/swarm.js

@@ -5,6 +5,7 @@
 import { output } from '../output.js';
 import { select, confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
+import { swarmJoinCommand } from './agntcy/swarm-join.js';
 import * as fs from 'fs';
 import * as path from 'path';
 // Get dynamic swarm status from memory/session files
@@ -1009,7 +1010,7 @@ const pheromoneCommand = {
 export const swarmCommand = {
     name: 'swarm',
     description: 'Swarm coordination commands',
-    subcommands: [initCommand, startCommand, statusCommand, stopCommand, scaleCommand, coordinateCommand, compressMessageCommand, pheromoneCommand],
+    subcommands: [initCommand, startCommand, statusCommand, stopCommand, scaleCommand, coordinateCommand, compressMessageCommand, pheromoneCommand, swarmJoinCommand],
     options: [],
     examples: [
         { command: 'claude-flow swarm init --v3-mode', description: 'Initialize V3 swarm' },

package/dist/src/log-filters.d.ts

@@ -40,7 +40,7 @@ declare const STDERR_REDIRECT_PREFIXES: string[];
 declare const AGENTDB_MOCK_FALLBACK_DROP_PREFIXES: string[];
 declare const shouldRedirectToStderr: (msg: unknown) => boolean;
 declare const isAgentdbMockFallbackNoise: (msg: unknown) => boolean;
-declare const origWarn: (message?: any, ...optionalParams: any[]) => void;
-declare const origLog: (message?: any, ...optionalParams: any[]) => void;
-declare const origError: (message?: any, ...optionalParams: any[]) => void;
+declare const origWarn: (...data: any[]) => void;
+declare const origLog: (...data: any[]) => void;
+declare const origError: (...data: any[]) => void;
 //# sourceMappingURL=log-filters.d.ts.map

package/dist/src/mcp-tools/metaharness-tools.js

@@ -53,7 +53,7 @@ import { join, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { runFlywheelWorker } from '../services/harness-flywheel-runtime.js';
 import { evaluatePolicyRequest } from '../services/policy-runtime.js';
-import { listFlywheelReceipts, promoteFlywheelCandidate, readFlywheelTransactionState, verifyFlywheelLedger, } from '../services/flywheel-transaction.js';
+import { listFlywheelReceipts, promoteFlywheelCandidate, readFlywheelTransactionState, resetSequentialEvidence, verifyFlywheelLedger, } from '../services/flywheel-transaction.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 /**
  * Walk up from this module to find plugins/ruflo-metaharness/scripts/.
@@ -690,7 +690,7 @@ export const metaharnessTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                operation: { type: 'string', enum: ['run', 'status', 'receipts', 'history', 'promote'], description: 'Flywheel operation', default: 'status' },
+                operation: { type: 'string', enum: ['run', 'status', 'receipts', 'history', 'promote', 'evidence-reset'], description: 'Flywheel operation', default: 'status' },
                 projectRoot: { type: 'string', description: 'Target project root (default: active project cwd)' },
                 receiptId: { type: 'string', description: 'Receipt content ID for promote' },
                 sample: { type: 'number', description: 'Maximum harvested evaluation sample', default: 40 },
@@ -704,6 +704,8 @@ export const metaharnessTools = [
                 anchorHash: { type: 'string', description: 'Pinned sha256 of canonical anchor tasks; requires anchorPath' },
                 anchorManifestPath: { type: 'string', description: 'Project-contained anchor manifest path (default .claude/eval/flywheel-anchor.manifest.json)' },
                 approvalIds: { type: 'array', items: { type: 'string' }, description: 'Scoped ADR-324 approval IDs for privileged promotion' },
+                allowAggregateEvidence: { type: 'boolean', description: 'Migration escape hatch: accept a pre-upgrade receipt without task-level pairedOutcomes. Default false — aggregate-only evidence is refused by the strict sequential-evidence gate.', default: false },
+                reason: { type: 'string', description: 'Required for evidence-reset (ADR-381): the human intent recorded in the append-only reset audit trail.' },
             },
             required: ['operation'],
         },
@@ -758,6 +760,36 @@ export const metaharnessTools = [
                 });
                 return { success: data.ran, data, degraded: false, exitCode: data.ran ? 0 : 1 };
             }
+            if (operation === 'evidence-reset') {
+                // ADR-381 §2 — reopens the family-wise alpha budget; same policy
+                // gate as promote, plus a mandatory recorded reason.
+                const reason = String(input.reason ?? '').trim();
+                if (!reason) {
+                    return { success: false, data: { reason: 'evidence-reset requires a non-empty reason — the reset audit trail records intent' }, degraded: false, exitCode: 2 };
+                }
+                const policy = await evaluatePolicyRequest({
+                    identity: { id: 'metaharness-mcp', type: 'agent', roles: ['optimizer'] },
+                    action: {
+                        type: 'metaharness.evidence.reset',
+                        resource: projectRoot,
+                        environment: 'production',
+                        destructive: true,
+                    },
+                    context: {
+                        approvalIds: Array.isArray(input.approvalIds) ? input.approvalIds.map(String) : undefined,
+                    },
+                }, projectRoot);
+                if (policy.enforcedOutcome !== 'allowed') {
+                    return {
+                        success: false,
+                        data: { reason: `policy-${policy.enforcedOutcome}:${policy.reason}`, policyReceiptId: policy.receiptId },
+                        degraded: false,
+                        exitCode: 1,
+                    };
+                }
+                const data = await resetSequentialEvidence(projectRoot, { confirm: input.confirm === true, reason });
+                return { success: data.success, data, degraded: false, exitCode: data.success ? 0 : 1 };
+            }
             if (operation === 'promote') {
                 if (!input.receiptId || !input.publicKeyPath) {
                     return { success: false, data: { reason: 'receiptId and publicKeyPath are required' }, degraded: false, exitCode: 2 };
@@ -786,6 +818,7 @@ export const metaharnessTools = [
                 const data = await promoteFlywheelCandidate(projectRoot, String(input.receiptId), {
                     confirm: input.confirm === true,
                     trustedPublicKeys: new Set([publicKey]),
+                    requirePairedEvidence: input.allowAggregateEvidence !== true,
                 });
                 return { success: data.success, data, degraded: false, exitCode: data.success ? 0 : 1 };
             }

package/dist/src/memory/memory-bridge.d.ts

@@ -487,6 +487,14 @@ export declare function bridgeHealthCheck(dbPath?: string): Promise<{
         hits: number;
         misses: number;
     };
+    hierarchicalMemory?: {
+        controller: string;
+        durable: boolean;
+        persistence: string;
+        /** Real row count in the backing table — null when nothing is on disk. */
+        persistedRows: number | null;
+        fallbackFrom?: string;
+    };
 } | null>;
 /**
  * Store to hierarchical memory with tier.
@@ -506,6 +514,23 @@ export declare function bridgeHealthCheck(dbPath?: string): Promise<{
  *   temporal fields are stored in metadata, and supersede is reported as
  *   unsupported (no public update API) rather than silently dropped.
  */
+/**
+ * Describe which store `agentdb_hierarchical-*` actually landed on and
+ * whether its writes survive the process (#2887).
+ *
+ * agentdb removed its `HierarchicalMemory` export at 3.0.0-alpha.17, so the
+ * @claude-flow/memory TieredMemoryStore fallback is the live path. It is only
+ * durable when it was handed a SQLite connection — callers must not report a
+ * volatile write as a success.
+ */
+export declare function describeHierarchicalStore(hm: any, fallback: {
+    reason: string;
+} | null): {
+    controller: string;
+    fallbackFrom?: string;
+    durable: boolean;
+    persistence: string;
+};
 export declare function bridgeHierarchicalStore(params: {
     key: string;
     value: string;