@claude-flow/cli 3.32.25 → 3.32.26

package/dist/src/services/harness-flywheel.js

@@ -11,10 +11,9 @@
  *   4. GATE the winner through the shipped runHarnessLoop on the HELD-OUT split:
  *      held_out_improves AND redblue(anchor-no-regress) AND drift<=thr AND
  *      replay-deterministic AND receipt_coverage AND canary-no-worse.
- *   5. On accept → APPLY locally (the install self-optimizes on its own data; no
- *      signing needed because nothing is propagated), CHAIN to the previous
- *      champion, and record the attempt in the improvement ledger. Also STAGE
- *      the unsigned champion for optional promotion to the signed global channel.
+ *   5. On accept → emit + persist an immutable evaluation receipt. Evaluation
+ *      never mutates active policy. Explicit promotion is handled by the
+ *      ADR-322A transaction service.
  *
  * Trust split: LOCAL self-optimization is unsigned (an install trusting its own
  * measured gate); CROSS-install propagation still requires the config-signed
@@ -27,6 +26,8 @@ import { hashCorpus } from './harness-benchmark.js';
 import { harvestSelfSupervisedTasks, blendCorpus } from './harness-corpus-harvester.js';
 import { applyChampionParams } from '../config/harness-feedback-applier.js';
 import { appendLedger, bootstrapDeltaCILow } from './harness-improvement-ledger.js';
+import { createFlywheelReceipt, sha256Ref, } from './flywheel-receipt.js';
+import { readFlywheelTransactionState, registerFlywheelReceipt, } from './flywheel-transaction.js';
 export const DEFAULT_CONFIG = { alpha: 0.5, subjectWeight: 2.0, mmrLambda: 0.7, bodyWeight: 1.0, typePenaltyFactor: 1.0 };
 const EPS = 1e-3;
 const cfgCanon = (c) => JSON.stringify(Object.fromEntries(Object.keys(c).sort().map((k) => [k, c[k]])));
@@ -50,7 +51,7 @@ function grade(ranked, expected) {
     const idx = ranked.findIndex((r) => r.id === expected);
     return idx >= 0 ? 1 / (idx + 1) : 0;
 }
-function neighbors(base) {
+export function retrievalPolicyNeighbors(base) {
     const steps = { alpha: 0.1, subjectWeight: 0.5, mmrLambda: 0.1, bodyWeight: 0.5, typePenaltyFactor: 0.25 };
     const out = [];
     const seen = new Set();
@@ -89,7 +90,7 @@ function split(tasks, frac) {
  * Returns a rich result AND (as a side effect) appends to the improvement ledger
  * and — on accept — applies the champion locally + chains it.
  */
-export async function runFlywheelTick(projectRoot, deps) {
+export async function evaluateFlywheelCandidate(projectRoot, deps) {
     try {
         const patterns = await deps.getPatterns();
         if (!patterns || patterns.length < 8)
@@ -100,7 +101,9 @@ export async function runFlywheelTick(projectRoot, deps) {
         const blended = blendCorpus(deps.anchorTasks, harvested);
         const anchorIdSet = new Set(blended.anchorIds);
         const baseline = { ...DEFAULT_CONFIG, ...(deps.activeParams?.() ?? {}) };
-        const candidates = neighbors(baseline);
+        const candidates = deps.candidatePolicies?.length
+            ? deps.candidatePolicies.map((candidate) => ({ ...candidate }))
+            : retrievalPolicyNeighbors(baseline);
         // OBJECTIVE = the human-labeled anchor (the relevance we actually care about,
         // where headroom is known to exist). GUARD = the large, growing harvested set
         // (don't wreck broad retrieval while tuning the objective). Optimize the
@@ -171,7 +174,76 @@ export async function runFlywheelTick(projectRoot, deps) {
         const heldDeltas = held.map((t) => heldScoreFor(candidate, t) - heldScoreFor(baseline, t));
         const deltaCILow = bootstrapDeltaCILow(heldDeltas);
         const significant = deltaCILow > 0;
-        const finalAccept = result.accepted && significant;
+        const provisionalGates = Object.fromEntries(Object.entries(result.verdict?.terms ?? {}).map(([k, v]) => [k, v.pass]));
+        const txState = readFlywheelTransactionState(projectRoot);
+        const safetyEnvelopeRef = deps.safetyEnvelopeRef ?? sha256Ref(JSON.stringify({
+            schema: 'ruflo.safety-envelope/local-default-v1',
+            authorizationExpansion: false,
+            networkExpansion: false,
+            spendExpansion: false,
+        }));
+        const receipt = createFlywheelReceipt({
+            lineageId: deps.lineageId,
+            evaluationRunId: deps.evaluationRunId,
+            baselineRef: refOf(baseline),
+            expectedLedgerHead: txState.ledgerHead,
+            candidatePolicy: candidate,
+            safetyEnvelopeRef,
+            requestedProposer: deps.requestedProposer ?? 'local',
+            effectiveProposer: deps.effectiveProposer ?? 'local',
+            proposerSubstitution: deps.proposerSubstitution,
+            corpusVersion: blended.version,
+            corpusHash: blended.corpusHash,
+            baselineScore,
+            candidateScore,
+            heldOutDeltas: heldDeltas,
+            frozenAnchorRegression: guardRegressed ? 1 : 0,
+            gates: provisionalGates,
+            resourceEvidence: {
+                p95LatencyMicros: 0,
+                costMicrosPerTask: 0,
+                tokensPerTask: 0,
+                failureRate: '0',
+                evaluationCostMicros: 0,
+                currency: 'USD',
+            },
+            evidence: {
+                corpusRoles: {
+                    selectionTaskIds: train.map((task) => task.id),
+                    promotionHoldoutTaskIds: held.map((task) => task.id),
+                    guardTaskIds: guard.map((task) => task.id),
+                },
+                verification: {
+                    redblue: result.verify?.redblue ?? 'SKIPPED',
+                    drift: result.verify?.drift ?? -1,
+                    driftThreshold: result.verify?.driftThreshold ?? 0.2,
+                    driftVerdict: result.verify?.driftVerdict ?? 'skipped',
+                    adversarialPass: result.verify?.adversarialPass ?? false,
+                },
+                canary: {
+                    candidate: result.canary?.candidate ?? {},
+                    baseline: result.canary?.baseline ?? {},
+                    pass: result.canary?.pass ?? false,
+                },
+            },
+            termVerification: Object.keys(provisionalGates).map((term) => ({
+                term,
+                verification: 'recomputed',
+                evidenceRef: sha256Ref(JSON.stringify({
+                    term,
+                    corpusHash: blended.corpusHash,
+                    heldOutDeltas: heldDeltas,
+                    verification: result.verify,
+                    canary: result.canary,
+                })),
+            })),
+            now: deps.now,
+            privateKeyPem: deps.receiptPrivateKeyPem,
+            publicKeyPem: deps.receiptPublicKeyPem,
+            bootstrapIterations: deps.bootstrapIterations,
+        });
+        await registerFlywheelReceipt(projectRoot, receipt, deps.now ?? Date.now());
+        const finalAccept = result.accepted && significant && receipt.payload.decision === 'accepted';
         const entry = {
             ts: deps.now ?? Date.now(),
             corpusVersion: blended.version, corpusHash: blended.corpusHash,
@@ -180,28 +252,46 @@ export async function runFlywheelTick(projectRoot, deps) {
             baselineScore, candidateScore, delta: candidateScore - baselineScore,
             deltaCILow, significant, loopAccepted: result.accepted,
             anchorRegressed, accepted: finalAccept,
-            gates: Object.fromEntries(Object.entries(result.verdict?.terms ?? {}).map(([k, v]) => [k, v.pass])),
+            gates: provisionalGates,
             reason: finalAccept ? result.reason : (result.accepted ? `held back — improvement not significant (CI low ${deltaCILow.toFixed(4)})` : result.reason),
         };
-        let applied = false;
-        if (finalAccept && result.manifest) {
-            entry.championRef = refOf(candidate);
-            // Apply locally (self-optimization) + chain to the previous champion.
-            const ap = applyChampionParams(projectRoot, {
-                championId: refOf(candidate), params: candidate,
-                layer: 'repo/local', previous: refOf(baseline), now: deps.now,
-            });
-            applied = ap.applied;
-        }
         appendLedger(`${projectRoot}/.claude-flow/metrics`, entry);
         return {
-            ran: true, reason: entry.reason, accepted: finalAccept, applied,
+            ran: true, reason: entry.reason, accepted: finalAccept, applied: false,
             baselineScore, candidateScore, delta: candidateScore - baselineScore,
-            anchorRegressed, championRef: entry.championRef, corpusVersion: blended.version,
+            anchorRegressed, championRef: finalAccept ? refOf(candidate) : undefined,
+            corpusVersion: blended.version, candidateConfig: candidate,
+            receiptId: receipt.payload.receiptId, receipt, promotable: finalAccept && !!receipt.signature,
         };
     }
     catch (e) {
         return { ran: false, reason: `error: ${e?.message ?? e}` };
     }
 }
+/**
+ * Compatibility wrapper. New callers get evaluation-only semantics. The legacy
+ * implicit apply path exists for one release behind an explicit opt-in flag.
+ */
+export async function runFlywheelTick(projectRoot, deps) {
+    const result = await evaluateFlywheelCandidate(projectRoot, deps);
+    if (process.env.RUFLO_FLYWHEEL_LEGACY_APPLY === '1'
+        && result.accepted
+        && result.candidateConfig
+        && result.championRef) {
+        const applied = applyChampionParams(projectRoot, {
+            championId: result.championRef,
+            params: result.candidateConfig,
+            layer: 'repo/local',
+            previous: result.receipt?.payload.baselineRef,
+            now: deps.now,
+        });
+        return {
+            ...result,
+            applied: applied.applied,
+            legacyDeprecation: true,
+            reason: `${result.reason}; deprecated implicit apply path`,
+        };
+    }
+    return result;
+}
 //# sourceMappingURL=harness-flywheel.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.32.25",
+  "version": "3.32.26",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -86,6 +86,7 @@
   ],
   "scripts": {
     "build": "tsc",
+    "check:metaharness-pins": "node ../../../scripts/check-metaharness-pins.mjs",
     "test": "vitest run",
     "test:plugin-store": "npx tsx src/plugins/tests/standalone-test.ts",
     "test:pattern-store": "npx tsx src/transfer/store/tests/standalone-test.ts",
@@ -116,6 +117,7 @@
     "@claude-flow/memory": "^3.0.0-alpha.21",
     "@claude-flow/security": "^3.0.0-alpha.12",
     "@metaharness/darwin": "^0.8.0",
+    "@metaharness/flywheel": "^0.1.7",
     "agentdb": "^3.0.0-alpha.17",
     "agentic-flow": "^3.0.0-alpha.1",
     "better-sqlite3": "^12.9.0",

package/.claude/.proven-config-version

@@ -1 +0,0 @@
-sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319

package/.claude/proven-config.json

@@ -1,42 +0,0 @@
-{
-  "adoptedAt": 1785250806308,
-  "championId": "sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319",
-  "manifest": {
-    "schema": "ruflo.proven-config/v1",
-    "policy": {
-      "ref": "sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319",
-      "value": {
-        "alpha": 0.3,
-        "subjectWeight": 1,
-        "mmrLambda": 0.5,
-        "bodyWeight": 1.5,
-        "typePenaltyFactor": 0.5
-      }
-    },
-    "layer": "framework/node-cli",
-    "compatibility": {
-      "ruflo": ">=3.24.0"
-    },
-    "benchmark": {
-      "corpus": "ADR-081-labelled-v1",
-      "corpusHash": "sha256:2f700b5c363e20a3bd88ce2bc9b87bbbbaa61732c6177894c6ec37890f888982"
-    },
-    "receipt": {
-      "heldOutDelta": 0.07381404928570845,
-      "redblue": "PASS",
-      "drift": 0,
-      "canary": {
-        "rollbackRate": 0,
-        "latencyP95": 244.612458000076,
-        "costPerTask": 0
-      },
-      "receiptCoverage": 1
-    },
-    "platform": [
-      "linux",
-      "macOS",
-      "windows"
-    ]
-  },
-  "previous": ""
-}