claude-flow 3.7.0-alpha.12 → 3.7.0-alpha.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.7.0-alpha.12",
+  "version": "3.7.0-alpha.13",
   "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/services/worker-daemon.d.ts

@@ -182,6 +182,17 @@ export declare class WorkerDaemon extends EventEmitter {
      * Run the actual worker logic
      */
     private runWorkerLogic;
+    /**
+     * #1793: persist a headless worker result to the same metrics file the
+     * local fallback writes to. Without this, AI-mode workers produced rich
+     * structured output (audit findings, perf signals, test-gap analysis)
+     * that lived only in `.claude-flow/logs/headless/*_result.log` and was
+     * invisible to `npx ruflo memory stats` or the metrics consumers.
+     *
+     * The mapping mirrors the `*Local` worker implementations below so a
+     * single consumer path works regardless of execution mode.
+     */
+    private persistHeadlessResult;
     private runMapWorker;
     /**
      * Local audit worker (fallback when headless unavailable)

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

@@ -725,6 +725,17 @@ export class WorkerDaemon extends EventEmitter {
             try {
                 this.log('info', `Running ${workerConfig.type} in headless mode (Claude Code AI)`);
                 const result = await this.headlessExecutor.execute(workerConfig.type);
+                // #1793: persist the headless result to the same metrics files the
+                // local workers write to. Without this, AI-mode runs produced rich
+                // parsedOutput that lived only in `.claude-flow/logs/headless/*` and
+                // never reached `.claude-flow/metrics/<name>.json` — `memory stats`
+                // and downstream consumers saw nothing despite successful runs.
+                try {
+                    this.persistHeadlessResult(workerConfig.type, result);
+                }
+                catch (persistError) {
+                    this.log('warn', `Failed to persist headless result for ${workerConfig.type}: ${persistError.message}`);
+                }
                 return {
                     mode: 'headless',
                     ...result,
@@ -769,6 +780,53 @@ export class WorkerDaemon extends EventEmitter {
                 return { status: 'unknown worker type', mode: 'local' };
         }
     }
+    /**
+     * #1793: persist a headless worker result to the same metrics file the
+     * local fallback writes to. Without this, AI-mode workers produced rich
+     * structured output (audit findings, perf signals, test-gap analysis)
+     * that lived only in `.claude-flow/logs/headless/*_result.log` and was
+     * invisible to `npx ruflo memory stats` or the metrics consumers.
+     *
+     * The mapping mirrors the `*Local` worker implementations below so a
+     * single consumer path works regardless of execution mode.
+     */
+    persistHeadlessResult(workerType, result) {
+        const metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
+        if (!existsSync(metricsDir))
+            mkdirSync(metricsDir, { recursive: true });
+        // Filename mirrors the local-mode worker writes (security-audit.json,
+        // performance.json, test-gaps.json) so a downstream reader doesn't
+        // care which mode produced the data.
+        const filenameMap = {
+            audit: 'security-audit.json',
+            optimize: 'performance.json',
+            testgaps: 'test-gaps.json',
+            document: 'documentation.json',
+            refactor: 'refactor.json',
+            deepdive: 'deepdive.json',
+            ultralearn: 'ultralearn.json',
+            predict: 'predictions.json',
+        };
+        const filename = filenameMap[workerType] ?? `${workerType}.json`;
+        const metricsFile = join(metricsDir, filename);
+        const persisted = {
+            timestamp: result.timestamp instanceof Date ? result.timestamp.toISOString() : new Date().toISOString(),
+            mode: 'headless',
+            workerType,
+            model: result.model,
+            durationMs: result.durationMs,
+            tokensUsed: result.tokensUsed,
+            executionId: result.executionId,
+            success: result.success,
+            // Structured findings live here when the worker emits JSON (e.g. the
+            // audit worker's vulnerability list). Fall back to a raw-output
+            // pointer so consumers can still locate the full log.
+            findings: result.parsedOutput ?? null,
+            rawOutputPreview: typeof result.output === 'string' ? result.output.slice(0, 2000) : undefined,
+            rawOutputLength: typeof result.output === 'string' ? result.output.length : 0,
+        };
+        writeFileSync(metricsFile, JSON.stringify(persisted, null, 2));
+    }
     // Worker implementations
     async runMapWorker() {
         // Scan project structure and update metrics

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.7.0-alpha.12",
+  "version": "3.7.0-alpha.13",
   "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",

package/v3/@claude-flow/guidance/dist/analyzer.js

@@ -2461,6 +2461,15 @@ function pad(value) {
 export async function abBenchmark(claudeMdContent, options = {}) {
     const { executor = new DefaultHeadlessExecutor(), tasks = getABTasks(), proofKey, workDir = process.cwd(), } = options;
     const contentAware = isContentAwareExecutor(executor);
+    // #1652: a non-content-aware executor reads CLAUDE.md from disk for both
+    // configs, so the delta is architecturally guaranteed to be zero — yet
+    // the verdict implies the user's CLAUDE.md is ineffective. Detect and
+    // abort with a clear, actionable message before spending ~$23 in tokens
+    // on a meaningless run. The default executor IS content-aware, so this
+    // only triggers when callers inject a bare IHeadlessExecutor.
+    if (!contentAware) {
+        throw new Error('abBenchmark requires a content-aware executor. The provided IHeadlessExecutor lacks `setContext()`, so Config A and Config B will both read the same on-disk CLAUDE.md and the delta is guaranteed to be zero. Either use the DefaultHeadlessExecutor (content-aware as of @claude-flow/guidance@3.0.0-alpha.2) or implement IContentAwareExecutor on your custom executor.');
+    }
     // ── Config A: No control plane ──────────────────────────────────────
     // For content-aware executors, set empty context (simulating no guidance)
     if (contentAware)

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/guidance",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.3",
   "description": "Guidance Control Plane - Compiles, retrieves, enforces, and evolves guidance rules for Claude Code sessions",
   "type": "module",
   "main": "./dist/index.js",