@claude-flow/cli 3.32.2 → 3.32.3

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

@@ -1,85 +0,0 @@
-/**
- * Loop orchestrator (ADR-176 phase 8).
- *
- * Composes every gate into one pass:
- *   OBSERVE → QUALIFY → BENCHMARK(held-out) → VERIFY(adversarial+drift)
- *           → CANARY → ACCEPT(conjunction) → emit champion manifest.
- *
- * $0 + fail-closed by default: with no optimizer/verifier/canary wired, nothing
- * is promoted and the current signed champion stands. A champion manifest is
- * emitted ONLY when every accept() term holds — and it is emitted UNSIGNED here;
- * signing is a separate publish step (scripts/sign-proven-config.mjs, GCP key)
- * so key material never touches the loop. The daemon worker runs this bounded.
- */
-import { admitTrajectories } from './harness-qualification.js';
-import { computeHeldOutSplit, scoreOnTasks, accept, } from './harness-benchmark.js';
-import { runVerify } from './harness-verify.js';
-import { runCanary, compareCanary } from './harness-canary.js';
-export async function runHarnessLoop(opts) {
-    const driftThreshold = opts.driftThreshold ?? 0.05;
-    // 1. QUALIFY — only receipt-backed, deterministic, benchmark-attributed
-    //    trajectories become training data; rejects → anti-pattern archive.
-    const admission = admitTrajectories(opts.trajectories, { replay: opts.replay, archive: opts.archive, ts: opts.now });
-    const base = { admitted: admission.admittedCount, rejected: admission.rejectedCount, accepted: false, reason: '' };
-    if (admission.admittedCount === 0)
-        return { ...base, reason: 'no qualified trajectories (receipt_coverage=0)' };
-    if (opts.candidate === undefined)
-        return { ...base, reason: 'no candidate to evaluate' };
-    // 2. BENCHMARK — held-out scoring (isolated, reproducible split).
-    const { heldOut } = computeHeldOutSplit(opts.corpus.tasks, opts.holdoutFrac ?? 0.2);
-    const baselineScore = scoreOnTasks(heldOut, opts.baseline, opts.evalFn, opts.gradeFn).fitness;
-    const candidateScore = scoreOnTasks(heldOut, opts.candidate, opts.evalFn, opts.gradeFn).fitness;
-    // 3. VERIFY — adversarial + drift (fail-closed: SKIPPED cannot pass).
-    const verify = await runVerify({ ...opts.verify, driftThreshold });
-    // 4. CANARY — required (separate promotion from deployment); absent => no promote.
-    if (!opts.canaryRunner) {
-        return { ...base, baselineScore, candidateScore, verify, accepted: false, reason: 'canary required (no runner) — cannot promote' };
-    }
-    const slice = opts.corpus.tasks.map(t => ({ id: t.id, input: t.input }));
-    const canaryCand = runCanary(opts.candidate, slice, opts.canaryRunner);
-    const canaryBase = runCanary(opts.baseline, slice, opts.canaryRunner);
-    const canaryCmp = compareCanary(canaryCand, canaryBase);
-    // 5. ACCEPT — the full conjunction. receipt_coverage=1 by construction (only
-    //    qualified trajectories are used; rejects were excluded).
-    const verdict = {
-        heldOutScore: candidateScore,
-        baselineHeldOutScore: baselineScore,
-        redblue: verify.redblue,
-        drift: verify.drift < 0 ? Number.POSITIVE_INFINITY : verify.drift,
-        driftThreshold,
-        replayDeterministic: !!opts.replay, // qualification already enforced replay determinism on admitted set
-        receiptCoverage: 1,
-        canaryRollbackRate: canaryCand.rollbackRate,
-        baselineRollbackRate: canaryBase.rollbackRate,
-    };
-    const decision = accept(verdict);
-    const result = {
-        ...base, baselineScore, candidateScore, verify,
-        canary: { candidate: canaryCand, baseline: canaryBase, pass: canaryCmp.pass },
-        verdict: decision, accepted: decision.accept,
-        reason: decision.accept ? 'accepted — all gates hold' : `rejected — ${decision.failed.join(', ')}`,
-    };
-    // 6. EMIT the champion manifest (UNSIGNED) on acceptance.
-    if (decision.accept && canaryCmp.pass) {
-        result.manifest = {
-            schema: 'ruflo.proven-config/v1',
-            policy: { ref: opts.policyRefOf ? opts.policyRefOf(opts.candidate) : 'sha256:unknown' },
-            layer: opts.layer,
-            compatibility: { ruflo: '>=3.24.0' },
-            benchmark: { corpus: opts.corpus.version, corpusHash: opts.corpus.corpusHash },
-            receipt: {
-                heldOutDelta: candidateScore - baselineScore,
-                redblue: verify.redblue,
-                drift: verify.drift,
-                canary: { rollbackRate: canaryCand.rollbackRate, latencyP95: canaryCand.latencyP95, costPerTask: canaryCand.costPerTask },
-                receiptCoverage: 1,
-            },
-        };
-    }
-    else if (decision.accept && !canaryCmp.pass) {
-        result.accepted = false;
-        result.reason = `rejected — canary regressed (${canaryCmp.failed.join(', ')})`;
-    }
-    return result;
-}
-//# sourceMappingURL=harness-loop.js.map

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

@@ -1,66 +0,0 @@
-export type ProvenanceTier = 'oracle:test-exec' | 'judge:fable' | 'proxy:structural';
-export interface TrajectoryStep {
-    action: string;
-    tier: ProvenanceTier;
-}
-export interface Trajectory {
-    id: string;
-    steps: TrajectoryStep[];
-    outcome: 'success' | 'failure';
-    benchmarkTaskId?: string;
-    inputs: unknown;
-    recordedOutputs: unknown;
-}
-/** Re-execute a trajectory's recorded inputs and return the outputs. */
-export type ReplayFn = (t: Trajectory) => unknown;
-export interface QualificationResult {
-    qualified: boolean;
-    reasons: string[];
-}
-/** Fingerprint a trajectory by its shape (step actions + outcome) so identical failures dedupe. */
-export declare function fingerprintTrajectory(t: Trajectory): string;
-/**
- * Invariant Q. `replay` is required — determinism cannot be asserted without
- * re-executing; a trajectory with no verifiable replay is REJECTED (fail-closed).
- */
-export declare function qualifyTrajectory(t: Trajectory, replay?: ReplayFn): QualificationResult;
-export interface AntiPattern {
-    fingerprint: string;
-    stage: string;
-    reasons: string[];
-    ts: number;
-}
-/**
- * File-backed avoid-list of rejected trajectories/mutations. JSONL, append-only
- * with a bounded cap: once the file exceeds `maxEntries` it is rewritten to the
- * newest `maxEntries` (rotation), so the archive can never grow unbounded —
- * runaway-storage guard. Deduped by fingerprint at the call site.
- */
-export declare class AntiPatternArchive {
-    private readonly filePath;
-    private readonly maxEntries;
-    constructor(filePath: string, maxEntries?: number);
-    private load;
-    record(entry: AntiPattern): void;
-    has(fingerprint: string): boolean;
-    list(): AntiPattern[];
-}
-export interface AdmissionReport {
-    qualified: Trajectory[];
-    rejected: Array<{
-        id: string;
-        reasons: string[];
-    }>;
-    admittedCount: number;
-    rejectedCount: number;
-}
-/**
- * Admit a batch of observed trajectories into the candidate dataset. Rejects are
- * recorded to the anti-pattern archive (deduped by fingerprint).
- */
-export declare function admitTrajectories(trajectories: Trajectory[], opts?: {
-    replay?: ReplayFn;
-    archive?: AntiPatternArchive;
-    ts?: number;
-}): AdmissionReport;
-//# sourceMappingURL=harness-qualification.d.ts.map

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

@@ -1,143 +0,0 @@
-/**
- * Qualification + anti-pattern archive (ADR-176 phase 1).
- *
- * Separates OBSERVATION from TRAINING DATA. Raw observed trajectories are NOT
- * training data — they enter optimization only through the Qualification gate,
- * which enforces:
- *
- *   Invariant Q: a trajectory is admitted iff it has
- *     (a) complete provenance   — every step attributed, tier >= oracle/judge
- *                                  (ADR-171; proxy:structural is triage-only),
- *     (b) deterministic replay   — re-running its recorded inputs reproduces its
- *                                  recorded outputs, and
- *     (c) benchmark attribution  — it maps to a task in the versioned corpus.
- *
- * Rejected trajectories are not discarded — they are recorded to the
- * ANTI-PATTERN ARCHIVE (negative learning), so future optimization runs avoid
- * re-discovering identical failures. Zero dependencies, $0.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { createHash } from 'crypto';
-/** Deterministic JSON for the replay comparison (recursively key-sorted). */
-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));
-}
-/** Fingerprint a trajectory by its shape (step actions + outcome) so identical failures dedupe. */
-export function fingerprintTrajectory(t) {
-    const shape = t.steps.map(s => s.action).join('→') + '#' + t.outcome + '#' + (t.benchmarkTaskId ?? '');
-    return createHash('sha256').update(shape).digest('hex').slice(0, 32);
-}
-/**
- * Invariant Q. `replay` is required — determinism cannot be asserted without
- * re-executing; a trajectory with no verifiable replay is REJECTED (fail-closed).
- */
-export function qualifyTrajectory(t, replay) {
-    const reasons = [];
-    // (a) complete provenance
-    if (!t.steps || t.steps.length === 0)
-        reasons.push('incomplete: no steps');
-    else {
-        if (t.steps.some(s => !s.action))
-            reasons.push('incomplete provenance: a step has no action');
-        if (t.steps.some(s => s.tier === 'proxy:structural'))
-            reasons.push('proxy-tier step present (below oracle/judge; ADR-171)');
-    }
-    // (c) benchmark attribution
-    if (!t.benchmarkTaskId)
-        reasons.push('no benchmark attribution');
-    // (b) deterministic replay
-    if (!replay) {
-        reasons.push('deterministic replay not verified (no replay fn)');
-    }
-    else {
-        let out;
-        try {
-            out = replay(t);
-        }
-        catch (e) {
-            reasons.push(`replay threw: ${e?.message ?? e}`);
-            out = undefined;
-        }
-        if (reasons.every(r => !r.startsWith('replay threw')) && stable(out) !== stable(t.recordedOutputs)) {
-            reasons.push('replay non-deterministic (outputs differ from recorded)');
-        }
-    }
-    return { qualified: reasons.length === 0, reasons };
-}
-/**
- * File-backed avoid-list of rejected trajectories/mutations. JSONL, append-only
- * with a bounded cap: once the file exceeds `maxEntries` it is rewritten to the
- * newest `maxEntries` (rotation), so the archive can never grow unbounded —
- * runaway-storage guard. Deduped by fingerprint at the call site.
- */
-export class AntiPatternArchive {
-    filePath;
-    maxEntries;
-    constructor(filePath, maxEntries = 10000) {
-        this.filePath = filePath;
-        this.maxEntries = maxEntries;
-    }
-    load() {
-        try {
-            return fs.readFileSync(this.filePath, 'utf-8').split('\n').filter(Boolean).map(l => JSON.parse(l));
-        }
-        catch {
-            return [];
-        }
-    }
-    record(entry) {
-        try {
-            fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
-            const existing = this.load();
-            if (existing.length >= this.maxEntries) {
-                // Rotate: keep the newest (maxEntries-1) + the new entry.
-                const kept = existing.slice(existing.length - (this.maxEntries - 1));
-                fs.writeFileSync(this.filePath, kept.concat(entry).map(e => JSON.stringify(e)).join('\n') + '\n', 'utf-8');
-            }
-            else {
-                fs.appendFileSync(this.filePath, JSON.stringify(entry) + '\n', 'utf-8');
-            }
-        }
-        catch { /* best-effort */ }
-    }
-    has(fingerprint) {
-        return this.load().some(a => a.fingerprint === fingerprint);
-    }
-    list() { return this.load(); }
-}
-/**
- * Admit a batch of observed trajectories into the candidate dataset. Rejects are
- * recorded to the anti-pattern archive (deduped by fingerprint).
- */
-export function admitTrajectories(trajectories, opts = {}) {
-    const qualified = [];
-    const rejected = [];
-    const ts = opts.ts ?? Date.now();
-    for (const t of trajectories) {
-        const r = qualifyTrajectory(t, opts.replay);
-        if (r.qualified) {
-            qualified.push(t);
-        }
-        else {
-            rejected.push({ id: t.id, reasons: r.reasons });
-            const fp = fingerprintTrajectory(t);
-            if (opts.archive && !opts.archive.has(fp)) {
-                opts.archive.record({ fingerprint: fp, stage: 'qualification', reasons: r.reasons, ts });
-            }
-        }
-    }
-    return { qualified, rejected, admittedCount: qualified.length, rejectedCount: rejected.length };
-}
-//# sourceMappingURL=harness-qualification.js.map

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

@@ -1,37 +0,0 @@
-/** Content digest of a value (canonical, order-independent). */
-export declare function digest(v: unknown): string;
-export interface RecordedRun {
-    id: string;
-    inputs: unknown;
-    outputDigest: string;
-    recordedAt?: number;
-}
-/** Re-executable unit: given inputs, produce outputs. Must be pure for determinism. */
-export type RunFn = (inputs: unknown) => unknown;
-/** Capture a run: execute once and record the output digest. */
-export declare function recordRun(id: string, inputs: unknown, run: RunFn, ts?: number): RecordedRun;
-export interface ReplayResult {
-    deterministic: boolean;
-    expectedDigest: string;
-    actualDigest: string;
-}
-/** Replay a recorded run and check it reproduces the recorded output digest. */
-export declare function verifyReplay(recorded: RecordedRun, run: RunFn): ReplayResult;
-/** Batch predicate for accept(): all recorded runs replay deterministically. */
-export declare function allDeterministic(recorded: RecordedRun[], run: RunFn): boolean;
-/**
- * File-backed store of recorded runs (JSONL). Append-only with a bounded cap:
- * once it exceeds `maxEntries` it rotates to the newest `maxEntries` — so the
- * store can never grow unbounded (runaway-storage guard). `get` returns the
- * latest for an id.
- */
-export declare class ReplayStore {
-    private readonly filePath;
-    private readonly maxEntries;
-    constructor(filePath: string, maxEntries?: number);
-    private load;
-    record(r: RecordedRun): void;
-    get(id: string): RecordedRun | undefined;
-    all(): RecordedRun[];
-}
-//# sourceMappingURL=harness-replay.d.ts.map

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

@@ -1,92 +0,0 @@
-/**
- * Deterministic replay engine (ADR-176 phase 3).
- *
- * The `replay == deterministic` predicate in Invariant Q (qualification) and in
- * accept() requires re-executing a recorded run's inputs and confirming they
- * reproduce the recorded outputs. This module records an output DIGEST at
- * capture time and verifies a replay reproduces it — so a trajectory only
- * counts as training data / promotion evidence if its behavior is reproducible.
- * Zero deps, $0.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-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 digest of a value (canonical, order-independent). */
-export function digest(v) {
-    return createHash('sha256').update(stable(v)).digest('hex');
-}
-/** Capture a run: execute once and record the output digest. */
-export function recordRun(id, inputs, run, ts) {
-    return { id, inputs, outputDigest: digest(run(inputs)), recordedAt: ts };
-}
-/** Replay a recorded run and check it reproduces the recorded output digest. */
-export function verifyReplay(recorded, run) {
-    let actual;
-    try {
-        actual = digest(run(recorded.inputs));
-    }
-    catch {
-        actual = 'THREW';
-    }
-    return { deterministic: actual === recorded.outputDigest, expectedDigest: recorded.outputDigest, actualDigest: actual };
-}
-/** Batch predicate for accept(): all recorded runs replay deterministically. */
-export function allDeterministic(recorded, run) {
-    return recorded.every(r => verifyReplay(r, run).deterministic);
-}
-/**
- * File-backed store of recorded runs (JSONL). Append-only with a bounded cap:
- * once it exceeds `maxEntries` it rotates to the newest `maxEntries` — so the
- * store can never grow unbounded (runaway-storage guard). `get` returns the
- * latest for an id.
- */
-export class ReplayStore {
-    filePath;
-    maxEntries;
-    constructor(filePath, maxEntries = 10000) {
-        this.filePath = filePath;
-        this.maxEntries = maxEntries;
-    }
-    load() {
-        try {
-            return fs.readFileSync(this.filePath, 'utf-8').split('\n').filter(Boolean).map(l => JSON.parse(l));
-        }
-        catch {
-            return [];
-        }
-    }
-    record(r) {
-        try {
-            fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
-            const existing = this.load();
-            if (existing.length >= this.maxEntries) {
-                const kept = existing.slice(existing.length - (this.maxEntries - 1));
-                fs.writeFileSync(this.filePath, kept.concat(r).map(e => JSON.stringify(e)).join('\n') + '\n', 'utf-8');
-            }
-            else {
-                fs.appendFileSync(this.filePath, JSON.stringify(r) + '\n', 'utf-8');
-            }
-        }
-        catch { /* best-effort */ }
-    }
-    get(id) {
-        const all = this.load().filter(r => r.id === id);
-        return all.length ? all[all.length - 1] : undefined; // latest wins
-    }
-    all() { return this.load(); }
-}
-//# sourceMappingURL=harness-replay.js.map

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

@@ -1,33 +0,0 @@
-/**
- * Adversarial + drift verify gate (ADR-176 phase 4).
- *
- * Produces the two verdicts accept() consumes beyond held-out benchmarking:
- *   - redblue: an adversarial red-team pass (@metaharness/redblue, mock-judge/$0
- *     by default, loopback-only, cost-capped),
- *   - drift:   distance from the current champion (@metaharness/drift_from_history).
- *
- * FAIL-CLOSED: if the adversarial verifier is unavailable (metaharness is an
- * optional dependency — ADR-150), redblue is SKIPPED, and since accept() requires
- * redblue === 'PASS', a candidate CANNOT be promoted without real adversarial
- * evidence. The loop then safely degrades to "observe + benchmark, don't
- * promote" and the current signed champion stands. Runners are injectable so the
- * orchestrator supplies the real metaharness bridge; defaults degrade. $0.
- */
-export type RedblueVerdict = 'PASS' | 'FAIL' | 'SKIPPED';
-export type RedblueRunner = () => Promise<RedblueVerdict>;
-/** Returns the drift distance from the champion (>=0), or a negative value = unavailable. */
-export type DriftRunner = () => Promise<number>;
-export interface VerifyResult {
-    redblue: RedblueVerdict;
-    drift: number;
-    driftThreshold: number;
-    driftVerdict: 'ok' | 'regressed' | 'skipped';
-    adversarialPass: boolean;
-}
-export interface VerifyOptions {
-    redblue?: RedblueRunner;
-    drift?: DriftRunner;
-    driftThreshold?: number;
-}
-export declare function runVerify(opts?: VerifyOptions): Promise<VerifyResult>;
-//# sourceMappingURL=harness-verify.d.ts.map

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

@@ -1,26 +0,0 @@
-/** Default redblue: no verifier wired in this module → SKIPPED (fail-closed). */
-const defaultRedblue = async () => 'SKIPPED';
-/** Default drift: no baseline → 0. */
-const defaultDrift = async () => 0;
-export async function runVerify(opts = {}) {
-    const driftThreshold = opts.driftThreshold ?? 0.05;
-    let redblue;
-    try {
-        redblue = await (opts.redblue ?? defaultRedblue)();
-    }
-    catch {
-        redblue = 'SKIPPED';
-    } // a throwing verifier is not a PASS
-    let drift;
-    try {
-        drift = await (opts.drift ?? defaultDrift)();
-    }
-    catch {
-        drift = -1;
-    }
-    const driftVerdict = drift < 0 ? 'skipped' : (drift <= driftThreshold ? 'ok' : 'regressed');
-    // Fail-closed: promotion requires a real PASS and a non-regressing, non-skipped drift.
-    const adversarialPass = redblue === 'PASS' && driftVerdict === 'ok';
-    return { redblue, drift, driftThreshold, driftVerdict, adversarialPass };
-}
-//# sourceMappingURL=harness-verify.js.map

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

@@ -1,23 +0,0 @@
-import { type HarnessLoopOptions } from './harness-loop.js';
-export declare const STAGED_CHAMPION_FILE = "harness-champion.manifest.json";
-export type HarnessWorkerInput = HarnessLoopOptions<any>;
-export type LoadHarnessInput = (projectRoot: string) => HarnessWorkerInput | null;
-export interface HarnessWorkerResult {
-    ran: boolean;
-    reason: string;
-    accepted?: boolean;
-    staged?: boolean;
-    admitted?: number;
-    rejected?: number;
-}
-export declare function harnessLoopOptedIn(): boolean;
-/**
- * Execute one bounded, opt-in harness-loop tick for `projectRoot`. Injectable
- * `loadInput`/`optInOverride` for tests. Best-effort; never throws.
- */
-export declare function runHarnessLoopWorker(projectRoot: string, opts?: {
-    loadInput?: LoadHarnessInput;
-    maxTrajectories?: number;
-    optInOverride?: boolean;
-}): Promise<HarnessWorkerResult>;
-//# sourceMappingURL=harness-worker.d.ts.map

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

@@ -1,66 +0,0 @@
-/**
- * Harness loop daemon worker (ADR-176 phase 8, part 2).
- *
- * Runs runHarnessLoop() on the daemon's schedule — but strictly bounded, given
- * the runaway-resource posture:
- *   - OPT-IN: no-op unless RUFLO_HARNESS_LOOP is truthy. The self-optimizing
- *     loop never runs autonomously without an explicit opt-in.
- *   - $0: with no optimizer/verifier/canary wired (the default), runHarnessLoop
- *     qualifies + benchmarks but promotes nothing (fail-closed). No LLM, no
- *     metaharness subprocess, no spend unless the operator opts those in too.
- *   - bounded: trajectories capped per tick; the daemon adds single-flight
- *     (maxConcurrent) + a 16-min worker timeout + TTL/idle shutdown.
- *   - never throws: a worker must not crash the daemon.
- *
- * On acceptance it STAGES the (unsigned) champion manifest for the separate
- * publish/sign step — the worker never signs (no key material in the daemon).
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { runHarnessLoop } from './harness-loop.js';
-export const STAGED_CHAMPION_FILE = 'harness-champion.manifest.json';
-/** No built-in input source yet — the operator wires a corpus + optimizer. */
-const defaultLoadInput = () => null;
-export function harnessLoopOptedIn() {
-    return /^(1|true|yes|on)$/i.test(process.env.RUFLO_HARNESS_LOOP ?? '');
-}
-/**
- * Execute one bounded, opt-in harness-loop tick for `projectRoot`. Injectable
- * `loadInput`/`optInOverride` for tests. Best-effort; never throws.
- */
-export async function runHarnessLoopWorker(projectRoot, opts = {}) {
-    try {
-        const optedIn = opts.optInOverride ?? harnessLoopOptedIn();
-        if (!optedIn)
-            return { ran: false, reason: 'opt-in required (RUFLO_HARNESS_LOOP=1)' };
-        const input = (opts.loadInput ?? defaultLoadInput)(projectRoot);
-        if (!input)
-            return { ran: false, reason: 'no harness input (corpus/optimizer) configured' };
-        const cap = opts.maxTrajectories ?? 2000;
-        const bounded = { ...input, trajectories: input.trajectories.slice(0, cap) };
-        const result = await runHarnessLoop(bounded);
-        let staged = false;
-        if (result.accepted && result.manifest) {
-            // Stage the UNSIGNED champion for the separate publish/sign step.
-            try {
-                const dir = path.join(projectRoot, '.claude-flow');
-                fs.mkdirSync(dir, { recursive: true });
-                fs.writeFileSync(path.join(dir, STAGED_CHAMPION_FILE), JSON.stringify(result.manifest, null, 2), 'utf-8');
-                staged = true;
-            }
-            catch { /* non-fatal */ }
-        }
-        return {
-            ran: true,
-            reason: result.reason,
-            accepted: result.accepted,
-            staged,
-            admitted: result.admitted,
-            rejected: result.rejected,
-        };
-    }
-    catch (e) {
-        return { ran: false, reason: `error: ${e?.message ?? e}` };
-    }
-}
-//# sourceMappingURL=harness-worker.js.map