claude-flow 3.61.1 → 3.63.0

package/v3/@claude-flow/cli/dist/src/rure/cuda-plan.js

@@ -0,0 +1,197 @@
+import { limitsFor, occupancy } from './cuda-occupancy.js';
+export const DEFAULT_BLOCK_SIZES = [32, 64, 96, 128, 192, 256, 384, 512, 768, 1024];
+export const MAX_BLOCK_SIZES = 24;
+export const MAX_DYNAMIC_SHARED_BYTES = 1024 * 1024;
+export const MAX_PLANNED_KERNELS = 200;
+export const ASSUMPTIONS = [
+    'Theoretical occupancy: how many warps can be resident on one multiprocessor given the kernel\'s registers and static shared memory. It bounds, and does not predict, performance.',
+    'Static shared memory is the amount in the file, less the 1 KiB the driver reserves per block where the compiler folds it into that figure (sm_90 and later); a kernel with no static shared section uses none. Dynamic shared memory is not in the file, so it is the dynamicSharedBytes parameter (default 0), the same for every kernel.',
+    'Default shared-memory carveout and cache configuration, one block barrier per block (the default), no cluster launch, and no opt-in to more than 48 KiB of shared memory per block.',
+    'The registers in the file are what the compiler chose for that architecture; the driver may JIT PTX to different numbers.',
+    'Running the plan is a separate step that you take; nothing here compiles or runs GPU code.',
+];
+const round4 = (n) => Math.round(n * 10_000) / 10_000;
+function cleanSizes(sizes) {
+    const wanted = sizes === undefined ? [...DEFAULT_BLOCK_SIZES] : [...sizes];
+    if (wanted.length === 0 || wanted.length > MAX_BLOCK_SIZES)
+        throw new RangeError(`blockSizes must hold 1 to ${MAX_BLOCK_SIZES} sizes`);
+    for (const size of wanted)
+        if (!Number.isInteger(size) || size < 1 || size > 1024)
+            throw new RangeError('each block size must be an integer from 1 to 1024');
+    return [...new Set(wanted)].sort((a, b) => a - b);
+}
+function planKernel(kernel, arch, sizes, dynamic) {
+    const limits = limitsFor(arch);
+    const sectionShared = kernel.sharedBytes ?? 0;
+    const staticShared = Math.max(0, sectionShared - (limits.cubinSharedIncludesReserve ? limits.sharedReservedPerBlock : 0));
+    const local = kernel.localBytes ?? 0;
+    const out = {
+        name: kernel.name,
+        identifier: kernel.identifier,
+        resources: { registers: kernel.registers, staticSharedBytes: staticShared, sharedSectionBytes: sectionShared, localBytes: local, constantBytes: kernel.constantBytes, codeBytes: kernel.codeBytes },
+        flags: [],
+    };
+    if (local > 0)
+        out.flags.push('local-memory');
+    if (kernel.registers === null || kernel.registers < 1) {
+        out.note = 'the file holds no register count for this kernel, so occupancy cannot be worked out';
+        return out;
+    }
+    out.blockSizes = sizes.map((blockSize) => {
+        const r = occupancy(limits, { registers: kernel.registers, staticSharedBytes: staticShared, dynamicSharedBytes: dynamic, blockSize });
+        return { blockSize, activeBlocksPerSM: r.blocks, activeWarpsPerSM: r.activeWarps, occupancy: round4(r.occupancy), limitedBy: r.limiters };
+    });
+    const top = Math.max(...out.blockSizes.map((b) => b.occupancy));
+    const best = out.blockSizes.filter((b) => b.occupancy === top);
+    if (top > 0) {
+        // The limiters at the smallest best size are the ones to report: a larger one only repeats them.
+        const first = best[0];
+        out.best = { blockSizes: best.map((b) => b.blockSize), occupancy: top, limitedBy: first.limitedBy };
+        if (top < 1 && first.limitedBy.includes('registers'))
+            out.flags.push('register-limited');
+        if (top < 1 && first.limitedBy.includes('sharedMemory'))
+            out.flags.push('shared-memory-limited');
+    }
+    else
+        out.note = 'no listed block size can launch with these resources';
+    return out;
+}
+export function planCuda(info, options = {}) {
+    const sizes = cleanSizes(options.blockSizes);
+    const dynamic = options.dynamicSharedBytes ?? 0;
+    if (!Number.isInteger(dynamic) || dynamic < 0 || dynamic > MAX_DYNAMIC_SHARED_BYTES)
+        throw new RangeError(`dynamicSharedBytes must be an integer from 0 to ${MAX_DYNAMIC_SHARED_BYTES}`);
+    const wanted = options.arch === undefined ? info.cubinArchs : [options.arch];
+    const archs = [];
+    let planned = 0;
+    let truncated = false;
+    for (const arch of wanted) {
+        const limits = limitsFor(arch);
+        if (limits === null) {
+            archs.push({ arch, supported: false, provenance: null, kernels: [], note: `no occupancy limits are tabulated for ${arch}` });
+            continue;
+        }
+        const entries = info.kernels.filter((kernel) => kernel.isEntry && kernel.arch === arch);
+        const kernels = [];
+        for (const kernel of entries) {
+            if (planned >= MAX_PLANNED_KERNELS) {
+                truncated = true;
+                break;
+            }
+            kernels.push(planKernel(kernel, arch, sizes, dynamic));
+            planned++;
+        }
+        archs.push({
+            arch,
+            supported: true,
+            provenance: limits.provenance,
+            limits: { maxThreadsPerSM: limits.maxThreadsPerSM, maxBlocksPerSM: limits.maxBlocksPerSM, regsPerSM: limits.regsPerSM, sharedPerSM: limits.sharedPerSM, sharedReservedPerBlock: limits.sharedReservedPerBlock },
+            kernels,
+            ...(entries.length === 0 && { note: `${arch} is in the file but holds no launchable kernel` }),
+        });
+    }
+    const noCubins = info.cubinArchs.length === 0;
+    return {
+        archs,
+        blockSizes: sizes,
+        dynamicSharedBytes: dynamic,
+        assumptions: [...ASSUMPTIONS, ...(noCubins ? ['The file holds no compiled code for any architecture (PTX only, or nothing readable), so there are no register counts to plan from.'] : [])],
+        ...(options.includeHarness === true && { harness: HARNESS_SOURCE }),
+        truncated,
+    };
+}
+/**
+ * A program a person can build and run. It is text, fixed in this file: it contains nothing from the analyzed file. Run as
+ *   ./occ_check <file.cubin|file.fatbin> <kernel name as listed> [dynamicSharedBytes]
+ * it asks the CUDA driver how many blocks fit per multiprocessor at each block size (compare with the plan), and, if built with -DRURE_BENCH and a
+ * rure_bench.h of your own that sets up the kernel's arguments, times launches. It loads the file's code onto the GPU; the benchmark mode runs it.
+ */
+export const HARNESS_SOURCE = `// occ_check.cpp: written by ruflo's rure_cuda_launch_plan. ruRE did not build or run this; building and running it is your decision.
+// Build:  nvcc -O2 -o occ_check occ_check.cpp -lcuda            (add -DRURE_BENCH with your own rure_bench.h to time launches)
+// Run:    ./occ_check <file.cubin|file.fatbin> <kernel name> [dynamicSharedBytes]
+// Without RURE_BENCH it loads the code onto device 0 and asks the driver for occupancy; it launches nothing.
+// With RURE_BENCH it LAUNCHES THE KERNEL with the arguments your rure_bench.h gives it. Only do that for code you trust, on a GPU you can spare.
+#include <cuda.h>
+#include <algorithm>
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
+#include <iterator>
+#include <vector>
+#ifdef RURE_BENCH
+// rure_bench.h must define:
+//   bool rure_prepare(void*** kernelParams);   allocate buffers, fill an array of pointers to the kernel's arguments
+//   unsigned rure_grid(int blockSize);         how many blocks to launch at this block size
+//   void rure_release();
+#include "rure_bench.h"
+#endif
+
+#define CK(call) do { CUresult r_ = (call); if (r_ != CUDA_SUCCESS) { const char* m_ = nullptr; cuGetErrorString(r_, &m_); fprintf(stderr, "line %d: %s\\n", __LINE__, m_ ? m_ : "error"); return 1; } } while (0)
+
+int main(int argc, char** argv) {
+  if (argc < 3) { fprintf(stderr, "usage: %s <file.cubin|file.fatbin> <kernel name> [dynamicSharedBytes]\\n", argv[0]); return 2; }
+  size_t dyn = argc > 3 ? strtoull(argv[3], nullptr, 10) : 0;
+  std::ifstream in(argv[1], std::ios::binary);
+  std::vector<char> image((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
+  if (image.empty()) { fprintf(stderr, "cannot read %s\\n", argv[1]); return 2; }
+
+  CK(cuInit(0));
+  CUdevice dev; CK(cuDeviceGet(&dev, 0));
+  CUcontext ctx; CK(cuDevicePrimaryCtxRetain(&ctx, dev)); CK(cuCtxSetCurrent(ctx));
+  CUmodule mod; CK(cuModuleLoadData(&mod, image.data()));
+  CUfunction fn; CK(cuModuleGetFunction(&fn, mod, argv[2]));
+
+  int regs, shared, local, maxThreads, maxThreadsSM, major, minor, blocksSM, regsSM, sharedSM, reserved, optin;
+  CK(cuFuncGetAttribute(&regs, CU_FUNC_ATTRIBUTE_NUM_REGS, fn));
+  CK(cuFuncGetAttribute(&shared, CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES, fn));
+  CK(cuFuncGetAttribute(&local, CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES, fn));
+  CK(cuFuncGetAttribute(&maxThreads, CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK, fn));
+  CK(cuDeviceGetAttribute(&maxThreadsSM, CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR, dev));
+  CK(cuDeviceGetAttribute(&major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, dev));
+  CK(cuDeviceGetAttribute(&minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, dev));
+  CK(cuDeviceGetAttribute(&blocksSM, CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR, dev));
+  CK(cuDeviceGetAttribute(&regsSM, CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR, dev));
+  CK(cuDeviceGetAttribute(&sharedSM, CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR, dev));
+  CK(cuDeviceGetAttribute(&reserved, CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK, dev));
+  CK(cuDeviceGetAttribute(&optin, CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN, dev));
+  printf("device sm_%d%d: maxThreadsPerSM %d, maxBlocksPerSM %d, regsPerSM %d, sharedPerSM %d, sharedReservedPerBlock %d, sharedPerBlockOptin %d\\n", major, minor, maxThreadsSM, blocksSM, regsSM, sharedSM, reserved, optin);
+  printf("kernel: registers %d, static shared %d, local %d, max threads per block %d\\n", regs, shared, local, maxThreads);
+  printf("blockSize activeBlocksPerSM activeWarpsPerSM occupancy%s\\n",
+#ifdef RURE_BENCH
+         " medianMs");
+#else
+         "");
+#endif
+
+  const int sizes[] = {32, 64, 96, 128, 192, 256, 384, 512, 768, 1024};
+  for (int b : sizes) {
+    int blocks = 0;
+    if (cuOccupancyMaxActiveBlocksPerMultiprocessor(&blocks, fn, b, dyn) != CUDA_SUCCESS) blocks = 0;
+    int warps = blocks * ((b + 31) / 32);
+    printf("%d %d %d %.4f", b, blocks, warps, (double)warps / (maxThreadsSM / 32));
+#ifdef RURE_BENCH
+    double ms = -1;
+    if (blocks > 0) {
+      void** params = nullptr;
+      if (!rure_prepare(&params)) { fprintf(stderr, "rure_prepare failed\\n"); return 1; }
+      CUevent t0, t1; CK(cuEventCreate(&t0, CU_EVENT_DEFAULT)); CK(cuEventCreate(&t1, CU_EVENT_DEFAULT));
+      std::vector<float> times;
+      for (int i = 0; i < 23; i++) {
+        CK(cuEventRecord(t0, 0));
+        CK(cuLaunchKernel(fn, rure_grid(b), 1, 1, b, 1, 1, (unsigned)dyn, 0, params, 0));
+        CK(cuEventRecord(t1, 0)); CK(cuEventSynchronize(t1));
+        float t; CK(cuEventElapsedTime(&t, t0, t1));
+        if (i >= 3) times.push_back(t);
+      }
+      std::sort(times.begin(), times.end());
+      ms = times[times.size() / 2];
+      rure_release();
+    }
+    printf(" %.4f", ms);
+#endif
+    printf("\\n");
+  }
+  return 0;
+}
+`;
+//# sourceMappingURL=cuda-plan.js.map

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

@@ -584,7 +584,12 @@ export class HeadlessWorkerExecutor extends EventEmitter {
             return false;
         }
         clearTimeout(entry.timeout);
-        this.killEntryTree(entry.process, 'SIGTERM');
+        if (entry.abort) {
+            entry.abort();
+        }
+        else {
+            this.killEntryTree(entry.process, 'SIGTERM');
+        }
         this.processPool.delete(executionId);
         this.emit('cancelled', { executionId });
         // Process next in queue
@@ -600,15 +605,21 @@ export class HeadlessWorkerExecutor extends EventEmitter {
         const entries = Array.from(this.processPool.entries());
         for (const [executionId, entry] of entries) {
             clearTimeout(entry.timeout);
-            this.killEntryTree(entry.process, 'SIGTERM');
-            // SIGKILL fallback after 5s to prevent orphan processes (#1395 Bug 6)
-            setTimeout(() => {
-                try {
-                    if (!entry.process.killed)
-                        this.killEntryTree(entry.process, 'SIGKILL');
-                }
-                catch { /* already dead */ }
-            }, 5000).unref();
+            if (entry.abort) {
+                // Settles the promise and owns the SIGTERM -> SIGKILL escalation (#4463).
+                entry.abort();
+            }
+            else {
+                this.killEntryTree(entry.process, 'SIGTERM');
+                // SIGKILL fallback after 5s to prevent orphan processes (#1395 Bug 6)
+                setTimeout(() => {
+                    try {
+                        if (entry.process.exitCode === null && entry.process.signalCode === null)
+                            this.killEntryTree(entry.process, 'SIGKILL');
+                    }
+                    catch { /* already dead */ }
+                }, 5000).unref();
+            }
             this.emit('cancelled', { executionId });
             cancelled++;
         }
@@ -1075,16 +1086,31 @@ Analyze the above codebase context and provide your response following the forma
                 }
                 catch { /* already dead */ }
             };
+            // #4463 — `child.killed` only means a signal was delivered, not that the
+            // child exited, so escalation keys off the exit state instead.
+            const hasExited = () => child.exitCode !== null || child.signalCode !== null;
+            let escalationHandle;
+            let deadlineHandle;
+            const terminate = () => {
+                if (escalationHandle)
+                    return; // already signalled; never repeat SIGTERM
+                killTree('SIGTERM');
+                // Give it a moment to terminate gracefully, then force it.
+                escalationHandle = setTimeout(() => {
+                    if (!hasExited())
+                        killTree('SIGKILL');
+                }, 5000);
+            };
+            const stopTimers = () => {
+                clearTimeout(escalationHandle);
+                clearTimeout(deadlineHandle);
+            };
+            child.once('exit', () => clearTimeout(escalationHandle));
+            child.once('close', stopTimers);
             // Setup timeout
             const timeoutHandle = setTimeout(() => {
                 if (this.processPool.has(options.executionId)) {
-                    killTree('SIGTERM');
-                    // Give it a moment to terminate gracefully
-                    setTimeout(() => {
-                        if (!child.killed) {
-                            killTree('SIGKILL');
-                        }
-                    }, 5000);
+                    terminate();
                 }
             }, options.timeoutMs);
             // Track in process pool
@@ -1101,8 +1127,17 @@ Analyze the above codebase context and provide your response following the forma
             let resolved = false;
             const cleanup = () => {
                 clearTimeout(timeoutHandle);
+                clearTimeout(deadlineHandle);
                 this.processPool.delete(options.executionId);
             };
+            poolEntry.abort = () => {
+                if (resolved)
+                    return;
+                resolved = true;
+                terminate();
+                cleanup();
+                resolve({ success: false, output: stdout || stderr, error: 'Execution cancelled' });
+            };
             child.stdout?.on('data', (data) => {
                 const chunk = data.toString();
                 stdout += chunk;
@@ -1152,13 +1187,15 @@ Analyze the above codebase context and provide your response following the forma
                 });
             });
             // Handle timeout
-            setTimeout(() => {
+            deadlineHandle = setTimeout(() => {
                 if (resolved)
                     return;
                 if (!this.processPool.has(options.executionId))
                     return;
                 resolved = true;
-                killTree('SIGTERM');
+                // Normally a no-op: the timeout handler above already signalled the
+                // tree and owns the SIGKILL escalation (no duplicate SIGTERM).
+                terminate();
                 cleanup();
                 resolve({
                     success: false,

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