@claude-flow/cli 3.32.1 → 3.32.3

package/dist/src/services/harness-benchmark.d.ts

@@ -1,68 +0,0 @@
-export interface BenchTask {
-    id: string;
-    input: unknown;
-    expected: unknown;
-    weight?: number;
-}
-export interface HarnessBenchmarkCorpus {
-    version: string;
-    corpusHash: string;
-    tasks: BenchTask[];
-}
-/** Run a candidate policy on a task's input, producing an output. */
-export type EvalFn<C> = (input: unknown, candidate: C) => unknown;
-/** Grade an output against expected → [0,1]. */
-export type GradeFn = (output: unknown, expected: unknown) => number;
-/** Content hash of a corpus's tasks — the tamper-evident pin for the held-out set. */
-export declare function hashCorpus(tasks: BenchTask[]): string;
-/** Verify a corpus's declared hash matches its tasks (integrity of the benchmark). */
-export declare function verifyCorpus(corpus: HarnessBenchmarkCorpus): boolean;
-export interface ScoreResult {
-    fitness: number;
-    passRate: number;
-    n: number;
-}
-/** Score a candidate over a task set, on isolated tasks (no shared state). */
-export declare function scoreOnTasks<C>(tasks: BenchTask[], candidate: C, evalFn: EvalFn<C>, gradeFn: GradeFn): ScoreResult;
-export interface HeldOutSplit {
-    train: BenchTask[];
-    heldOut: BenchTask[];
-}
-/**
- * Deterministic held-out split. Tasks are stably ordered by id, and the last
- * `holdoutFrac` become the held-out set — disjoint from train, reproducible
- * (so two runs converge, per the ADR-176 acceptance test).
- */
-export declare function computeHeldOutSplit(tasks: BenchTask[], holdoutFrac?: number): HeldOutSplit;
-/** Independently-measured verdicts fed to accept(). Each comes from a different mechanism. */
-export interface PromotionVerdict {
-    heldOutScore: number;
-    baselineHeldOutScore: number;
-    redblue: 'PASS' | 'FAIL' | 'SKIPPED';
-    drift: number;
-    driftThreshold: number;
-    replayDeterministic: boolean;
-    receiptCoverage: number;
-    canaryRollbackRate: number;
-    baselineRollbackRate: number;
-}
-export interface AcceptResult {
-    accept: boolean;
-    terms: Record<string, {
-        value: unknown;
-        pass: boolean;
-    }>;
-    failed: string[];
-}
-/**
- * accept(candidate) ⟺
- *   held_out_score  >  baseline
- *   AND redblue     == PASS
- *   AND drift       <= threshold
- *   AND replay      == deterministic
- *   AND receipt_cov == 100%
- *   AND canary.rollback_rate <= baseline
- * Every term is externally measurable; ANY failure → reject.
- */
-export declare function accept(v: PromotionVerdict): AcceptResult;
-//# sourceMappingURL=harness-benchmark.d.ts.map

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

@@ -1,94 +0,0 @@
-/**
- * Benchmark corpus + held-out scoring + the accept() promotion gate
- * (ADR-176 phase 2 + the multi-term promotion rule).
- *
- * Proof #1 (measured, held-out): a candidate is scored against a VERSIONED,
- * content-hashed corpus on a held-out split — the "prove-before-ship" pattern
- * distill-tuning.ts established (train/held-out disjoint by index; held-out
- * scored once). Fitness is a composite, not a single gameable number.
- *
- * Promotion is a CONJUNCTION of externally-measurable predicates (ADR-176) —
- * never a scalar. accept() takes the independently-measured verdicts (held-out
- * delta, redblue, drift, deterministic replay, receipt coverage, canary
- * rollback) and admits only when EVERY term holds. Multi-dimensional +
- * Goodhart-resistant. Zero deps, $0.
- */
-import { createHash } from 'crypto';
-function stable(v) {
-    const c = (x) => {
-        if (Array.isArray(x))
-            return x.map(c);
-        if (x && typeof x === 'object') {
-            const o = {};
-            for (const k of Object.keys(x).sort())
-                o[k] = c(x[k]);
-            return o;
-        }
-        return x;
-    };
-    return JSON.stringify(c(v));
-}
-/** Content hash of a corpus's tasks — the tamper-evident pin for the held-out set. */
-export function hashCorpus(tasks) {
-    const canon = tasks.map(t => ({ id: t.id, input: t.input, expected: t.expected, weight: t.weight ?? 1 }))
-        .sort((a, b) => a.id.localeCompare(b.id));
-    return 'sha256:' + createHash('sha256').update(stable(canon)).digest('hex');
-}
-/** Verify a corpus's declared hash matches its tasks (integrity of the benchmark). */
-export function verifyCorpus(corpus) {
-    return hashCorpus(corpus.tasks) === corpus.corpusHash;
-}
-/** Score a candidate over a task set, on isolated tasks (no shared state). */
-export function scoreOnTasks(tasks, candidate, evalFn, gradeFn) {
-    if (tasks.length === 0)
-        return { fitness: 0, passRate: 0, n: 0 };
-    let weighted = 0, totalW = 0, passes = 0;
-    for (const t of tasks) {
-        const w = t.weight ?? 1;
-        let g = 0;
-        try {
-            g = Math.max(0, Math.min(1, gradeFn(evalFn(t.input, candidate), t.expected)));
-        }
-        catch {
-            g = 0;
-        }
-        weighted += g * w;
-        totalW += w;
-        if (g >= 0.999)
-            passes++;
-    }
-    return { fitness: totalW > 0 ? weighted / totalW : 0, passRate: passes / tasks.length, n: tasks.length };
-}
-/**
- * Deterministic held-out split. Tasks are stably ordered by id, and the last
- * `holdoutFrac` become the held-out set — disjoint from train, reproducible
- * (so two runs converge, per the ADR-176 acceptance test).
- */
-export function computeHeldOutSplit(tasks, holdoutFrac = 0.2) {
-    const ordered = [...tasks].sort((a, b) => a.id.localeCompare(b.id));
-    const cut = Math.max(0, ordered.length - Math.max(1, Math.round(ordered.length * holdoutFrac)));
-    return { train: ordered.slice(0, cut), heldOut: ordered.slice(cut) };
-}
-/**
- * accept(candidate) ⟺
- *   held_out_score  >  baseline
- *   AND redblue     == PASS
- *   AND drift       <= threshold
- *   AND replay      == deterministic
- *   AND receipt_cov == 100%
- *   AND canary.rollback_rate <= baseline
- * Every term is externally measurable; ANY failure → reject.
- */
-export function accept(v) {
-    const terms = {
-        held_out_improves: { value: `${v.heldOutScore.toFixed(4)} > ${v.baselineHeldOutScore.toFixed(4)}`, pass: v.heldOutScore > v.baselineHeldOutScore },
-        redblue_pass: { value: v.redblue, pass: v.redblue === 'PASS' },
-        drift_within: { value: `${v.drift} <= ${v.driftThreshold}`, pass: v.drift <= v.driftThreshold },
-        replay_deterministic: { value: v.replayDeterministic, pass: v.replayDeterministic === true },
-        receipt_coverage_full: { value: v.receiptCoverage, pass: v.receiptCoverage >= 1 },
-        canary_no_worse: { value: `${v.canaryRollbackRate} <= ${v.baselineRollbackRate}`, pass: v.canaryRollbackRate <= v.baselineRollbackRate },
-    };
-    const failed = Object.entries(terms).filter(([, t]) => !t.pass).map(([k]) => k);
-    return { accept: failed.length === 0, terms, failed };
-}
-//# sourceMappingURL=harness-benchmark.js.map

package/dist/src/services/harness-canary.d.ts

@@ -1,60 +0,0 @@
-/**
- * Canary — separate promotion from deployment (ADR-176 phase 5).
- *
- * Held-out evaluation proves a candidate on FROZEN data; it has not observed
- * real-world behavior. The canary runs the candidate on a bounded, reversible
- * SLICE of live work and measures rollback rate, latency, cost, failure
- * frequency, and acceptance — the telemetry the accept() conjunction needs
- * (canary.rollback_rate <= baseline). Only after canary evidence does PROMOTE
- * fire. This is what stops benchmark-specific evolution from reaching global
- * rollout. Zero deps, $0 (the runner is injected; a real one meters real work).
- */
-/** One canary run's observed outcome. */
-export interface CanaryOutcome {
-    ok: boolean;
-    rolledBack: boolean;
-    latencyMs: number;
-    costUsd: number;
-    accepted: boolean;
-}
-/** Executes a candidate on one task input under real (or simulated) conditions. */
-export type CanaryRunner<C> = (input: unknown, candidate: C) => CanaryOutcome;
-export interface CanaryTelemetry {
-    n: number;
-    rollbackRate: number;
-    failureRate: number;
-    acceptanceRate: number;
-    latencyP95: number;
-    latencyMean: number;
-    costPerTask: number;
-    costTotalUsd: number;
-}
-export interface CanaryOptions {
-    sampleFraction?: number;
-    maxSamples?: number;
-}
-/**
- * Run the candidate on a bounded, deterministic sample of the slice and
- * aggregate telemetry. Deterministic sampling (stride over id-sorted inputs) so
- * two runs converge (ADR-176 acceptance test).
- */
-export declare function runCanary<C>(candidate: C, slice: Array<{
-    id: string;
-    input: unknown;
-}>, runner: CanaryRunner<C>, opts?: CanaryOptions): CanaryTelemetry;
-export interface CanaryComparison {
-    pass: boolean;
-    checks: Record<string, {
-        candidate: number;
-        baseline: number;
-        pass: boolean;
-    }>;
-    failed: string[];
-}
-/**
- * Canary gate: the candidate must be NO WORSE than the baseline on rollback,
- * latency, and cost (the ADR-176 metrics table constraints). Feeds accept()'s
- * `canary.rollback_rate <= baseline` term plus the latency/cost guards.
- */
-export declare function compareCanary(candidate: CanaryTelemetry, baseline: CanaryTelemetry, tolerance?: number): CanaryComparison;
-//# sourceMappingURL=harness-canary.d.ts.map

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

@@ -1,69 +0,0 @@
-/**
- * Canary — separate promotion from deployment (ADR-176 phase 5).
- *
- * Held-out evaluation proves a candidate on FROZEN data; it has not observed
- * real-world behavior. The canary runs the candidate on a bounded, reversible
- * SLICE of live work and measures rollback rate, latency, cost, failure
- * frequency, and acceptance — the telemetry the accept() conjunction needs
- * (canary.rollback_rate <= baseline). Only after canary evidence does PROMOTE
- * fire. This is what stops benchmark-specific evolution from reaching global
- * rollout. Zero deps, $0 (the runner is injected; a real one meters real work).
- */
-function percentile(sorted, p) {
-    if (sorted.length === 0)
-        return 0;
-    const idx = Math.min(sorted.length - 1, Math.max(0, Math.ceil(p * sorted.length) - 1));
-    return sorted[idx];
-}
-/**
- * Run the candidate on a bounded, deterministic sample of the slice and
- * aggregate telemetry. Deterministic sampling (stride over id-sorted inputs) so
- * two runs converge (ADR-176 acceptance test).
- */
-export function runCanary(candidate, slice, runner, opts = {}) {
-    const frac = opts.sampleFraction ?? 0.1;
-    const cap = opts.maxSamples ?? 100;
-    const ordered = [...slice].sort((a, b) => a.id.localeCompare(b.id));
-    const want = Math.min(cap, Math.max(1, Math.round(ordered.length * frac)));
-    // Even stride so the sample spans the slice rather than a contiguous head.
-    const stride = Math.max(1, Math.floor(ordered.length / want));
-    const sample = [];
-    for (let i = 0; i < ordered.length && sample.length < want; i += stride)
-        sample.push(ordered[i]);
-    const outcomes = sample.map(s => {
-        try {
-            return runner(s.input, candidate);
-        }
-        catch {
-            return { ok: false, rolledBack: true, latencyMs: 0, costUsd: 0, accepted: false };
-        }
-    });
-    const n = outcomes.length || 1;
-    const lat = outcomes.map(o => o.latencyMs).sort((a, b) => a - b);
-    const costTotal = outcomes.reduce((s, o) => s + o.costUsd, 0);
-    return {
-        n: outcomes.length,
-        rollbackRate: outcomes.filter(o => o.rolledBack).length / n,
-        failureRate: outcomes.filter(o => !o.ok).length / n,
-        acceptanceRate: outcomes.filter(o => o.accepted).length / n,
-        latencyP95: percentile(lat, 0.95),
-        latencyMean: lat.reduce((s, v) => s + v, 0) / n,
-        costPerTask: costTotal / n,
-        costTotalUsd: costTotal,
-    };
-}
-/**
- * Canary gate: the candidate must be NO WORSE than the baseline on rollback,
- * latency, and cost (the ADR-176 metrics table constraints). Feeds accept()'s
- * `canary.rollback_rate <= baseline` term plus the latency/cost guards.
- */
-export function compareCanary(candidate, baseline, tolerance = 1e-9) {
-    const checks = {
-        rollback_no_worse: { candidate: candidate.rollbackRate, baseline: baseline.rollbackRate, pass: candidate.rollbackRate <= baseline.rollbackRate + tolerance },
-        latency_no_worse: { candidate: candidate.latencyP95, baseline: baseline.latencyP95, pass: candidate.latencyP95 <= baseline.latencyP95 * (1 + 0.01) },
-        cost_no_worse: { candidate: candidate.costPerTask, baseline: baseline.costPerTask, pass: candidate.costPerTask <= baseline.costPerTask * (1 + 0.01) },
-    };
-    const failed = Object.entries(checks).filter(([, c]) => !c.pass).map(([k]) => k);
-    return { pass: failed.length === 0, checks, failed };
-}
-//# sourceMappingURL=harness-canary.js.map

package/dist/src/services/harness-corpus-harvester.d.ts

@@ -1,51 +0,0 @@
-export interface HarvestPattern {
-    id: string;
-    name?: string;
-    content?: string;
-}
-export interface HarvestedTask {
-    id: string;
-    input: {
-        id: string;
-        q: string;
-        targetId: string;
-    };
-    expected: string;
-    provenanceTier: 'oracle:self-identity';
-}
-export interface BlendedCorpus {
-    version: string;
-    corpusHash: string;
-    anchorIds: string[];
-    tasks: Array<{
-        id: string;
-        input: unknown;
-        expected: unknown;
-    }>;
-}
-/**
- * Harvest up to `sample` self-retrieval tasks from real patterns. Deterministic
- * stride sampling (stable across runs); skips docs whose body is too thin to
- * form a discriminative query.
- */
-export declare function harvestSelfSupervisedTasks(patterns: HarvestPattern[], opts?: {
-    sample?: number;
-    minQueryTerms?: number;
-}): HarvestedTask[];
-/** Content hash over the task ids+queries — changes iff the corpus changes. */
-export declare function hashBlend(tasks: Array<{
-    id: string;
-    input: unknown;
-    expected: unknown;
-}>): string;
-/**
- * Blend a human-labeled anchor set with harvested tasks into one versioned,
- * hashed corpus. The version encodes the sizes + hash so it visibly grows as the
- * store does; `anchorIds` marks the never-regress subset.
- */
-export declare function blendCorpus(anchor: Array<{
-    id: string;
-    input: unknown;
-    expected: unknown;
-}>, harvested: HarvestedTask[]): BlendedCorpus;
-//# sourceMappingURL=harness-corpus-harvester.d.ts.map

package/dist/src/services/harness-corpus-harvester.js

@@ -1,74 +0,0 @@
-/**
- * Corpus harvester — grows the benchmark yardstick from REAL store data so the
- * flywheel gets a bigger, fresher test set as ruflo is used (ADR-176).
- *
- * Self-supervised self-retrieval: a stored doc is unambiguous ground truth for a
- * query derived from its OWN body. To make it discriminative (so different
- * retrieval configs actually score differently — a usable gradient) the query is
- * built from body keywords with the doc's SUBJECT tokens removed: "can retrieval
- * find this doc from its content when the obvious title words are withheld?"
- * The label is the doc's identity — oracle-grade, not a proxy guess.
- *
- * This grows the auto signal; callers keep the human-labeled seed as a separate
- * NON-REGRESSION anchor (Goodhart guard) so optimizing self-retrieval can never
- * silently drift away from human relevance. Pure + deterministic (no RNG): the
- * sample is a fixed stride, so the same store yields the same corpus.
- */
-import { createHash } from 'node:crypto';
-const STOP = new Set(['the', 'a', 'an', 'of', 'to', 'in', 'on', 'for', 'and', 'or', 'is', 'was', 'with', 'by', 'at', 'as', 'it', 'this', 'that', 'from', 'be', 'are', 'so', 'if', 'we', 'i', 'you', 'not', 'no', 'do', 'via', 'per']);
-function tokenize(s) {
-    return (s.toLowerCase().match(/[a-z0-9][a-z0-9_-]{1,}/g) ?? []).filter((t) => !STOP.has(t));
-}
-/** Top-K body keywords with the subject tokens removed, most-frequent first. */
-function deriveQuery(name, content, k = 6) {
-    const nameToks = new Set(tokenize(name));
-    const freq = new Map();
-    for (const t of tokenize(content)) {
-        if (nameToks.has(t))
-            continue; // withhold the obvious title words
-        freq.set(t, (freq.get(t) ?? 0) + 1);
-    }
-    return [...freq.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, k).map(([t]) => t).join(' ');
-}
-/**
- * Harvest up to `sample` self-retrieval tasks from real patterns. Deterministic
- * stride sampling (stable across runs); skips docs whose body is too thin to
- * form a discriminative query.
- */
-export function harvestSelfSupervisedTasks(patterns, opts = {}) {
-    const sample = Math.max(1, opts.sample ?? 40);
-    const minTerms = opts.minQueryTerms ?? 3;
-    // Deterministic order: sort by id, then take an even stride to cover the store.
-    const ordered = [...patterns].sort((a, b) => a.id.localeCompare(b.id));
-    const stride = Math.max(1, Math.floor(ordered.length / sample));
-    const out = [];
-    for (let i = 0; i < ordered.length && out.length < sample; i += stride) {
-        const p = ordered[i];
-        const q = deriveQuery(p.name ?? '', p.content ?? '', 6);
-        if (q.split(' ').filter(Boolean).length < minTerms)
-            continue; // too thin → skip
-        out.push({ id: `hv-${p.id}`, input: { id: `hv-${p.id}`, q, targetId: p.id }, expected: p.id, provenanceTier: 'oracle:self-identity' });
-    }
-    return out;
-}
-/** Content hash over the task ids+queries — changes iff the corpus changes. */
-export function hashBlend(tasks) {
-    const canon = tasks.map((t) => `${t.id}|${JSON.stringify(t.input)}|${JSON.stringify(t.expected)}`).sort().join('\n');
-    return 'sha256:' + createHash('sha256').update(canon).digest('hex');
-}
-/**
- * Blend a human-labeled anchor set with harvested tasks into one versioned,
- * hashed corpus. The version encodes the sizes + hash so it visibly grows as the
- * store does; `anchorIds` marks the never-regress subset.
- */
-export function blendCorpus(anchor, harvested) {
-    const tasks = [...anchor, ...harvested.map((h) => ({ id: h.id, input: h.input, expected: h.expected }))];
-    const corpusHash = hashBlend(tasks);
-    return {
-        version: `flywheel-a${anchor.length}-h${harvested.length}-${corpusHash.slice(7, 19)}`,
-        corpusHash,
-        anchorIds: anchor.map((a) => a.id),
-        tasks,
-    };
-}
-//# sourceMappingURL=harness-corpus-harvester.js.map

package/dist/src/services/harness-flywheel-generations.d.ts

@@ -1,115 +0,0 @@
-import { type EvolveReceiptBundle, type LineageTelemetry, type PlateauReport, type MutationStat } from './evolve-proof.js';
-import { type HarvestPattern } from './harness-corpus-harvester.js';
-import { type RetrievalConfig, type RankedItem } from './harness-flywheel.js';
-export declare const FLYWHEEL_DIR: string[];
-export declare const FROZEN_CORPUS = "harvested-selfsup-frozen-v1";
-export interface AnchorTask {
-    id: string;
-    q: string;
-    labels: string[];
-}
-export interface GenerationDeps {
-    getPatterns: () => HarvestPattern[] | Promise<HarvestPattern[]>;
-    search: (q: string, cfg: RetrievalConfig) => Promise<RankedItem[]> | RankedItem[];
-    anchorTasks: AnchorTask[];
-    humanEvalHash?: string;
-    sample?: number;
-    now: number;
-    applyFn?: (cfg: Record<string, number>, hash: string, generation: number) => void;
-}
-export interface GenerationResult {
-    ran: boolean;
-    reason: string;
-    generation: number;
-    promoted?: boolean;
-    delta?: number;
-    significant?: boolean;
-    championConfig?: Record<string, number>;
-    servedChampion?: string | null;
-    anchorRegressed?: boolean;
-}
-/** Promotions only — the champion chain (generation-N.json), sorted by generation. */
-export declare function loadPromotions(root: string): EvolveReceiptBundle[];
-/** Every attempt (promoted + rejected) — for telemetry + mutation-effectiveness. */
-export declare function loadAttempts(root: string): EvolveReceiptBundle[];
-/** The current operating champion (last promotion's config), or defaults. */
-export declare function currentChampion(root: string): {
-    config: Record<string, number>;
-    hash: string | null;
-    generation: number;
-};
-export interface ServedState {
-    championHash: string | null;
-    config: Record<string, number> | null;
-    servedAt: number | null;
-    fromGeneration: number | null;
-}
-export declare function servedChampion(root: string): ServedState;
-/**
- * Shadow→serve gate: apply the latest promoted champion to the ACTIVE policy iff
- * it is newer than what is currently served. Called at tick START, so a champion
- * promoted last tick is served this tick (a 1-generation shadow delay) — never
- * auto-served the instant it is promoted.
- */
-export declare function serveCurrentChampionIfPending(root: string, now: number, applyFn?: GenerationDeps['applyFn']): string | null;
-export interface AxisStat {
-    axis: string;
-    promotions: number;
-    meanDelta: number;
-}
-/**
- * Which policy AXES have historically paid off — attribute each promotion's
- * held-out Δ to the axes that changed in it. Turns the lineage into a
- * knowledge base the optimizer can act on (not just audit).
- */
-export declare function axisEffectiveness(promotions: EvolveReceiptBundle[]): AxisStat[];
-/**
- * Candidate set biased by measured axis payoff (meta-learning). Every axis keeps
- * a ±1 exploration floor (never abandon a dimension), but axes with a positive
- * historical Δ get EXPANDED range (±2, ±3) and PAIRWISE joint moves with other
- * productive axes — so compute concentrates on the dimensions that have actually
- * produced gains, instead of a uniform grid. Deterministic; bounded.
- */
-export declare function biasedGrid(c: RetrievalConfig, ranking: AxisStat[]): RetrievalConfig[];
-/**
- * Run ONE generation against `root`, compounding on the persisted champion.
- * Serves the prior champion first (shadow delay), then evaluates a new candidate.
- */
-export declare function runFlywheelGeneration(root: string, deps: GenerationDeps): Promise<GenerationResult>;
-export interface DriftCheck {
-    checked: boolean;
-    rolledBack: boolean;
-    reason: string;
-    servedScore?: number;
-    predecessorScore?: number;
-}
-/**
- * A real deployment-safety check on real (not fabricated) data: the store keeps
- * changing as ruflo is used, so a champion benchmarked at promotion time can
- * DRIFT. Each tick, re-score the currently-SERVED champion against its
- * predecessor on a FRESH harvest of the current store; if it now regresses
- * (self-retrieval OR the human anchor), automatically ROLL BACK the active policy
- * to the predecessor. This is the honest analogue of a live-traffic canary —
- * genuine ongoing measurement + genuine rollback — without fabricating traffic.
- * $0; never throws.
- */
-export declare function checkServedChampionDrift(root: string, deps: GenerationDeps): Promise<DriftCheck>;
-export interface FlywheelStatus {
-    generations: number;
-    attempts: number;
-    lineage: LineageTelemetry;
-    plateau: PlateauReport;
-    mutation: MutationStat[];
-    axisEffectiveness: AxisStat[];
-    cumulativeBenchmarkDelta: number;
-    cumulativeHumanRelevanceDelta: number;
-    humanEvalHash: string | null;
-    served: ServedState;
-    champion: {
-        config: Record<string, number>;
-        hash: string | null;
-    };
-}
-/** Reconstruct the persisted lineage + telemetry for a status endpoint / CLI. */
-export declare function flywheelStatus(root: string): FlywheelStatus;
-//# sourceMappingURL=harness-flywheel-generations.d.ts.map