@claude-flow/cli 3.32.24 → 3.32.26

package/catalog-manifest.json

@@ -1,11 +1,11 @@
 {
   "schemaVersion": 1,
-  "generation": 1,
-  "generatedAt": "2026-07-28T03:57:39.626Z",
-  "gitSha": "c50581b4",
+  "generation": 2,
+  "generatedAt": "2026-07-28T19:25:02.626Z",
+  "gitSha": "80634fa0",
   "catalog": {
     "agents": 164,
-    "tools": 387,
+    "tools": 388,
     "skills": 34
   },
   "benchmark": null

package/dist/src/commands/metaharness.js

@@ -35,9 +35,11 @@
  */
 import { output } from '../output.js';
 import { spawnSync } from 'child_process';
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
+import { runFlywheelWorker } from '../services/harness-flywheel-runtime.js';
+import { listFlywheelReceipts, promoteFlywheelCandidate, readFlywheelTransactionState, verifyFlywheelLedger, } from '../services/flywheel-transaction.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // Subcommand → plugin script filename
 const SUBCOMMANDS = {
@@ -65,7 +67,77 @@ const SUBCOMMANDS = {
     // @metaharness/darwin@0.8.0 — GEPA library surface (genome ops; the
     // gepaOptimize loop itself stays library-only / behind evolve)
     gepa: 'gepa.mjs',
+    // ADR-153 Darwin evolution and stable benchmark-corpus operations.
+    evolve: 'evolve.mjs',
+    bench: 'bench.mjs',
+    // ADR-322 evaluation receipt + atomic promotion loop; handled in-process.
+    flywheel: '__internal__',
 };
+function flywheelFlag(flags, name, fallback) {
+    const value = flags[name];
+    return (value === undefined ? fallback : value);
+}
+async function dispatchFlywheel(operation, positional, flags) {
+    const projectRoot = resolve(String(flywheelFlag(flags, 'projectRoot', process.cwd())));
+    let data;
+    if (!operation || operation === 'status') {
+        data = {
+            state: readFlywheelTransactionState(projectRoot),
+            ledger: verifyFlywheelLedger(projectRoot),
+        };
+    }
+    else if (operation === 'run') {
+        const privateKeyPath = flywheelFlag(flags, 'privateKey');
+        const publicKeyPath = flywheelFlag(flags, 'publicKey');
+        if (!!privateKeyPath !== !!publicKeyPath) {
+            data = { success: false, reason: '--private-key and --public-key must be supplied together' };
+        }
+        else {
+            data = await runFlywheelWorker(projectRoot, {
+                optInOverride: true,
+                sample: Number(flywheelFlag(flags, 'sample', 40)),
+                proposer: String(flywheelFlag(flags, 'proposer', 'auto')),
+                receiptPrivateKeyPem: privateKeyPath ? readFileSync(resolve(privateKeyPath), 'utf8') : undefined,
+                receiptPublicKeyPem: publicKeyPath ? readFileSync(resolve(publicKeyPath), 'utf8') : undefined,
+            });
+        }
+    }
+    else if (operation === 'receipts') {
+        data = listFlywheelReceipts(projectRoot).map(({ receipt, state }) => ({
+            receiptId: receipt.payload.receiptId,
+            candidateId: receipt.payload.candidateId,
+            baselineRef: receipt.payload.baselineRef,
+            decision: receipt.payload.decision,
+            signed: !!receipt.signature,
+            issuedAt: receipt.payload.issuedAt,
+            state,
+        }));
+    }
+    else if (operation === 'history') {
+        const state = readFlywheelTransactionState(projectRoot);
+        data = { ledgerHead: state.ledgerHead, commits: state.commits };
+    }
+    else if (operation === 'promote') {
+        const receiptId = positional[0];
+        const publicKeyPath = flywheelFlag(flags, 'publicKey');
+        if (!receiptId || !publicKeyPath) {
+            data = { success: false, reason: 'promote requires <receipt-id> and --public-key <PEM path>' };
+        }
+        else {
+            const publicKey = readFileSync(resolve(publicKeyPath), 'utf8');
+            data = await promoteFlywheelCandidate(projectRoot, receiptId, {
+                confirm: flywheelFlag(flags, 'confirm', false) === true,
+                trustedPublicKeys: new Set([publicKey]),
+            });
+        }
+    }
+    else {
+        data = { success: false, reason: `unknown flywheel operation: ${operation}` };
+    }
+    output.writeln(JSON.stringify(data, null, 2));
+    const success = !(data && typeof data === 'object' && data.success === false);
+    return { success, exitCode: success ? 0 : 1, data };
+}
 /**
  * Walk up from the current dirname to find the ruflo repo root that
  * contains plugins/ruflo-metaharness/. Handles three install layouts:
@@ -127,7 +199,7 @@ export const metaharnessCommand = {
             // iter 73 — list reflects all dispatchable subcommands (was
             // stale at the iter-3 list of 5). Keep this synced with the
             // SUBCOMMANDS map above.
-            description: 'One of: score | genome | mcp-scan | threat-model | oia-audit | audit-list | audit-trend | similarity | drift-from-history | mint | redblue | learn | gepa',
+            description: 'One of: score | genome | mcp-scan | threat-model | oia-audit | audit-list | audit-trend | similarity | drift-from-history | mint | redblue | learn | gepa | evolve | bench | flywheel',
             type: 'string',
         },
     ],
@@ -190,6 +262,9 @@ export const metaharnessCommand = {
             output.writeln('  drift-from-history  iter 53 — diff current state against most recent audit (1-command drift)');
             output.writeln('  mint          scaffold a custom harness (dry-run by default)');
             output.writeln('  redblue       adversarial red/blue LLM testing (init|run|patch|attack|report)');
+            output.writeln('  evolve        Darwin candidate evolution');
+            output.writeln('  bench         create or verify a stable benchmark suite');
+            output.writeln('  flywheel      receipt loop: run | status | receipts | history | promote');
             output.writeln('');
             output.writeln('Each subcommand accepts --format json|table and --help.');
             output.writeln('');
@@ -201,6 +276,9 @@ export const metaharnessCommand = {
             output.writeln(`Valid: ${Object.keys(SUBCOMMANDS).join(', ')}`);
             return { success: false, exitCode: 2, data: { subcommand } };
         }
+        if (subcommand === 'flywheel') {
+            return dispatchFlywheel(positionalRest[0], positionalRest.slice(1), ctxFlags);
+        }
         const scriptDir = locatePluginScripts(SUBCOMMANDS[subcommand]);
         if (!scriptDir) {
             output.writeln(output.warning('metaharness: plugins/ruflo-metaharness/scripts/ not found. Install ruflo with `npm i ruflo` or run from the ruflo repo.'));

package/dist/src/mcp-tools/metaharness-tools.js

@@ -48,9 +48,11 @@
  */
 import { getProjectCwd } from './types.js';
 import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { join, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { runFlywheelWorker } from '../services/harness-flywheel-runtime.js';
+import { listFlywheelReceipts, promoteFlywheelCandidate, readFlywheelTransactionState, verifyFlywheelLedger, } from '../services/flywheel-transaction.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 /**
  * Walk up from this module to find plugins/ruflo-metaharness/scripts/.
@@ -399,7 +401,7 @@ export const metaharnessTools = [
     },
     // ───────────────────────────────────────────────────────────────────────
     // ADR-153 — @metaharness/darwin integration (3 tools).
-    // Backed by the separate `@metaharness/darwin@~0.3.1` npm package, NOT
+    // Backed by the separate `@metaharness/darwin@~0.8.0` npm package, NOT
     // the umbrella `metaharness`. Plugin scripts shell out via _darwin.mjs.
     // Same {success, data, degraded, exitCode} contract.
     // ───────────────────────────────────────────────────────────────────────
@@ -680,5 +682,82 @@ export const metaharnessTools = [
             return { success: r.success, data: r.json, degraded: r.degraded, exitCode: r.exitCode };
         },
     },
+    {
+        name: 'metaharness_flywheel',
+        description: 'ADR-322 — evaluate candidates into immutable receipts, inspect the append-only promotion ledger, and explicitly promote one signed receipt with atomic compare-and-swap semantics. Evaluation never mutates the active champion. Promotion requires confirm=true and a local approved Ed25519 public-key PEM path; explicit trust is mandatory.',
+        category: 'metaharness',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                operation: { type: 'string', enum: ['run', 'status', 'receipts', 'history', 'promote'], description: 'Flywheel operation', default: 'status' },
+                projectRoot: { type: 'string', description: 'Target project root (default: active project cwd)' },
+                receiptId: { type: 'string', description: 'Receipt content ID for promote' },
+                sample: { type: 'number', description: 'Maximum harvested evaluation sample', default: 40 },
+                proposer: { type: 'string', enum: ['local', 'auto', 'darwin'], description: 'Candidate proposer. Auto fallback is evaluation-only; explicit darwin fails closed when no compatible adapter is installed.', default: 'auto' },
+                privateKeyPath: { type: 'string', description: 'Local Ed25519 private-key PEM path for signing run receipts; must be paired with publicKeyPath' },
+                publicKeyPath: { type: 'string', description: 'Local Ed25519 public-key PEM path used to sign a run or approve a promotion' },
+                confirm: { type: 'boolean', description: 'Required for promote; never inferred', default: false },
+            },
+            required: ['operation'],
+        },
+        handler: async (input) => {
+            const operation = String(input.operation ?? 'status');
+            const projectRoot = resolve(String(input.projectRoot ?? getProjectCwd()));
+            if (operation === 'status') {
+                return {
+                    success: true,
+                    data: {
+                        state: readFlywheelTransactionState(projectRoot),
+                        ledger: verifyFlywheelLedger(projectRoot),
+                    },
+                    degraded: false,
+                    exitCode: 0,
+                };
+            }
+            if (operation === 'receipts') {
+                const data = listFlywheelReceipts(projectRoot).map(({ receipt, state }) => ({
+                    receiptId: receipt.payload.receiptId,
+                    candidateId: receipt.payload.candidateId,
+                    baselineRef: receipt.payload.baselineRef,
+                    decision: receipt.payload.decision,
+                    signed: !!receipt.signature,
+                    issuedAt: receipt.payload.issuedAt,
+                    state,
+                }));
+                return { success: true, data, degraded: false, exitCode: 0 };
+            }
+            if (operation === 'history') {
+                const state = readFlywheelTransactionState(projectRoot);
+                return { success: true, data: { ledgerHead: state.ledgerHead, commits: state.commits }, degraded: false, exitCode: 0 };
+            }
+            if (operation === 'run') {
+                const privateKeyPath = input.privateKeyPath ? resolve(String(input.privateKeyPath)) : undefined;
+                const publicKeyPath = input.publicKeyPath ? resolve(String(input.publicKeyPath)) : undefined;
+                if (!!privateKeyPath !== !!publicKeyPath) {
+                    return { success: false, data: { reason: 'privateKeyPath and publicKeyPath must be supplied together' }, degraded: false, exitCode: 2 };
+                }
+                const data = await runFlywheelWorker(projectRoot, {
+                    optInOverride: true,
+                    sample: Number(input.sample ?? 40),
+                    proposer: String(input.proposer ?? 'auto'),
+                    receiptPrivateKeyPem: privateKeyPath ? readFileSync(privateKeyPath, 'utf8') : undefined,
+                    receiptPublicKeyPem: publicKeyPath ? readFileSync(publicKeyPath, 'utf8') : undefined,
+                });
+                return { success: data.ran, data, degraded: false, exitCode: data.ran ? 0 : 1 };
+            }
+            if (operation === 'promote') {
+                if (!input.receiptId || !input.publicKeyPath) {
+                    return { success: false, data: { reason: 'receiptId and publicKeyPath are required' }, degraded: false, exitCode: 2 };
+                }
+                const publicKey = readFileSync(resolve(String(input.publicKeyPath)), 'utf8');
+                const data = await promoteFlywheelCandidate(projectRoot, String(input.receiptId), {
+                    confirm: input.confirm === true,
+                    trustedPublicKeys: new Set([publicKey]),
+                });
+                return { success: data.success, data, degraded: false, exitCode: data.success ? 0 : 1 };
+            }
+            return { success: false, data: { reason: `unsupported operation: ${operation}` }, degraded: false, exitCode: 2 };
+        },
+    },
 ];
 //# sourceMappingURL=metaharness-tools.js.map

package/dist/src/services/distill-oracle.d.ts

@@ -36,6 +36,7 @@
  */
 import { type VerifyTaskKind } from '../ruvector/output-verifier.js';
 import { FableHarness, type ReflectItem, type ReflectResult } from './fable-harness.js';
+export declare const MH_DARWIN_PIN = "0.8.0";
 export type ResolvedProvenance = 'oracle:test-exec' | 'judge:fable' | 'proxy:structural';
 /** SWE-bench-shaped / bench-suite-mapped test spec that Tier 1 can execute. */
 export interface TestSpec {

package/dist/src/services/distill-oracle.js

@@ -37,6 +37,14 @@
 import { spawn } from 'child_process';
 import { verifyAndEscalate } from '../ruvector/output-verifier.js';
 import { FableHarness, } from './fable-harness.js';
+// Pinned @metaharness/darwin version for the Tier-1 mechanical oracle's `npx`
+// invocations. Bare `npx --yes @metaharness/darwin` floats to whatever npm
+// `latest` is, so a breaking darwin release could silently change eval
+// behavior mid-run (the #142 pin-drift failure mode). Pin it, and let
+// scripts/check-metaharness-pins.mjs watch this constant for drift. Kept in
+// lock-step with the optionalDependencies pin in package.json and the plugin
+// darwin cache (darwin-cache-0.8.0).
+export const MH_DARWIN_PIN = '0.8.0';
 // ── Public API ───────────────────────────────────────────────────────────
 /**
  * Label each trajectory with `resolved` + honest provenance, trying the tiers
@@ -198,7 +206,7 @@ export function buildOraclePlan(spec, remote) {
     const probeCommands = [
         `ssh -o BatchMode=yes -o ConnectTimeout=8 ${r} 'echo ok'`,
         `${sshLocal}'command -v docker >/dev/null 2>&1 && echo docker-present || echo docker-missing'`,
-        `${sshLocal}'command -v darwin >/dev/null 2>&1 || npx --yes @metaharness/darwin --version'`,
+        `${sshLocal}'command -v darwin >/dev/null 2>&1 || npx --yes @metaharness/darwin@${MH_DARWIN_PIN} --version'`,
     ];
     let kind;
     const evalCommands = [];
@@ -207,7 +215,7 @@ export function buildOraclePlan(spec, remote) {
         kind = 'ssh-darwin-bench';
         const suite = spec.benchSuite ? `--suite ${shq(spec.benchSuite)}` : '';
         const kase = spec.benchCase ? `--case ${shq(spec.benchCase)}` : '';
-        evalCommands.push(`${sshLocal}'cd ${workdir} && npx --yes @metaharness/darwin bench run ${suite} ${kase} --json'`.replace(/\s+/g, ' ').trim());
+        evalCommands.push(`${sshLocal}'cd ${workdir} && npx --yes @metaharness/darwin@${MH_DARWIN_PIN} bench run ${suite} ${kase} --json'`.replace(/\s+/g, ' ').trim());
         parseHint = 'resolved = darwin bench run reports the case scored PASS (exit 0, json.passed=true)';
     }
     else if (spec.evalCommand) {
@@ -222,7 +230,7 @@ export function buildOraclePlan(spec, remote) {
         }
         const f2p = (spec.failToPass ?? []).map(shq).join(' ');
         const p2p = (spec.passToPass ?? []).map(shq).join(' ');
-        evalCommands.push(`${sshLocal}'cd ${workdir} && npx --yes @metaharness/darwin swebench-eval` +
+        evalCommands.push(`${sshLocal}'cd ${workdir} && npx --yes @metaharness/darwin@${MH_DARWIN_PIN} swebench-eval` +
             `${spec.repo ? ` --repo ${shq(spec.repo)}` : ''}` +
             `${spec.baseCommit ? ` --base ${shq(spec.baseCommit)}` : ''}` +
             `${f2p ? ` --fail-to-pass ${f2p}` : ''}` +

package/dist/src/services/flywheel-proposer.d.ts

@@ -0,0 +1,87 @@
+/**
+ * ADR-322B proposer adapter.
+ *
+ * Proposers are untrusted candidate generators. This adapter normalizes local
+ * and Darwin output, enforces hard policy/resource admissibility before Pareto
+ * ranking, and makes auto-mode substitution evaluation-only by default.
+ */
+import { type ProposerName } from './flywheel-receipt.js';
+export type ProposerMode = 'auto' | ProposerName;
+export interface SafetyEnvelope {
+    ref: string;
+    allowedPolicyKeys: string[];
+    numericBounds?: Record<string, {
+        min?: number;
+        max?: number;
+    }>;
+    maxP95LatencyMicros: number;
+    maxCostMicrosPerTask: number;
+    maxTokensPerTask: number;
+    maxFailureRate: number;
+    maxEvaluationCostMicros: number;
+}
+export interface CandidateResources {
+    p95LatencyMicros: number;
+    costMicrosPerTask: number;
+    tokensPerTask: number;
+    failureRate: number;
+    evaluationCostMicros: number;
+}
+export interface ProposedCandidate {
+    policy: Record<string, unknown>;
+    resources: CandidateResources;
+    score?: number;
+    mutation?: string;
+    parentIds?: string[];
+}
+export interface NormalizedCandidate extends ProposedCandidate {
+    candidateId: string;
+    admissible: boolean;
+    rejectionReasons: string[];
+}
+export interface CandidateArchive {
+    archiveVersion: 'ruflo.candidate-archive/v1';
+    archiveId: string;
+    requestedProposer: ProposerMode;
+    effectiveProposer: ProposerName;
+    proposerSubstitution?: string;
+    promotionAllowed: boolean;
+    baselineRef: string;
+    safetyEnvelopeRef: string;
+    seed: number;
+    candidates: NormalizedCandidate[];
+    admissibleCandidates: NormalizedCandidate[];
+    paretoCandidates: NormalizedCandidate[];
+    completed: boolean;
+}
+export interface DarwinRunInput {
+    baselinePolicy: Record<string, unknown>;
+    seed: number;
+    budget: {
+        maxEvaluationCostMicros: number;
+        maxConcurrency: number;
+        maxWallTimeMs: number;
+    };
+}
+export type DarwinInvoker = (input: DarwinRunInput) => Promise<{
+    completed: boolean;
+    candidates: ProposedCandidate[];
+    reason?: string;
+}>;
+export interface ProposeCandidatesInput {
+    mode: ProposerMode;
+    baselinePolicy: Record<string, unknown>;
+    safetyEnvelope: SafetyEnvelope;
+    seed: number;
+    localProposer: (baseline: Record<string, unknown>, seed: number) => ProposedCandidate[] | Promise<ProposedCandidate[]>;
+    darwinInvoker?: DarwinInvoker;
+    allowSubstitutionPromotion?: boolean;
+    maxConcurrency?: number;
+    maxWallTimeMs?: number;
+    maxCandidates?: number;
+}
+export declare class DarwinUnavailableError extends Error {
+    constructor(message: string);
+}
+export declare function proposeFlywheelCandidates(input: ProposeCandidatesInput): Promise<CandidateArchive>;
+//# sourceMappingURL=flywheel-proposer.d.ts.map

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

@@ -0,0 +1,165 @@
+/**
+ * ADR-322B proposer adapter.
+ *
+ * Proposers are untrusted candidate generators. This adapter normalizes local
+ * and Darwin output, enforces hard policy/resource admissibility before Pareto
+ * ranking, and makes auto-mode substitution evaluation-only by default.
+ */
+import { canonicalizeJcs, policyCandidateId, sha256Ref } from './flywheel-receipt.js';
+export class DarwinUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DarwinUnavailableError';
+    }
+}
+function validateCandidate(candidate, envelope) {
+    const reasons = [];
+    const allowed = new Set(envelope.allowedPolicyKeys);
+    for (const [key, value] of Object.entries(candidate.policy)) {
+        if (!allowed.has(key)) {
+            reasons.push(`policy key not allowed: ${key}`);
+            continue;
+        }
+        const bounds = envelope.numericBounds?.[key];
+        if (bounds && typeof value === 'number') {
+            if (bounds.min !== undefined && value < bounds.min)
+                reasons.push(`${key} below minimum`);
+            if (bounds.max !== undefined && value > bounds.max)
+                reasons.push(`${key} above maximum`);
+        }
+    }
+    const r = candidate.resources;
+    if (r.p95LatencyMicros > envelope.maxP95LatencyMicros)
+        reasons.push('p95 latency exceeds envelope');
+    if (r.costMicrosPerTask > envelope.maxCostMicrosPerTask)
+        reasons.push('cost per task exceeds envelope');
+    if (r.tokensPerTask > envelope.maxTokensPerTask)
+        reasons.push('tokens per task exceeds envelope');
+    if (r.failureRate > envelope.maxFailureRate)
+        reasons.push('failure rate exceeds envelope');
+    if (r.evaluationCostMicros > envelope.maxEvaluationCostMicros)
+        reasons.push('evaluation cost exceeds envelope');
+    return {
+        ...candidate,
+        candidateId: policyCandidateId(candidate.policy),
+        admissible: reasons.length === 0,
+        rejectionReasons: reasons,
+    };
+}
+function finalizeArchive(input) {
+    const normalized = input.candidates.map((candidate) => validateCandidate(candidate, input.safetyEnvelope));
+    const admissible = normalized.filter((candidate) => candidate.admissible);
+    const dominates = (a, b) => {
+        const av = [
+            a.score ?? 0,
+            -a.resources.p95LatencyMicros,
+            -a.resources.costMicrosPerTask,
+            -a.resources.tokensPerTask,
+            -a.resources.failureRate,
+            -a.resources.evaluationCostMicros,
+        ];
+        const bv = [
+            b.score ?? 0,
+            -b.resources.p95LatencyMicros,
+            -b.resources.costMicrosPerTask,
+            -b.resources.tokensPerTask,
+            -b.resources.failureRate,
+            -b.resources.evaluationCostMicros,
+        ];
+        return av.every((value, index) => value >= bv[index])
+            && av.some((value, index) => value > bv[index]);
+    };
+    const paretoCandidates = admissible.filter((candidate, index) => !admissible.some((other, otherIndex) => otherIndex !== index && dominates(other, candidate)));
+    const core = {
+        archiveVersion: 'ruflo.candidate-archive/v1',
+        requestedProposer: input.requested,
+        effectiveProposer: input.effective,
+        ...(input.substitution ? { proposerSubstitution: input.substitution } : {}),
+        promotionAllowed: input.promotionAllowed,
+        baselineRef: input.baselineRef,
+        safetyEnvelopeRef: input.safetyEnvelope.ref,
+        seed: input.seed,
+        candidates: normalized,
+        completed: input.completed,
+    };
+    return {
+        ...core,
+        archiveId: sha256Ref(canonicalizeJcs(core)),
+        admissibleCandidates: admissible,
+        paretoCandidates,
+    };
+}
+export async function proposeFlywheelCandidates(input) {
+    const baselineRef = policyCandidateId(input.baselinePolicy);
+    const runLocal = async (substitution) => finalizeArchive({
+        requested: input.mode,
+        effective: 'local',
+        substitution,
+        promotionAllowed: substitution ? input.allowSubstitutionPromotion === true : true,
+        baselineRef,
+        safetyEnvelope: input.safetyEnvelope,
+        seed: input.seed,
+        candidates: await input.localProposer(input.baselinePolicy, input.seed),
+        completed: true,
+    });
+    if (input.mode === 'local')
+        return runLocal();
+    if (!input.darwinInvoker) {
+        if (input.mode === 'darwin')
+            throw new DarwinUnavailableError('Darwin explicitly requested but unavailable');
+        return runLocal('darwin-unavailable');
+    }
+    try {
+        const maxWallTimeMs = input.maxWallTimeMs ?? 60_000;
+        let timeout;
+        const result = await Promise.race([
+            input.darwinInvoker({
+                baselinePolicy: input.baselinePolicy,
+                seed: input.seed,
+                budget: {
+                    maxEvaluationCostMicros: input.safetyEnvelope.maxEvaluationCostMicros,
+                    maxConcurrency: input.maxConcurrency ?? 2,
+                    maxWallTimeMs,
+                },
+            }),
+            new Promise((_, reject) => {
+                timeout = setTimeout(() => reject(new DarwinUnavailableError('Darwin exceeded wall-time budget')), maxWallTimeMs);
+                timeout.unref?.();
+            }),
+        ]).finally(() => {
+            if (timeout)
+                clearTimeout(timeout);
+        });
+        if (!result.completed) {
+            if (input.mode === 'darwin')
+                throw new DarwinUnavailableError(result.reason ?? 'Darwin archive incomplete');
+            return runLocal(`darwin-incomplete:${result.reason ?? 'unknown'}`);
+        }
+        if (result.candidates.length > (input.maxCandidates ?? 256)) {
+            throw new DarwinUnavailableError('Darwin archive exceeded candidate-count budget');
+        }
+        const evaluationCost = result.candidates.reduce((sum, candidate) => sum + candidate.resources.evaluationCostMicros, 0);
+        if (evaluationCost > input.safetyEnvelope.maxEvaluationCostMicros) {
+            throw new DarwinUnavailableError('Darwin archive exceeded evaluation-cost budget');
+        }
+        return finalizeArchive({
+            requested: input.mode,
+            effective: 'darwin',
+            promotionAllowed: true,
+            baselineRef,
+            safetyEnvelope: input.safetyEnvelope,
+            seed: input.seed,
+            candidates: result.candidates,
+            completed: true,
+        });
+    }
+    catch (error) {
+        if (input.mode === 'darwin') {
+            if (error instanceof DarwinUnavailableError)
+                throw error;
+            throw new DarwinUnavailableError(`Darwin failed closed: ${error.message}`);
+        }
+        return runLocal(`darwin-error:${error.message}`);
+    }
+}
+//# sourceMappingURL=flywheel-proposer.js.map