claude-flow 3.62.0 → 3.63.0

package/v3/@claude-flow/cli/dist/src/mcp-tools/managed-learning-tool.js

@@ -0,0 +1,46 @@
+/** Learning MCP boundary, kept separate from provider transport and native workers. */
+import { getProjectCwd } from './types.js';
+export const managedLearningTool = {
+    inputSchema: { type: 'object', properties: {
+            action: { type: 'string', enum: ['status', 'record', 'recommend', 'evaluate', 'index', 'recall', 'cycle'] },
+            evidence: { type: 'object', description: 'Closed version1 observation and optional host signature; caller trust labels rejected' },
+            scope: { type: 'object', description: 'Exact taskType, policyHash and evaluatorHash cohort' },
+            manifest: { type: 'object', description: 'Frozen unique heldout taskHashes and at least three trials' },
+            cycle: { type: 'object', description: 'Closed scope/evidence batch, optional index, maxP95Ms and evaluation; no commands, keys or promotion flags' },
+            baselineId: { type: 'string' }, candidateId: { type: 'string' }, id: { type: 'string' }, maxP95Ms: { type: 'number' },
+        }, required: ['action'] },
+    handler: async (input) => {
+        if (input.action !== 'status' && process.env.RUFLO_MANAGED_LEARNING !== '1')
+            return { success: false, error: 'Managed learning writes require host RUFLO_MANAGED_LEARNING=1' };
+        const root = getProjectCwd(), key = process.env.RUFLO_MANAGED_VERIFIER_PUBLIC_KEY;
+        const authorize = () => process.env.RUFLO_MANAGED_LEARNING === '1' && process.env.RUFLO_MANAGED_VERIFIER_PUBLIC_KEY === key && getProjectCwd() === root;
+        try {
+            const learning = await import('../services/managed-learning-store.js');
+            if (input.action !== 'status' && !authorize())
+                throw new Error('Host learning policy changed');
+            if (input.action === 'cycle') {
+                if (Object.keys(input).some(k => !['action', 'cycle'].includes(k)))
+                    throw new Error('Invalid cycle envelope');
+                const { cycleLearning } = await import('../services/managed-learning-loop.js');
+                return { success: true, ...await cycleLearning(root, input.cycle, key, authorize) };
+            }
+            if (input.action === 'status')
+                return { success: true, ...learning.learningStatus(root, key) };
+            if (input.action === 'record')
+                return { success: true, ...learning.recordLearning(root, input.evidence, key) };
+            if (input.action === 'recommend')
+                return { success: true, ...learning.recommendLearning(root, input.scope, key, input.maxP95Ms) };
+            if (input.action === 'evaluate')
+                return { success: true, ...learning.evaluateLearning(root, { scope: input.scope, manifest: input.manifest, baselineId: String(input.baselineId ?? ''), candidateId: String(input.candidateId ?? '') }, key) };
+            if (input.action === 'recall')
+                return { success: true, ...await learning.recallLearning(root, input.scope, key, authorize) };
+            if (input.action === 'index')
+                return { success: true, ...await learning.indexLearning(root, String(input.id ?? ''), key, authorize) };
+            return { success: false, error: 'Unknown managed learning action' };
+        }
+        catch {
+            return { success: false, error: 'Managed learning failed: validate metadata, verifier and store; state may persist, inspect status before retrying; no default changed' };
+        }
+    },
+};
+//# sourceMappingURL=managed-learning-tool.js.map

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

@@ -1466,13 +1466,16 @@ export const memoryTools = [
                 }
                 catch { /* namespace may not exist */ }
             }
-            // Sort by score, deduplicate by key, take top N
+            // Sort by score, deduplicate by (namespace, key), take top N. An entry is
+            // identified by both (see #2271), so the same key in another namespace is
+            // a different entry and must not be dropped as a duplicate.
             allResults.sort((a, b) => b.score - a.score);
             const seen = new Set();
             const deduplicated = allResults.filter(r => {
-                if (seen.has(r.key))
+                const id = JSON.stringify([r.namespace, r.key]);
+                if (seen.has(id))
                     return false;
-                seen.add(r.key);
+                seen.add(id);
                 return true;
             }).slice(0, limit);
             return {

package/v3/@claude-flow/cli/dist/src/missions/schemas.d.ts

@@ -77,6 +77,10 @@ export declare const missionRecordSchema: z.ZodObject<{
     updatedAt: string;
     schemaVersion: 1;
     state: "completed" | "cancelled" | "failed" | "blocked" | "running" | "paused" | "queued" | "draft" | "planned" | "awaitingAuthorization" | "pauseRequested" | "verifying" | "cancelRequested";
+    acceptance: {
+        revision: number;
+        criteriaDigest: string;
+    };
     plan: {
         revision: number;
         digest: string;
@@ -92,10 +96,6 @@ export declare const missionRecordSchema: z.ZodObject<{
     budgetRef: string;
     executionMode: "durable-executor" | "session-bound";
     evidenceRefs: string[];
-    acceptance: {
-        revision: number;
-        criteriaDigest: string;
-    };
     lastEventSequence: number;
     authorizationRef?: string | undefined;
 }, {
@@ -103,6 +103,10 @@ export declare const missionRecordSchema: z.ZodObject<{
     updatedAt: string;
     schemaVersion: 1;
     state: "completed" | "cancelled" | "failed" | "blocked" | "running" | "paused" | "queued" | "draft" | "planned" | "awaitingAuthorization" | "pauseRequested" | "verifying" | "cancelRequested";
+    acceptance: {
+        revision: number;
+        criteriaDigest: string;
+    };
     plan: {
         revision: number;
         digest: string;
@@ -118,10 +122,6 @@ export declare const missionRecordSchema: z.ZodObject<{
     budgetRef: string;
     executionMode: "durable-executor" | "session-bound";
     evidenceRefs: string[];
-    acceptance: {
-        revision: number;
-        criteriaDigest: string;
-    };
     lastEventSequence: number;
     authorizationRef?: string | undefined;
 }>;
@@ -397,11 +397,11 @@ export declare const createInputSchema: z.ZodObject<{
     requestId: z.ZodString;
     objective: z.ZodString;
 }, "strict", z.ZodTypeAny, {
-    objective: string;
     requestId: string;
-}, {
     objective: string;
+}, {
     requestId: string;
+    objective: string;
 }>;
 export declare const planInputSchema: z.ZodObject<{
     requestId: z.ZodString;
@@ -580,6 +580,7 @@ export declare const planInputSchema: z.ZodObject<{
         } | undefined;
     }>;
 }, "strict", z.ZodTypeAny, {
+    requestId: string;
     plan: {
         tasks: {
             id: string;
@@ -616,10 +617,10 @@ export declare const planInputSchema: z.ZodObject<{
             baseline?: string | undefined;
         }[];
     };
-    requestId: string;
     missionId: string;
     expectedRevision: number;
 }, {
+    requestId: string;
     plan: {
         tasks: {
             id: string;
@@ -656,7 +657,6 @@ export declare const planInputSchema: z.ZodObject<{
             capabilities?: string[] | undefined;
         } | undefined;
     };
-    requestId: string;
     missionId: string;
     expectedRevision: number;
 }>;

package/v3/@claude-flow/cli/dist/src/services/managed-learning-loop.d.ts

@@ -0,0 +1,79 @@
+export type ManagedCycleInput = {
+    scope: unknown;
+    evidence: unknown[];
+    index?: boolean;
+    maxP95Ms?: number;
+    evaluation?: {
+        manifest: unknown;
+        baselineId: string;
+        candidateId: string;
+    };
+};
+/** authorize is host-owned and rechecked across asynchronous boundaries. */
+export declare function cycleLearning(root: string, value: unknown, publicKey: string | undefined, authorize: () => boolean): Promise<{
+    cycleId: string;
+    phases: string[];
+    recorded: string[];
+    duplicates: string[];
+    indexed: string[];
+    deferred: string[];
+    recommendation: {
+        advisory: boolean;
+        selected: {
+            strategy: {
+                id: string;
+                model: string;
+                workers: number;
+                template: string;
+            };
+            samples: number;
+            successes: number;
+            successRate: number;
+            successesPerDollar: number;
+            p95Ms: number;
+            evidenceIds: string[];
+        };
+        candidates: {
+            strategy: {
+                id: string;
+                model: string;
+                workers: number;
+                template: string;
+            };
+            samples: number;
+            successes: number;
+            successRate: number;
+            successesPerDollar: number;
+            p95Ms: number;
+            evidenceIds: string[];
+        }[];
+        abstained: boolean;
+        reason: string;
+        defaultsChanged: boolean;
+    };
+    evaluation: {
+        advisory: boolean;
+        eligible: boolean;
+        baselineP95Ms: number;
+        candidateP95Ms: number;
+        delta: number;
+        baselineEfficiency: number;
+        candidateEfficiency: number;
+        pairedResults: number;
+        corpusHash: string;
+        noRegression: boolean;
+        metaharness: import("./harness-benchmark.js").AcceptResult;
+        defaultsChanged: boolean;
+        evidenceIds: string[];
+    } | null;
+    memory: {
+        available: boolean;
+        recalled: number;
+        backend: string;
+    } | null;
+    elapsedMs: number;
+    advisory: boolean;
+    defaultsChanged: boolean;
+    promotionRequested: boolean;
+}>;
+//# sourceMappingURL=managed-learning-loop.d.ts.map

package/v3/@claude-flow/cli/dist/src/services/managed-learning-loop.js

@@ -0,0 +1,76 @@
+/** Bounded, replayable feedback cycle. Evaluation is never promotion authority. */
+import { digest, evidenceOf, isVerified, manifestOf, scopeOf, trustedEvidence } from './managed-learning.js';
+import { evaluateLearning, indexLearning, recallLearning, recordLearningBatch, recommendLearning } from './managed-learning-store.js';
+function inputOf(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Expected a managed cycle');
+    const v = value;
+    if (Object.keys(v).some(k => !['scope', 'evidence', 'index', 'maxP95Ms', 'evaluation'].includes(k)) || !Array.isArray(v.evidence) || v.evidence.length > 24)
+        throw new Error('Managed cycle accepts at most 24 signed outcomes');
+    if (v.index !== undefined && typeof v.index !== 'boolean')
+        throw new Error('Invalid indexing request');
+    if (v.maxP95Ms !== undefined && (typeof v.maxP95Ms !== 'number' || !Number.isFinite(v.maxP95Ms) || v.maxP95Ms <= 0 || v.maxP95Ms > 86_400_000))
+        throw new Error('Invalid latency constraint');
+    if (v.evaluation !== undefined) {
+        const e = v.evaluation;
+        if (!e || typeof e !== 'object' || Array.isArray(e) || Object.keys(e).length !== 3 || Object.keys(e).some(k => !['manifest', 'baselineId', 'candidateId'].includes(k)) || typeof e.baselineId !== 'string' || typeof e.candidateId !== 'string' || !/^[a-z][a-z0-9-]{0,39}$/.test(e.baselineId) || !/^[a-z][a-z0-9-]{0,39}$/.test(e.candidateId) || e.baselineId === e.candidateId)
+            throw new Error('Invalid evaluation request');
+        manifestOf(e.manifest);
+    }
+    scopeOf(v.scope);
+    return structuredClone(v);
+}
+/** authorize is host-owned and rechecked across asynchronous boundaries. */
+export async function cycleLearning(root, value, publicKey, authorize) {
+    const started = performance.now(), input = inputOf(value), scope = scopeOf(input.scope);
+    const rows = input.evidence.map(evidenceOf);
+    const check = () => { if (!authorize() || !publicKey)
+        throw new Error('Host learning policy or verifier changed'); };
+    check();
+    // Reject the whole batch before any write; unsigned input cannot start a cycle.
+    for (const e of rows)
+        if (!isVerified(e, publicKey) || e.observation.costCents === null || e.observation.durationMs === null || e.observation.taskType !== scope.taskType || e.observation.policyHash !== scope.policyHash || e.observation.evaluatorHash !== scope.evaluatorHash)
+            throw new Error('Every cycle outcome must be authenticated, measured and in scope');
+    const trusted = trustedEvidence(rows, publicKey).sort((a, b) => digest(a.observation).localeCompare(digest(b.observation)));
+    if (input.index && trusted.filter(e => e.observation.split === 'train').length > 6)
+        throw new Error('Indexing cycles accept at most six training outcomes; split the batch');
+    const cycleId = digest({ scope, evidence: trusted.map(e => digest(e.observation)).sort(), evaluation: input.evaluation ?? null, index: input.index ?? false, maxP95Ms: input.maxP95Ms ?? null });
+    const recorded = [], duplicates = [], indexed = [], deferred = [];
+    const phases = ['admitted'];
+    // One atomic batch avoids per-row sync/summary work. Later native failures
+    // leave a resumable signed batch, never a claimed indexed outcome.
+    check();
+    for (const r of trusted.length ? recordLearningBatch(root, trusted, publicKey) : []) {
+        (r.duplicate ? duplicates : recorded).push(r.id);
+    }
+    phases.push('recorded');
+    let memory;
+    if (input.index) {
+        const training = trusted.filter(e => e.observation.split === 'train');
+        for (const e of training.slice(0, 6)) {
+            check();
+            const r = await indexLearning(root, digest(e.observation), publicKey, authorize);
+            check();
+            if (r.indexed)
+                indexed.push(r.id);
+            else
+                deferred.push(r.id);
+        }
+        phases.push('indexed');
+        check();
+        memory = await recallLearning(root, scope, publicKey, authorize);
+        check();
+        phases.push('recalled');
+    }
+    check();
+    const recommendation = recommendLearning(root, scope, publicKey, input.maxP95Ms);
+    phases.push('recommended');
+    check();
+    const evaluation = input.evaluation ? evaluateLearning(root, { scope, ...input.evaluation }, publicKey) : null;
+    if (evaluation)
+        phases.push('evaluated');
+    return { cycleId, phases, recorded, duplicates, indexed, deferred, recommendation, evaluation,
+        memory: memory ? { available: memory.available, recalled: memory.evidence.length, backend: memory.backend } : null,
+        elapsedMs: performance.now() - started, advisory: true, defaultsChanged: false, promotionRequested: false };
+}
+//# sourceMappingURL=managed-learning-loop.js.map

package/v3/@claude-flow/cli/dist/src/services/managed-learning-store.d.ts

@@ -0,0 +1,187 @@
+import { type Evidence } from './managed-learning.js';
+export declare const LEARNING_PATH = ".claude-flow/managed-learning/state.json";
+export declare function learningStatus(root: string, publicKey?: string): {
+    version: number;
+    updatedMs: number;
+    observations: number;
+    verified: number;
+    quarantined: number;
+    training: number;
+    holdout: number;
+    verifierConfigured: boolean;
+    lastRecommendation: {
+        selected: {
+            evidenceIds: string[];
+            strategy: {
+                id: string;
+                model: string;
+                workers: number;
+                template: string;
+            };
+            samples: number;
+            successes: number;
+            successRate: number;
+            successesPerDollar: number;
+            p95Ms: number;
+        } | null;
+        candidates: {
+            evidenceIds: string[];
+            strategy: {
+                id: string;
+                model: string;
+                workers: number;
+                template: string;
+            };
+            samples: number;
+            successes: number;
+            successRate: number;
+            successesPerDollar: number;
+            p95Ms: number;
+        }[];
+        advisory: boolean;
+        abstained: boolean;
+        reason: string;
+        defaultsChanged: boolean;
+    } | null;
+    lastEvaluation: {
+        evidenceIds: string[];
+        advisory: boolean;
+        eligible: boolean;
+        baselineP95Ms: number;
+        candidateP95Ms: number;
+        delta: number;
+        baselineEfficiency: number;
+        candidateEfficiency: number;
+        pairedResults: number;
+        corpusHash: string;
+        noRegression: boolean;
+        metaharness: import("./harness-benchmark.js").AcceptResult;
+        defaultsChanged: boolean;
+    } | null;
+    advisory: boolean;
+    defaultsChanged: boolean;
+};
+/** Validate all input before acquiring the writer lock; publish the batch atomically. */
+export declare function recordLearningBatch(root: string, inputs: unknown[], publicKey?: string): {
+    stored: boolean;
+    duplicate: boolean;
+    id: string;
+    verified: boolean;
+}[];
+export declare function recordLearning(root: string, input: unknown, publicKey?: string): {
+    stored: boolean;
+    duplicate: boolean;
+    id: string;
+    verified: boolean;
+};
+export declare function recommendLearning(root: string, scope: unknown, publicKey?: string, maxP95Ms?: number): {
+    advisory: boolean;
+    selected: {
+        strategy: {
+            id: string;
+            model: string;
+            workers: number;
+            template: string;
+        };
+        samples: number;
+        successes: number;
+        successRate: number;
+        successesPerDollar: number;
+        p95Ms: number;
+        evidenceIds: string[];
+    };
+    candidates: {
+        strategy: {
+            id: string;
+            model: string;
+            workers: number;
+            template: string;
+        };
+        samples: number;
+        successes: number;
+        successRate: number;
+        successesPerDollar: number;
+        p95Ms: number;
+        evidenceIds: string[];
+    }[];
+    abstained: boolean;
+    reason: string;
+    defaultsChanged: boolean;
+};
+export declare function evaluateLearning(root: string, input: {
+    scope: unknown;
+    manifest: unknown;
+    baselineId: string;
+    candidateId: string;
+}, publicKey?: string): {
+    advisory: boolean;
+    eligible: boolean;
+    baselineP95Ms: number;
+    candidateP95Ms: number;
+    delta: number;
+    baselineEfficiency: number;
+    candidateEfficiency: number;
+    pairedResults: number;
+    corpusHash: string;
+    noRegression: boolean;
+    metaharness: import("./harness-benchmark.js").AcceptResult;
+    defaultsChanged: boolean;
+    evidenceIds: string[];
+};
+/** Export only verified training evidence to native append-only AgentDB/RuVector storage. */
+export declare function indexLearning(root: string, id: string, publicKey?: string, authorize?: () => boolean): Promise<{
+    indexed: boolean;
+    durable: boolean;
+    namespace: string;
+    id: string;
+    hasEmbedding: boolean;
+    advisory: boolean;
+}>;
+/** Memory similarity supplies recall evidence, never authority or a cherry-picked quality denominator. */
+export declare function recallLearning(root: string, input: unknown, publicKey?: string, authorize?: () => boolean): Promise<{
+    available: boolean;
+    backend: string;
+    evidence: {
+        id: string;
+        similarity: number;
+        strategy: Evidence["observation"]["strategy"];
+        sourceHash: string;
+    }[];
+    recommendation: {
+        advisory: boolean;
+        selected: {
+            strategy: {
+                id: string;
+                model: string;
+                workers: number;
+                template: string;
+            };
+            samples: number;
+            successes: number;
+            successRate: number;
+            successesPerDollar: number;
+            p95Ms: number;
+            evidenceIds: string[];
+        };
+        candidates: {
+            strategy: {
+                id: string;
+                model: string;
+                workers: number;
+                template: string;
+            };
+            samples: number;
+            successes: number;
+            successRate: number;
+            successesPerDollar: number;
+            p95Ms: number;
+            evidenceIds: string[];
+        }[];
+        abstained: boolean;
+        reason: string;
+        defaultsChanged: boolean;
+    };
+    advisory: boolean;
+    similarityIsVerification: boolean;
+}>;
+//# sourceMappingURL=managed-learning-store.d.ts.map