claude-flow 3.5.82 → 3.5.83

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.5.82",
+  "version": "3.5.83",
   "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/commands/daemon.js

@@ -64,6 +64,15 @@ const startCommand = {
                 config.resourceThresholds = thresholds;
             }
         }
+        // Detect Claude Code runtime — suggest native alternatives
+        if (!isDaemonProcess && (process.env.CLAUDE_CODE || !process.stdin.isTTY)) {
+            if (!quiet) {
+                output.printInfo('[NATIVE_AVAILABLE] Running inside Claude Code. Consider using:');
+                output.writeln('  /loop "Run workers" — for in-session periodic execution');
+                output.writeln('  CronCreate — for persistent background workers');
+                output.writeln('  Proceeding with daemon start as fallback...');
+            }
+        }
         // Check if background daemon already running (skip if we ARE the daemon process)
         if (!isDaemonProcess) {
             const bgPid = getBackgroundDaemonPid(projectRoot);
@@ -628,6 +637,49 @@ const enableCommand = {
         }
     },
 };
+// Schedule subcommand - suggest native Claude Code alternatives for persistent scheduling
+const scheduleCommand = {
+    name: 'schedule',
+    description: 'Schedule a worker for periodic execution (suggests native Claude Code primitives)',
+    options: [
+        { name: 'worker', short: 'w', type: 'string', description: 'Worker type to schedule', required: true },
+        { name: 'interval', short: 'i', type: 'string', description: 'Interval in minutes (e.g. 15)', required: true },
+    ],
+    examples: [
+        { command: 'claude-flow daemon schedule -w audit -i 30', description: 'Schedule audit worker every 30 minutes' },
+        { command: 'claude-flow daemon schedule -w map -i 5', description: 'Schedule map worker every 5 minutes' },
+    ],
+    action: async (ctx) => {
+        const worker = ctx.flags.worker;
+        const intervalStr = ctx.flags.interval;
+        if (!worker) {
+            output.printError('Worker type is required. Use --worker or -w flag.');
+            return { success: false, exitCode: 1 };
+        }
+        if (!intervalStr) {
+            output.printError('Interval is required. Use --interval or -i flag.');
+            return { success: false, exitCode: 1 };
+        }
+        const minutes = parseInt(intervalStr, 10);
+        if (isNaN(minutes) || minutes < 1 || minutes > 1440) {
+            output.printError('Interval must be a number between 1 and 1440 (minutes).');
+            return { success: false, exitCode: 1 };
+        }
+        // Convert minutes to cron expression
+        const cronExpr = minutes < 60
+            ? `*/${minutes} * * * *`
+            : `0 */${Math.floor(minutes / 60)} * * *`;
+        output.writeln();
+        output.printBox([
+            `[CRON_SUGGESTION] To schedule this worker persistently:`,
+            `CronCreate("${worker}-worker", "${cronExpr}", "Run npx @claude-flow/cli hooks worker dispatch --trigger ${worker}")`,
+            ``,
+            `For in-session periodic execution, use:`,
+            `/loop "Run ${worker} worker" (auto-paced with cache-aware delays)`,
+        ].join('\n'), 'Schedule Worker');
+        return { success: true };
+    },
+};
 // Helper functions for time formatting
 function formatTimeAgo(date) {
     const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
@@ -661,6 +713,7 @@ export const daemonCommand = {
         statusCommand,
         triggerCommand,
         enableCommand,
+        scheduleCommand,
     ],
     options: [],
     examples: [
@@ -699,11 +752,12 @@ export const daemonCommand = {
         output.writeln();
         output.writeln(output.bold('Subcommands'));
         output.printList([
-            `${output.highlight('start')}   - Start the daemon`,
-            `${output.highlight('stop')}    - Stop the daemon`,
-            `${output.highlight('status')}  - Show daemon status`,
-            `${output.highlight('trigger')} - Manually run a worker`,
-            `${output.highlight('enable')}  - Enable/disable a worker`,
+            `${output.highlight('start')}    - Start the daemon`,
+            `${output.highlight('stop')}     - Stop the daemon`,
+            `${output.highlight('status')}   - Show daemon status`,
+            `${output.highlight('trigger')}  - Manually run a worker`,
+            `${output.highlight('enable')}   - Enable/disable a worker`,
+            `${output.highlight('schedule')} - Schedule periodic worker execution`,
         ]);
         output.writeln();
         output.writeln('Run "claude-flow daemon <subcommand> --help" for details');

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

@@ -5,6 +5,7 @@
 import { output } from '../output.js';
 import { select, confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
+import { createRunId, emitEvent } from '../services/event-stream.js';
 import * as fs from 'fs';
 import * as path from 'path';
 // Get dynamic swarm status from memory/session files
@@ -524,14 +525,72 @@ const startCommand = {
         return { success: true, data: executionState };
     }
 };
+// Shared polling loop used by `status --stream` and `watch`
+function startStatusPoll(swarmId, runId, includeHealth) {
+    let prev = '';
+    const tick = () => {
+        const s = getSwarmStatus(swarmId);
+        const key = JSON.stringify(s);
+        if (key !== prev) {
+            prev = key;
+            emitEvent({
+                runId,
+                event: 'swarm_status',
+                agents: s.agents.total,
+                active: s.agents.active,
+                completed: s.tasks.completed,
+                pending: s.tasks.pending,
+                inProgress: s.tasks.inProgress,
+                progress: s.progress,
+                status: s.status,
+            });
+        }
+        if (includeHealth) {
+            emitEvent({
+                runId,
+                event: 'swarm_health',
+                memoryOk: s.hasActiveSwarm,
+                agentsTotal: s.agents.total,
+                agentsActive: s.agents.active,
+                successRate: s.metrics.successRate,
+                avgResponseTime: s.metrics.avgResponseTime,
+                elapsedTime: s.metrics.elapsedTime,
+            });
+        }
+    };
+    // Emit once immediately, then every 2 s
+    tick();
+    const timer = setInterval(tick, 2000);
+    const stop = () => { clearInterval(timer); };
+    return { stop };
+}
 // Swarm status
 const statusCommand = {
     name: 'status',
-    description: 'Show swarm status',
+    description: 'Show swarm status. Use --stream for live NDJSON output (pairs with Claude Code Monitor tool)',
+    options: [
+        {
+            name: 'stream',
+            description: 'Continuously emit NDJSON status events to stdout (use with Claude Code Monitor tool for live updates)',
+            type: 'boolean',
+            default: false
+        }
+    ],
     action: async (ctx) => {
         const swarmId = ctx.args[0];
         // Get dynamic status from actual swarm state files
         const status = getSwarmStatus(swarmId);
+        // --stream: enter NDJSON polling mode instead of one-shot output
+        if (ctx.flags.stream) {
+            const runId = createRunId();
+            const { stop } = startStatusPoll(swarmId, runId, false);
+            await new Promise((resolve) => {
+                const onSig = () => { stop(); resolve(); };
+                process.once('SIGINT', onSig);
+                process.once('SIGTERM', onSig);
+            });
+            return { success: true };
+        }
         if (ctx.flags.format === 'json') {
             output.printJson(status);
             return { success: true, data: status };
@@ -797,11 +856,48 @@ const coordinateCommand = {
         return { success: true, data: { agents: v3Agents, count: agentCount } };
     }
 };
+// Watch swarm (NDJSON event stream)
+const watchCommand = {
+    name: 'watch',
+    description: 'Stream live swarm status as NDJSON events to stdout',
+    options: [
+        {
+            name: 'health',
+            description: 'Include periodic health-metric events',
+            type: 'boolean',
+            default: false
+        }
+    ],
+    examples: [
+        { command: 'claude-flow swarm watch', description: 'Stream NDJSON status events' },
+        { command: 'claude-flow swarm watch --health', description: 'Include health metrics' }
+    ],
+    action: async (ctx) => {
+        const swarmId = ctx.args[0];
+        const includeHealth = ctx.flags.health;
+        const runId = createRunId();
+        emitEvent({
+            runId,
+            event: 'watch_start',
+            swarmId: swarmId ?? null,
+            health: includeHealth,
+        });
+        const { stop } = startStatusPoll(swarmId, runId, includeHealth);
+        // Block until SIGINT / SIGTERM, then clean up
+        await new Promise((resolve) => {
+            const onSig = () => { stop(); resolve(); };
+            process.once('SIGINT', onSig);
+            process.once('SIGTERM', onSig);
+        });
+        emitEvent({ runId, event: 'watch_stop' });
+        return { success: true };
+    }
+};
 // Main swarm command
 export const swarmCommand = {
     name: 'swarm',
     description: 'Swarm coordination commands',
-    subcommands: [initCommand, startCommand, statusCommand, stopCommand, scaleCommand, coordinateCommand],
+    subcommands: [initCommand, startCommand, statusCommand, stopCommand, scaleCommand, coordinateCommand, watchCommand],
     options: [],
     examples: [
         { command: 'claude-flow swarm init --v3-mode', description: 'Initialize V3 swarm' },
@@ -818,10 +914,11 @@ export const swarmCommand = {
         output.printList([
             `${output.highlight('init')}        - Initialize a new swarm`,
             `${output.highlight('start')}       - Start swarm execution`,
-            `${output.highlight('status')}      - Show swarm status`,
+            `${output.highlight('status')}      - Show swarm status (--stream for live NDJSON)`,
             `${output.highlight('stop')}        - Stop swarm execution`,
             `${output.highlight('scale')}       - Scale swarm agent count`,
-            `${output.highlight('coordinate')}  - V3 15-agent coordination`
+            `${output.highlight('coordinate')}  - V3 15-agent coordination`,
+            `${output.highlight('watch')}       - Stream live NDJSON status events`
         ]);
         return { success: true };
     }

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

@@ -394,6 +394,22 @@ ToolSearch("hive consensus")    → hive-mind_consensus, hive-mind_status
 ToolSearch("+aidefence")        → aidefence_scan, aidefence_is_safe, aidefence_has_pii
 \`\`\``;
 }
+function nativeCapabilities() {
+    return `## Native Claude Code Capabilities (PREFER OVER MCP) — ADR-091
+
+When running inside Claude Code, ALWAYS prefer native tools over MCP equivalents:
+
+| Need | Use This | Not This |
+|------|----------|----------|
+| Periodic tasks | \`/loop\` with ScheduleWakeup (delay <270s for cache) | \`daemon start\` |
+| Live monitoring | \`Monitor("npx @claude-flow/cli swarm watch --stream")\` | Polling \`swarm status\` |
+| Background workers | \`CronCreate("audit", "*/15 * * * *", "...")\` | \`daemon start --background\` |
+| Agent isolation | \`Task({ ..., isolation: "worktree" })\` | Shared worktree |
+| Multi-agent comms | \`TeamCreate\` + \`SendMessage\` | Memory namespace coordination |
+| Cross-session | \`PushNotification\` + \`RemoteTrigger\` | No equivalent |
+
+MCP tool responses include hints: \`[LOOP_SUGGESTION]\`, \`[MONITOR_AVAILABLE]\`, \`[CRON_SUGGESTION]\`, \`[TEAM_SUGGESTION]\`, \`[WORKTREE_SUGGESTION]\` — follow them. In CI/headless, Ruflo falls back to daemon mode automatically.`;
+}
 function setupAndBoundary() {
     return `## Quick Setup
 
@@ -422,6 +438,7 @@ npx @claude-flow/cli@latest doctor --fix
 const TEMPLATE_SECTIONS = {
     minimal: [
         behavioralRules,
+        (_opts) => nativeCapabilities(),
         fileOrganization,
         projectArchitecture,
         (_opts) => buildAndTest(),
@@ -434,6 +451,7 @@ const TEMPLATE_SECTIONS = {
     ],
     standard: [
         behavioralRules,
+        (_opts) => nativeCapabilities(),
         fileOrganization,
         projectArchitecture,
         (_opts) => buildAndTest(),
@@ -450,6 +468,7 @@ const TEMPLATE_SECTIONS = {
     ],
     full: [
         behavioralRules,
+        (_opts) => nativeCapabilities(),
         fileOrganization,
         projectArchitecture,
         (_opts) => buildAndTest(),
@@ -471,6 +490,7 @@ const TEMPLATE_SECTIONS = {
     ],
     security: [
         behavioralRules,
+        (_opts) => nativeCapabilities(),
         fileOrganization,
         projectArchitecture,
         (_opts) => buildAndTest(),
@@ -486,6 +506,7 @@ const TEMPLATE_SECTIONS = {
     ],
     performance: [
         behavioralRules,
+        (_opts) => nativeCapabilities(),
         fileOrganization,
         projectArchitecture,
         (_opts) => buildAndTest(),

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

@@ -211,6 +211,13 @@ export const agentTools = [
             else if (routingResult.tier) {
                 response.tier = routingResult.tier;
             }
+            // ADR-091 Phase 1: Native Claude Code capability suggestions
+            response.nativeIntegration = {
+                taskSuggestion: '[AGENT_NATIVE] For better isolation, spawn this agent via Claude Code Task tool: Task({ prompt: "...", subagent_type: "' + (input.agentType || 'coder') + '", isolation: "worktree" })',
+                isolationNote: agentType === 'coder' || agentType === 'reviewer'
+                    ? '[WORKTREE_SUGGESTION] This agent type modifies files. Use isolation: "worktree" to prevent conflicts.'
+                    : undefined,
+            };
             return response;
         },
     },
@@ -277,6 +284,10 @@ export const agentTools = [
                     createdAt: agent.createdAt,
                     domain: agent.domain,
                     lastResult: agent.lastResult || null,
+                    // ADR-091 Phase 1: Native Claude Code capability suggestions
+                    nativeIntegration: {
+                        monitorSuggestion: '[MONITOR_AVAILABLE] For live agent updates: Monitor("npx @claude-flow/cli agent logs --stream")',
+                    },
                 };
             }
             return {

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

@@ -1743,6 +1743,9 @@ export const hooksSessionStart = {
                 tasksRestored: sessionMemory?.restoredPatterns || 0,
                 memoryRestored: sessionMemory?.restoredPatterns || 0,
             } : null,
+            nativeCapabilities: {
+                note: 'Claude Code native capabilities detected. Prefer /loop over daemon start, Monitor over polling, CronCreate over background processes.',
+            },
         };
     },
 };
@@ -3351,6 +3354,12 @@ export const hooksWorkerDispatch = {
             background,
             note: background ? 'Worker scheduled. Use hooks_worker-status to check progress. Start the daemon (daemon start) for real background execution.' : undefined,
             timestamp: new Date().toISOString(),
+            nativeIntegration: {
+                loopSuggestion: `[LOOP_SUGGESTION] This worker would benefit from /loop for periodic execution.\nRecommended: /loop "${trigger} worker"\nInterval: 270s (stays within cache window)`,
+                suggestedDelay: 270,
+                loopPrompt: `Run ${trigger} worker and check results`,
+                cronSuggestion: `[CRON_SUGGESTION] For persistent background execution: CronCreate("${trigger}-worker", "*/15 * * * *", "Run ${trigger} worker")`,
+            },
         };
     },
 };
@@ -3408,6 +3417,9 @@ export const hooksWorkerStatus = {
                 completed: workers.filter(w => w.status === 'completed').length,
                 failed: workers.filter(w => w.status === 'failed').length,
             },
+            nativeIntegration: {
+                monitorSuggestion: '[MONITOR_AVAILABLE] For live worker updates: Monitor("npx @claude-flow/cli hooks worker list --stream")',
+            },
         };
     },
 };

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

@@ -109,6 +109,10 @@ export const swarmTools = [
                 initializedAt: now,
                 config: swarmState.config,
                 persisted: true,
+                nativeIntegration: {
+                    teamSuggestion: '[TEAM_SUGGESTION] Create a Claude Code team for this swarm: TeamCreate({ team_name: "' + (input.name || 'swarm') + '", description: "Ruflo swarm coordination" })',
+                    worktreeNote: '[WORKTREE_SUGGESTION] Spawn file-modifying agents with isolation: "worktree" to prevent conflicts',
+                },
             };
         },
     },
@@ -168,6 +172,9 @@ export const swarmTools = [
                 createdAt: latest.createdAt,
                 updatedAt: latest.updatedAt,
                 totalSwarms: swarmIds.length,
+                nativeIntegration: {
+                    monitorSuggestion: '[MONITOR_AVAILABLE] For live swarm updates: Monitor("npx @claude-flow/cli swarm watch --stream")',
+                },
             };
         },
     },
@@ -312,6 +319,9 @@ export const swarmTools = [
                 agentCount: target.agents.length,
                 checks,
                 checkedAt: new Date().toISOString(),
+                nativeIntegration: {
+                    monitorSuggestion: '[MONITOR_AVAILABLE] For continuous health monitoring: Monitor("npx @claude-flow/cli swarm watch --stream --health")',
+                },
             };
         },
     },

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

@@ -90,6 +90,10 @@ export const taskTools = [
                 createdAt: task.createdAt,
                 assignedTo: task.assignedTo,
                 tags: task.tags,
+                // ADR-091 Phase 1: Native Claude Code capability suggestions
+                nativeIntegration: {
+                    nativeTaskNote: '[TASK_NATIVE] Claude Code has a native task system. Consider TaskCreate({ subject: "...", description: "..." }) for shared visibility across agents.',
+                },
             };
         },
     },
@@ -246,6 +250,10 @@ export const taskTools = [
                     status: task.status,
                     completedAt: task.completedAt,
                     result: task.result,
+                    // ADR-091 Phase 1: Native Claude Code capability suggestions
+                    nativeIntegration: {
+                        notifySuggestion: '[NOTIFY_SUGGESTION] For tasks spanning sessions, use PushNotification to alert when complete.',
+                    },
                 };
             }
             return {

package/v3/@claude-flow/cli/dist/src/services/event-stream.d.ts

@@ -0,0 +1,25 @@
+/**
+ * NDJSON Event Stream for CLI --stream mode
+ *
+ * Emits newline-delimited JSON events to stdout for consumption
+ * by Claude Code's Monitor tool. Each event includes schema versioning.
+ *
+ * @see ADR-091: NDJSON event streaming infrastructure
+ */
+export interface StreamEvent {
+    schema: 'ruflo.event.v1';
+    event: string;
+    runId: string;
+    agentId?: string;
+    ts: string;
+    [key: string]: unknown;
+}
+/** Generate a short unique run ID (e.g. run_m1abc_3f2a1b) */
+export declare function createRunId(): string;
+/** Write one NDJSON line to stdout with schema and timestamp auto-populated */
+export declare function emitEvent(event: Omit<StreamEvent, 'schema' | 'ts'>): void;
+/** Convenience wrapper that binds a runId to an emitter */
+export declare function createEventEmitter(runId: string): {
+    emit(event: string, data?: Record<string, unknown>): void;
+};
+//# sourceMappingURL=event-stream.d.ts.map

package/v3/@claude-flow/cli/dist/src/services/event-stream.js

@@ -0,0 +1,27 @@
+/**
+ * NDJSON Event Stream for CLI --stream mode
+ *
+ * Emits newline-delimited JSON events to stdout for consumption
+ * by Claude Code's Monitor tool. Each event includes schema versioning.
+ *
+ * @see ADR-091: NDJSON event streaming infrastructure
+ */
+import { randomBytes } from 'crypto';
+/** Generate a short unique run ID (e.g. run_m1abc_3f2a1b) */
+export function createRunId() {
+    return `run_${Date.now().toString(36)}_${randomBytes(3).toString('hex')}`;
+}
+/** Write one NDJSON line to stdout with schema and timestamp auto-populated */
+export function emitEvent(event) {
+    const full = Object.assign({ schema: 'ruflo.event.v1', ts: new Date().toISOString() }, event);
+    process.stdout.write(JSON.stringify(full) + '\n');
+}
+/** Convenience wrapper that binds a runId to an emitter */
+export function createEventEmitter(runId) {
+    return {
+        emit(event, data) {
+            emitEvent({ runId, event, ...data });
+        },
+    };
+}
+//# sourceMappingURL=event-stream.js.map

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

@@ -6,6 +6,9 @@ export { WorkerDaemon, getDaemon, startDaemon, stopDaemon, type WorkerType, } fr
 export { HeadlessWorkerExecutor, HEADLESS_WORKER_TYPES, HEADLESS_WORKER_CONFIGS, LOCAL_WORKER_TYPES, LOCAL_WORKER_CONFIGS, ALL_WORKER_CONFIGS, isHeadlessWorker, isLocalWorker, getModelId, getWorkerConfig, type HeadlessWorkerType, type LocalWorkerType, type HeadlessWorkerConfig, type HeadlessExecutionResult, type HeadlessExecutorConfig, type HeadlessOptions, type PoolStatus, type SandboxMode, type ModelType, type OutputFormat, type ExecutionMode, type WorkerPriority, type WorkerConfig, } from './headless-worker-executor.js';
 export { ContainerWorkerPool, type ContainerInfo, type ContainerPoolConfig, type ContainerExecutionOptions, type ContainerPoolStatus, type ContainerState, } from './container-worker-pool.js';
 export { WorkerQueue, type QueueTask, type WorkerQueueConfig, type QueueStats, type WorkerRegistration, type TaskStatus, } from './worker-queue.js';
+export { createRunId, emitEvent, createEventEmitter, type StreamEvent, } from './event-stream.js';
+export { detectCapabilities, getRuntimeTier, getCacheWarmDelay, type RuntimeCapabilities, type RuntimeTier, } from './runtime-capabilities.js';
+export { runLoopWorker, type LoopWorkerResult, } from './loop-worker-runner.js';
 export type { default as WorkerDaemonType, DaemonConfig } from './worker-daemon.js';
 export type { default as HeadlessWorkerExecutorType } from './headless-worker-executor.js';
 export type { default as ContainerWorkerPoolType } from './container-worker-pool.js';

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

@@ -8,4 +8,10 @@ export { HeadlessWorkerExecutor, HEADLESS_WORKER_TYPES, HEADLESS_WORKER_CONFIGS,
 export { ContainerWorkerPool, } from './container-worker-pool.js';
 // Worker Queue (Phase 4)
 export { WorkerQueue, } from './worker-queue.js';
+// Event Stream (ADR-091)
+export { createRunId, emitEvent, createEventEmitter, } from './event-stream.js';
+// Runtime Capabilities (ADR-091)
+export { detectCapabilities, getRuntimeTier, getCacheWarmDelay, } from './runtime-capabilities.js';
+// Loop Worker Runner (ADR-091 Phase 2)
+export { runLoopWorker, } from './loop-worker-runner.js';
 //# sourceMappingURL=index.js.map

package/v3/@claude-flow/cli/dist/src/services/loop-worker-runner.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ADR-091 Phase 2 -- Stateless Loop Worker Runner
+ *
+ * Designed for /loop execution: runs a single worker iteration and returns
+ * metadata that the caller can use with ScheduleWakeup.
+ */
+export interface LoopWorkerResult {
+    workerType: string;
+    success: boolean;
+    suggestedDelay: number;
+    reason: string;
+    loopPrompt: string;
+    metrics?: Record<string, unknown>;
+}
+export declare function runLoopWorker(workerType: string): Promise<LoopWorkerResult>;
+//# sourceMappingURL=loop-worker-runner.d.ts.map

package/v3/@claude-flow/cli/dist/src/services/loop-worker-runner.js

@@ -0,0 +1,34 @@
+/**
+ * ADR-091 Phase 2 -- Stateless Loop Worker Runner
+ *
+ * Designed for /loop execution: runs a single worker iteration and returns
+ * metadata that the caller can use with ScheduleWakeup.
+ */
+import { execSync } from 'child_process';
+import { getCacheWarmDelay } from './runtime-capabilities.js';
+export async function runLoopWorker(workerType) {
+    const startMs = Date.now();
+    let success = false;
+    let reason = '';
+    try {
+        const safeWorkerType = workerType.replace(/[^a-zA-Z0-9_-]/g, '');
+        const stdout = execSync(`npx @claude-flow/cli hooks worker dispatch --trigger ${safeWorkerType}`, { encoding: 'utf-8', timeout: 120_000, stdio: ['ignore', 'pipe', 'pipe'] });
+        success = true;
+        reason = stdout.trim().slice(0, 200) || `${workerType} completed`;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        reason = `${workerType} failed: ${msg.slice(0, 200)}`;
+    }
+    const durationMs = Date.now() - startMs;
+    const suggestedDelay = getCacheWarmDelay();
+    return {
+        workerType,
+        success,
+        suggestedDelay,
+        reason,
+        loopPrompt: `Run ${workerType} worker and report results`,
+        metrics: { durationMs, timestamp: new Date().toISOString() },
+    };
+}
+//# sourceMappingURL=loop-worker-runner.js.map

package/v3/@claude-flow/cli/dist/src/services/runtime-capabilities.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ADR-091 Phase 1 -- Runtime Capabilities Detection
+ *
+ * Detects the host environment and exposes which execution primitives are
+ * available so that higher-level services can choose the right path:
+ *   1. claude-code-native  -- full Claude Code tooling (loop, monitor, cron, teams)
+ *   2. mcp-fallback        -- MCP transport active but native tools missing
+ *   3. ci-daemon           -- headless / CI, use detached daemon
+ */
+export interface RuntimeCapabilities {
+    loop: boolean;
+    monitor: boolean;
+    cron: boolean;
+    teams: boolean;
+    worktreeIsolation: boolean;
+    pushNotification: boolean;
+}
+export type RuntimeTier = 'claude-code-native' | 'mcp-fallback' | 'ci-daemon';
+export declare function detectCapabilities(): RuntimeCapabilities;
+export declare function getRuntimeTier(): RuntimeTier;
+export declare function getCacheWarmDelay(providerCacheTtlSeconds?: number): number;
+//# sourceMappingURL=runtime-capabilities.d.ts.map

package/v3/@claude-flow/cli/dist/src/services/runtime-capabilities.js

@@ -0,0 +1,45 @@
+/**
+ * ADR-091 Phase 1 -- Runtime Capabilities Detection
+ *
+ * Detects the host environment and exposes which execution primitives are
+ * available so that higher-level services can choose the right path:
+ *   1. claude-code-native  -- full Claude Code tooling (loop, monitor, cron, teams)
+ *   2. mcp-fallback        -- MCP transport active but native tools missing
+ *   3. ci-daemon           -- headless / CI, use detached daemon
+ */
+function isClaudeCodeNative() {
+    return !!(process.env.CLAUDE_CODE ||
+        process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS);
+}
+function isMcpTransportActive() {
+    return (!process.stdin.isTTY &&
+        process.env.CLAUDE_FLOW_MCP_TRANSPORT === 'stdio');
+}
+function isCiOrHeadless() {
+    return !!(process.env.CI || process.env.CLAUDE_FLOW_HEADLESS);
+}
+export function detectCapabilities() {
+    const native = isClaudeCodeNative();
+    const teamsEnabled = !!process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS;
+    return {
+        loop: native,
+        monitor: native,
+        cron: native,
+        teams: native && teamsEnabled,
+        worktreeIsolation: native,
+        pushNotification: native,
+    };
+}
+export function getRuntimeTier() {
+    if (isClaudeCodeNative())
+        return 'claude-code-native';
+    if (isMcpTransportActive())
+        return 'mcp-fallback';
+    if (isCiOrHeadless())
+        return 'ci-daemon';
+    return 'mcp-fallback';
+}
+export function getCacheWarmDelay(providerCacheTtlSeconds) {
+    return Math.min(270, (providerCacheTtlSeconds ?? 300) * 0.9);
+}
+//# sourceMappingURL=runtime-capabilities.js.map

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.5.82",
+  "version": "3.5.83",
   "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",