@claude-flow/cli 3.56.8 → 3.56.10

package/dist/src/ruvector/diff-classifier.js

@@ -2,6 +2,7 @@
  * Diff Classifier for Change Analysis
  */
 import { execFileSync, execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { promisify } from 'node:util';
 const DEFAULT_CONFIG = {
     maxDiffSize: 10000,
@@ -9,7 +10,7 @@ const DEFAULT_CONFIG = {
     detectRefactoring: true,
     minConfidence: 0.5,
 };
-const CLASSIFICATION_PATTERNS = {
+const COMMIT_CLASSIFICATION_PATTERNS = {
     feature: [/^feat/, /add.*feature/, /implement/, /new.*functionality/i],
     bugfix: [/^fix/, /bug/, /patch/, /resolve.*issue/i, /hotfix/i],
     refactor: [/^refactor/, /restructure/, /reorganize/, /cleanup/i, /rename/i],
@@ -18,10 +19,45 @@ const CLASSIFICATION_PATTERNS = {
     config: [/^config/, /\.config\./, /package\.json/, /tsconfig/, /\.env/],
     style: [/^style/, /format/, /lint/, /prettier/, /eslint/],
 };
+// File paths and commit subjects are different signals. Prefixes such as
+// "fix" and words such as "bug" are useful in subjects, but match unrelated
+// paths like src/debug/logger.ts and src/dispatcher.ts.
+const PATH_CLASSIFICATION_PATTERNS = {
+    docs: [/(^|\/)docs?\//i, /(^|\/)readme(?:\.[^/]*)?$/i, /\.mdx?$/i],
+    test: [/(^|\/)(?:__tests__|tests?|specs?)\//i, /\.(?:test|spec)\.[^/]+$/i],
+    config: [/(^|\/)(?:configs?\/|config(?:\.[^/]*)?$)/i, /\.config\.[^/]+$/i,
+        /(^|\/)(?:package|tsconfig)(?:\.[^/]*)?\.json$/i, /(^|\/)\.env(?:\.[^/]*)?$/i],
+    style: [/\.(?:css|scss|sass|less)$/i],
+};
 const IMPACT_KEYWORDS = {
-    security: 3, auth: 3, payment: 3, database: 2, api: 2, core: 2,
+    payment: 3, database: 2, api: 2, core: 2,
     util: 1, helper: 1, test: 0, mock: 0, fixture: 0,
 };
+function pathHasTerm(path, term) {
+    const tokens = path.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase().split(/[^a-z0-9]+/);
+    const aliases = {
+        auth: ['auth', 'authentication', 'authorization', 'authenticator', 'oauth'],
+        util: ['util', 'utils', 'utility', 'utilities'],
+        test: ['test', 'tests'],
+        mock: ['mock', 'mocks'],
+        fixture: ['fixture', 'fixtures'],
+        config: ['config', 'configuration'],
+    };
+    return (aliases[term] ?? [term]).some(value => tokens.includes(value));
+}
+// Match path terms rather than substrings: `encryption` must trigger review,
+// while unrelated names such as `author` and `tokenizer` must not.
+const SECURITY_PATH_TERMS = new Set([
+    'security', 'secure', 'auth', 'oauth', 'authenticate', 'authentication',
+    'authorization', 'authorized', 'authenticator', 'crypto', 'cryptography',
+    'encrypt', 'encryption', 'encrypted', 'decrypt', 'decryption', 'decrypted',
+    'cipher', 'secret', 'secrets', 'password', 'passwords', 'token', 'tokens',
+    'vault', 'kms',
+]);
+function isSecuritySensitivePath(path) {
+    const terms = path.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase().split(/[^a-z0-9]+/);
+    return terms.some(term => SECURITY_PATH_TERMS.has(term));
+}
 export class DiffClassifier {
     config;
     ruvectorEngine = null;
@@ -47,10 +83,12 @@ export class DiffClassifier {
         const files = [];
         const fileBlocks = diffContent.split(/^diff --git/m).filter(Boolean);
         for (const block of fileBlocks) {
-            const pathMatch = block.match(/a\/(.+?)\s+b\/(.+)/);
-            if (!pathMatch)
+            const headerEnd = block.indexOf('\n');
+            const header = block.slice(0, headerEnd < 0 ? undefined : headerEnd);
+            const destination = header.lastIndexOf(' b/');
+            if (!header.startsWith(' a/') || destination < 0)
                 continue;
-            const path = pathMatch[2];
+            const path = header.slice(destination + 3);
             const hunks = this.parseHunks(block);
             const additions = hunks.reduce((sum, h) => sum + h.changes.filter(c => c.type === 'add').length, 0);
             const deletions = hunks.reduce((sum, h) => sum + h.changes.filter(c => c.type === 'remove').length, 0);
@@ -71,7 +109,15 @@ export class DiffClassifier {
     }
     classifyCommitMessage(message) {
         const lowerMessage = message.toLowerCase();
-        for (const [type, patterns] of Object.entries(CLASSIFICATION_PATTERNS)) {
+        const conventional = lowerMessage.match(/^([a-z]+)(?:\([^)]*\))?!?:/);
+        const conventionalTypes = {
+            feat: 'feature', feature: 'feature', fix: 'bugfix', refactor: 'refactor',
+            docs: 'docs', doc: 'docs', test: 'test', config: 'config', style: 'style',
+        };
+        if (conventional && conventionalTypes[conventional[1]]) {
+            return conventionalTypes[conventional[1]];
+        }
+        for (const [type, patterns] of Object.entries(COMMIT_CLASSIFICATION_PATTERNS)) {
             for (const pattern of patterns) {
                 if (pattern.test(lowerMessage))
                     return type;
@@ -85,16 +131,43 @@ export class DiffClassifier {
     clearCache() { this.classificationCache.clear(); }
     parseHunks(block) {
         const hunks = [];
-        const hunkMatches = block.matchAll(/@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@([^\n]*)\n([\s\S]*?)(?=@@|$)/g);
-        for (const match of hunkMatches) {
-            const oldStart = parseInt(match[1], 10);
-            const oldLines = parseInt(match[2] || '1', 10);
-            const newStart = parseInt(match[3], 10);
-            const newLines = parseInt(match[4] || '1', 10);
-            const content = match[6] || '';
-            const changes = this.parseChanges(content, newStart);
-            hunks.push({ oldStart, oldLines, newStart, newLines, content, changes });
+        const readRange = (value, prefix) => {
+            if (!value.startsWith(prefix))
+                return null;
+            const parts = value.slice(1).split(',');
+            if (parts.length > 2 || parts.some(part => !/^\d+$/.test(part)))
+                return null;
+            const start = Number(parts[0]);
+            const count = parts.length === 2 ? Number(parts[1]) : 1;
+            return Number.isSafeInteger(start) && Number.isSafeInteger(count) ? [start, count] : null;
+        };
+        let current = null;
+        const finish = () => {
+            if (!current)
+                return;
+            const content = current.lines.join('\n');
+            hunks.push({
+                oldStart: current.oldStart, oldLines: current.oldLines,
+                newStart: current.newStart, newLines: current.newLines,
+                content, changes: this.parseChanges(content, current.newStart),
+            });
+        };
+        for (const line of block.split('\n')) {
+            if (line.startsWith('@@ -')) {
+                const end = line.indexOf(' @@', 3);
+                const coordinates = end < 0 ? [] : line.slice(3, end).split(' ');
+                const oldRange = coordinates.length === 2 ? readRange(coordinates[0], '-') : null;
+                const newRange = coordinates.length === 2 ? readRange(coordinates[1], '+') : null;
+                if (oldRange && newRange) {
+                    finish();
+                    current = { oldStart: oldRange[0], oldLines: oldRange[1], newStart: newRange[0], newLines: newRange[1], lines: [] };
+                    continue;
+                }
+            }
+            if (current)
+                current.lines.push(line);
         }
+        finish();
         return hunks;
     }
     parseChanges(content, startLine) {
@@ -133,20 +206,26 @@ export class DiffClassifier {
         return classification;
     }
     getCacheKey(path, hunks) {
-        const hunkSummary = hunks.map(h => h.oldStart + ':' + h.newStart).join(',');
-        return path + ':' + hunkSummary;
+        const digest = createHash('sha256');
+        digest.update(path);
+        for (const hunk of hunks) {
+            digest.update(`${hunk.oldStart}:${hunk.newStart}:`);
+            for (const change of hunk.changes)
+                digest.update(`${change.type}:${change.content}\n`);
+        }
+        return digest.digest('hex');
     }
     determinePrimaryClassification(path, hunks) {
-        for (const [type, patterns] of Object.entries(CLASSIFICATION_PATTERNS)) {
+        for (const [type, patterns] of Object.entries(PATH_CLASSIFICATION_PATTERNS)) {
             for (const pattern of patterns) {
                 if (pattern.test(path))
                     return type;
             }
         }
-        const allContent = hunks.flatMap(h => h.changes.map(c => c.content)).join('\n').toLowerCase();
+        const allContent = hunks.flatMap(h => h.changes.filter(c => c.type !== 'context').map(c => c.content)).join('\n').toLowerCase();
         if (/function|class|interface|type\s+\w+/.test(allContent) && hunks.some(h => h.changes.filter(c => c.type === 'add').length > 10))
             return 'feature';
-        if (/fix|bug|issue|error|exception/.test(allContent))
+        if (/\b(?:fix(?:ed|es)?|bug|issue|exception)\b/.test(allContent))
             return 'bugfix';
         if (this.config.detectRefactoring && this.isRefactoring(hunks))
             return 'refactor';
@@ -167,7 +246,7 @@ export class DiffClassifier {
     }
     determineSecondaryClassifications(path, hunks, primary) {
         const secondary = [];
-        for (const [type, patterns] of Object.entries(CLASSIFICATION_PATTERNS)) {
+        for (const [type, patterns] of Object.entries(PATH_CLASSIFICATION_PATTERNS)) {
             if (type === primary)
                 continue;
             for (const pattern of patterns) {
@@ -181,7 +260,7 @@ export class DiffClassifier {
     }
     calculateConfidence(path, hunks, primary) {
         let confidence = 0.5;
-        for (const patterns of Object.values(CLASSIFICATION_PATTERNS)) {
+        for (const patterns of Object.values(PATH_CLASSIFICATION_PATTERNS)) {
             for (const pattern of patterns) {
                 if (pattern.test(path)) {
                     confidence += 0.2;
@@ -200,11 +279,12 @@ export class DiffClassifier {
     }
     determineImpactLevel(path, hunks) {
         let score = 0;
-        const lowerPath = path.toLowerCase();
         for (const [keyword, weight] of Object.entries(IMPACT_KEYWORDS)) {
-            if (lowerPath.includes(keyword))
+            if (pathHasTerm(path, keyword))
                 score = Math.max(score, weight);
         }
+        if (isSecuritySensitivePath(path))
+            score = Math.max(score, 3);
         const totalChanges = hunks.reduce((sum, h) => sum + h.changes.filter(c => c.type !== 'context').length, 0);
         if (totalChanges > 100)
             score = Math.max(score, 2);
@@ -224,9 +304,9 @@ export class DiffClassifier {
         reviewers.push(...(typeReviewers[primary] || typeReviewers.unknown));
         if (impact === 'critical' || impact === 'high')
             reviewers.push('security-reviewer');
-        if (/security|auth/.test(path))
+        if (isSecuritySensitivePath(path))
             reviewers.push('security-team');
-        if (/database|migration/.test(path))
+        if (pathHasTerm(path, 'database') || pathHasTerm(path, 'migration'))
             reviewers.push('dba');
         return [...new Set(reviewers)].slice(0, 4);
     }
@@ -240,9 +320,9 @@ export class DiffClassifier {
             strategies.push('regression-tests');
             strategies.push('e2e-tests');
         }
-        if (/api|endpoint|route|handler/.test(path))
+        if (['api', 'endpoint', 'route', 'handler'].some(term => pathHasTerm(path, term)))
             strategies.push('api-contract-tests');
-        if (/security|auth|crypto/.test(path))
+        if (isSecuritySensitivePath(path))
             strategies.push('security-audit');
         return strategies.slice(0, 5);
     }
@@ -255,11 +335,11 @@ export class DiffClassifier {
             risks.push('Critical system component - requires careful review');
         if (impact === 'high')
             risks.push('High-impact area - monitor after deployment');
-        if (/security|auth/.test(path))
+        if (isSecuritySensitivePath(path))
             risks.push('Security-sensitive code');
-        if (/database|migration/.test(path))
+        if (pathHasTerm(path, 'database') || pathHasTerm(path, 'migration'))
             risks.push('Database changes - ensure backup strategy');
-        if (/config|env/.test(path))
+        if (pathHasTerm(path, 'config') || pathHasTerm(path, 'env'))
             risks.push('Configuration changes - verify all environments');
         const allContent = hunks.flatMap(h => h.changes.map(c => c.content)).join('\n');
         if (/TODO|FIXME|HACK/.test(allContent))
@@ -318,20 +398,24 @@ const CACHE_TTL_MS = 5000; // 5 seconds - short TTL since diffs change frequentl
  * Only allows safe characters: alphanumeric, -, _, /, ., ~, ^
  */
 function validateGitRef(ref) {
-    // Block shell metacharacters and dangerous patterns
-    if (!/^[a-zA-Z0-9_\-./~^@]+$/.test(ref)) {
+    if (ref.length > 256) {
+        throw new Error(`Invalid git ref: too long`);
+    }
+    // A ref is passed as one argv element, but still must not be an option or
+    // contain shell metacharacters. A range may omit its right endpoint (HEAD).
+    if (!/^[a-zA-Z0-9_][a-zA-Z0-9_\-./~^@]*$/.test(ref)) {
         throw new Error(`Invalid git ref: contains unsafe characters`);
     }
-    // Block multiple dots (path traversal)
-    if (ref.includes('..') && !ref.match(/^[a-zA-Z0-9_\-]+\.\.\.?[a-zA-Z0-9_\-]+$/)) {
-        if (!/^\w+\.\.[.\w]+$/.test(ref)) {
+    if (ref.includes('..')) {
+        const range = ref.match(/^(.+?)(\.\.\.?)(.*)$/);
+        // Only one range separator is allowed. In particular, reject traversal
+        // inside either endpoint, while accepting branch paths and ancestry syntax.
+        if (!range || range[1].includes('..') || range[3].includes('..') ||
+            !/^[a-zA-Z0-9_][a-zA-Z0-9_\-./~^@]*$/.test(range[1]) ||
+            (range[3] !== '' && !/^[a-zA-Z0-9_][a-zA-Z0-9_\-./~^@]*$/.test(range[3]))) {
             throw new Error(`Invalid git ref: suspicious pattern`);
         }
     }
-    // Max length check
-    if (ref.length > 256) {
-        throw new Error(`Invalid git ref: too long`);
-    }
 }
 /**
  * Get git diff statistics using SINGLE combined command (optimized)
@@ -500,24 +584,23 @@ export function assessFileRisk(file) {
         reasons.push('Medium change size (>100 lines)');
     }
     // Path-based risk
-    const lowerPath = file.path.toLowerCase();
-    if (/security|auth|crypto|password/.test(lowerPath)) {
+    if (isSecuritySensitivePath(file.path)) {
         score += 40;
         reasons.push('Security-sensitive file');
     }
-    if (/payment|billing|transaction/.test(lowerPath)) {
+    if (['payment', 'billing', 'transaction'].some(term => pathHasTerm(file.path, term))) {
         score += 35;
         reasons.push('Payment-related file');
     }
-    if (/database|migration|schema/.test(lowerPath)) {
+    if (['database', 'migration', 'schema'].some(term => pathHasTerm(file.path, term))) {
         score += 25;
         reasons.push('Database-related file');
     }
-    if (/core|main|index/.test(lowerPath)) {
+    if (['core', 'main', 'index'].some(term => pathHasTerm(file.path, term))) {
         score += 15;
         reasons.push('Core module');
     }
-    if (/config|env|settings/.test(lowerPath)) {
+    if (['config', 'env', 'settings'].some(term => pathHasTerm(file.path, term))) {
         score += 20;
         reasons.push('Configuration file');
     }
@@ -570,19 +653,68 @@ function getClassifier() {
     }
     return classifierInstance;
 }
-/**
- * Classify a diff based on files (uses singleton classifier)
- */
-export function classifyDiff(files) {
+/** Classify file metadata with the actual patch and, for one-commit ranges, its subject. */
+export function classifyDiff(files, patch = '', commitSubject = '') {
     const classifier = getClassifier();
-    const fileDiffs = files.map(f => ({
-        path: f.path,
-        hunks: [],
-        additions: f.additions,
-        deletions: f.deletions,
-        classification: classifier['classifyFile'](f.path, []),
-    }));
-    return classifier['computeOverallClassification'](fileDiffs);
+    const parsed = new Map(classifier.parseDiff(patch).map(file => [file.path, file]));
+    const fileDiffs = files.map(f => {
+        const patchFile = parsed.get(f.path);
+        const hunks = patchFile?.hunks ?? [];
+        return {
+            path: f.path,
+            hunks,
+            additions: f.additions,
+            deletions: f.deletions,
+            classification: patchFile?.classification ?? classifier['classifyFile'](f.path, hunks),
+        };
+    });
+    const overall = classifier['computeOverallClassification'](fileDiffs);
+    if (fileDiffs.length > 0 && commitSubject) {
+        const subjectType = classifier.classifyCommitMessage(commitSubject);
+        if (subjectType !== 'unknown') {
+            if (overall.primary !== subjectType && overall.primary !== 'unknown') {
+                overall.secondary = [overall.primary, ...overall.secondary].filter((type, index, all) => type !== subjectType && all.indexOf(type) === index).slice(0, 3);
+            }
+            overall.primary = subjectType;
+            overall.confidence = Math.max(overall.confidence, 0.85);
+        }
+    }
+    return overall;
+}
+function getSingleCommitSubjectSync(ref) {
+    if (!ref.includes('..'))
+        return '';
+    try {
+        const output = execFileSync('git', ['log', '-2', '--format=%s', ref], { encoding: 'utf-8', maxBuffer: 64 * 1024 });
+        const subjects = output.trim().split('\n').filter(Boolean);
+        return subjects.length === 1 ? subjects[0] : '';
+    }
+    catch {
+        return '';
+    }
+}
+function getDiffContextSync(ref) {
+    validateGitRef(ref);
+    let patch = '';
+    try {
+        patch = execFileSync('git', ['diff', '--no-ext-diff', '--no-textconv', '--unified=0', ref], { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+    }
+    catch { /* A large or unavailable patch falls back to path-only classification. */ }
+    return { patch, subject: getSingleCommitSubjectSync(ref) };
+}
+async function getDiffContextAsync(ref) {
+    validateGitRef(ref);
+    const execFileAsync = promisify(execFile);
+    const patchPromise = execFileAsync('git', ['diff', '--no-ext-diff', '--no-textconv', '--unified=0', ref], { maxBuffer: 10 * 1024 * 1024 }).then(({ stdout }) => stdout).catch(() => '');
+    const subjectPromise = ref.includes('..')
+        ? execFileAsync('git', ['log', '-2', '--format=%s', ref], { maxBuffer: 64 * 1024 })
+            .then(({ stdout }) => {
+            const subjects = stdout.trim().split('\n').filter(Boolean);
+            return subjects.length === 1 ? subjects[0] : '';
+        }).catch(() => '')
+        : Promise.resolve('');
+    const [patch, subject] = await Promise.all([patchPromise, subjectPromise]);
+    return { patch, subject };
 }
 /**
  * Suggest reviewers based on files and risks
@@ -590,20 +722,20 @@ export function classifyDiff(files) {
 export function suggestReviewers(files, fileRisks) {
     const reviewers = new Set();
     for (const file of files) {
-        const lowerPath = file.path.toLowerCase();
-        if (/security|auth|crypto/.test(lowerPath))
+        const hasAny = (...terms) => terms.some(term => pathHasTerm(file.path, term));
+        if (isSecuritySensitivePath(file.path))
             reviewers.add('security-team');
-        if (/database|migration/.test(lowerPath))
+        if (hasAny('database', 'migration'))
             reviewers.add('dba');
-        if (/api|endpoint|route/.test(lowerPath))
+        if (hasAny('api', 'endpoint', 'route'))
             reviewers.add('api-owner');
-        if (/test|spec/.test(lowerPath))
+        if (hasAny('test', 'spec'))
             reviewers.add('qa-engineer');
-        if (/config|deploy|ci/.test(lowerPath))
+        if (hasAny('config', 'deploy', 'ci'))
             reviewers.add('devops');
-        if (/ui|component|style/.test(lowerPath))
+        if (hasAny('ui', 'component', 'style'))
             reviewers.add('frontend-lead');
-        if (/model|service|repository/.test(lowerPath))
+        if (hasAny('model', 'service', 'repository'))
             reviewers.add('backend-lead');
     }
     // Add based on risk
@@ -634,13 +766,13 @@ export async function analyzeDiff(options) {
         }
     }
     // Use async git diff for non-blocking operation
-    const files = await getGitDiffNumstatAsync(ref);
+    const [files, context] = await Promise.all([getGitDiffNumstatAsync(ref), getDiffContextAsync(ref)]);
     // Parallel file risk assessment for large diffs
     const fileRisks = files.length > 20
         ? await Promise.all(files.map(f => Promise.resolve(assessFileRisk(f))))
         : files.map(assessFileRisk);
     const risk = assessOverallRisk(files, fileRisks);
-    const classification = classifyDiff(files);
+    const classification = classifyDiff(files, context.patch, context.subject);
     const recommendedReviewers = suggestReviewers(files, fileRisks);
     const totalAdditions = files.reduce((sum, f) => sum + f.additions, 0);
     const totalDeletions = files.reduce((sum, f) => sum + f.deletions, 0);
@@ -669,9 +801,10 @@ export function analyzeDiffSync(options) {
         return cached.result;
     }
     const files = getGitDiffNumstat(ref);
+    const context = getDiffContextSync(ref);
     const fileRisks = files.map(assessFileRisk);
     const risk = assessOverallRisk(files, fileRisks);
-    const classification = classifyDiff(files);
+    const classification = classifyDiff(files, context.patch, context.subject);
     const recommendedReviewers = suggestReviewers(files, fileRisks);
     const totalAdditions = files.reduce((sum, f) => sum + f.additions, 0);
     const totalDeletions = files.reduce((sum, f) => sum + f.deletions, 0);

package/dist/src/ruvector/ruvllm-wasm.d.ts

@@ -65,7 +65,11 @@ export interface RuvllmStatus {
     available: boolean;
     initialized: boolean;
     version: string | null;
+    /** Present when unavailable: how to install the missing package. */
+    hint?: string;
 }
+/** #4149: the wasm package is an optional add-on, not bundled with the CLI. */
+export declare const RUVLLM_WASM_INSTALL_HINT: string;
 /**
  * Check if @ruvector/ruvllm-wasm is installed and loadable.
  */

package/dist/src/ruvector/ruvllm-wasm.js

@@ -24,6 +24,14 @@ import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 // WASM binary requires at least 768-dim input for MicroLoRA adapt()
 const MICROLORA_WASM_MIN_DIM = 768;
+/** #4149: the wasm package is an optional add-on, not bundled with the CLI. */
+export const RUVLLM_WASM_INSTALL_HINT = '@ruvector/ruvllm-wasm is not installed. Install it next to the CLI: ' +
+    '"npm i -g @ruvector/ruvllm-wasm" for a global install, or ' +
+    '"npm i @ruvector/ruvllm-wasm" in your project.';
+function isModuleNotFound(err) {
+    const code = err?.code;
+    return code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND';
+}
 // ── WASM Module Detection & Init ─────────────────────────────
 let _wasmReady = false;
 /**
@@ -55,6 +63,9 @@ export async function initRuvllmWasm() {
         _wasmReady = true;
     }
     catch (err) {
+        if (isModuleNotFound(err)) {
+            throw new Error(`Failed to initialize @ruvector/ruvllm-wasm: ${RUVLLM_WASM_INSTALL_HINT}`);
+        }
         throw new Error(`Failed to initialize @ruvector/ruvllm-wasm: ${err}`);
     }
 }
@@ -64,7 +75,7 @@ export async function initRuvllmWasm() {
 export async function getRuvllmStatus() {
     const available = await isRuvllmWasmAvailable();
     if (!available) {
-        return { available: false, initialized: false, version: null };
+        return { available: false, initialized: false, version: null, hint: RUVLLM_WASM_INSTALL_HINT };
     }
     try {
         const mod = await import('@ruvector/ruvllm-wasm');

package/dist/src/services/config-file-manager.js

@@ -123,16 +123,16 @@ export class ConfigFileManager {
         this.selectProject(cwd);
         // A targeted update must not persist unrelated defaults (notably the
         // default memory path, which would relocate an existing memory store).
-        const config = this.config ?? this.load(cwd) ?? {};
+        const config = structuredClone(this.config ?? this.load(cwd) ?? {});
         if (Object.hasOwn(config, key)) {
             config[key] = value;
         }
         else {
             setNestedValue(config, key, value);
         }
-        this.config = config;
         const targetPath = this.configPath ?? path.resolve(cwd, CONFIG_FILENAMES[0]);
         this.writeAtomic(targetPath, config);
+        this.config = config;
         this.configPath = targetPath;
     }
     /** Create a new config file with defaults */
@@ -271,7 +271,7 @@ export function parseConfigValue(value) {
         return parseFloat(value);
     try {
         const parsed = JSON.parse(value);
-        if (typeof parsed === 'object')
+        if (typeof parsed === 'object' || (typeof parsed === 'number' && Number.isFinite(parsed)))
             return parsed;
     }
     catch { /* not JSON, use as string */ }

package/dist/src/services/policy-runtime.d.ts

@@ -1,4 +1,4 @@
-import { AgenticPolicyEngine, type BudgetLimit, type CapabilityEnvelope, type PolicyApproval, type PolicyDecision, type PolicyRequest, type PolicyRule, type PolicyState } from '@claude-flow/security';
+import { AgenticPolicyEngine, type BudgetLimit, type CapabilityEnvelope, type PolicyApproval, type PolicyDecision, type PolicyRequest, type PolicyRule, type PolicyState } from '@claude-flow/security/policy/index';
 /**
  * Exported for ADR-406 mission storage, which takes the same per-file lock
  * (pid, pid namespace and boot id identify a dead owner) rather than a copy.

package/dist/src/services/policy-runtime.js

@@ -1,4 +1,10 @@
-import { AgenticPolicyEngine, createLegacyCompatibleState, isMcpCallerAuthEnabled, decodeTokenEnvelope, publicKeyFromHex, verifyInvocationToken, } from '@claude-flow/security';
+// Narrow subpath imports (not the '@claude-flow/security' barrel): this module
+// is loaded eagerly by the MCP server, and the barrel also evaluates the OAuth
+// callback server (an ESM `node:http` import that materialises http's lazy
+// undici getters), bcryptjs, keychain and credential helpers that the policy
+// runtime never uses.
+import { AgenticPolicyEngine, createLegacyCompatibleState, } from '@claude-flow/security/policy/index';
+import { isMcpCallerAuthEnabled, decodeTokenEnvelope, publicKeyFromHex, verifyInvocationToken, } from '@claude-flow/security/mcp-caller-identity';
 import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import { closeSync, constants as fsConstants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readlinkSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';

package/dist/src/services/worker-daemon.d.ts

@@ -316,6 +316,17 @@ export declare class WorkerDaemon extends EventEmitter {
      * Execute a worker with timeout protection
      */
     private executeWorker;
+    /**
+     * Feed a finished worker job into the self-learning pipeline as a one-step
+     * trajectory (SONA + ReasoningBank + @ruvector/ruvllm forwarding, persisted
+     * to `.claude-flow/neural/stats.json`). Before this, the daemon could run
+     * hundreds of jobs at "100% success" while `trajectoriesRecorded` stayed 0:
+     * no daemon code path ever called the intelligence module.
+     *
+     * Best-effort and bounded: never throws, never changes the WorkerResult.
+     * Opt-out: RUFLO_DAEMON_NO_LEARN=1.
+     */
+    private recordWorkerTrajectory;
     /**
      * Run a function with timeout (P1 fix)
      * @param fn - The async function to execute

package/dist/src/services/worker-daemon.js

@@ -75,6 +75,9 @@ const CONSOLIDATE_DEDUP_DISTANCE = 0.2;
 // `--no-distill` flag on `daemon start` (see commands/daemon.ts), which sets
 // this env var on the forked/foreground daemon process.
 const NO_DISTILL_ENV = 'RUFLO_DAEMON_NO_DISTILL';
+// Opt-out for recording each finished worker job as a learning trajectory
+// (see WorkerDaemon.recordWorkerTrajectory).
+const NO_LEARN_ENV = 'RUFLO_DAEMON_NO_LEARN';
 // #2356 — Self-terminating lifecycle defaults. A background daemon with no
 // upper bound on its lifetime runs until the box reboots; in the field this
 // leaked tens of thousands of headless `claude --print` sweeps over many days
@@ -1234,6 +1237,7 @@ export class WorkerDaemon extends EventEmitter {
             this.emit('worker:complete', result);
             this.log('info', `Worker ${workerConfig.type} completed in ${durationMs}ms`);
             this.saveState();
+            await this.recordWorkerTrajectory(result);
             return result;
         }
         catch (error) {
@@ -1253,6 +1257,7 @@ export class WorkerDaemon extends EventEmitter {
             this.emit('worker:error', result);
             this.log('error', `Worker ${workerConfig.type} failed: ${result.error}`);
             this.saveState();
+            await this.recordWorkerTrajectory(result);
             return result;
         }
         finally {
@@ -1261,6 +1266,38 @@ export class WorkerDaemon extends EventEmitter {
             this.processPendingWorkers();
         }
     }
+    /**
+     * Feed a finished worker job into the self-learning pipeline as a one-step
+     * trajectory (SONA + ReasoningBank + @ruvector/ruvllm forwarding, persisted
+     * to `.claude-flow/neural/stats.json`). Before this, the daemon could run
+     * hundreds of jobs at "100% success" while `trajectoriesRecorded` stayed 0:
+     * no daemon code path ever called the intelligence module.
+     *
+     * Best-effort and bounded: never throws, never changes the WorkerResult.
+     * Opt-out: RUFLO_DAEMON_NO_LEARN=1.
+     */
+    async recordWorkerTrajectory(result) {
+        if (process.env[NO_LEARN_ENV] === '1')
+            return;
+        try {
+            const intel = await import('../memory/intelligence.js');
+            await intel.recordTrajectory([{
+                    type: 'result',
+                    // A worker error is free text (it can quote command output): keep only its first line, cut, so it cannot fill the learning store.
+                    content: `daemon worker ${result.type} ${result.success ? 'succeeded' : `failed: ${String(result.error ?? 'unknown error').split('\n')[0].slice(0, 200)}`}`,
+                    metadata: {
+                        source: 'worker-daemon',
+                        worker: result.type,
+                        success: result.success,
+                        durationMs: result.durationMs,
+                    },
+                    timestamp: Date.now(),
+                }], result.success ? 'success' : 'failure');
+        }
+        catch (error) {
+            this.log('warn', `Worker ${result.type}: trajectory recording skipped: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     /**
      * Run a function with timeout (P1 fix)
      * @param fn - The async function to execute