@claude-flow/cli 3.32.3 → 3.32.4

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

@@ -0,0 +1,306 @@
+/**
+ * Terminal MCP Tools for CLI
+ *
+ * Terminal session management with real command execution.
+ */
+import { getProjectCwd } from './types.js';
+import { existsSync } from 'node:fs';
+import { mkdirRestricted, readFileMaybeEncrypted, writeFileRestricted, } from '../fs-secure.js';
+import { validateEnv, validateIdentifier, validatePath, validateText } from './validate-input.js';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+// Storage paths
+const STORAGE_DIR = '.claude-flow';
+const TERMINAL_DIR = 'terminals';
+const TERMINAL_FILE = 'store.json';
+function getTerminalDir() {
+    return join(getProjectCwd(), STORAGE_DIR, TERMINAL_DIR);
+}
+function getTerminalPath() {
+    return join(getTerminalDir(), TERMINAL_FILE);
+}
+function ensureTerminalDir() {
+    const dir = getTerminalDir();
+    if (!existsSync(dir)) {
+        mkdirRestricted(dir);
+    }
+}
+function loadTerminalStore() {
+    try {
+        const path = getTerminalPath();
+        if (existsSync(path)) {
+            // ADR-096 Phase 3: readFileMaybeEncrypted handles both legacy
+            // plaintext stores and post-migration encrypted ones via the RFE1
+            // magic-byte sniff.
+            return JSON.parse(readFileMaybeEncrypted(path, 'utf-8'));
+        }
+    }
+    catch {
+        // Return empty store
+    }
+    return { sessions: {}, version: '3.0.0' };
+}
+function saveTerminalStore(store) {
+    ensureTerminalDir();
+    // audit_1776853149979: terminal command history can contain credentials
+    // pasted into commands; restrict to owner read/write (mode 0600).
+    // ADR-096 Phase 3: opt-in AES-256-GCM encrypt-at-rest. Honored only
+    // when CLAUDE_FLOW_ENCRYPT_AT_REST is set; otherwise legacy plaintext
+    // path runs unchanged.
+    writeFileRestricted(getTerminalPath(), JSON.stringify(store, null, 2), { encrypt: true });
+}
+export const terminalTools = [
+    {
+        name: 'terminal_create',
+        description: 'Create a new terminal session Use when native Bash is wrong because you need a persistent terminal session across turns/agents with output capture and replay. For one-shot shell commands, native Bash is fine.',
+        category: 'terminal',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Session name' },
+                workingDir: { type: 'string', description: 'Working directory' },
+                env: { type: 'object', description: 'Environment variables' },
+            },
+        },
+        handler: async (input) => {
+            // Validate user-provided input (#1425, audit_1776853149979)
+            if (input.name) {
+                const v = validateText(input.name, 'name', 256);
+                if (!v.valid)
+                    return { success: false, error: v.error };
+            }
+            if (input.workingDir) {
+                const v = validatePath(input.workingDir, 'workingDir');
+                if (!v.valid)
+                    return { success: false, error: v.error };
+            }
+            // env is merged into execSync's process env on every command; reject
+            // loader/runtime hijack vars (LD_PRELOAD, NODE_OPTIONS, …) and enforce
+            // POSIX-shaped names + null-byte-free values.
+            const vEnv = validateEnv(input.env, 'env');
+            if (!vEnv.valid)
+                return { success: false, error: vEnv.error };
+            const store = loadTerminalStore();
+            const id = `term-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const session = {
+                id,
+                name: input.name || `Terminal ${Object.keys(store.sessions).length + 1}`,
+                status: 'active',
+                createdAt: new Date().toISOString(),
+                lastActivity: new Date().toISOString(),
+                workingDir: input.workingDir || getProjectCwd(),
+                history: [],
+                env: vEnv.sanitized,
+            };
+            store.sessions[id] = session;
+            saveTerminalStore(store);
+            return {
+                success: true,
+                sessionId: id,
+                name: session.name,
+                status: session.status,
+                workingDir: session.workingDir,
+                createdAt: session.createdAt,
+            };
+        },
+    },
+    {
+        name: 'terminal_execute',
+        description: 'Execute a command in a terminal session Use when native Bash is wrong because you need a persistent terminal session across turns/agents with output capture and replay. For one-shot shell commands, native Bash is fine.',
+        category: 'terminal',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sessionId: { type: 'string', description: 'Terminal session ID' },
+                command: { type: 'string', description: 'Command to execute' },
+                timeout: { type: 'number', description: 'Command timeout in ms' },
+                captureOutput: { type: 'boolean', description: 'Capture command output' },
+            },
+            required: ['command'],
+        },
+        handler: async (input) => {
+            // Validate user-provided input (#1425)
+            const vCmd = validateText(input.command, 'command', 10_000);
+            if (!vCmd.valid)
+                return { success: false, error: vCmd.error };
+            if (input.sessionId) {
+                const v = validateIdentifier(input.sessionId, 'sessionId');
+                if (!v.valid)
+                    return { success: false, error: v.error };
+            }
+            const store = loadTerminalStore();
+            const sessionId = input.sessionId;
+            const command = input.command;
+            // Find or create default session
+            let session = sessionId ? store.sessions[sessionId] : Object.values(store.sessions).find(s => s.status === 'active');
+            if (!session) {
+                // Create default session
+                const id = `term-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                session = {
+                    id,
+                    name: 'Default Terminal',
+                    status: 'active',
+                    createdAt: new Date().toISOString(),
+                    lastActivity: new Date().toISOString(),
+                    workingDir: getProjectCwd(),
+                    history: [],
+                    env: {},
+                };
+                store.sessions[id] = session;
+            }
+            const timeout = input.timeout || 30_000;
+            const cwd = session.workingDir || getProjectCwd();
+            const startTime = Date.now();
+            let output;
+            let exitCode;
+            try {
+                output = execSync(command, {
+                    cwd,
+                    encoding: 'utf-8',
+                    timeout,
+                    maxBuffer: 5 * 1024 * 1024,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    env: { ...process.env, ...session.env },
+                });
+                exitCode = 0;
+            }
+            catch (err) {
+                output = (err.stdout || '') + (err.stderr ? `\n[stderr] ${err.stderr}` : '');
+                exitCode = err.status ?? 1;
+            }
+            const duration = Date.now() - startTime;
+            const timestamp = new Date().toISOString();
+            // Record in history
+            session.history.push({
+                command,
+                output,
+                timestamp,
+                exitCode,
+            });
+            session.lastActivity = timestamp;
+            session.status = 'active';
+            saveTerminalStore(store);
+            return {
+                success: exitCode === 0,
+                sessionId: session.id,
+                command,
+                output,
+                exitCode,
+                executedAt: timestamp,
+                duration,
+            };
+        },
+    },
+    {
+        name: 'terminal_list',
+        description: 'List all terminal sessions Use when native Bash is wrong because you need a persistent terminal session across turns/agents with output capture and replay. For one-shot shell commands, native Bash is fine.',
+        category: 'terminal',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: { type: 'string', enum: ['all', 'active', 'idle', 'closed'], description: 'Filter by status' },
+                includeHistory: { type: 'boolean', description: 'Include command history' },
+            },
+        },
+        handler: async (input) => {
+            const store = loadTerminalStore();
+            let sessions = Object.values(store.sessions);
+            if (input.status && input.status !== 'all') {
+                sessions = sessions.filter(s => s.status === input.status);
+            }
+            return {
+                sessions: sessions.map(s => ({
+                    id: s.id,
+                    name: s.name,
+                    status: s.status,
+                    workingDir: s.workingDir,
+                    createdAt: s.createdAt,
+                    lastActivity: s.lastActivity,
+                    historyLength: s.history.length,
+                    ...(input.includeHistory ? { history: s.history.slice(-10) } : {}),
+                })),
+                total: sessions.length,
+                active: sessions.filter(s => s.status === 'active').length,
+            };
+        },
+    },
+    {
+        name: 'terminal_close',
+        description: 'Close a terminal session Use when native Bash is wrong because you need a persistent terminal session across turns/agents with output capture and replay. For one-shot shell commands, native Bash is fine.',
+        category: 'terminal',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sessionId: { type: 'string', description: 'Session ID to close' },
+                force: { type: 'boolean', description: 'Force close' },
+            },
+            required: ['sessionId'],
+        },
+        handler: async (input) => {
+            // Validate user-provided input (#1425)
+            const vId = validateIdentifier(input.sessionId, 'sessionId');
+            if (!vId.valid)
+                return { success: false, error: vId.error };
+            const store = loadTerminalStore();
+            const sessionId = input.sessionId;
+            const session = store.sessions[sessionId];
+            if (!session) {
+                return { success: false, error: 'Session not found' };
+            }
+            session.status = 'closed';
+            saveTerminalStore(store);
+            return {
+                success: true,
+                sessionId,
+                closedAt: new Date().toISOString(),
+            };
+        },
+    },
+    {
+        name: 'terminal_history',
+        description: 'Get command history for a terminal session Use when native Bash is wrong because you need a persistent terminal session across turns/agents with output capture and replay. For one-shot shell commands, native Bash is fine.',
+        category: 'terminal',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sessionId: { type: 'string', description: 'Session ID' },
+                limit: { type: 'number', description: 'Number of entries to return' },
+                offset: { type: 'number', description: 'Offset from latest' },
+            },
+        },
+        handler: async (input) => {
+            // Validate user-provided input (#1425)
+            if (input.sessionId) {
+                const v = validateIdentifier(input.sessionId, 'sessionId');
+                if (!v.valid)
+                    return { success: false, error: v.error };
+            }
+            const store = loadTerminalStore();
+            const sessionId = input.sessionId;
+            const limit = input.limit || 50;
+            const offset = input.offset || 0;
+            if (sessionId) {
+                const session = store.sessions[sessionId];
+                if (!session) {
+                    return { success: false, error: 'Session not found' };
+                }
+                const history = session.history.slice(-(limit + offset), offset ? -offset : undefined);
+                return {
+                    sessionId,
+                    history,
+                    total: session.history.length,
+                };
+            }
+            // Return combined history from all sessions
+            const allHistory = Object.values(store.sessions)
+                .flatMap(s => s.history.map(h => ({ ...h, sessionId: s.id })))
+                .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
+                .slice(offset, offset + limit);
+            return {
+                history: allHistory,
+                total: allHistory.length,
+            };
+        },
+    },
+];
+//# sourceMappingURL=terminal-tools.js.map

package/dist/src/mcp-tools/testgen-tools.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Testgen MCP Tools — Test-Driven Repair surface.
+ *
+ * Exposes `ruflo-testgen` plugin scripts as first-class MCP tools so
+ * agents (Claude Code, Codex, etc.) can invoke them programmatically.
+ *
+ * Current surface (one tool, narrow on purpose — Conformant mode follows
+ * in a separate ADR):
+ *
+ *   - testgen_tdd_repair     Test-Driven Repair via headless `claude -p`
+ *                            (read failing test → fix source → verify)
+ *
+ * Inspired by agent-harness-generator/packages/darwin-mode ADR-175.
+ *
+ * ARCHITECTURAL CONSTRAINT (mirrors metaharness-tools.ts)
+ * Zero static `ruflo-testgen/*` imports. All script invocation stays
+ * behind a subprocess bridge. When the plugin isn't reachable at
+ * runtime, the tool returns `{success: true, degraded: true,
+ * reason: 'plugin-not-found'}` and exits 0 — same posture as
+ * metaharness-tools so callers see one contract.
+ *
+ * @module @claude-flow/cli/mcp-tools/testgen
+ */
+import type { MCPTool } from './types.js';
+export declare const testgenTools: MCPTool[];
+//# sourceMappingURL=testgen-tools.d.ts.map

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

@@ -0,0 +1,168 @@
+/**
+ * Testgen MCP Tools — Test-Driven Repair surface.
+ *
+ * Exposes `ruflo-testgen` plugin scripts as first-class MCP tools so
+ * agents (Claude Code, Codex, etc.) can invoke them programmatically.
+ *
+ * Current surface (one tool, narrow on purpose — Conformant mode follows
+ * in a separate ADR):
+ *
+ *   - testgen_tdd_repair     Test-Driven Repair via headless `claude -p`
+ *                            (read failing test → fix source → verify)
+ *
+ * Inspired by agent-harness-generator/packages/darwin-mode ADR-175.
+ *
+ * ARCHITECTURAL CONSTRAINT (mirrors metaharness-tools.ts)
+ * Zero static `ruflo-testgen/*` imports. All script invocation stays
+ * behind a subprocess bridge. When the plugin isn't reachable at
+ * runtime, the tool returns `{success: true, degraded: true,
+ * reason: 'plugin-not-found'}` and exits 0 — same posture as
+ * metaharness-tools so callers see one contract.
+ *
+ * @module @claude-flow/cli/mcp-tools/testgen
+ */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getProjectCwd } from './types.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Locate the ruflo-testgen plugin's scripts directory.
+ *
+ * Mirrors `metaharness-tools.ts::locatePluginScripts()` strategy but
+ * targets the testgen plugin. Walks up from this module's own location
+ * (covers npx + global install) then falls back to cwd-walks. We probe
+ * for `tdd-repair/tdd-repair.mjs` (the only script in this surface
+ * today) — when that lands at a candidate path, we've found the dir.
+ */
+function locateTestgenScripts() {
+    const candidates = [];
+    let p = resolve(__dirname);
+    for (let i = 0; i < 8; i++) {
+        candidates.push(join(p, 'plugins', 'ruflo-testgen', 'scripts'));
+        candidates.push(join(p, '..', 'plugins', 'ruflo-testgen', 'scripts'));
+        p = dirname(p);
+    }
+    const cwd = getProjectCwd();
+    candidates.push(join(cwd, 'plugins', 'ruflo-testgen', 'scripts'));
+    candidates.push(join(cwd, 'node_modules', '@claude-flow', 'cli', 'plugins', 'ruflo-testgen', 'scripts'));
+    for (const c of candidates) {
+        if (existsSync(join(c, 'tdd-repair', 'tdd-repair.mjs')))
+            return c;
+    }
+    return null;
+}
+/**
+ * Run a testgen plugin script with the same success-semantics contract
+ * as metaharness-tools.ts (exit 0 ⇒ success: true even if degraded).
+ */
+function runTestgenScript(scriptName, args) {
+    return new Promise((resolve) => {
+        const dir = locateTestgenScripts();
+        if (!dir) {
+            resolve({
+                exitCode: 0,
+                json: { degraded: true, reason: 'plugin-not-found' },
+                degraded: true,
+                success: true,
+            });
+            return;
+        }
+        const scriptPath = join(dir, scriptName);
+        const p = spawn('node', [scriptPath, ...args], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: process.env,
+        });
+        let stdout = '';
+        p.stdout?.on('data', (d) => { stdout += d.toString(); });
+        p.stderr?.on('data', () => { });
+        // 20 min hard ceiling (tdd-repair has its own 15 min cap; we add 5 min slack)
+        const timer = setTimeout(() => { try {
+            p.kill('SIGTERM');
+        }
+        catch { /* ignore */ } }, 20 * 60_000);
+        p.on('close', (code) => {
+            clearTimeout(timer);
+            let json = null;
+            const m = /\{[\s\S]*\}/.exec(stdout);
+            if (m) {
+                try {
+                    json = JSON.parse(m[0]);
+                }
+                catch { /* leave null */ }
+            }
+            const looksDegraded = !!(json && typeof json === 'object' && json.data?.reason === 'plugin-not-found');
+            const exitCode = code ?? 0;
+            resolve({
+                exitCode,
+                json,
+                degraded: looksDegraded,
+                success: exitCode === 0,
+            });
+        });
+        p.on('error', () => {
+            clearTimeout(timer);
+            resolve({
+                exitCode: 127,
+                json: { degraded: true, reason: 'spawn-failed' },
+                degraded: true,
+                success: false,
+            });
+        });
+    });
+}
+const TESTGEN_SUCCESS_SEMANTIC = 'Returns `{success, data, degraded, exitCode}`. success=true when the script ran as designed (including graceful-degradation payloads); ' +
+    'success=false when the test could not be repaired within --max-attempts (exit 1) or on config error (exit 2). ' +
+    'Reads data.repaired for the actual outcome — true means the test now passes, false means it does not.';
+export const testgenTools = [
+    {
+        name: 'testgen_tdd_repair',
+        description: 'ADR-175-inspired Test-Driven Repair. Use when you have a failing test and want a verified, bounded-cost fix. Spawns a bounded headless `claude -p` (Read/Edit/Bash only, --max-budget-usd capped) ' +
+            'that makes the test pass without modifying it. The test\'s exit code IS the fitness function — no LLM-as-judge. ' +
+            'Use when you have a failing test and want a verified fix. Skipping this and asking an agent to "fix the bug" is wrong because (a) you lose the bounded-cost guarantee, ' +
+            '(b) you lose the strict no-test-modification constraint, (c) you lose the verify-on-finish step. ' +
+            'REQUIRES --confirm — without it returns a dry-run plan. Cost ladder: Haiku $0.02-0.20, Sonnet $0.30-2.00, Opus $1.50-8.00 per attempt. ' + TESTGEN_SUCCESS_SEMANTIC,
+        category: 'testgen',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                repo: { type: 'string', description: 'Absolute path to the repo root (default: cwd)', default: '.' },
+                test: { type: 'string', description: 'Relative path (from repo root) to the failing test file. REQUIRED.' },
+                testCommand: { type: 'string', description: 'Shell command to run the test (e.g. `npx vitest run tests/auth.test.ts`). REQUIRED.' },
+                maxAttempts: { type: 'number', description: '1..5 (ruflo cap). Each attempt gets budgetUsd/maxAttempts of the total budget.', default: 1 },
+                budgetUsd: { type: 'number', description: 'Total cost ceiling across all attempts. Hard cap — claude exits when reached.', default: 5.0 },
+                model: { type: 'string', enum: ['haiku', 'sonnet', 'opus'], description: 'Claude model tier. Haiku for simple bugs (default); Sonnet for multi-file; Opus rarely worth it.', default: 'haiku' },
+                confirm: { type: 'boolean', description: 'REQUIRED to actually run. Without it returns a dry-run plan.', default: false },
+                noTestOracle: { type: 'boolean', description: 'Conformant mode (agent writes its own repro). NOT YET IMPLEMENTED — returns config error.', default: false },
+                timeoutMs: { type: 'number', description: 'Hard wall-clock cap. Default 15 min.', default: 900000 },
+            },
+            required: ['test', 'testCommand'],
+        },
+        handler: async (input) => {
+            const args = [];
+            if (input.repo)
+                args.push('--repo', String(input.repo));
+            if (input.test)
+                args.push('--test', String(input.test));
+            if (input.testCommand)
+                args.push('--test-command', String(input.testCommand));
+            if (input.maxAttempts !== undefined)
+                args.push('--max-attempts', String(input.maxAttempts));
+            if (input.budgetUsd !== undefined)
+                args.push('--budget', String(input.budgetUsd));
+            if (input.model)
+                args.push('--model', String(input.model));
+            if (input.confirm === true)
+                args.push('--confirm');
+            if (input.noTestOracle === true)
+                args.push('--no-test-oracle');
+            if (input.timeoutMs !== undefined)
+                args.push('--timeout-ms', String(input.timeoutMs));
+            const r = await runTestgenScript('tdd-repair/tdd-repair.mjs', args);
+            return { success: r.success, data: r.json, degraded: r.degraded, exitCode: r.exitCode };
+        },
+    },
+];
+//# sourceMappingURL=testgen-tools.js.map

package/dist/src/mcp-tools/tool-loop-guardrail.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Tool-loop circuit breaker (hermes-agent tool_guardrails pattern).
+ *
+ * Detects an agent stuck repeating the same failing command — a real silent
+ * failure mode where a loop burns turns with no signal. This is ORTHOGONAL to
+ * the security `tool-output-guardrail` (which detects indirect prompt injection
+ * in tool *output*); this one watches the agent's own *call* pattern.
+ *
+ * Design (deterministic, in-memory, bounded):
+ *  - `recordCommandOutcome` (called by post-command) appends (command, success)
+ *    to a small ring buffer.
+ *  - `checkCommandLoop` (called by pre-command) returns a verdict for a command
+ *    about to run, based on its recent consecutive-failure streak.
+ *  - Verdict is advisory by default (`warn`); callers decide whether to block.
+ *    An orchestration layer that doesn't own the UI should not hard-stop.
+ */
+export type LoopVerdict = 'allow' | 'warn' | 'block';
+/** Record a command's outcome. Called from the post-command hook. */
+export declare function recordCommandOutcome(command: string, success: boolean): void;
+/**
+ * Verdict for a command about to execute. Called from the pre-command hook.
+ * Returns the verdict, the failure streak, and a recovery hint when looping.
+ */
+export declare function checkCommandLoop(command: string): {
+    verdict: LoopVerdict;
+    consecutiveFailures: number;
+    hint?: string;
+};
+/** Test/reset helper — clears the in-memory history. */
+export declare function _resetLoopHistory(): void;
+//# sourceMappingURL=tool-loop-guardrail.d.ts.map

package/dist/src/mcp-tools/tool-loop-guardrail.js

@@ -0,0 +1,71 @@
+/**
+ * Tool-loop circuit breaker (hermes-agent tool_guardrails pattern).
+ *
+ * Detects an agent stuck repeating the same failing command — a real silent
+ * failure mode where a loop burns turns with no signal. This is ORTHOGONAL to
+ * the security `tool-output-guardrail` (which detects indirect prompt injection
+ * in tool *output*); this one watches the agent's own *call* pattern.
+ *
+ * Design (deterministic, in-memory, bounded):
+ *  - `recordCommandOutcome` (called by post-command) appends (command, success)
+ *    to a small ring buffer.
+ *  - `checkCommandLoop` (called by pre-command) returns a verdict for a command
+ *    about to run, based on its recent consecutive-failure streak.
+ *  - Verdict is advisory by default (`warn`); callers decide whether to block.
+ *    An orchestration layer that doesn't own the UI should not hard-stop.
+ */
+const MAX_HISTORY = 64;
+const history = [];
+/** Consecutive-failure thresholds for the same command (exact match). */
+const WARN_AT = 3;
+const BLOCK_AT = 5;
+function normalize(command) {
+    return command.trim().replace(/\s+/g, ' ');
+}
+/** Record a command's outcome. Called from the post-command hook. */
+export function recordCommandOutcome(command, success) {
+    history.push({ command: normalize(command), success, at: history.length });
+    if (history.length > MAX_HISTORY)
+        history.shift();
+}
+/** Count the trailing run of consecutive failures of `command` (exact match),
+ * stopping at the first success of that command or a gap. */
+function consecutiveFailures(command) {
+    const norm = normalize(command);
+    let streak = 0;
+    for (let i = history.length - 1; i >= 0; i--) {
+        if (history[i].command !== norm)
+            continue; // ignore interleaved other commands
+        if (history[i].success)
+            break; // a success breaks the streak
+        streak++;
+    }
+    return streak;
+}
+/**
+ * Verdict for a command about to execute. Called from the pre-command hook.
+ * Returns the verdict, the failure streak, and a recovery hint when looping.
+ */
+export function checkCommandLoop(command) {
+    const fails = consecutiveFailures(command);
+    if (fails >= BLOCK_AT) {
+        return {
+            verdict: 'block',
+            consecutiveFailures: fails,
+            hint: `This exact command has failed ${fails}× in a row. Stop repeating it — inspect state first (e.g. \`pwd && ls -la\`), change the approach, or ask for help.`,
+        };
+    }
+    if (fails >= WARN_AT) {
+        return {
+            verdict: 'warn',
+            consecutiveFailures: fails,
+            hint: `This command has failed ${fails}× in a row. Before retrying, verify preconditions (paths, args, prior step output) rather than re-running the same call.`,
+        };
+    }
+    return { verdict: 'allow', consecutiveFailures: fails };
+}
+/** Test/reset helper — clears the in-memory history. */
+export function _resetLoopHistory() {
+    history.length = 0;
+}
+//# sourceMappingURL=tool-loop-guardrail.js.map

package/dist/src/mcp-tools/transfer-tools.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Transfer MCP Tools
+ * Pattern and plugin sharing via IPFS-based decentralized registry
+ *
+ * @module @claude-flow/cli/mcp-tools/transfer-tools
+ * @version 3.0.0
+ */
+import type { MCPTool } from './types.js';
+/**
+ * Transfer MCP tools for pattern export, import, anonymization, and sharing
+ */
+export declare const transferTools: MCPTool[];
+export default transferTools;
+//# sourceMappingURL=transfer-tools.d.ts.map