claude-flow 3.61.1 → 3.63.0

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

@@ -0,0 +1,238 @@
+/** Project-local bounded evidence ledger. Local files are revalidated, never trusted by label. */
+import { constants, closeSync, existsSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { nativeMemoryIndex, nativeMemoryRecall } from './managed-memory-client.js';
+import { digest, evidenceOf, evaluate, isVerified, manifestOf, recommend, scopeOf, trustedEvidence } from './managed-learning.js';
+export const LEARNING_PATH = '.claude-flow/managed-learning/state.json';
+const MAX_BYTES = 2_000_000;
+function directory(root, create = false) {
+    let dir = resolve(root);
+    if (!lstatSync(dir).isDirectory())
+        throw new Error('Learning root must be a directory');
+    for (const part of ['.claude-flow', 'managed-learning']) {
+        dir = join(dir, part);
+        if (!existsSync(dir)) {
+            if (create)
+                mkdirSync(dir, { mode: 0o700 });
+            else
+                return join(resolve(root), '.claude-flow', 'managed-learning');
+        }
+        if (existsSync(dir) && (!lstatSync(dir).isDirectory() || lstatSync(dir).isSymbolicLink()))
+            throw new Error('Learning directory must not be a symlink');
+    }
+    return dir;
+}
+function read(dir) {
+    const path = join(dir, 'state.json');
+    if (!existsSync(path))
+        return { version: 1, records: [], updatedMs: 0 };
+    if (!lstatSync(path).isFile() || lstatSync(path).isSymbolicLink())
+        throw new Error('Learning state must be a regular file');
+    const fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    let text;
+    try {
+        const stat = fstatSync(fd);
+        if (!stat.isFile() || stat.size > MAX_BYTES)
+            throw new Error('Learning state exceeds read limit');
+        // Fixed buffer also bounds a file that grows after fstat.
+        const buffer = Buffer.alloc(MAX_BYTES + 1);
+        const size = readSync(fd, buffer, 0, buffer.length, 0);
+        if (size > MAX_BYTES)
+            throw new Error('Learning state exceeds read limit');
+        text = buffer.subarray(0, size).toString('utf8');
+    }
+    finally {
+        closeSync(fd);
+    }
+    const value = JSON.parse(text);
+    if (value.version !== 1 || !Array.isArray(value.records) || value.records.length > 500 || !Number.isFinite(value.updatedMs))
+        throw new Error('Invalid learning state');
+    value.records = value.records.map(evidenceOf);
+    // Summaries are display-only; never rehydrate them as routing or promotion authority.
+    return value;
+}
+function syncDirectory(dir) { const fd = openSync(dir, constants.O_RDONLY); try {
+    fsyncSync(fd);
+}
+finally {
+    closeSync(fd);
+} }
+function mutate(root, action, publicKey) {
+    const dir = directory(root, true);
+    const lockPath = join(dir, 'writer.lock');
+    const lock = openSync(lockPath, 'wx', 0o600);
+    const temporary = join(dir, `${randomUUID()}.tmp`);
+    try {
+        syncDirectory(dir); // Refuse unsupported durability semantics before changing the ledger.
+        const state = read(dir), result = action(state);
+        state.updatedMs = Date.now();
+        const payload = JSON.stringify(state);
+        if (Buffer.byteLength(payload) > MAX_BYTES)
+            throw new Error('Learning ledger is full');
+        const fd = openSync(temporary, 'wx', 0o600);
+        try {
+            writeFileSync(fd, payload);
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        renameSync(temporary, join(dir, 'state.json'));
+        syncDirectory(dir);
+        // The console reads only this bounded advisory projection, never the full evidence ledger.
+        const summary = summaryOf(state, publicKey);
+        const summaryText = JSON.stringify(summary);
+        if (Buffer.byteLength(summaryText) > 64_000)
+            throw new Error('Learning summary limit exceeded');
+        const summaryFd = openSync(temporary, 'wx', 0o600);
+        try {
+            writeFileSync(summaryFd, summaryText);
+            fsyncSync(summaryFd);
+        }
+        finally {
+            closeSync(summaryFd);
+        }
+        renameSync(temporary, join(dir, 'summary.json'));
+        syncDirectory(dir);
+        return result;
+    }
+    finally {
+        if (existsSync(temporary))
+            unlinkSync(temporary);
+        closeSync(lock);
+        unlinkSync(lockPath);
+    }
+}
+function summaryOf(state, publicKey) {
+    const verified = trustedEvidence(state.records, publicKey);
+    let last = null;
+    let evaluation = null;
+    try {
+        if (state.recommendationInput)
+            last = recommend(verified, scopeOf(state.recommendationInput.scope), state.recommendationInput.maxP95Ms);
+    }
+    catch { /* invalidated advice */ }
+    try {
+        if (state.evaluationInput) {
+            const e = state.evaluationInput;
+            evaluation = evaluate(verified, scopeOf(e.scope), manifestOf(e.manifest), e.baselineId, e.candidateId);
+        }
+    }
+    catch { /* invalidated confirmation */ }
+    const compact = (r) => ({ ...r, evidenceIds: r.evidenceIds.slice(0, 6) });
+    return { version: 1, updatedMs: state.updatedMs, observations: state.records.length, verified: verified.length, quarantined: state.records.length - verified.length, training: verified.filter(e => e.observation.split === 'train').length, holdout: verified.filter(e => e.observation.split === 'holdout').length, verifierConfigured: !!publicKey,
+        lastRecommendation: last ? { ...last, selected: last.selected ? compact(last.selected) : null, candidates: last.candidates.slice(0, 6).map(compact) } : null,
+        lastEvaluation: evaluation ? { ...evaluation, evidenceIds: evaluation.evidenceIds.slice(0, 6) } : null,
+        advisory: true, defaultsChanged: false };
+}
+export function learningStatus(root, publicKey) { return summaryOf(read(directory(root)), publicKey); }
+function applyRecord(state, evidence, publicKey) {
+    const verified = isVerified(evidence, publicKey);
+    const previous = state.records.find(e => e.observation.attemptId === evidence.observation.attemptId && isVerified(e, publicKey));
+    if (previous && verified && digest(previous.observation) !== digest(evidence.observation))
+        throw new Error('Conflicting learning attempt; immutable verified observations cannot be overwritten');
+    const duplicate = state.records.find(e => digest(e) === digest(evidence));
+    if (duplicate)
+        return { stored: false, duplicate: true, id: digest(evidence.observation), verified };
+    const unsigned = state.records.find(e => !e.signature && digest(e.observation) === digest(evidence.observation));
+    if (unsigned && verified) {
+        unsigned.signature = evidence.signature;
+        return { stored: true, duplicate: false, id: digest(evidence.observation), verified: true };
+    }
+    if (!verified && state.records.filter(e => !isVerified(e, publicKey)).length >= 100)
+        throw new Error('Learning quarantine is full');
+    if (state.records.length >= 500)
+        throw new Error('Learning ledger is full');
+    state.records.push(evidence);
+    return { stored: true, duplicate: false, id: digest(evidence.observation), verified };
+}
+/** Validate all input before acquiring the writer lock; publish the batch atomically. */
+export function recordLearningBatch(root, inputs, publicKey) {
+    if (!Array.isArray(inputs) || inputs.length < 1 || inputs.length > 24)
+        throw new Error('Learning batch must contain 1 to 24 records');
+    const evidence = inputs.map(evidenceOf);
+    if (evidence.some(e => e.signature && !isVerified(e, publicKey)))
+        throw new Error('Untrusted or mismatched verifier receipt');
+    return mutate(root, state => evidence.map(e => applyRecord(state, e, publicKey)), publicKey);
+}
+export function recordLearning(root, input, publicKey) {
+    return recordLearningBatch(root, [input], publicKey)[0];
+}
+export function recommendLearning(root, scope, publicKey, maxP95Ms) {
+    return mutate(root, state => {
+        const result = recommend(trustedEvidence(state.records, publicKey), scopeOf(scope), maxP95Ms);
+        state.recommendationInput = { scope: scopeOf(scope), maxP95Ms };
+        state.lastRecommendation = result;
+        return result;
+    }, publicKey);
+}
+export function evaluateLearning(root, input, publicKey) {
+    return mutate(root, state => {
+        const result = evaluate(trustedEvidence(state.records, publicKey), scopeOf(input.scope), manifestOf(input.manifest), input.baselineId, input.candidateId);
+        const cohort = result.corpusHash, experiment = digest({ scope: scopeOf(input.scope), baselineId: input.baselineId, candidateId: input.candidateId });
+        if (state.confirmations?.[cohort] && state.confirmations[cohort] !== experiment)
+            throw new Error('Heldout corpus is already bound to another confirmation experiment');
+        state.confirmations = { ...(state.confirmations ?? {}), [cohort]: experiment };
+        state.evaluationInput = { ...input, scope: scopeOf(input.scope), manifest: manifestOf(input.manifest) };
+        state.lastEvaluation = result;
+        return result;
+    }, publicKey);
+}
+/** Export only verified training evidence to native append-only AgentDB/RuVector storage. */
+export async function indexLearning(root, id, publicKey, authorize = () => true) {
+    if (!/^[a-f0-9]{64}$/.test(id))
+        throw new Error('Invalid evidence ID');
+    const evidence = trustedEvidence(read(directory(root)).records, publicKey).find(e => digest(e.observation) === id && e.observation.split === 'train');
+    if (!evidence)
+        throw new Error('Verified training evidence required for indexing');
+    if (!authorize())
+        throw new Error('Managed memory policy denied');
+    const result = await nativeMemoryIndex(root, { id, value: JSON.stringify(evidence), taskType: evidence.observation.taskType }, authorize);
+    if (!authorize())
+        throw new Error('Managed memory policy changed; admitted write may have completed');
+    if (!result.durable)
+        throw new Error('Native evidence index did not confirm durable persistence');
+    return { indexed: result.hasEmbedding, durable: true, namespace: 'managed-workflow-evidence', id, hasEmbedding: result.hasEmbedding, advisory: true };
+}
+/** Memory similarity supplies recall evidence, never authority or a cherry-picked quality denominator. */
+export async function recallLearning(root, input, publicKey, authorize = () => true) {
+    const scope = scopeOf(input);
+    const local = trustedEvidence(read(directory(root)).records, publicKey).filter(e => e.observation.split === 'train' && e.observation.taskType === scope.taskType && e.observation.policyHash === scope.policyHash && e.observation.evaluatorHash === scope.evaluatorHash);
+    const allowed = new Set(local.map(e => digest(e.observation)));
+    let result;
+    if (!authorize())
+        throw new Error('Managed memory policy denied');
+    try {
+        result = await nativeMemoryRecall(root, { taskType: scope.taskType, allowedIds: [...allowed] }, authorize);
+    }
+    catch {
+        if (!authorize())
+            throw new Error('Managed memory policy denied');
+        return { available: false, backend: 'ruflo-memory-child', evidence: [], recommendation: recommend(local, scope), advisory: true, similarityIsVerification: false };
+    }
+    if (!authorize())
+        throw new Error('Managed memory policy denied');
+    if (!result.available)
+        return { available: false, backend: 'ruflo-memory-child', evidence: [], recommendation: recommend(local, scope), advisory: true, similarityIsVerification: false };
+    const seen = new Set();
+    const evidence = [];
+    for (const hit of result.rows.slice(0, 20)) {
+        if (hit.namespace !== 'managed-workflow-evidence' || !allowed.has(hit.key) || seen.has(hit.key) || !Number.isFinite(hit.score))
+            continue;
+        seen.add(hit.key);
+        try {
+            // The child hydrates exact native rows, not display previews. The MCP
+            // parent still authenticates every receipt and joins the local cohort.
+            if (typeof hit.content !== 'string' || Buffer.byteLength(hit.content) > 8192)
+                continue;
+            const receipt = evidenceOf(JSON.parse(hit.content));
+            if (!isVerified(receipt, publicKey) || digest(receipt.observation) !== hit.key)
+                continue;
+            evidence.push({ id: hit.key, similarity: hit.score, strategy: receipt.observation.strategy, sourceHash: receipt.observation.sourceHash });
+        }
+        catch { /* A missing or malformed row is not verified recall evidence. */ }
+    }
+    return { available: true, backend: 'ruflo-memory-child', evidence, recommendation: recommend(local, scope), advisory: true, similarityIsVerification: false };
+}
+//# sourceMappingURL=managed-learning-store.js.map

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

@@ -0,0 +1,108 @@
+export declare const TASK_TYPES: readonly ["code-review", "migration", "research", "test-generation", "implementation", "other"];
+export type Observation = {
+    v: 1;
+    attemptId: string;
+    taskHash: string;
+    sourceHash: string;
+    artifactHash: string;
+    policyHash: string;
+    corpusHash: string;
+    evaluatorHash: string;
+    taskType: typeof TASK_TYPES[number];
+    split: 'train' | 'holdout';
+    trial: number;
+    strategy: {
+        id: string;
+        model: string;
+        workers: number;
+        template: string;
+    };
+    budgetCents: number;
+    costCents: number | null;
+    durationMs: number | null;
+    checks: {
+        acceptance: boolean;
+        safety: boolean;
+        replay: boolean;
+        adversarial: boolean;
+        drift: number;
+        driftThreshold: number;
+        rollbackRate: number;
+    };
+};
+export type Evidence = {
+    observation: Observation;
+    signature?: string;
+};
+export type Manifest = {
+    taskHashes: string[];
+    trials: number[];
+};
+export declare function canonical(v: unknown): string;
+export declare const digest: (v: unknown) => string;
+/** Closed metadata contract: no prompts, arbitrary commands, transcripts or caller trust labels. */
+export declare function observationOf(value: unknown): Observation;
+export declare function evidenceOf(value: unknown): Evidence;
+/** Public key is configured by the host, never accepted from an MCP argument or stored record. */
+export declare function isVerified(evidence: Evidence, publicKey?: string): boolean;
+/** Revalidate every persisted record on each use; a JSON provenance label is not authority. */
+export declare function trustedEvidence(records: unknown[], publicKey?: string): Evidence[];
+export declare function manifestOf(value: unknown): Manifest;
+export type Scope = {
+    taskType: Observation['taskType'];
+    policyHash: string;
+    evaluatorHash: string;
+};
+export declare function scopeOf(value: unknown): Scope;
+/** Training evidence only; holdout records and unsigned observations cannot influence a pick. */
+export declare function recommend(records: Evidence[], scope: Scope, 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;
+};
+/** Complete paired heldout data, equal admitted budgets, source identity and existing MetaHarness conjunction. */
+export declare function evaluate(records: Evidence[], scope: Scope, manifest: Manifest, baselineId: string, candidateId: 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[];
+};
+//# sourceMappingURL=managed-learning.d.ts.map

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

@@ -0,0 +1,197 @@
+/** Verified, advisory workflow learning. Caller labels never establish trust. */
+import { createHash, createPublicKey, verify } from 'node:crypto';
+import { accept } from './harness-benchmark.js';
+export const TASK_TYPES = ['code-review', 'migration', 'research', 'test-generation', 'implementation', 'other'];
+const trusted = new WeakSet();
+const HASH = /^[a-f0-9]{64}$/;
+const ID = /^[a-z][a-z0-9-]{0,39}$/;
+const MODEL = /^[a-z][a-z0-9./-]{0,79}$/;
+const object = (v) => {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        throw new Error('Expected an object');
+    return v;
+};
+function exact(v, keys) {
+    if (Object.keys(v).length !== keys.length || Object.keys(v).some(k => !keys.includes(k)))
+        throw new Error('Unknown or missing learning fields');
+}
+const integer = (v, min, max) => typeof v === 'number' && Number.isSafeInteger(v) && v >= min && v <= max;
+const unit = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0 && v <= 1;
+export function canonical(v) {
+    if (Array.isArray(v))
+        return '[' + v.map(canonical).join(',') + ']';
+    if (v && typeof v === 'object')
+        return '{' + Object.keys(v).sort().map(k => JSON.stringify(k) + ':' + canonical(v[k])).join(',') + '}';
+    return JSON.stringify(v);
+}
+export const digest = (v) => createHash('sha256').update(canonical(v)).digest('hex');
+/** Closed metadata contract: no prompts, arbitrary commands, transcripts or caller trust labels. */
+export function observationOf(value) {
+    const v = object(value);
+    exact(v, ['v', 'attemptId', 'taskHash', 'sourceHash', 'artifactHash', 'policyHash', 'corpusHash', 'evaluatorHash', 'taskType', 'split', 'trial', 'strategy', 'budgetCents', 'costCents', 'durationMs', 'checks']);
+    if (v.v !== 1 || !TASK_TYPES.includes(v.taskType) || !['train', 'holdout'].includes(v.split) || !integer(v.trial, 0, 99))
+        throw new Error('Invalid learning cohort');
+    for (const key of ['attemptId', 'taskHash', 'sourceHash', 'artifactHash', 'policyHash', 'corpusHash', 'evaluatorHash'])
+        if (typeof v[key] !== 'string' || !HASH.test(v[key]))
+            throw new Error('Invalid evidence hash');
+    const strategy = object(v.strategy);
+    exact(strategy, ['id', 'model', 'workers', 'template']);
+    if (!ID.test(String(strategy.id)) || !ID.test(String(strategy.template)) || !MODEL.test(String(strategy.model)) || !integer(strategy.workers, 1, 64))
+        throw new Error('Invalid workflow strategy');
+    if (!integer(v.budgetCents, 1, 999_999_999) || (v.costCents !== null && !integer(v.costCents, 0, 999_999_999)) || (v.durationMs !== null && !integer(v.durationMs, 0, 86_400_000)))
+        throw new Error('Invalid measured cost or duration');
+    const checks = object(v.checks);
+    exact(checks, ['acceptance', 'safety', 'replay', 'adversarial', 'drift', 'driftThreshold', 'rollbackRate']);
+    if (['acceptance', 'safety', 'replay', 'adversarial'].some(k => typeof checks[k] !== 'boolean') || !unit(checks.drift) || !unit(checks.driftThreshold) || !unit(checks.rollbackRate))
+        throw new Error('Invalid verification measurements');
+    // Detach caller objects, including nested strategy/checks, before hashing or persistence.
+    return JSON.parse(JSON.stringify(v));
+}
+export function evidenceOf(value) {
+    const v = object(value);
+    if (Object.keys(v).some(k => !['observation', 'signature'].includes(k)))
+        throw new Error('Unknown evidence fields');
+    const observation = observationOf(v.observation);
+    // Canonical form only: the last base64 character of a 64-byte signature has 4 unused bits that the decoder ignores, so
+    // other spellings of the same bytes would verify yet digest differently and be stored as separate records.
+    if (v.signature !== undefined && (typeof v.signature !== 'string' || !/^[A-Za-z0-9+/]{86}==$/.test(v.signature)
+        || Buffer.from(v.signature, 'base64').toString('base64') !== v.signature))
+        throw new Error('Invalid verifier signature');
+    return { observation, ...(v.signature ? { signature: v.signature } : {}) };
+}
+/** Public key is configured by the host, never accepted from an MCP argument or stored record. */
+export function isVerified(evidence, publicKey) {
+    if (!publicKey || !evidence.signature)
+        return false;
+    try {
+        const key = createPublicKey(publicKey);
+        return key.asymmetricKeyType === 'ed25519' && verify(null, Buffer.from(canonical(evidence.observation)), key, Buffer.from(evidence.signature, 'base64'));
+    }
+    catch {
+        return false;
+    }
+}
+/** Revalidate every persisted record on each use; a JSON provenance label is not authority. */
+export function trustedEvidence(records, publicKey) {
+    const out = [];
+    const ids = new Map();
+    for (const raw of records) {
+        const e = evidenceOf(raw);
+        if (!isVerified(e, publicKey) || e.observation.costCents === null || e.observation.durationMs === null)
+            continue;
+        const hash = digest(e.observation);
+        const previous = ids.get(e.observation.attemptId);
+        if (previous && previous !== hash)
+            throw new Error('Conflicting learning attempt');
+        if (previous)
+            continue;
+        ids.set(e.observation.attemptId, hash);
+        {
+            Object.freeze(e.observation.strategy);
+            Object.freeze(e.observation.checks);
+            Object.freeze(e.observation);
+            Object.freeze(e);
+            trusted.add(e);
+            out.push(e);
+        }
+    }
+    return out;
+}
+export function manifestOf(value) {
+    const m = object(value);
+    exact(m, ['taskHashes', 'trials']);
+    if (!Array.isArray(m.taskHashes) || m.taskHashes.length < 2 || m.taskHashes.length > 100 || m.taskHashes.some(h => typeof h !== 'string' || !HASH.test(h)) || new Set(m.taskHashes).size !== m.taskHashes.length)
+        throw new Error('Manifest needs 2 to 100 unique task hashes');
+    if (!Array.isArray(m.trials) || m.trials.length < 3 || m.trials.length > 10 || m.trials.some(t => !integer(t, 0, 99)) || new Set(m.trials).size !== m.trials.length)
+        throw new Error('Manifest needs 3 to 10 unique trials');
+    return { taskHashes: [...m.taskHashes].sort(), trials: [...m.trials].sort((a, b) => a - b) };
+}
+export function scopeOf(value) {
+    const s = object(value);
+    exact(s, ['taskType', 'policyHash', 'evaluatorHash']);
+    if (!TASK_TYPES.includes(s.taskType) || !HASH.test(String(s.policyHash)) || !HASH.test(String(s.evaluatorHash)))
+        throw new Error('Invalid recommendation scope');
+    return { taskType: s.taskType, policyHash: s.policyHash, evaluatorHash: s.evaluatorHash };
+}
+const inScope = (o, s) => o.taskType === s.taskType && o.policyHash === s.policyHash && o.evaluatorHash === s.evaluatorHash;
+const success = (o) => o.checks.acceptance && o.checks.safety ? 1 : 0;
+const p95 = (values) => [...values].sort((a, b) => a - b)[Math.max(0, Math.ceil(values.length * .95) - 1)] ?? 0;
+/** Training evidence only; holdout records and unsigned observations cannot influence a pick. */
+export function recommend(records, scope, maxP95Ms = 86_400_000) {
+    if (records.some(e => !trusted.has(e)))
+        throw new Error('Host-verified evidence required');
+    if (!integer(maxP95Ms, 1, 86_400_000))
+        throw new Error('Invalid latency constraint');
+    const groups = new Map();
+    for (const e of records) {
+        if (e.observation.split !== 'train' || !inScope(e.observation, scope))
+            continue;
+        const key = canonical(e.observation.strategy);
+        groups.set(key, [...(groups.get(key) ?? []), e]);
+    }
+    const candidates = [...groups.values()].flatMap(rows => {
+        if (rows.length < 3 || new Set(rows.map(r => r.observation.taskHash)).size < 3)
+            return [];
+        const totalCost = rows.reduce((n, r) => n + (r.observation.costCents ?? 0), 0);
+        const latency = p95(rows.map(r => r.observation.durationMs));
+        if (totalCost <= 0 || latency > maxP95Ms || rows.some(r => !r.observation.checks.safety))
+            return [];
+        const successes = rows.reduce((n, r) => n + success(r.observation), 0);
+        if (successes === 0)
+            return [];
+        return [{ strategy: rows[0].observation.strategy, samples: rows.length, successes, successRate: successes / rows.length, successesPerDollar: successes * 100 / totalCost, p95Ms: latency, evidenceIds: rows.map(r => digest(r.observation)).sort() }];
+    }).sort((a, b) => b.successesPerDollar - a.successesPerDollar || a.p95Ms - b.p95Ms || canonical(a.strategy).localeCompare(canonical(b.strategy)));
+    return { advisory: true, selected: candidates[0] ?? null, candidates, abstained: candidates.length === 0, reason: candidates.length ? 'Ranked by measured training successes per dollar within exact policy/evaluator scope' : 'Insufficient trusted training evidence within scope and latency constraint', defaultsChanged: false };
+}
+/** Complete paired heldout data, equal admitted budgets, source identity and existing MetaHarness conjunction. */
+export function evaluate(records, scope, manifest, baselineId, candidateId) {
+    if (records.some(e => !trusted.has(e)))
+        throw new Error('Host-verified evidence required');
+    if (!ID.test(baselineId) || !ID.test(candidateId) || baselineId === candidateId)
+        throw new Error('Distinct strategy IDs required');
+    const corpusHash = digest(manifest);
+    const relevant = records.filter(e => inScope(e.observation, scope) && [baselineId, candidateId].includes(e.observation.strategy.id));
+    const trainingTasks = new Set(records.filter(e => inScope(e.observation, scope) && e.observation.split === 'train').map(e => e.observation.taskHash));
+    if (manifest.taskHashes.some(h => trainingTasks.has(h)))
+        throw new Error('Training and heldout tasks overlap');
+    const rows = relevant.filter(e => e.observation.split === 'holdout' && e.observation.corpusHash === corpusHash);
+    for (const id of [baselineId, candidateId])
+        if (new Set(rows.filter(r => r.observation.strategy.id === id).map(r => canonical(r.observation.strategy))).size !== 1)
+            throw new Error('Missing or inconsistent strategy configuration');
+    const paired = [];
+    for (const taskHash of manifest.taskHashes)
+        for (const trial of manifest.trials) {
+            const pick = (id) => rows.filter(e => e.observation.taskHash === taskHash && e.observation.trial === trial && e.observation.strategy.id === id);
+            const base = pick(baselineId), candidate = pick(candidateId);
+            if (base.length !== 1 || candidate.length !== 1)
+                throw new Error('Missing or duplicate paired heldout result');
+            const b = base[0].observation, c = candidate[0].observation;
+            if (b.sourceHash !== c.sourceHash || b.budgetCents !== c.budgetCents)
+                throw new Error('Source identity or admitted budgets differ');
+            paired.push([b, c]);
+        }
+    const base = paired.map(p => p[0]), candidate = paired.map(p => p[1]);
+    const efficiency = (rows) => {
+        const cost = rows.reduce((n, r) => n + r.costCents, 0);
+        if (cost <= 0)
+            throw new Error('Positive measured cost required');
+        return rows.reduce((n, r) => n + success(r), 0) * 100 / cost;
+    };
+    const baselineEfficiency = efficiency(base), candidateEfficiency = efficiency(candidate);
+    if (baselineEfficiency <= 0)
+        throw new Error('Nonzero baseline success required for relative improvement');
+    const delta = candidateEfficiency / baselineEfficiency - 1;
+    const total = baselineEfficiency + candidateEfficiency;
+    const all = [...base, ...candidate];
+    const gate = accept({
+        heldOutScore: candidateEfficiency / total, baselineHeldOutScore: baselineEfficiency / total,
+        redblue: all.every(o => o.checks.adversarial) ? 'PASS' : 'FAIL',
+        drift: Math.max(...candidate.map(o => o.checks.drift)), driftThreshold: Math.min(...candidate.map(o => o.checks.driftThreshold)),
+        replayDeterministic: all.every(o => o.checks.replay), receiptCoverage: 1,
+        canaryRollbackRate: Math.max(...candidate.map(o => o.checks.rollbackRate)), baselineRollbackRate: Math.max(...base.map(o => o.checks.rollbackRate)),
+    });
+    const noRegression = paired.every(([b, c]) => success(c) >= success(b)) && all.every(o => o.checks.safety);
+    const baselineP95Ms = p95(base.map(o => o.durationMs)), candidateP95Ms = p95(candidate.map(o => o.durationMs));
+    return { advisory: true, eligible: gate.accept && delta >= .10 - Number.EPSILON && noRegression && candidateP95Ms <= baselineP95Ms, baselineP95Ms, candidateP95Ms, delta, baselineEfficiency, candidateEfficiency, pairedResults: paired.length, corpusHash, noRegression, metaharness: gate, defaultsChanged: false, evidenceIds: rows.map(r => digest(r.observation)).sort() };
+}
+//# sourceMappingURL=managed-learning.js.map

package/v3/@claude-flow/cli/dist/src/services/managed-memory-client.d.ts

@@ -0,0 +1,72 @@
+/** Native memory runs behind a bounded child boundary, never in the MCP process. */
+import { type ChildProcess } from 'node:child_process';
+export declare const MANAGED_MEMORY_NAMESPACE = "managed-workflow-evidence";
+export declare const MANAGED_MEMORY_LIMITS: {
+    readonly workers: 1;
+    readonly requestBytes: 80000;
+    readonly resultBytes: 200000;
+    readonly rows: 20;
+    readonly rowBytes: 8192;
+    readonly timeoutMs: 15000;
+    readonly idleMs: 5000;
+};
+export type MemoryRequest = {
+    operation: 'index';
+    id: string;
+    value: string;
+    taskType: string;
+} | {
+    operation: 'recall';
+    taskType: string;
+    allowedIds: string[];
+};
+export type MemoryRow = {
+    key: string;
+    namespace: typeof MANAGED_MEMORY_NAMESPACE;
+    score: number;
+    content: string;
+};
+export type MemoryResult = {
+    operation: 'index';
+    durable: true;
+    hasEmbedding: boolean;
+} | {
+    operation: 'recall';
+    available: boolean;
+    rows: MemoryRow[];
+};
+/** The optional fork callback is an in-process host test seam, not a serialized tool argument. */
+export declare class ManagedMemoryClient {
+    private readonly slots;
+    private readonly timeoutMs;
+    private readonly idleMs;
+    private readonly forkWorker;
+    constructor(options?: {
+        timeoutMs?: number;
+        idleMs?: number;
+        forkWorker?: (root: string) => ChildProcess;
+    });
+    run(root: string, raw: unknown, authorize?: () => boolean): Promise<MemoryResult>;
+    stats(): {
+        workers: number;
+        busy: number;
+    };
+    close(): void;
+    private remove;
+}
+export declare const managedMemoryClient: ManagedMemoryClient;
+export declare function nativeMemoryIndex(root: string, input: Omit<Extract<MemoryRequest, {
+    operation: 'index';
+}>, 'operation'>, authorize?: () => boolean): Promise<{
+    operation: "index";
+    durable: true;
+    hasEmbedding: boolean;
+}>;
+export declare function nativeMemoryRecall(root: string, input: Omit<Extract<MemoryRequest, {
+    operation: 'recall';
+}>, 'operation'>, authorize?: () => boolean): Promise<{
+    operation: "recall";
+    available: boolean;
+    rows: MemoryRow[];
+}>;
+//# sourceMappingURL=managed-memory-client.d.ts.map