@claude-flow/cli 3.32.2 → 3.32.3

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

@@ -1,306 +0,0 @@
-/**
- * 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

@@ -1,26 +0,0 @@
-/**
- * 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

@@ -1,168 +0,0 @@
-/**
- * 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

@@ -1,31 +0,0 @@
-/**
- * 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

@@ -1,71 +0,0 @@
-/**
- * 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

@@ -1,14 +0,0 @@
-/**
- * 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