@claude-flow/cli 3.32.3 → 3.32.4

package/dist/src/commands/auth.js

@@ -0,0 +1,244 @@
+/**
+ * `ruflo auth` — Cognitum identity (ADR-306).
+ *
+ * `login` obtains OAuth tokens via the loopback PKCE flow (default,
+ * interactive desktop), the OOB manual-paste flow (`--no-browser`, or
+ * auto-detected headless environments), or `--token-stdin` (CI/enterprise
+ * automation — refuses interactively otherwise, per ADR-306). The refresh
+ * token goes to the OS keychain when reachable, or nowhere (session-only —
+ * a deliberate usability cost, not a bug) when it isn't. The access token
+ * itself is NEVER written to disk; see src/auth/session.ts.
+ */
+import { output } from '../output.js';
+import { isCI, isInteractive, hasConsent, recordConsent, revokeConsent } from '../funnel/index.js';
+import { browserLogin, manualLogin, tokenStdinLogin, isProbablyHeadless, LoginCancelledError, LoginDeniedError, StateMismatchError, } from '../auth/client.js';
+import { loadSecurityOAuth, SecurityPackageMissingError } from '../auth/security-bridge.js';
+import { setProfile, removeProfile, listProfiles, clearAllProfiles, DEFAULT_PROFILE } from '../auth/state.js';
+import { setSessionToken, clearSessionToken } from '../auth/session.js';
+import { INITIAL_SCOPE, domainForScope } from '../auth/scopes.js';
+import { KEYCHAIN_SERVICE } from '../auth/constants.js';
+import { getValidAccessToken, NotLoggedInError, SessionOnlyExpiredError } from '../auth/client.js';
+import { removeInjectedToken } from '../proxy/token-bridge.js';
+function nowIso() {
+    return new Date().toISOString();
+}
+async function persistLogin(profileName, tokens, method) {
+    const expiresInSec = tokens.expires_in ?? 0;
+    const expiresAtMs = Date.now() + expiresInSec * 1000;
+    setSessionToken(profileName, tokens.access_token, expiresAtMs);
+    let keychainRef = null;
+    if (tokens.refresh_token) {
+        const sec = await loadSecurityOAuth();
+        const keychain = await sec.createKeychainAdapter();
+        if (await keychain.isAvailable()) {
+            await keychain.setSecret(KEYCHAIN_SERVICE, profileName, tokens.refresh_token);
+            keychainRef = profileName;
+        }
+        // else: session-only — the refresh token is simply not persisted anywhere.
+    }
+    const state = {
+        accountId: tokens.account_email ?? 'unknown',
+        scopes: [INITIAL_SCOPE],
+        accessTokenExpiresAt: new Date(expiresAtMs).toISOString(),
+        keychainRef,
+        profile: profileName,
+        loginMethod: method,
+        linkedAt: nowIso(),
+    };
+    setProfile(profileName, state);
+    recordConsent('account', true, 'auth-login');
+    return state;
+}
+function refuseNonInteractive(hasTokenStdin) {
+    if (hasTokenStdin)
+        return null;
+    if (isInteractive() && !isCI())
+        return null;
+    // The CLI harness only acts on exitCode — it never auto-prints
+    // CommandResult.message, so this path must print for itself.
+    const message = 'ruflo auth login refuses to run interactively in a non-TTY/CI environment. ' +
+        'Use --token-stdin for automation (reads {"access_token",...} JSON from stdin).';
+    output.printError(message);
+    return { success: false, message, exitCode: 1 };
+}
+const loginCommand = {
+    name: 'login',
+    description: 'Sign in to Cognitum (PKCE browser flow, OOB manual flow, or --token-stdin)',
+    options: [
+        { name: 'profile', description: 'Named profile to store this login under', type: 'string', default: DEFAULT_PROFILE },
+        { name: 'no-browser', description: 'Force the headless OOB copy-paste flow', type: 'boolean', default: false },
+        { name: 'token-stdin', description: 'Read a pre-obtained token as JSON from stdin (CI/automation)', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        const profileName = typeof ctx.flags.profile === 'string' ? ctx.flags.profile : DEFAULT_PROFILE;
+        // Parser camelCases kebab-case flag names — read via tokenStdin/noBrowser,
+        // not ['token-stdin']/['no-browser'] (see doctor.ts's fixHandles comment).
+        const tokenStdin = Boolean(ctx.flags.tokenStdin ?? ctx.flags['token-stdin']);
+        const noBrowser = Boolean(ctx.flags.noBrowser ?? ctx.flags['no-browser']);
+        const refusal = refuseNonInteractive(tokenStdin);
+        if (refusal)
+            return refusal;
+        try {
+            const result = tokenStdin
+                ? await tokenStdinLogin()
+                : noBrowser || isProbablyHeadless()
+                    ? await manualLogin((line) => output.writeln(line))
+                    : await browserLogin((line) => output.writeln(line));
+            const state = await persistLogin(profileName, result.tokens, result.method);
+            output.printSuccess(`Logged in as ${state.accountId} (profile: ${profileName})`);
+            output.writeln(state.keychainRef
+                ? '  refresh token: stored in the OS keychain'
+                : '  refresh token: NOT stored (no keychain backend reachable) — session-only, you will need to log in again next time');
+            return { success: true, data: { profile: profileName, accountId: state.accountId } };
+        }
+        catch (e) {
+            if (e instanceof SecurityPackageMissingError || e instanceof LoginCancelledError || e instanceof LoginDeniedError || e instanceof StateMismatchError) {
+                output.printError(e.message);
+                return { success: false, message: e.message, exitCode: 1 };
+            }
+            const message = e instanceof Error ? e.message : String(e);
+            output.printError('Sign-in failed', message);
+            return { success: false, message, exitCode: 1 };
+        }
+    },
+};
+const logoutCommand = {
+    name: 'logout',
+    description: 'Sign out — clears the local session, keychain entry, and account consent',
+    options: [
+        { name: 'profile', description: 'Profile to log out of', type: 'string', default: DEFAULT_PROFILE },
+        { name: 'all', description: 'Log out of every profile', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        removeInjectedToken();
+        const all = ctx.flags.all === true;
+        const profileName = typeof ctx.flags.profile === 'string' ? ctx.flags.profile : DEFAULT_PROFILE;
+        const { profiles } = listProfiles();
+        if (profiles.length === 0) {
+            output.writeln('Nothing to log out of — no profile is signed in.');
+            return { success: true, data: { hadSession: false } };
+        }
+        const toClear = all ? profiles : profiles.filter((p) => p.profile === profileName);
+        if (toClear.length === 0) {
+            output.writeln(`No such profile: ${profileName}`);
+            return { success: false, exitCode: 1 };
+        }
+        let sec;
+        try {
+            sec = await loadSecurityOAuth();
+        }
+        catch {
+            sec = null; // best-effort keychain cleanup — logout must still succeed locally
+        }
+        for (const p of toClear) {
+            clearSessionToken(p.profile);
+            if (p.keychainRef && sec) {
+                const keychain = await sec.createKeychainAdapter();
+                await keychain.deleteSecret(KEYCHAIN_SERVICE, p.keychainRef).catch(() => { });
+            }
+            removeProfile(p.profile);
+        }
+        if (all) {
+            clearAllProfiles();
+            revokeConsent('account', 'auth-logout');
+        }
+        else if (listProfiles().profiles.length === 0) {
+            revokeConsent('account', 'auth-logout');
+        }
+        output.printSuccess(all ? 'Logged out of all profiles.' : `Logged out of profile "${profileName}".`);
+        output.writeln('  Note: this only forgets the local copy. Cognitum does not currently expose a token ' +
+            'revocation endpoint for this flow, matching the same known limitation meta-proxy documents ' +
+            'for its own logout — revoke server-side access from the Cognitum dashboard if needed.');
+        return { success: true, data: { hadSession: true } };
+    },
+};
+const statusCommand = {
+    name: 'status',
+    description: 'Show signed-in profile(s), scopes, and expiry',
+    options: [
+        { name: 'profile', description: 'Show only this profile', type: 'string' },
+        { name: 'json', description: 'Machine-readable output', type: 'boolean', default: false },
+        {
+            name: 'check',
+            description: 'Validate credentials now; silently refresh from the OS keychain when needed',
+            type: 'boolean',
+            default: false,
+        },
+    ],
+    action: async (ctx) => {
+        const { defaultProfile, profiles } = listProfiles();
+        const filterName = typeof ctx.flags.profile === 'string' ? ctx.flags.profile : undefined;
+        const shown = filterName ? profiles.filter((p) => p.profile === filterName) : profiles;
+        if (shown.length === 0) {
+            const message = filterName ? `No such profile: ${filterName}` : 'Not logged in. Run: ruflo auth login';
+            if (ctx.flags.json) {
+                output.printJson({ profiles: [] });
+            }
+            else {
+                output.writeln(message);
+            }
+            return { success: true, data: { profiles: [] } };
+        }
+        const withConsistency = shown.map((p) => {
+            const missingConsent = p.scopes.filter((scope) => {
+                const domain = domainForScope(scope);
+                return domain !== undefined && !hasConsent(domain);
+            });
+            return { ...p, isDefault: p.profile === defaultProfile, missingConsent };
+        });
+        const checked = await Promise.all(withConsistency.map(async (p) => {
+            if (!ctx.flags.check)
+                return { ...p, credentialStatus: 'not-checked' };
+            try {
+                await getValidAccessToken(p.profile);
+                return { ...p, credentialStatus: 'valid' };
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                return {
+                    ...p,
+                    credentialStatus: e instanceof NotLoggedInError || e instanceof SessionOnlyExpiredError
+                        ? 'login-required'
+                        : 'unavailable',
+                    credentialError: message,
+                };
+            }
+        }));
+        if (ctx.flags.json) {
+            output.printJson({ profiles: checked });
+            return { success: true, data: { profiles: checked } };
+        }
+        for (const p of checked) {
+            output.writeln(`Profile: ${p.profile}${p.isDefault ? ' (default)' : ''}`);
+            output.writeln(`  account: ${p.accountId}`);
+            output.writeln(`  scopes: ${p.scopes.join(', ')}`);
+            output.writeln(`  access token expires: ${p.accessTokenExpiresAt}`);
+            output.writeln(`  refresh token: ${p.keychainRef ? 'in OS keychain' : 'session-only (not persisted)'}`);
+            if (ctx.flags.check) {
+                output.writeln(`  credential check: ${p.credentialStatus}`);
+                if ('credentialError' in p && p.credentialError)
+                    output.writeln(`    ${p.credentialError}`);
+            }
+            if (p.missingConsent.length > 0) {
+                output.printError(`  scope-vs-consent mismatch: ${p.missingConsent.join(', ')} granted without a matching consent receipt`);
+            }
+            output.writeln('');
+        }
+        return { success: true, data: { profiles: checked } };
+    },
+};
+export const authCommand = {
+    name: 'auth',
+    description: 'Cognitum identity — login, logout, status (ADR-306)',
+    subcommands: [loginCommand, logoutCommand, statusCommand],
+    examples: [
+        { command: 'ruflo auth login', description: 'Sign in via the browser PKCE flow' },
+        { command: 'ruflo auth login --no-browser', description: 'Sign in via the headless OOB copy-paste flow' },
+        { command: 'ruflo auth status', description: 'Show signed-in profile(s)' },
+        { command: 'ruflo auth status --check', description: 'Validate or silently refresh credentials now' },
+        { command: 'ruflo auth logout', description: 'Sign out of the default profile' },
+    ],
+    action: statusCommand.action,
+};
+export default authCommand;
+//# sourceMappingURL=auth.js.map

package/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/dist/src/commands/autopilot.js

@@ -0,0 +1,407 @@
+/**
+ * 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';
+import { getCheckpointGate, CheckpointGate } from '../services/checkpoint-gate.js';
+/**
+ * Opt-in checkpoint/rollback gate for the autopilot tick (agenticow step 3).
+ *
+ * The autopilot loop's memory mutation happens OUT OF PROCESS — a re-engaged
+ * tick returns a continuation prompt, and the spawned agent (plus agentic-flow
+ * learning) mutates `.rvf` memory. So there is no in-process fn to wrap with
+ * CheckpointGate.guard() here; instead we bracket the loop across ticks:
+ *   - checkpoint the configured `.rvf` right before handing off a risky tick
+ *     (re-engage), and
+ *   - roll it back when the loop's own regression signal fires (stall auto-disable).
+ *
+ * Entirely opt-in: it does nothing unless CLAUDE_FLOW_AUTOPILOT_CHECKPOINT_MEM
+ * points at an `.rvf` file the loop mutates, agenticow is installed, and the
+ * CLAUDE_FLOW_AGENTICOW_DISABLE kill switch is unset. Every call is non-fatal —
+ * a checkpoint/rollback failure never breaks the loop.
+ */
+async function checkpointTick(label) {
+    const memPath = CheckpointGate.configuredMemPath();
+    if (!memPath)
+        return;
+    try {
+        const r = await getCheckpointGate().checkpoint(memPath, label);
+        if (r.ok)
+            appendLog({ ts: Date.now(), event: 'checkpoint', label, memPath });
+    }
+    catch { /* non-fatal: memory branching is best-effort */ }
+}
+async function rollbackTick(reason) {
+    const memPath = CheckpointGate.configuredMemPath();
+    if (!memPath)
+        return;
+    try {
+        const r = await getCheckpointGate().rollback(memPath);
+        if (r.ok)
+            appendLog({ ts: Date.now(), event: 'rollback', reason, memPath });
+    }
+    catch { /* non-fatal */ }
+}
+// ── 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 });
+        // Regression signal: the loop stalled. Roll `.rvf` memory back to the last
+        // good per-tick checkpoint (opt-in via CLAUDE_FLOW_AUTOPILOT_CHECKPOINT_MEM).
+        await rollbackTick('stall-auto-disable');
+        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);
+    // Checkpoint `.rvf` memory before the risky tick runs (opt-in). The next
+    // check() rolls back to here if this tick regresses (stall detection above).
+    await checkpointTick(`autopilot-iter-${state.iterations}`);
+    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 { writeFileSync } = await import('node:fs');
+            const { resolve } = await import('node:path');
+            try {
+                writeFileSync(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 && 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/dist/src/commands/benchmark.d.ts

@@ -0,0 +1,10 @@
+/**
+ * V3 CLI Benchmark Command
+ * Comprehensive benchmarking for self-learning, pre-training, and neural systems
+ *
+ * @module v3/cli/commands/benchmark
+ */
+import type { Command } from '../types.js';
+export declare const benchmarkCommand: Command;
+export default benchmarkCommand;
+//# sourceMappingURL=benchmark.d.ts.map