claude-flow 3.5.44 → 3.5.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.5.44",
+  "version": "3.5.46",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@claude-flow/cli/dist/src/autopilot-state.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Autopilot Shared State Module
+ *
+ * Centralizes state management, validation, and task discovery
+ * for both CLI command and MCP tools. Eliminates code duplication.
+ *
+ * ADR-072: Autopilot Integration
+ * Security: Addresses prototype pollution, NaN bypass, input validation
+ */
+export declare const STATE_DIR = ".claude-flow/data";
+export declare const STATE_FILE = ".claude-flow/data/autopilot-state.json";
+export declare const LOG_FILE = ".claude-flow/data/autopilot-log.json";
+/** Allowlist for valid task sources */
+export declare const VALID_TASK_SOURCES: Set<string>;
+/** Terminal task statuses */
+export declare const TERMINAL_STATUSES: Set<string>;
+export interface AutopilotState {
+    sessionId: string;
+    enabled: boolean;
+    startTime: number;
+    iterations: number;
+    maxIterations: number;
+    timeoutMinutes: number;
+    taskSources: string[];
+    lastCheck: number | null;
+    history: Array<{
+        ts: number;
+        iteration: number;
+        completed: number;
+        total: number;
+    }>;
+}
+export interface AutopilotLogEntry {
+    ts: number;
+    event: string;
+    [key: string]: unknown;
+}
+export interface TaskInfo {
+    id: string;
+    subject: string;
+    status: string;
+    source: string;
+}
+export interface TaskProgress {
+    completed: number;
+    total: number;
+    percent: number;
+    incomplete: TaskInfo[];
+}
+/**
+ * Safe JSON.parse that prevents prototype pollution.
+ */
+export declare function safeJsonParse<T>(raw: string): T;
+/**
+ * Validate and coerce a numeric parameter. Returns the default if
+ * the input is NaN, undefined, or outside the allowed range.
+ */
+export declare function validateNumber(value: unknown, min: number, max: number, defaultValue: number): number;
+/**
+ * Validate task sources against the allowlist.
+ * Returns only valid sources; falls back to defaults if none are valid.
+ */
+export declare function validateTaskSources(sources: unknown): string[];
+export declare function getDefaultState(): AutopilotState;
+export declare function loadState(): AutopilotState;
+export declare function saveState(state: AutopilotState): void;
+export declare function appendLog(entry: AutopilotLogEntry): void;
+export declare function loadLog(): AutopilotLogEntry[];
+export declare function discoverTasks(sources: string[]): TaskInfo[];
+export declare function isTerminal(status: string): boolean;
+export declare function getProgress(tasks: TaskInfo[]): TaskProgress;
+export declare function calculateReward(iterations: number, durationMs: number): number;
+export declare function tryLoadLearning(): Promise<{
+    initialize: () => Promise<boolean>;
+    [key: string]: unknown;
+} | null>;
+//# sourceMappingURL=autopilot-state.d.ts.map

package/v3/@claude-flow/cli/dist/src/autopilot-state.js

@@ -0,0 +1,279 @@
+/**
+ * Autopilot Shared State Module
+ *
+ * Centralizes state management, validation, and task discovery
+ * for both CLI command and MCP tools. Eliminates code duplication.
+ *
+ * ADR-072: Autopilot Integration
+ * Security: Addresses prototype pollution, NaN bypass, input validation
+ */
+// ── Constants ─────────────────────────────────────────────────
+export const STATE_DIR = '.claude-flow/data';
+export const STATE_FILE = `${STATE_DIR}/autopilot-state.json`;
+export const LOG_FILE = `${STATE_DIR}/autopilot-log.json`;
+/** Maximum entries kept in state.history (prevents unbounded growth) */
+const MAX_HISTORY_ENTRIES = 50;
+/** Maximum entries kept in the event log */
+const MAX_LOG_ENTRIES = 1000;
+/** Allowlist for valid task sources */
+export const VALID_TASK_SOURCES = new Set(['team-tasks', 'swarm-tasks', 'file-checklist']);
+/** Terminal task statuses */
+export const TERMINAL_STATUSES = new Set(['completed', 'done', 'cancelled', 'skipped', 'failed']);
+// ── Validation Helpers ────────────────────────────────────────
+/**
+ * Sanitize a parsed JSON object to prevent prototype pollution.
+ * Removes __proto__, constructor, and prototype keys recursively.
+ */
+function sanitizeObject(obj) {
+    if (obj === null || typeof obj !== 'object')
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map(sanitizeObject);
+    const clean = {};
+    for (const key of Object.keys(obj)) {
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype')
+            continue;
+        clean[key] = sanitizeObject(obj[key]);
+    }
+    return clean;
+}
+/**
+ * Safe JSON.parse that prevents prototype pollution.
+ */
+export function safeJsonParse(raw) {
+    return sanitizeObject(JSON.parse(raw));
+}
+/**
+ * Validate and coerce a numeric parameter. Returns the default if
+ * the input is NaN, undefined, or outside the allowed range.
+ */
+export function validateNumber(value, min, max, defaultValue) {
+    if (value === undefined || value === null)
+        return defaultValue;
+    const num = Number(value);
+    if (!Number.isFinite(num))
+        return defaultValue;
+    return Math.min(Math.max(min, Math.round(num)), max);
+}
+/**
+ * Validate task sources against the allowlist.
+ * Returns only valid sources; falls back to defaults if none are valid.
+ */
+export function validateTaskSources(sources) {
+    const defaults = ['team-tasks', 'swarm-tasks', 'file-checklist'];
+    if (!Array.isArray(sources))
+        return defaults;
+    const valid = sources
+        .filter((s) => typeof s === 'string')
+        .map(s => s.trim())
+        .filter(s => VALID_TASK_SOURCES.has(s));
+    return valid.length > 0 ? valid : defaults;
+}
+// ── State Management ──────────────────────────────────────────
+export function getDefaultState() {
+    const crypto = require('crypto');
+    return {
+        sessionId: crypto.randomUUID(),
+        enabled: false,
+        startTime: Date.now(),
+        iterations: 0,
+        maxIterations: 50,
+        timeoutMinutes: 240,
+        taskSources: ['team-tasks', 'swarm-tasks', 'file-checklist'],
+        lastCheck: null,
+        history: [],
+    };
+}
+export function loadState() {
+    const fs = require('fs');
+    const path = require('path');
+    const filePath = path.resolve(STATE_FILE);
+    const defaults = getDefaultState();
+    try {
+        if (fs.existsSync(filePath)) {
+            const raw = safeJsonParse(fs.readFileSync(filePath, 'utf-8'));
+            const merged = { ...defaults, ...raw };
+            // Re-validate fields that could be tampered with
+            merged.maxIterations = validateNumber(merged.maxIterations, 1, 1000, 50);
+            merged.timeoutMinutes = validateNumber(merged.timeoutMinutes, 1, 1440, 240);
+            merged.iterations = validateNumber(merged.iterations, 0, 1000, 0);
+            merged.taskSources = validateTaskSources(merged.taskSources);
+            // Cap history to prevent unbounded growth
+            if (Array.isArray(merged.history) && merged.history.length > MAX_HISTORY_ENTRIES) {
+                merged.history = merged.history.slice(-MAX_HISTORY_ENTRIES);
+            }
+            return merged;
+        }
+    }
+    catch {
+        // Corrupted state file — return defaults
+    }
+    return defaults;
+}
+export function saveState(state) {
+    const fs = require('fs');
+    const path = require('path');
+    const dir = path.resolve(STATE_DIR);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    // Cap history before saving
+    if (state.history.length > MAX_HISTORY_ENTRIES) {
+        state.history = state.history.slice(-MAX_HISTORY_ENTRIES);
+    }
+    const tmpFile = path.resolve(STATE_FILE) + '.tmp';
+    fs.writeFileSync(tmpFile, JSON.stringify(state, null, 2));
+    fs.renameSync(tmpFile, path.resolve(STATE_FILE));
+}
+export function appendLog(entry) {
+    const fs = require('fs');
+    const path = require('path');
+    const filePath = path.resolve(LOG_FILE);
+    const dir = path.resolve(STATE_DIR);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    let log = [];
+    try {
+        if (fs.existsSync(filePath)) {
+            log = safeJsonParse(fs.readFileSync(filePath, 'utf-8'));
+            if (!Array.isArray(log))
+                log = [];
+        }
+    }
+    catch {
+        log = [];
+    }
+    log.push(entry);
+    if (log.length > MAX_LOG_ENTRIES)
+        log = log.slice(-MAX_LOG_ENTRIES);
+    const tmpFile = filePath + '.tmp';
+    fs.writeFileSync(tmpFile, JSON.stringify(log, null, 2));
+    fs.renameSync(tmpFile, filePath);
+}
+export function loadLog() {
+    const fs = require('fs');
+    const path = require('path');
+    const filePath = path.resolve(LOG_FILE);
+    try {
+        if (fs.existsSync(filePath)) {
+            const result = safeJsonParse(fs.readFileSync(filePath, 'utf-8'));
+            return Array.isArray(result) ? result : [];
+        }
+    }
+    catch {
+        // Corrupted log — return empty
+    }
+    return [];
+}
+// ── Task Discovery ────────────────────────────────────────────
+export function discoverTasks(sources) {
+    const fs = require('fs');
+    const path = require('path');
+    const os = require('os');
+    const tasks = [];
+    // Only process valid sources
+    const validSources = sources.filter(s => VALID_TASK_SOURCES.has(s));
+    for (const source of validSources) {
+        if (source === 'team-tasks') {
+            const tasksDir = path.join(os.homedir(), '.claude', 'tasks');
+            try {
+                if (fs.existsSync(tasksDir)) {
+                    const teams = fs.readdirSync(tasksDir, { withFileTypes: true });
+                    for (const team of teams) {
+                        if (!team.isDirectory())
+                            continue;
+                        const teamDir = path.join(tasksDir, team.name);
+                        const files = fs.readdirSync(teamDir).filter((f) => f.endsWith('.json'));
+                        for (const file of files) {
+                            try {
+                                const data = safeJsonParse(fs.readFileSync(path.join(teamDir, file), 'utf-8'));
+                                tasks.push({
+                                    id: String(data.id || file.replace('.json', '')),
+                                    subject: String(data.subject || data.title || file),
+                                    status: String(data.status || 'unknown'),
+                                    source: 'team-tasks',
+                                });
+                            }
+                            catch { /* skip individual file */ }
+                        }
+                    }
+                }
+            }
+            catch { /* skip source */ }
+        }
+        if (source === 'swarm-tasks') {
+            const swarmFile = path.resolve('.claude-flow/swarm-tasks.json');
+            try {
+                if (fs.existsSync(swarmFile)) {
+                    const data = safeJsonParse(fs.readFileSync(swarmFile, 'utf-8'));
+                    const swarmTasks = Array.isArray(data) ? data : (data.tasks || []);
+                    for (const t of swarmTasks) {
+                        if (t && typeof t === 'object') {
+                            const task = t;
+                            tasks.push({
+                                id: String(task.id || task.taskId || `swarm-${tasks.length}`),
+                                subject: String(task.subject || task.description || task.name || 'Unnamed task'),
+                                status: String(task.status || 'unknown'),
+                                source: 'swarm-tasks',
+                            });
+                        }
+                    }
+                }
+            }
+            catch { /* skip source */ }
+        }
+        if (source === 'file-checklist') {
+            const checklistFile = path.resolve('.claude-flow/data/checklist.json');
+            try {
+                if (fs.existsSync(checklistFile)) {
+                    const data = safeJsonParse(fs.readFileSync(checklistFile, 'utf-8'));
+                    const items = Array.isArray(data) ? data : (data.items || []);
+                    for (const item of items) {
+                        if (item && typeof item === 'object') {
+                            const i = item;
+                            tasks.push({
+                                id: String(i.id || `check-${tasks.length}`),
+                                subject: String(i.subject || i.text || i.description || 'Unnamed item'),
+                                status: String(i.status || (i.done ? 'completed' : 'pending')),
+                                source: 'file-checklist',
+                            });
+                        }
+                    }
+                }
+            }
+            catch { /* skip source */ }
+        }
+    }
+    return tasks;
+}
+// ── Progress Helpers ──────────────────────────────────────────
+export function isTerminal(status) {
+    return TERMINAL_STATUSES.has(status.toLowerCase());
+}
+export function getProgress(tasks) {
+    const completed = tasks.filter(t => isTerminal(t.status)).length;
+    const total = tasks.length;
+    const percent = total === 0 ? 100 : Math.round((completed / total) * 100);
+    const incomplete = tasks.filter(t => !isTerminal(t.status));
+    return { completed, total, percent, incomplete };
+}
+// ── Reward Calculation ────────────────────────────────────────
+export function calculateReward(iterations, durationMs) {
+    const iterFactor = (1 - iterations / (iterations + 10)) * 0.6;
+    const timeFactor = (1 - Math.min(durationMs / 3600000, 1)) * 0.4;
+    return Math.round((iterFactor + timeFactor) * 100) / 100;
+}
+// ── Learning Integration ──────────────────────────────────────
+export async function tryLoadLearning() {
+    try {
+        const modPath = 'agentic-flow/dist/coordination/autopilot-learning.js';
+        const mod = await import(/* webpackIgnore: true */ modPath).catch(() => null);
+        if (mod?.AutopilotLearning) {
+            const instance = new mod.AutopilotLearning();
+            if (await instance.initialize())
+                return instance;
+        }
+    }
+    catch { /* not available */ }
+    return null;
+}
+//# sourceMappingURL=autopilot-state.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * V3 CLI Autopilot Command
+ * Persistent swarm completion — keeps agents working until ALL tasks are done.
+ *
+ * ADR-072: Autopilot Integration
+ */
+import type { Command } from '../types.js';
+export declare function autopilotCheck(): Promise<{
+    allowStop: boolean;
+    reason: string;
+    continueWith?: string;
+}>;
+export declare const autopilotCommand: Command;
+export default autopilotCommand;
+//# sourceMappingURL=autopilot.d.ts.map

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

@@ -0,0 +1,362 @@
+/**
+ * V3 CLI Autopilot Command
+ * Persistent swarm completion — keeps agents working until ALL tasks are done.
+ *
+ * ADR-072: Autopilot Integration
+ */
+import { output } from '../output.js';
+import { loadState, saveState, appendLog, loadLog, discoverTasks, getProgress, calculateReward, tryLoadLearning, validateNumber, validateTaskSources, LOG_FILE, } from '../autopilot-state.js';
+// ── Check Handler (for Stop hook) ─────────────────────────────
+export async function autopilotCheck() {
+    const state = loadState();
+    if (!state.enabled) {
+        return { allowStop: true, reason: 'Autopilot disabled' };
+    }
+    // Safety: max iterations
+    if (state.iterations >= state.maxIterations) {
+        state.enabled = false;
+        saveState(state);
+        appendLog({ ts: Date.now(), event: 'max-iterations-reached', iterations: state.iterations });
+        return { allowStop: true, reason: `Max iterations (${state.maxIterations}) reached` };
+    }
+    // Safety: timeout
+    const elapsed = Date.now() - state.startTime;
+    if (elapsed > state.timeoutMinutes * 60000) {
+        state.enabled = false;
+        saveState(state);
+        appendLog({ ts: Date.now(), event: 'timeout-reached', elapsed: Math.round(elapsed / 60000) });
+        return { allowStop: true, reason: `Timeout (${state.timeoutMinutes} min) reached` };
+    }
+    // Discover tasks
+    const tasks = discoverTasks(state.taskSources);
+    if (tasks.length === 0) {
+        return { allowStop: true, reason: 'No tasks discovered from any source' };
+    }
+    const progress = getProgress(tasks);
+    if (progress.incomplete.length === 0) {
+        const reward = calculateReward(state.iterations, elapsed);
+        state.enabled = false;
+        saveState(state);
+        appendLog({ ts: Date.now(), event: 'all-tasks-complete', total: progress.total, iterations: state.iterations, durationMs: elapsed, reward });
+        return { allowStop: true, reason: `All ${progress.total} tasks complete (${state.iterations} iterations, reward: ${reward})` };
+    }
+    // Stall detection
+    const recentHistory = state.history.slice(-5);
+    const isStalled = recentHistory.length >= 5 && recentHistory.every(h => h.completed === progress.completed);
+    if (isStalled && state.history.length >= 10) {
+        state.enabled = false;
+        saveState(state);
+        appendLog({ ts: Date.now(), event: 'stall-auto-disable', iterations: state.iterations, completed: progress.completed });
+        return { allowStop: true, reason: `Stalled: no progress in 10 iterations (${progress.completed}/${progress.total} complete)` };
+    }
+    // Re-engage
+    state.iterations++;
+    state.lastCheck = Date.now();
+    state.history.push({ ts: Date.now(), iteration: state.iterations, completed: progress.completed, total: progress.total });
+    saveState(state);
+    const stallWarning = isStalled
+        ? '\nWARNING: No progress in 5 iterations. Consider breaking tasks into smaller subtasks or trying a different approach.'
+        : '';
+    const taskList = progress.incomplete.slice(0, 5).map(t => `- ${t.subject} (${t.status})`).join('\n');
+    const moreCount = progress.incomplete.length > 5 ? `\n... and ${progress.incomplete.length - 5} more` : '';
+    const continuePrompt = [
+        `AUTOPILOT: ${progress.completed}/${progress.total} tasks complete (${progress.percent}%).`,
+        `Iteration ${state.iterations}/${state.maxIterations}.`,
+        `Remaining tasks:\n${taskList}${moreCount}`,
+        stallWarning,
+        `Continue working on the remaining tasks. Do not stop until all are complete.`,
+    ].join('\n');
+    appendLog({ ts: Date.now(), event: 're-engaging', iteration: state.iterations, completed: progress.completed, remaining: progress.incomplete.length });
+    return { allowStop: false, reason: `${progress.incomplete.length}/${progress.total} tasks remaining (iteration ${state.iterations}/${state.maxIterations})`, continueWith: continuePrompt };
+}
+// ── Subcommands ───────────────────────────────────────────────
+const statusCommand = {
+    name: 'status',
+    description: 'Show autopilot state, iterations, and task progress',
+    options: [{ name: 'json', type: 'boolean', description: 'Output as JSON' }],
+    action: async (ctx) => {
+        const state = loadState();
+        const tasks = discoverTasks(state.taskSources);
+        const progress = getProgress(tasks);
+        const elapsed = state.enabled ? Date.now() - state.startTime : 0;
+        if (ctx.flags?.json) {
+            output.printJson({
+                enabled: state.enabled, sessionId: state.sessionId, iterations: state.iterations,
+                maxIterations: state.maxIterations, timeoutMinutes: state.timeoutMinutes, elapsedMs: elapsed,
+                tasks: { completed: progress.completed, total: progress.total, percent: progress.percent },
+                taskSources: state.taskSources,
+            });
+            return { success: true };
+        }
+        output.writeln(`Autopilot: ${state.enabled ? '✓ ENABLED' : '✗ DISABLED'}`);
+        output.writeln(`Session: ${state.sessionId.slice(0, 8)}...`);
+        output.writeln(`Iterations: ${state.iterations}/${state.maxIterations}`);
+        output.writeln(`Timeout: ${state.timeoutMinutes} min`);
+        output.writeln(`Elapsed: ${Math.round(elapsed / 60000)} min`);
+        output.writeln(`Tasks: ${progress.completed}/${progress.total} (${progress.percent}%)`);
+        output.writeln(`Sources: ${state.taskSources.join(', ')}`);
+        if (progress.incomplete.length > 0 && progress.incomplete.length <= 10) {
+            output.writeln('\nRemaining tasks:');
+            for (const t of progress.incomplete) {
+                output.writeln(`  - [${t.source}] ${t.subject} (${t.status})`);
+            }
+        }
+        return { success: true };
+    },
+};
+const enableCommand = {
+    name: 'enable',
+    description: 'Enable persistent completion',
+    action: async () => {
+        const state = loadState();
+        state.enabled = true;
+        state.startTime = Date.now();
+        state.iterations = 0;
+        saveState(state);
+        appendLog({ ts: Date.now(), event: 'enabled', sessionId: state.sessionId, maxIterations: state.maxIterations });
+        output.writeln(output.success(`Autopilot enabled (max ${state.maxIterations} iterations, ${state.timeoutMinutes} min timeout)`));
+        return { success: true };
+    },
+};
+const disableCommand = {
+    name: 'disable',
+    description: 'Disable re-engagement loop',
+    action: async () => {
+        const state = loadState();
+        const wasEnabled = state.enabled;
+        state.enabled = false;
+        saveState(state);
+        if (wasEnabled)
+            appendLog({ ts: Date.now(), event: 'disabled', iterations: state.iterations });
+        output.writeln('Autopilot disabled');
+        return { success: true };
+    },
+};
+const configCommand = {
+    name: 'config',
+    description: 'Configure max iterations, timeout, and task sources',
+    options: [
+        { name: 'max-iterations', type: 'string', description: 'Max re-engagement iterations (1-1000)' },
+        { name: 'timeout', type: 'string', description: 'Timeout in minutes (1-1440)' },
+        { name: 'task-sources', type: 'string', description: 'Comma-separated task sources' },
+    ],
+    action: async (ctx) => {
+        const state = loadState();
+        const maxIter = ctx.flags?.['max-iterations'];
+        const timeout = ctx.flags?.timeout;
+        const sources = ctx.flags?.['task-sources'];
+        if (maxIter)
+            state.maxIterations = validateNumber(maxIter, 1, 1000, state.maxIterations);
+        if (timeout)
+            state.timeoutMinutes = validateNumber(timeout, 1, 1440, state.timeoutMinutes);
+        if (sources)
+            state.taskSources = validateTaskSources(sources.split(',').map(s => s.trim()).filter(Boolean));
+        saveState(state);
+        appendLog({ ts: Date.now(), event: 'config-updated', maxIterations: state.maxIterations, timeoutMinutes: state.timeoutMinutes, taskSources: state.taskSources });
+        output.writeln(`Config updated: maxIterations=${state.maxIterations}, timeout=${state.timeoutMinutes}min, sources=${state.taskSources.join(',')}`);
+        return { success: true };
+    },
+};
+const resetCommand = {
+    name: 'reset',
+    description: 'Reset iteration counter and timer',
+    action: async () => {
+        const state = loadState();
+        state.iterations = 0;
+        state.startTime = Date.now();
+        state.history = [];
+        state.lastCheck = null;
+        saveState(state);
+        appendLog({ ts: Date.now(), event: 'reset' });
+        output.writeln('Autopilot state reset (iterations=0, timer restarted)');
+        return { success: true };
+    },
+};
+const logCommand = {
+    name: 'log',
+    description: 'View autopilot event log',
+    options: [
+        { name: 'last', type: 'string', description: 'Show last N entries' },
+        { name: 'json', type: 'boolean', description: 'Output as JSON' },
+        { name: 'clear', type: 'boolean', description: 'Clear the log' },
+    ],
+    action: async (ctx) => {
+        if (ctx.flags?.clear) {
+            const fs = require('fs');
+            const path = require('path');
+            try {
+                fs.writeFileSync(path.resolve(LOG_FILE), '[]');
+            }
+            catch { /* ignore */ }
+            output.writeln('Autopilot log cleared');
+            return { success: true };
+        }
+        const log = loadLog();
+        const lastRaw = ctx.flags?.last;
+        const last = lastRaw ? validateNumber(lastRaw, 1, 10000, 50) : undefined;
+        const entries = last ? log.slice(-last) : log;
+        if (ctx.flags?.json) {
+            output.printJson(entries);
+            return { success: true };
+        }
+        if (entries.length === 0) {
+            output.writeln('No autopilot events logged');
+            return { success: true };
+        }
+        for (const e of entries) {
+            const time = new Date(e.ts).toISOString().slice(11, 19);
+            const details = Object.entries(e).filter(([k]) => k !== 'ts' && k !== 'event').map(([k, v]) => `${k}=${v}`).join(' ');
+            output.writeln(`[${time}] ${e.event} ${details}`);
+        }
+        return { success: true };
+    },
+};
+const learnCommand = {
+    name: 'learn',
+    description: 'Discover success patterns from past completions',
+    options: [{ name: 'json', type: 'boolean', description: 'Output as JSON' }],
+    action: async (ctx) => {
+        const learning = await tryLoadLearning();
+        if (!learning) {
+            output.writeln('Learning not available (AgentDB not initialized). Autopilot still works for task completion tracking.');
+            return { success: true };
+        }
+        const metrics = await learning.getMetrics();
+        const patterns = await learning.discoverSuccessPatterns();
+        if (ctx.flags?.json) {
+            output.printJson({ metrics, patterns });
+            return { success: true };
+        }
+        output.writeln(`Episodes: ${metrics.episodes}`);
+        output.writeln(`Patterns: ${metrics.patterns}`);
+        output.writeln(`Trajectories: ${metrics.trajectories}`);
+        if (patterns.length > 0) {
+            output.writeln('\nDiscovered patterns:');
+            for (const p of patterns) {
+                output.writeln(`  - ${p.pattern} (freq: ${p.frequency}, reward: ${p.avgReward.toFixed(2)})`);
+            }
+        }
+        return { success: true };
+    },
+};
+const historyCommand = {
+    name: 'history',
+    description: 'Search past completion episodes',
+    options: [
+        { name: 'query', type: 'string', description: 'Search query', required: true },
+        { name: 'limit', type: 'string', description: 'Max results (default 10)' },
+        { name: 'json', type: 'boolean', description: 'Output as JSON' },
+    ],
+    action: async (ctx) => {
+        const query = (ctx.flags?.query || '');
+        const limit = validateNumber(ctx.flags?.limit, 1, 100, 10);
+        if (!query) {
+            output.writeln('Usage: autopilot history --query "search terms" [--limit N]');
+            return { success: false, message: 'Missing --query' };
+        }
+        const learning = await tryLoadLearning();
+        if (!learning) {
+            output.writeln('Learning not available. No history to search.');
+            return { success: true };
+        }
+        const results = await learning.recallSimilarTasks(query, limit);
+        if (ctx.flags?.json) {
+            output.printJson(results);
+        }
+        else if (results.length === 0) {
+            output.writeln(`No matching episodes for: "${query}"`);
+        }
+        else {
+            output.printJson(results);
+        }
+        return { success: true };
+    },
+};
+const predictCommand = {
+    name: 'predict',
+    description: 'Predict optimal next action',
+    options: [{ name: 'json', type: 'boolean', description: 'Output as JSON' }],
+    action: async (ctx) => {
+        const state = loadState();
+        const learning = await tryLoadLearning();
+        if (learning) {
+            const prediction = await learning.predictNextAction(state);
+            if (ctx.flags?.json) {
+                output.printJson(prediction);
+            }
+            else {
+                output.writeln(`Action: ${prediction?.action || 'unknown'}`);
+                output.writeln(`Confidence: ${prediction?.confidence || 0}`);
+                if (prediction?.alternatives?.length > 0)
+                    output.writeln(`Alternatives: ${prediction.alternatives.join(', ')}`);
+            }
+            return { success: true };
+        }
+        // Heuristic fallback
+        const tasks = discoverTasks(state.taskSources);
+        const progress = getProgress(tasks);
+        if (progress.incomplete.length === 0) {
+            output.writeln('All tasks complete. No action needed.');
+            return { success: true };
+        }
+        const next = progress.incomplete[0];
+        const result = { action: `Work on: ${next.subject}`, confidence: 0.5, remaining: progress.incomplete.length };
+        if (ctx.flags?.json) {
+            output.printJson(result);
+        }
+        else {
+            output.writeln(`Action: ${result.action}`);
+            output.writeln(`Confidence: ${result.confidence} (heuristic — learning not available)`);
+            output.writeln(`Remaining: ${result.remaining} tasks`);
+        }
+        return { success: true };
+    },
+};
+const checkCommand = {
+    name: 'check',
+    description: 'Run completion check (used by stop hook)',
+    options: [{ name: 'json', type: 'boolean', description: 'Output as JSON' }],
+    action: async (ctx) => {
+        const result = await autopilotCheck();
+        if (ctx.flags?.json) {
+            output.printJson(result);
+        }
+        else {
+            output.writeln(`${result.allowStop ? 'ALLOW STOP' : 'CONTINUE'}: ${result.reason}`);
+        }
+        return { success: true };
+    },
+};
+// ── Main Command ──────────────────────────────────────────────
+export const autopilotCommand = {
+    name: 'autopilot',
+    description: 'Persistent swarm completion — keeps agents working until ALL tasks are done',
+    aliases: ['ap'],
+    subcommands: [statusCommand, enableCommand, disableCommand, configCommand, resetCommand, logCommand, learnCommand, historyCommand, predictCommand, checkCommand],
+    examples: [
+        { command: 'claude-flow autopilot status', description: 'Show current state and progress' },
+        { command: 'claude-flow autopilot enable', description: 'Enable persistent completion' },
+        { command: 'claude-flow autopilot config --max-iterations 100 --timeout 180', description: 'Configure limits' },
+        { command: 'claude-flow autopilot predict', description: 'Get recommended next action' },
+    ],
+    action: async () => {
+        output.writeln(output.bold('Autopilot — Persistent Swarm Completion'));
+        output.writeln(output.dim('Keeps agents working until ALL tasks are done'));
+        output.writeln();
+        output.printList([
+            'status    — Show state, iterations, and task progress',
+            'enable    — Enable persistent completion',
+            'disable   — Disable re-engagement loop',
+            'config    — Configure max iterations, timeout, sources',
+            'reset     — Reset iteration counter and timer',
+            'log       — View autopilot event log',
+            'learn     — Discover success patterns',
+            'history   — Search past completion episodes',
+            'predict   — Predict optimal next action',
+            'check     — Run completion check (stop hook)',
+        ]);
+        return { success: true };
+    },
+};
+export default autopilotCommand;
+//# sourceMappingURL=autopilot.js.map

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

@@ -30,6 +30,7 @@ export { hiveMindCommand } from './hive-mind.js';
 export { guidanceCommand } from './guidance.js';
 export { applianceCommand } from './appliance.js';
 export { cleanupCommand } from './cleanup.js';
+export { autopilotCommand } from './autopilot.js';
 export declare function getConfigCommand(): Promise<Command | undefined>;
 export declare function getMigrateCommand(): Promise<Command | undefined>;
 export declare function getWorkflowCommand(): Promise<Command | undefined>;
@@ -54,6 +55,7 @@ export declare function getRuvectorCommand(): Promise<Command | undefined>;
 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>;
 /**
  * Core commands loaded synchronously (available immediately)
  * Advanced commands loaded on-demand for faster startup

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

@@ -64,6 +64,7 @@ const commandLoaders = {
     'appliance-advanced': () => import('./appliance-advanced.js'),
     'transfer-store': () => import('./transfer-store.js'),
     cleanup: () => import('./cleanup.js'),
+    autopilot: () => import('./autopilot.js'),
 };
 // Cache for loaded commands
 const loadedCommands = new Map();
@@ -134,6 +135,7 @@ import { processCommand } from './process.js';
 import { guidanceCommand } from './guidance.js';
 import { applianceCommand } from './appliance.js';
 import { cleanupCommand } from './cleanup.js';
+import { autopilotCommand } from './autopilot.js';
 // Pre-populate cache with core commands
 loadedCommands.set('init', initCommand);
 loadedCommands.set('start', startCommand);
@@ -155,6 +157,7 @@ loadedCommands.set('ruvector', ruvectorCommand);
 loadedCommands.set('hive-mind', hiveMindCommand);
 loadedCommands.set('guidance', guidanceCommand);
 loadedCommands.set('cleanup', cleanupCommand);
+loadedCommands.set('autopilot', autopilotCommand);
 // =============================================================================
 // Exports (maintain backwards compatibility)
 // =============================================================================
@@ -180,6 +183,7 @@ export { hiveMindCommand } from './hive-mind.js';
 export { guidanceCommand } from './guidance.js';
 export { applianceCommand } from './appliance.js';
 export { cleanupCommand } from './cleanup.js';
+export { autopilotCommand } from './autopilot.js';
 // Lazy-loaded command re-exports (for backwards compatibility, but async-only)
 export async function getConfigCommand() { return loadCommand('config'); }
 export async function getMigrateCommand() { return loadCommand('migrate'); }
@@ -205,6 +209,7 @@ export async function getRuvectorCommand() { return loadCommand('ruvector'); }
 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'); }
 /**
  * Core commands loaded synchronously (available immediately)
  * Advanced commands loaded on-demand for faster startup
@@ -231,6 +236,7 @@ export const commands = [
     hiveMindCommand,
     guidanceCommand,
     cleanupCommand,
+    autopilotCommand,
 ];
 /**
  * Commands organized by category for help display
@@ -256,6 +262,7 @@ export const commandsByCategory = {
         hiveMindCommand,
         ruvectorCommand,
         guidanceCommand,
+        autopilotCommand,
     ],
     utility: [
         configCommand,

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

@@ -99,26 +99,15 @@ export function generateSettings(options) {
             enabled: options.runtime.enableNeural,
         },
         daemon: {
-            autoStart: true,
+            autoStart: false, // Opt-in only — prevents unintended token consumption (#1427, #1330)
             workers: [
                 'map', // Codebase mapping
                 'audit', // Security auditing (critical priority)
                 'optimize', // Performance optimization (high priority)
-                'consolidate', // Memory consolidation
-                'testgaps', // Test coverage gaps
-                'ultralearn', // Deep knowledge acquisition
-                'deepdive', // Deep code analysis
-                'document', // Auto-documentation for ADRs
-                'refactor', // Refactoring suggestions (DDD alignment)
-                'benchmark', // Performance benchmarking
             ],
             schedules: {
-                audit: { interval: '1h', priority: 'critical' },
-                optimize: { interval: '30m', priority: 'high' },
-                consolidate: { interval: '2h', priority: 'low' },
-                document: { interval: '1h', priority: 'normal', triggers: ['adr-update', 'api-change'] },
-                deepdive: { interval: '4h', priority: 'normal', triggers: ['complex-change'] },
-                ultralearn: { interval: '1h', priority: 'normal' },
+                audit: { interval: '4h', priority: 'critical' },
+                optimize: { interval: '2h', priority: 'high' },
             },
         },
         learning: {

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

@@ -38,6 +38,7 @@ import { agentdbTools } from './mcp-tools/agentdb-tools.js';
 import { ruvllmWasmTools } from './mcp-tools/ruvllm-tools.js';
 import { wasmAgentTools } from './mcp-tools/wasm-agent-tools.js';
 import { guidanceTools } from './mcp-tools/guidance-tools.js';
+import { autopilotTools } from './mcp-tools/autopilot-tools.js';
 /**
  * MCP Tool Registry
  * Maps tool names to their handler functions
@@ -82,6 +83,8 @@ registerTools([
     ...wasmAgentTools,
     // Guidance & discovery tools
     ...guidanceTools,
+    // Autopilot persistent completion tools
+    ...autopilotTools,
 ]);
 /**
  * MCP Client Error

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

@@ -0,0 +1,12 @@
+/**
+ * Autopilot MCP Tools
+ *
+ * 10 MCP tools for persistent swarm completion management.
+ * Allows programmatic control of the autopilot loop via MCP.
+ *
+ * ADR-072: Autopilot Integration
+ * @module @claude-flow/cli/mcp-tools/autopilot
+ */
+import type { MCPTool } from './types.js';
+export declare const autopilotTools: MCPTool[];
+//# sourceMappingURL=autopilot-tools.d.ts.map

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

@@ -0,0 +1,227 @@
+/**
+ * Autopilot MCP Tools
+ *
+ * 10 MCP tools for persistent swarm completion management.
+ * Allows programmatic control of the autopilot loop via MCP.
+ *
+ * ADR-072: Autopilot Integration
+ * @module @claude-flow/cli/mcp-tools/autopilot
+ */
+import { loadState, saveState, appendLog, loadLog, discoverTasks, isTerminal, tryLoadLearning, validateNumber, validateTaskSources, VALID_TASK_SOURCES, } from '../autopilot-state.js';
+function ok(data) {
+    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+}
+// ── MCP Tool Definitions ──────────────────────────────────────
+const autopilotStatus = {
+    name: 'autopilot_status',
+    description: 'Get autopilot state including enabled status, iteration count, task progress, and learning metrics.',
+    category: 'autopilot',
+    inputSchema: { type: 'object', properties: {} },
+    handler: async () => {
+        const state = loadState();
+        const tasks = discoverTasks(state.taskSources);
+        const completed = tasks.filter(t => isTerminal(t.status)).length;
+        return ok({
+            enabled: state.enabled,
+            sessionId: state.sessionId,
+            iterations: state.iterations,
+            maxIterations: state.maxIterations,
+            timeoutMinutes: state.timeoutMinutes,
+            elapsedMs: state.enabled ? Date.now() - state.startTime : 0,
+            tasks: { completed, total: tasks.length, percent: tasks.length === 0 ? 100 : Math.round((completed / tasks.length) * 100) },
+            taskSources: state.taskSources,
+        });
+    },
+};
+const autopilotEnable = {
+    name: 'autopilot_enable',
+    description: 'Enable autopilot persistent completion. Agents will be re-engaged when tasks remain incomplete.',
+    category: 'autopilot',
+    inputSchema: { type: 'object', properties: {} },
+    handler: async () => {
+        const state = loadState();
+        state.enabled = true;
+        state.startTime = Date.now();
+        state.iterations = 0;
+        saveState(state);
+        appendLog({ ts: Date.now(), event: 'enabled', sessionId: state.sessionId });
+        return ok({ enabled: true, maxIterations: state.maxIterations, timeoutMinutes: state.timeoutMinutes });
+    },
+};
+const autopilotDisable = {
+    name: 'autopilot_disable',
+    description: 'Disable autopilot. Agents will be allowed to stop even if tasks remain.',
+    category: 'autopilot',
+    inputSchema: { type: 'object', properties: {} },
+    handler: async () => {
+        const state = loadState();
+        state.enabled = false;
+        saveState(state);
+        appendLog({ ts: Date.now(), event: 'disabled', iterations: state.iterations });
+        return ok({ enabled: false });
+    },
+};
+const autopilotConfig = {
+    name: 'autopilot_config',
+    description: 'Configure autopilot limits: max iterations (1-1000), timeout in minutes (1-1440), and task sources.',
+    category: 'autopilot',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            maxIterations: { type: 'number', description: 'Max re-engagement iterations (1-1000)' },
+            timeoutMinutes: { type: 'number', description: 'Timeout in minutes (1-1440)' },
+            taskSources: { type: 'array', items: { type: 'string' }, description: `Task sources: ${[...VALID_TASK_SOURCES].join(', ')}` },
+        },
+    },
+    handler: async (params) => {
+        const state = loadState();
+        if (params.maxIterations !== undefined) {
+            state.maxIterations = validateNumber(params.maxIterations, 1, 1000, state.maxIterations);
+        }
+        if (params.timeoutMinutes !== undefined) {
+            state.timeoutMinutes = validateNumber(params.timeoutMinutes, 1, 1440, state.timeoutMinutes);
+        }
+        if (params.taskSources !== undefined) {
+            state.taskSources = validateTaskSources(params.taskSources);
+        }
+        saveState(state);
+        return ok({ maxIterations: state.maxIterations, timeoutMinutes: state.timeoutMinutes, taskSources: state.taskSources });
+    },
+};
+const autopilotReset = {
+    name: 'autopilot_reset',
+    description: 'Reset autopilot iteration counter and restart the timer.',
+    category: 'autopilot',
+    inputSchema: { type: 'object', properties: {} },
+    handler: async () => {
+        const state = loadState();
+        state.iterations = 0;
+        state.startTime = Date.now();
+        state.history = [];
+        state.lastCheck = null;
+        saveState(state);
+        appendLog({ ts: Date.now(), event: 'reset' });
+        return ok({ reset: true, iterations: 0 });
+    },
+};
+const autopilotLog = {
+    name: 'autopilot_log',
+    description: 'Retrieve the autopilot event log. Shows enable/disable events, re-engagements, completions.',
+    category: 'autopilot',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            last: { type: 'number', description: 'Return only the last N entries' },
+        },
+    },
+    handler: async (params) => {
+        const log = loadLog();
+        const last = validateNumber(params.last, 1, 10000, 0);
+        return ok(last > 0 ? log.slice(-last) : log);
+    },
+};
+const autopilotProgress = {
+    name: 'autopilot_progress',
+    description: 'Detailed task progress broken down by source (team-tasks, swarm-tasks, file-checklist).',
+    category: 'autopilot',
+    inputSchema: { type: 'object', properties: {} },
+    handler: async () => {
+        const state = loadState();
+        const tasks = discoverTasks(state.taskSources);
+        const bySource = {};
+        for (const t of tasks) {
+            if (!bySource[t.source])
+                bySource[t.source] = { completed: 0, total: 0, tasks: [] };
+            bySource[t.source].total++;
+            if (isTerminal(t.status)) {
+                bySource[t.source].completed++;
+            }
+            bySource[t.source].tasks.push(t);
+        }
+        const completed = tasks.filter(t => isTerminal(t.status)).length;
+        return ok({
+            overall: { completed, total: tasks.length, percent: tasks.length === 0 ? 100 : Math.round((completed / tasks.length) * 100) },
+            bySource,
+        });
+    },
+};
+const autopilotLearn = {
+    name: 'autopilot_learn',
+    description: 'Discover success patterns from past task completions. Requires AgentDB for full functionality.',
+    category: 'autopilot',
+    inputSchema: { type: 'object', properties: {} },
+    handler: async () => {
+        const learning = await tryLoadLearning();
+        if (learning) {
+            const [metrics, patterns] = await Promise.all([
+                learning.getMetrics(),
+                learning.discoverSuccessPatterns(),
+            ]);
+            return ok({ metrics, patterns });
+        }
+        return ok({ available: false, reason: 'AgentDB/AutopilotLearning not initialized', patterns: [] });
+    },
+};
+const autopilotHistory = {
+    name: 'autopilot_history',
+    description: 'Search past completion episodes by keyword. Requires AgentDB.',
+    category: 'autopilot',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Search query' },
+            limit: { type: 'number', description: 'Max results (default 10)' },
+        },
+        required: ['query'],
+    },
+    handler: async (params) => {
+        const query = String(params.query || '');
+        const limit = validateNumber(params.limit, 1, 100, 10);
+        const learning = await tryLoadLearning();
+        if (learning) {
+            const results = await learning.recallSimilarTasks(query, limit);
+            return ok({ query, results });
+        }
+        return ok({ query, results: [], available: false });
+    },
+};
+const autopilotPredict = {
+    name: 'autopilot_predict',
+    description: 'Predict the optimal next action based on current state and learned patterns.',
+    category: 'autopilot',
+    inputSchema: { type: 'object', properties: {} },
+    handler: async () => {
+        const state = loadState();
+        const learning = await tryLoadLearning();
+        if (learning) {
+            const prediction = await learning.predictNextAction(state);
+            return ok(prediction);
+        }
+        // Heuristic fallback
+        const tasks = discoverTasks(state.taskSources);
+        const incomplete = tasks.filter(t => !isTerminal(t.status));
+        if (incomplete.length === 0) {
+            return ok({ action: 'none', confidence: 1.0, reason: 'All tasks complete' });
+        }
+        return ok({
+            action: `Work on: ${incomplete[0].subject}`,
+            confidence: 0.5,
+            reason: 'Heuristic (learning not available)',
+            remaining: incomplete.length,
+        });
+    },
+};
+// ── Export ─────────────────────────────────────────────────────
+export const autopilotTools = [
+    autopilotStatus,
+    autopilotEnable,
+    autopilotDisable,
+    autopilotConfig,
+    autopilotReset,
+    autopilotLog,
+    autopilotProgress,
+    autopilotLearn,
+    autopilotHistory,
+    autopilotPredict,
+];
+//# sourceMappingURL=autopilot-tools.js.map

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

@@ -1376,13 +1376,13 @@ export const hooksSessionStart = {
         properties: {
             sessionId: { type: 'string', description: 'Optional session ID' },
             restoreLatest: { type: 'boolean', description: 'Restore latest session state' },
-            startDaemon: { type: 'boolean', description: 'Auto-start worker daemon (default: true)' },
+            startDaemon: { type: 'boolean', description: 'Start worker daemon (default: false — opt-in to prevent unintended token usage)' },
         },
     },
     handler: async (params) => {
         const sessionId = params.sessionId || `session-${Date.now()}`;
         const restoreLatest = params.restoreLatest;
-        const shouldStartDaemon = params.startDaemon !== false;
+        const shouldStartDaemon = params.startDaemon === true;
         // Auto-start daemon if enabled
         let daemonStatus = { started: false };
         if (shouldStartDaemon) {

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

@@ -23,4 +23,5 @@ export { claimsTools } from './claims-tools.js';
 export { wasmAgentTools } from './wasm-agent-tools.js';
 export { ruvllmWasmTools } from './ruvllm-tools.js';
 export { guidanceTools } from './guidance-tools.js';
+export { autopilotTools } from './autopilot-tools.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -22,4 +22,5 @@ export { claimsTools } from './claims-tools.js';
 export { wasmAgentTools } from './wasm-agent-tools.js';
 export { ruvllmWasmTools } from './ruvllm-tools.js';
 export { guidanceTools } from './guidance-tools.js';
+export { autopilotTools } from './autopilot-tools.js';
 //# sourceMappingURL=index.js.map

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.5.44",
+  "version": "3.5.46",
   "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",
@@ -94,7 +94,7 @@
     "@claude-flow/codex": "^3.0.0-alpha.8",
     "@claude-flow/embeddings": "^3.0.0-alpha.12",
     "@claude-flow/guidance": "^3.0.0-alpha.1",
-    "@claude-flow/memory": "^3.0.0-alpha.11",
+    "@claude-flow/memory": "^3.0.0-alpha.12",
     "@claude-flow/plugin-gastown-bridge": "^0.1.3",
     "agentic-flow": "^3.0.0-alpha.1",
     "@ruvector/attention": "^0.1.4",