@claude-flow/cli 3.23.0 → 3.24.0

package/.claude/evolve-proof/real-generation-1.json

@@ -0,0 +1,406 @@
+{
+  "label": "single-round proof-of-mechanism",
+  "disclaimers": [
+    "not flywheel proof",
+    "not compounding learning",
+    "not production learning"
+  ],
+  "generation": 1,
+  "parent": "sha256:3515c407c0555d491432fdce2405389fa6d33831fc64d342364defbf7cf7ffef",
+  "branch": "main",
+  "kind": "real",
+  "createdAt": 1700000201000,
+  "inputHoldoutHash": "sha256:9cdb7bdefd9d6897a5f6a5645c92a6616adefaf6d5c54b66f1a21b03ec6e841c",
+  "baselineManifestHash": "sha256:3515c407c0555d491432fdce2405389fa6d33831fc64d342364defbf7cf7ffef",
+  "candidateManifestHash": "sha256:fdb91acd74a34d71d5263f91fe230c87e18f8e69ef36bab77ca47b98692078c7",
+  "meetsPromotionRule": {
+    "version": "accept/v1+sig",
+    "result": true
+  },
+  "decisionReceipt": {
+    "promotionRuleVersion": "accept/v1+sig",
+    "verdictInputs": {
+      "heldOutScore": 0.8473484848484848,
+      "baselineHeldOutScore": 0.7575757575757577,
+      "redblue": "PASS",
+      "drift": 0,
+      "driftThreshold": 0.05,
+      "replayDeterministic": true,
+      "receiptCoverage": 1,
+      "canaryRollbackRate": 0,
+      "baselineRollbackRate": 0
+    },
+    "result": {
+      "accept": true,
+      "terms": {
+        "held_out_improves": {
+          "value": "0.8473 > 0.7576",
+          "pass": true
+        },
+        "redblue_pass": {
+          "value": "PASS",
+          "pass": true
+        },
+        "drift_within": {
+          "value": "0 <= 0.05",
+          "pass": true
+        },
+        "replay_deterministic": {
+          "value": true,
+          "pass": true
+        },
+        "receipt_coverage_full": {
+          "value": 1,
+          "pass": true
+        },
+        "canary_no_worse": {
+          "value": "0 <= 0",
+          "pass": true
+        }
+      },
+      "failed": []
+    },
+    "significant": true,
+    "deltaCILow": 0.038636363636363635,
+    "promoted": true,
+    "reason": "promoted (all accept/v1+sig terms held)"
+  },
+  "shadow": {
+    "registrationId": "shadow:8a148c1931e94b7f2b448e1327d08ba31924f3cd6773fc85064b4cc4b0a5359c",
+    "state": "shadow",
+    "served": false,
+    "candidateManifestHash": "sha256:fdb91acd74a34d71d5263f91fe230c87e18f8e69ef36bab77ca47b98692078c7",
+    "registeredAt": 1700000201000
+  },
+  "costReceipt": {
+    "usd": 0,
+    "llmCalls": 0,
+    "tier": "real-local",
+    "notes": "measured on the frozen anchor via live retrieval — no LLM, no network"
+  },
+  "mutationClass": "retrieval:multi",
+  "mutationSummary": "alpha:0.3→0.2, bodyWeight:1→1.5, mmrLambda:0.9→1, subjectWeight:1→0.5, typePenaltyFactor:1→0.75",
+  "deltas": {
+    "benchmark": 0.08977272727272712,
+    "security": 0,
+    "cost": 0
+  },
+  "promotion": {
+    "parentManifestHash": "sha256:3515c407c0555d491432fdce2405389fa6d33831fc64d342364defbf7cf7ffef",
+    "candidateManifestHash": "sha256:fdb91acd74a34d71d5263f91fe230c87e18f8e69ef36bab77ca47b98692078c7",
+    "mutationClass": "retrieval:multi",
+    "mutationSummary": "alpha:0.3→0.2, bodyWeight:1→1.5, mmrLambda:0.9→1, subjectWeight:1→0.5, typePenaltyFactor:1→0.75",
+    "deltas": {
+      "benchmark": 0.08977272727272712,
+      "security": 0,
+      "cost": 0
+    },
+    "decisionReceipt": {
+      "promotionRuleVersion": "accept/v1+sig",
+      "verdictInputs": {
+        "heldOutScore": 0.8473484848484848,
+        "baselineHeldOutScore": 0.7575757575757577,
+        "redblue": "PASS",
+        "drift": 0,
+        "driftThreshold": 0.05,
+        "replayDeterministic": true,
+        "receiptCoverage": 1,
+        "canaryRollbackRate": 0,
+        "baselineRollbackRate": 0
+      },
+      "result": {
+        "accept": true,
+        "terms": {
+          "held_out_improves": {
+            "value": "0.8473 > 0.7576",
+            "pass": true
+          },
+          "redblue_pass": {
+            "value": "PASS",
+            "pass": true
+          },
+          "drift_within": {
+            "value": "0 <= 0.05",
+            "pass": true
+          },
+          "replay_deterministic": {
+            "value": true,
+            "pass": true
+          },
+          "receipt_coverage_full": {
+            "value": 1,
+            "pass": true
+          },
+          "canary_no_worse": {
+            "value": "0 <= 0",
+            "pass": true
+          }
+        },
+        "failed": []
+      },
+      "significant": true,
+      "deltaCILow": 0.038636363636363635,
+      "promoted": true,
+      "reason": "promoted (all accept/v1+sig terms held)"
+    }
+  },
+  "regression": null,
+  "holdout": [
+    {
+      "taskId": "hv-pattern-1780161324685-1d-tgm8",
+      "baselineScore": 0.5,
+      "candidateScore": 0.5
+    },
+    {
+      "taskId": "hv-pattern-1780161324686-1g-p25o",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324686-1j-m5hq",
+      "baselineScore": 0.5,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324686-1m-j0ig",
+      "baselineScore": 0,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324687-1p-2lpj",
+      "baselineScore": 0.5,
+      "candidateScore": 0.5
+    },
+    {
+      "taskId": "hv-pattern-1780161324687-1s-ibq9",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324688-1v-qvm9",
+      "baselineScore": 0.5,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324688-1y-hjpj",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324689-21-o5x6",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324689-24-hkmf",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324690-27-igfa",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324690-2a-6t0p",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324690-2d-5hqx",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324691-2g-grco",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324691-2j-zfni",
+      "baselineScore": 0.25,
+      "candidateScore": 0.25
+    },
+    {
+      "taskId": "hv-pattern-1780161324691-2m-wx6m",
+      "baselineScore": 0,
+      "candidateScore": 0.2
+    },
+    {
+      "taskId": "hv-pattern-1780161324692-2p-8jhd",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324692-2s-c4t4",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324692-2v-afrs",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324693-2y-2ozh",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324693-31-ac3v",
+      "baselineScore": 0.3333333333333333,
+      "candidateScore": 0.3333333333333333
+    },
+    {
+      "taskId": "hv-pattern-1780161324694-34-ysmt",
+      "baselineScore": 0.5,
+      "candidateScore": 0.5
+    },
+    {
+      "taskId": "hv-pattern-1780161324694-37-lvvk",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324694-3a-i470",
+      "baselineScore": 0.25,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324695-3d-9awr",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324695-3g-y9cu",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324695-3j-wi4w",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324696-3m-tzr2",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324696-3p-49pp",
+      "baselineScore": 0,
+      "candidateScore": 0
+    },
+    {
+      "taskId": "hv-pattern-1780161324698-3s-5w1r",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324698-3v-4fri",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324698-3y-v3g2",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324699-41-hvmz",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324699-44-nys5",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324699-47-jghz",
+      "baselineScore": 0.5,
+      "candidateScore": 0.5
+    },
+    {
+      "taskId": "hv-pattern-1780161324700-4a-3pj8",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324700-4d-rmrn",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324700-4g-tb58",
+      "baselineScore": 0,
+      "candidateScore": 0
+    },
+    {
+      "taskId": "hv-pattern-1780161324701-4j-kodm",
+      "baselineScore": 0,
+      "candidateScore": 0.5
+    },
+    {
+      "taskId": "hv-pattern-1780161324701-4m-dt4j",
+      "baselineScore": 0.5,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324701-4p-e7fi",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324702-4s-bo8j",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324702-4v-6orz",
+      "baselineScore": 1,
+      "candidateScore": 1
+    },
+    {
+      "taskId": "hv-pattern-1780161324702-4y-0o2q",
+      "baselineScore": 1,
+      "candidateScore": 1
+    }
+  ],
+  "baselineManifest": {
+    "schema": "ruflo.proven-config/v1",
+    "policy": {
+      "ref": "sha256:7caf5bfd2878b84825b5f641f447a9ecaf177258fecd8b4e82d823d98fb84097",
+      "value": {
+        "alpha": 0.3,
+        "subjectWeight": 1,
+        "mmrLambda": 0.9,
+        "bodyWeight": 1,
+        "typePenaltyFactor": 1
+      }
+    },
+    "layer": "real/retrieval",
+    "benchmark": {
+      "corpus": "harvested-selfsup-frozen-v1",
+      "corpusHash": "sha256:cfeda09c42a88e2dc86efd650ff167880d7482a8e1af176bf861a09e6cca01be"
+    }
+  },
+  "candidateManifest": {
+    "schema": "ruflo.proven-config/v1",
+    "policy": {
+      "ref": "sha256:046b42190078dd450c4baa5b409cbc369662cc4dec5e847c8b839f9a2aed0ff5",
+      "value": {
+        "alpha": 0.2,
+        "subjectWeight": 0.5,
+        "mmrLambda": 1,
+        "bodyWeight": 1.5,
+        "typePenaltyFactor": 0.75
+      }
+    },
+    "layer": "real/retrieval",
+    "benchmark": {
+      "corpus": "harvested-selfsup-frozen-v1",
+      "corpusHash": "sha256:cfeda09c42a88e2dc86efd650ff167880d7482a8e1af176bf861a09e6cca01be"
+    }
+  }
+}

package/.claude/helpers/.helpers-version

@@ -1 +1 @@
-3.22.0
+3.23.0

package/.claude/helpers/intelligence.cjs

@@ -587,6 +587,16 @@ function recordEdit(file, success) {
     sessionId: sessionGet('sessionId') || null,
   });
   fs.appendFileSync(PENDING_PATH, entry + '\n', 'utf-8');
+  // Runaway-storage guard: pending-insights is append-only and only drained by
+  // consolidation. If it grows past ~512KB (thousands of un-consolidated edits
+  // — e.g. the daemon never ran), keep only the most recent 2000 lines so it
+  // can never grow unbounded. Cheap (a statSync per edit; rewrite only when over).
+  try {
+    if (fs.statSync(PENDING_PATH).size > 512 * 1024) {
+      const lines = fs.readFileSync(PENDING_PATH, 'utf-8').split('\n').filter(Boolean);
+      if (lines.length > 2000) fs.writeFileSync(PENDING_PATH, lines.slice(-2000).join('\n') + '\n', 'utf-8');
+    }
+  } catch (e) { /* non-fatal */ }
 }
 
 /**

package/.claude/proven-config.manifest.json

@@ -0,0 +1,37 @@
+{
+  "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"
+  ]
+}

package/.claude/proven-config.signed.json

@@ -0,0 +1,41 @@
+{
+  "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"
+    ]
+  },
+  "signature": "gC7VYhZ+l1RQQ9vO4Ml2pVV3fUy38rBBn5vsMx8XQP4wWuZBOzNd1ZGAhtfNvkTeV1hXd3Dr5Ln09Etr1VcdCw==",
+  "algorithm": "ed25519"
+}

package/dist/src/config/harness-feedback-applier.d.ts

@@ -0,0 +1,50 @@
+export declare const ADOPTED_CONFIG_FILE = "proven-config.json";
+export declare const ACTIVE_POLICY_FILE = "harness-active-policy.json";
+export interface ActivePolicy {
+    championId: string;
+    provenanceTier: string;
+    layer?: string;
+    appliedAt: number;
+    previous?: string | null;
+    rolledBack?: boolean;
+    params?: Record<string, unknown>;
+}
+export interface ApplyResult {
+    applied: boolean;
+    from?: string | null;
+    to?: string;
+    reason?: string;
+}
+/**
+ * Apply the adopted champion to the active harness policy. Idempotent (applying
+ * the same champion is a no-op), reversible (records the superseded champion),
+ * best-effort. `now` is injectable for tests.
+ */
+export declare function applyChampion(cwd: string, opts?: {
+    now?: number;
+}): ApplyResult;
+/**
+ * Apply a champion directly by its config payload (local self-optimization,
+ * ADR-176 flywheel). Unlike applyChampion (which reads a propagated, signed,
+ * adopted record), this activates a LOCALLY-mined champion that just cleared the
+ * install's own measured gate — no signing, because nothing is propagated. Still
+ * reversible (records `previous`) and idempotent. Consumers read `params`.
+ */
+export declare function applyChampionParams(cwd: string, opts: {
+    championId: string;
+    params?: Record<string, unknown>;
+    layer?: string;
+    previous?: string | null;
+    now?: number;
+}): ApplyResult;
+/**
+ * Reverse the last apply: point the active policy back at its `previous`
+ * champion (reversibility, ADR-177 rollback pointer). No-op if there is no
+ * previous. The previous champion's policy is fetched by ref by consumers.
+ */
+export declare function rollbackActivePolicy(cwd: string, opts?: {
+    now?: number;
+}): ApplyResult;
+/** The champion routing/agents should currently use, or null. */
+export declare function activeChampion(cwd: string): ActivePolicy | null;
+//# sourceMappingURL=harness-feedback-applier.d.ts.map

package/dist/src/config/harness-feedback-applier.js

@@ -0,0 +1,122 @@
+/**
+ * Feedback applier — close the loop (ADR-176 phase 9).
+ *
+ * A proven champion adopted by the propagation channel (ADR-177,
+ * proven-config-refresh.ts writes `.claude/proven-config.json`) is inert until
+ * something *applies* it to what ruflo actually runs. This applier promotes the
+ * adopted champion to the ACTIVE harness policy that routing/agents consume —
+ * reversibly (keeps the previous pointer) and provenance-tagged (ADR-171), so
+ * it composes with the promote-gate discipline rather than bypassing it. It only
+ * ever sets a pointer to a proven, signed champion; it never invents config.
+ * Zero deps, $0.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+export const ADOPTED_CONFIG_FILE = 'proven-config.json'; // written by proven-config-refresh (in .claude)
+export const ACTIVE_POLICY_FILE = 'harness-active-policy.json'; // consumed by routing/agents (in .claude-flow)
+function readJson(p) {
+    try {
+        return JSON.parse(fs.readFileSync(p, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Apply the adopted champion to the active harness policy. Idempotent (applying
+ * the same champion is a no-op), reversible (records the superseded champion),
+ * best-effort. `now` is injectable for tests.
+ */
+export function applyChampion(cwd, opts = {}) {
+    try {
+        const claudeDir = path.join(cwd, '.claude');
+        const adopted = readJson(path.join(claudeDir, ADOPTED_CONFIG_FILE));
+        if (!adopted?.championId)
+            return { applied: false, reason: 'no adopted champion' };
+        const cfDir = path.join(cwd, '.claude-flow');
+        const activePath = path.join(cfDir, ACTIVE_POLICY_FILE);
+        const current = readJson(activePath);
+        if (current?.championId === adopted.championId && !current.rolledBack) {
+            return { applied: false, reason: 'already active' }; // idempotent
+        }
+        const active = {
+            championId: adopted.championId,
+            // A champion only reaches adoption if it cleared the promote-gate, so it is
+            // oracle/judge-backed; proxy can never be here (ADR-171). Default oracle.
+            provenanceTier: 'oracle:test-exec',
+            layer: adopted.manifest?.layer,
+            appliedAt: opts.now ?? Date.now(),
+            previous: current?.championId ?? adopted.previous ?? null,
+            params: adopted.manifest?.policy?.value,
+        };
+        fs.mkdirSync(cfDir, { recursive: true });
+        fs.writeFileSync(activePath, JSON.stringify(active, null, 2), 'utf-8');
+        return { applied: true, from: active.previous, to: active.championId };
+    }
+    catch (e) {
+        return { applied: false, reason: `error: ${e?.message ?? e}` };
+    }
+}
+/**
+ * Apply a champion directly by its config payload (local self-optimization,
+ * ADR-176 flywheel). Unlike applyChampion (which reads a propagated, signed,
+ * adopted record), this activates a LOCALLY-mined champion that just cleared the
+ * install's own measured gate — no signing, because nothing is propagated. Still
+ * reversible (records `previous`) and idempotent. Consumers read `params`.
+ */
+export function applyChampionParams(cwd, opts) {
+    try {
+        const cfDir = path.join(cwd, '.claude-flow');
+        const activePath = path.join(cfDir, ACTIVE_POLICY_FILE);
+        const current = readJson(activePath);
+        if (current?.championId === opts.championId && !current.rolledBack)
+            return { applied: false, reason: 'already active' };
+        const active = {
+            championId: opts.championId,
+            provenanceTier: 'oracle:test-exec', // only a gate-cleared champion reaches here
+            layer: opts.layer,
+            appliedAt: opts.now ?? Date.now(),
+            previous: opts.previous ?? current?.championId ?? null,
+            params: opts.params,
+        };
+        fs.mkdirSync(cfDir, { recursive: true });
+        fs.writeFileSync(activePath, JSON.stringify(active, null, 2), 'utf-8');
+        return { applied: true, from: active.previous, to: active.championId };
+    }
+    catch (e) {
+        return { applied: false, reason: `error: ${e?.message ?? e}` };
+    }
+}
+/**
+ * Reverse the last apply: point the active policy back at its `previous`
+ * champion (reversibility, ADR-177 rollback pointer). No-op if there is no
+ * previous. The previous champion's policy is fetched by ref by consumers.
+ */
+export function rollbackActivePolicy(cwd, opts = {}) {
+    try {
+        const activePath = path.join(cwd, '.claude-flow', ACTIVE_POLICY_FILE);
+        const current = readJson(activePath);
+        if (!current)
+            return { applied: false, reason: 'no active policy' };
+        if (!current.previous)
+            return { applied: false, reason: 'no previous to roll back to' };
+        const reverted = {
+            championId: current.previous,
+            provenanceTier: current.provenanceTier,
+            layer: current.layer,
+            appliedAt: opts.now ?? Date.now(),
+            previous: null,
+            rolledBack: true,
+        };
+        fs.writeFileSync(activePath, JSON.stringify(reverted, null, 2), 'utf-8');
+        return { applied: true, from: current.championId, to: reverted.championId };
+    }
+    catch (e) {
+        return { applied: false, reason: `error: ${e?.message ?? e}` };
+    }
+}
+/** The champion routing/agents should currently use, or null. */
+export function activeChampion(cwd) {
+    return readJson(path.join(cwd, '.claude-flow', ACTIVE_POLICY_FILE));
+}
+//# sourceMappingURL=harness-feedback-applier.js.map