@jinn-network/client 0.1.2 → 0.1.3-canary.216cf7e6

package/dist/scripts/donation-consumption-acceptance.js

@@ -0,0 +1,1385 @@
+#!/usr/bin/env node
+/**
+ * Release-blocking two-operator donation consumption gate.
+ *
+ * This is intentionally not a mocked corpus test. It expects real testnet
+ * canonical on-chain/IPFS discovery, a producer daemon with fresh donated SWE execution
+ * data, and a separate consumer operator home/db that can consume that data
+ * through the same MCP tools exposed to the learner runtime.
+ */
+import { createHash, randomBytes } from 'node:crypto';
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import { parseArgs } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { Store } from '../store/store.js';
+import { DEFAULT_CONFIG_PATH, DEFAULT_TESTNET_SUBGRAPH_URL } from '../config.js';
+import { DEFAULT_EXECUTION_DISCOVERY_FROM_BLOCK, DEFAULT_IDENTITY_REGISTRY_BY_CHAIN_ID, runOnchainCorpusQuery, } from '../corpus/onchain-query.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function findPackageRoot(startDir) {
+    let current = startDir;
+    while (true) {
+        if (existsSync(join(current, 'package.json')))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return resolve(startDir, '..', '..');
+        current = parent;
+    }
+}
+const clientRoot = findPackageRoot(__dirname);
+const jinnBinPath = join(clientRoot, 'dist', 'bin', 'jinn.js');
+const mcpServerPath = join(clientRoot, 'dist', 'mcp', 'server.js');
+const DEFAULT_IPFS_GATEWAY_URL = 'https://gateway.autonolas.tech';
+const SWE_SOLUTION_ARTIFACT_TYPE = 'swe-rebench-v2_v1_solution';
+const CONSUMER_CLAUDE_DISABLED_HARNESSES = [
+    'legacy-claude',
+    'claude-code',
+    'claude-mcp-hyperliquid',
+    'claude-mcp-prediction',
+    'claude-mcp-prediction-apy',
+];
+const VERDICT_ARTIFACT_TYPES = new Set([
+    'swe-rebench_v2_verdict',
+    'swe-rebench-v2_v1_verdict',
+]);
+class GateFailure extends Error {
+    code;
+    details;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'GateFailure';
+    }
+}
+function fail(code, message, details = {}) {
+    throw new GateFailure(code, message, details);
+}
+function nowSlug(date = new Date()) {
+    return date.toISOString().replace(/[:.]/g, '-');
+}
+function sleep(ms) {
+    return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
+function boundedPollSleep(deadline, pollMs) {
+    return sleep(Math.max(0, Math.min(pollMs, deadline - Date.now())));
+}
+function asString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function defaultRpcUrlForChain(chainId) {
+    return chainId === 8453 ? 'https://mainnet.base.org' : 'https://sepolia.base.org';
+}
+function asInt(value, fallback) {
+    const n = Number.parseInt(String(value ?? ''), 10);
+    return Number.isFinite(n) ? n : fallback;
+}
+function readJsonFile(path) {
+    if (!existsSync(path))
+        return {};
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+function writeJson(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+function archiveManagedConsumerDb(dbPath, evidenceDir) {
+    const archived = [];
+    for (const path of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
+        if (!existsSync(path))
+            continue;
+        const target = join(evidenceDir, `previous-${basename(path)}`);
+        renameSync(path, target);
+        archived.push(target);
+    }
+    return archived;
+}
+function defaultClientHome(home) {
+    return join(home, '.jinn-client');
+}
+function engineImplStateRoot(config, home) {
+    const engine = config.engine && typeof config.engine === 'object' && !Array.isArray(config.engine)
+        ? config.engine
+        : {};
+    return asString(engine.implStateDirRoot) ?? join(defaultClientHome(home), 'engine', 'impl-state');
+}
+function sweEvaluatorStatePath(config, home) {
+    return join(engineImplStateRoot(config, home), 'swe-rebench-v2-evaluator', 'state.json');
+}
+function resolveConfigPath(path) {
+    return path ? resolve(path) : DEFAULT_CONFIG_PATH;
+}
+function loadLocalConfig(path) {
+    return readJsonFile(path);
+}
+function configApiPort(config, fallback) {
+    return asInt(config.apiPort, fallback);
+}
+function configDbPath(config, home) {
+    return asString(config.dbPath) ?? join(defaultClientHome(home), 'jinn.db');
+}
+function configEarningDir(config, home) {
+    return asString(config.earningDir) ?? join(defaultClientHome(home), 'earning');
+}
+function normalizeIpfsGateway(base, cid) {
+    const trimmed = base.replace(/\/+$/, '');
+    return trimmed.endsWith('/ipfs') ? `${trimmed}/${cid}` : `${trimmed}/ipfs/${cid}`;
+}
+async function fetchJson(url, init) {
+    const response = await fetch(url, init);
+    if (!response.ok) {
+        fail('http_error', `HTTP ${response.status} from ${url}`, { url, status: response.status });
+    }
+    return (await response.json());
+}
+async function fetchIpfsJson(gatewayUrl, cid) {
+    return fetchJson(normalizeIpfsGateway(gatewayUrl, cid));
+}
+function sha256Hex(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+function decodeBase64(value, label) {
+    if (typeof value !== 'string' || !value.trim()) {
+        fail('invalid_donation_wrapper', `${label} is missing base64 data`, { label });
+    }
+    return Buffer.from(value, 'base64');
+}
+async function querySubgraphExecution(subgraphUrl, manifestCid) {
+    const body = await fetchJson(subgraphUrl, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+            query: `
+        query DonationEnvelope($manifestCid: String!) {
+          executions(first: 1, where: { manifestCid: $manifestCid }) {
+            id
+            manifestCid
+            tier
+            publishedAt
+            operator {
+              agentId
+              owner
+              agentWallet
+            }
+          }
+        }
+      `,
+            variables: { manifestCid },
+        }),
+    });
+    const errors = body.errors;
+    if (Array.isArray(errors) && errors.length > 0) {
+        throw new Error(`Subgraph returned errors while checking donated envelope indexing: ${JSON.stringify(errors)}`);
+    }
+    const executions = (body.data?.executions ?? []);
+    const execution = executions[0];
+    return execution ?? null;
+}
+async function querySubgraphTaskIdByTaskCidDigest(subgraphUrl, taskCidDigest) {
+    const body = await fetchJson(subgraphUrl, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+            query: `
+        query TaskByTaskCidDigest($taskCidDigest: Bytes!) {
+          tasks(first: 1, where: { taskCidDigest: $taskCidDigest }) {
+            id
+            taskId
+            taskCidDigest
+            createdAtTx
+          }
+        }
+      `,
+            variables: { taskCidDigest: taskCidDigest.toLowerCase() },
+        }),
+    });
+    const errors = body.errors;
+    if (Array.isArray(errors) && errors.length > 0) {
+        throw new Error(`Subgraph returned errors while resolving producer task id: ${JSON.stringify(errors)}`);
+    }
+    const tasks = (body.data?.tasks ?? []);
+    const task = tasks[0];
+    return asString(task?.taskId) ?? asString(task?.id) ?? null;
+}
+async function queryCanonicalExecutionIndex(opts) {
+    const warnings = [];
+    if (opts.subgraphUrl) {
+        try {
+            const subgraphExecution = await querySubgraphExecution(opts.subgraphUrl, opts.manifestCid);
+            if (subgraphExecution)
+                return { source: 'subgraph', ...subgraphExecution };
+        }
+        catch (err) {
+            warnings.push(err instanceof Error ? err.message : String(err));
+        }
+    }
+    const identityRegistryAddress = DEFAULT_IDENTITY_REGISTRY_BY_CHAIN_ID[opts.chainId];
+    if (opts.rpcUrl && identityRegistryAddress) {
+        try {
+            const refs = await runOnchainCorpusQuery({ limit: 100 }, {
+                rpcUrl: opts.rpcUrl,
+                chainId: opts.chainId,
+                identityRegistryAddress,
+                fromBlock: DEFAULT_EXECUTION_DISCOVERY_FROM_BLOCK[opts.chainId],
+            });
+            const ref = refs.find((candidate) => candidate.manifestCid === opts.manifestCid);
+            if (ref) {
+                return {
+                    source: 'onchain',
+                    manifestCid: ref.manifestCid,
+                    manifestHash: ref.manifestHash,
+                    tier: ref.evidenceTier,
+                    publishedAt: ref.publishedAt,
+                    operator: ref.operator,
+                };
+            }
+        }
+        catch (err) {
+            warnings.push(err instanceof Error ? err.message : String(err));
+        }
+    }
+    return warnings.length > 0 ? { source: 'unavailable', warnings } : null;
+}
+async function waitForCanonicalExecutionIndex(opts) {
+    while (Date.now() < opts.deadline) {
+        const execution = await queryCanonicalExecutionIndex(opts);
+        if (execution && execution.source !== 'unavailable')
+            return execution;
+        await boundedPollSleep(opts.deadline, opts.pollMs);
+    }
+    fail('envelope_not_indexed', 'Donated envelope is not visible through the canonical on-chain/IPFS index path.', {
+        manifestCid: opts.manifestCid,
+    });
+}
+function redactEnvelope(envelope) {
+    const artifacts = Array.isArray(envelope.artifacts)
+        ? envelope.artifacts.map((raw) => {
+            const artifact = raw;
+            return {
+                artifactType: artifact.artifactType,
+                sha256: artifact.sha256,
+                access: artifact.access,
+                metadata: artifact.metadata,
+                sources: artifact.sources,
+            };
+        })
+        : [];
+    return {
+        schemaVersion: envelope.schemaVersion,
+        solverType: envelope.solverType,
+        role: envelope.role,
+        generatedAt: envelope.generatedAt,
+        participant: envelope.participant,
+        executor: envelope.executor,
+        trajectory: envelope.trajectory,
+        artifacts,
+        payload: '<redacted>',
+    };
+}
+async function verifyTrajectorySource(envelope, ipfsGatewayUrl) {
+    const trajectory = envelope.trajectory;
+    if (!trajectory || typeof trajectory !== 'object') {
+        fail('trajectory_missing', 'Donated envelope does not include a trajectory reference.', {});
+    }
+    const trajectorySha = trajectory.sha256;
+    if (typeof trajectorySha !== 'string' || !/^[0-9a-f]{64}$/.test(trajectorySha)) {
+        fail('trajectory_invalid', 'Envelope trajectory is missing a valid sha256.', { trajectory });
+    }
+    const sources = Array.isArray(trajectory.sources) ? trajectory.sources : [];
+    if (sources.length === 0) {
+        fail('trajectory_sources_missing', 'Envelope trajectory has no donated IPFS source.', { trajectory });
+    }
+    let firstCid = '';
+    for (const source of sources) {
+        if (source.kind !== 'ipfs' ||
+            typeof source.cid !== 'string' ||
+            source.sha256 !== trajectorySha ||
+            source.encoding !== 'jinn.artifact.donation.v1') {
+            fail('invalid_trajectory_source', 'Envelope trajectory source is not a valid donated IPFS source.', {
+                trajectory,
+                source,
+            });
+        }
+        firstCid ||= source.cid;
+        const wrapper = await fetchIpfsJson(ipfsGatewayUrl, source.cid);
+        if (wrapper.schemaVersion !== 'jinn.artifact.donation.v1' ||
+            wrapper.encoding !== 'jinn.artifact.donation.v1' ||
+            wrapper.artifactType !== 'jinn.trajectory.v1' ||
+            wrapper.sha256 !== trajectorySha) {
+            fail('invalid_trajectory_wrapper', 'Trajectory wrapper has unexpected schema, encoding, artifact type, or sha256.', {
+                cid: source.cid,
+                trajectorySha,
+            });
+        }
+        const bytes = decodeBase64(wrapper.data, 'trajectory donation wrapper');
+        const actualSha = sha256Hex(bytes);
+        if (actualSha !== trajectorySha) {
+            fail('trajectory_wrapper_hash_mismatch', 'Trajectory wrapper bytes do not match the advertised sha256.', {
+                cid: source.cid,
+                expected: trajectorySha,
+                actual: actualSha,
+            });
+        }
+        const trajectoryPayload = parseMaybeJson(bytes);
+        if (trajectoryPayload?.schemaVersion !== 'jinn.trajectory.v1') {
+            fail('trajectory_wrapper_payload_invalid', 'Trajectory wrapper bytes are not a jinn.trajectory.v1 payload.', {
+                cid: source.cid,
+                schemaVersion: trajectoryPayload?.schemaVersion,
+            });
+        }
+    }
+    return firstCid;
+}
+async function verifyDonatedEnvelope(artifact, ipfsGatewayUrl, indexOpts, deadline, pollMs) {
+    const envelope = await fetchIpfsJson(ipfsGatewayUrl, artifact.envelopeCid);
+    const artifacts = Array.isArray(envelope.artifacts) ? envelope.artifacts : [];
+    const target = artifacts.find((candidate) => candidate.sha256 === artifact.sha256);
+    if (!target) {
+        fail('artifact_missing_from_envelope', 'Producer artifact sha256 is not present in its envelope.', {
+            sha256: artifact.sha256,
+            envelopeCid: artifact.envelopeCid,
+        });
+    }
+    const sources = Array.isArray(target.sources) ? target.sources : [];
+    if (sources.length === 0) {
+        fail('donation_sources_missing', 'Donated SWE artifact has no IPFS sources.', {
+            sha256: artifact.sha256,
+            envelopeCid: artifact.envelopeCid,
+        });
+    }
+    let firstCid = '';
+    for (const source of sources) {
+        if (source.kind !== 'ipfs' ||
+            typeof source.cid !== 'string' ||
+            source.sha256 !== artifact.sha256 ||
+            source.encoding !== 'jinn.artifact.donation.v1') {
+            fail('invalid_donation_source', 'Envelope source is not a valid donation IPFS source.', {
+                sha256: artifact.sha256,
+                source,
+            });
+        }
+        firstCid ||= source.cid;
+        const wrapper = await fetchIpfsJson(ipfsGatewayUrl, source.cid);
+        if (wrapper.schemaVersion !== 'jinn.artifact.donation.v1' ||
+            wrapper.encoding !== 'jinn.artifact.donation.v1' ||
+            wrapper.sha256 !== artifact.sha256) {
+            fail('invalid_donation_wrapper', 'Donation wrapper has unexpected schema, encoding, or sha256.', {
+                cid: source.cid,
+                sha256: artifact.sha256,
+            });
+        }
+        const bytes = decodeBase64(wrapper.data, 'donation wrapper');
+        const actualSha = sha256Hex(bytes);
+        if (actualSha !== artifact.sha256) {
+            fail('donation_wrapper_hash_mismatch', 'Donation wrapper bytes do not match the advertised sha256.', {
+                cid: source.cid,
+                expected: artifact.sha256,
+                actual: actualSha,
+            });
+        }
+    }
+    const trajectorySourceCid = await verifyTrajectorySource(envelope, ipfsGatewayUrl);
+    const indexExecution = await waitForCanonicalExecutionIndex({
+        ...indexOpts,
+        manifestCid: artifact.envelopeCid,
+        deadline,
+        pollMs,
+    });
+    return {
+        artifact,
+        sourceCid: firstCid,
+        trajectorySourceCid,
+        envelope,
+        redactedEnvelope: redactEnvelope(envelope),
+        indexExecution,
+    };
+}
+async function fetchOperatorArtifacts(baseUrl, source, artifactType, auth = {}) {
+    const url = new URL('/v1/operator/artifacts', baseUrl);
+    url.searchParams.set('source', source);
+    url.searchParams.set('artifactType', artifactType);
+    url.searchParams.set('limit', '50');
+    return fetchJson(url.toString(), auth.headers ? { headers: auth.headers } : undefined);
+}
+async function waitForProducerArtifact(opts) {
+    let lastError = null;
+    while (Date.now() < opts.deadline) {
+        try {
+            const response = await fetchOperatorArtifacts(opts.producerUrl, 'served', SWE_SOLUTION_ARTIFACT_TYPE, opts.producerAuth);
+            const artifacts = response.artifacts ?? [];
+            const candidate = artifacts.find((row) => {
+                if (row.artifactType !== SWE_SOLUTION_ARTIFACT_TYPE ||
+                    typeof row.sha256 !== 'string' ||
+                    !row.envelopeCid ||
+                    typeof row.createdAt !== 'string') {
+                    return false;
+                }
+                return opts.reuseExisting || Date.parse(row.createdAt) >= opts.startedAt.getTime();
+            });
+            if (candidate?.sha256 && candidate.envelopeCid && candidate.createdAt) {
+                return {
+                    sha256: candidate.sha256,
+                    artifactType: SWE_SOLUTION_ARTIFACT_TYPE,
+                    requestId: candidate.requestId ?? null,
+                    envelopeCid: candidate.envelopeCid,
+                    createdAt: candidate.createdAt,
+                };
+            }
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err.message : String(err);
+        }
+        await boundedPollSleep(opts.deadline, opts.pollMs);
+    }
+    fail('producer_artifact_timeout', opts.reuseExisting
+        ? 'No donated SWE solution artifact with an envelope CID was found on the producer.'
+        : 'No fresh donated SWE solution artifact was produced after the release gate started.', { producerUrl: opts.producerUrl, artifactType: SWE_SOLUTION_ARTIFACT_TYPE, lastError });
+}
+async function producerAuthFromHandshake(producerUrl, handshakeKey) {
+    const url = new URL('/auth/handshake', producerUrl);
+    url.searchParams.set('k', handshakeKey);
+    const response = await fetch(url);
+    if (!response.ok) {
+        fail('producer_handshake_failed', 'Producer UI handshake failed.', {
+            producerUrl,
+            status: response.status,
+        });
+    }
+    const setCookie = response.headers.get('set-cookie');
+    const cookie = setCookie?.split(';')[0]?.trim();
+    if (!cookie) {
+        fail('producer_handshake_cookie_missing', 'Producer UI handshake did not return a session cookie.', {
+            producerUrl,
+        });
+    }
+    return { headers: { cookie } };
+}
+async function resolveProducerAuth(opts) {
+    if (opts.producerUiToken) {
+        return { headers: { 'x-jinn-ui-token': opts.producerUiToken } };
+    }
+    if (opts.producerHandshakeKey) {
+        return producerAuthFromHandshake(opts.producerUrl, opts.producerHandshakeKey);
+    }
+    return {};
+}
+function buildConsumerHarnesses(raw) {
+    const base = raw && typeof raw === 'object' && !Array.isArray(raw)
+        ? { ...raw }
+        : {};
+    const disabled = new Set();
+    for (const entry of Array.isArray(base.disabled) ? base.disabled : []) {
+        if (typeof entry === 'string' && entry.trim())
+            disabled.add(entry.trim());
+    }
+    for (const name of CONSUMER_CLAUDE_DISABLED_HARNESSES)
+        disabled.add(name);
+    delete base.externalImpls;
+    return {
+        ...base,
+        default: 'codex',
+        disabled: [...disabled],
+    };
+}
+export function buildConsumerConfig(opts) {
+    const clientHome = defaultClientHome(opts.consumerHome);
+    const solverNets = cloneSolverNetsForConsumer(opts.producerConfig.solverNets);
+    const base = {
+        network: opts.producerConfig.network ?? 'testnet',
+        rpcUrl: opts.producerConfig.rpcUrl,
+        earningDir: join(clientHome, 'earning'),
+        dbPath: join(clientHome, 'jinn.db'),
+        apiPort: opts.consumerPort,
+        pollIntervalMs: opts.producerConfig.pollIntervalMs ?? 5000,
+        subgraphUrl: opts.subgraphUrl,
+        ipfsGatewayUrl: opts.ipfsGatewayUrl,
+        ipfsRegistryUrl: opts.producerConfig.ipfsRegistryUrl ?? 'https://registry.autonolas.tech',
+        operator: {
+            publicEndpoint: `http://localhost:${opts.consumerPort}`,
+            defaultPriceUsdc: '0',
+            perArtifactTypePrice: {},
+            donation: { enabled: true },
+        },
+        ...(opts.producerConfig.claudePath ? { claudePath: opts.producerConfig.claudePath } : {}),
+        ...(opts.producerConfig.claudeModel ? { claudeModel: opts.producerConfig.claudeModel } : {}),
+        ...(opts.producerConfig.runtimeMode ? { runtimeMode: opts.producerConfig.runtimeMode } : {}),
+        ...(opts.producerConfig.harness ? { harness: opts.producerConfig.harness } : {}),
+        harnesses: buildConsumerHarnesses(opts.producerConfig.harnesses),
+        ...(solverNets ? { solverNets } : {}),
+        ...(opts.producerConfig.joinedSolverNets ? { joinedSolverNets: opts.producerConfig.joinedSolverNets } : {}),
+        engine: {
+            workingDirRoot: join(clientHome, 'engine', 'work'),
+            implStateDirRoot: join(clientHome, 'engine', 'impl-state'),
+        },
+        tasks: [],
+    };
+    for (const key of [
+        'testnetL2DeploymentPath',
+        'testnetL2TokenDeploymentPath',
+        'testnetMechDeploymentPath',
+        'testnetStolasDeploymentPath',
+        'jinnMviL1DeploymentPath',
+        'jinnMviL2DeploymentPath',
+        'ethereumRpcUrl',
+        'jinnDistributorAddress',
+        'jinnClaimEmitterAddress',
+    ]) {
+        if (opts.producerConfig[key] !== undefined)
+            base[key] = opts.producerConfig[key];
+    }
+    return base;
+}
+export function ensureConsumerSweEvaluatorState(opts) {
+    const consumerStatePath = sweEvaluatorStatePath(opts.consumerConfig, opts.consumerHome);
+    const consumerState = readJsonFile(consumerStatePath);
+    const existingUpstream = asString(consumerState.upstreamRepoDir);
+    if (consumerState.schemaVersion === 'swe-rebench-v2-evaluator-state.v1' && existingUpstream && existsSync(existingUpstream)) {
+        return consumerStatePath;
+    }
+    const producerStatePath = sweEvaluatorStatePath(opts.producerConfig, opts.producerHome);
+    const producerState = readJsonFile(producerStatePath);
+    const upstreamRepoDir = asString(producerState.upstreamRepoDir);
+    if (producerState.schemaVersion !== 'swe-rebench-v2-evaluator-state.v1' || !upstreamRepoDir || !existsSync(upstreamRepoDir)) {
+        fail('consumer_evaluator_setup_required', 'Consumer SWE evaluator is not enabled and no reusable producer evaluator checkout was found.', {
+            producerStatePath,
+            consumerStatePath,
+            remedy: 'Run `jinn harnesses enable swe-rebench-v2-evaluator` for the producer or the consumer config, then rerun the donation-consumption gate.',
+        });
+    }
+    const nextState = {
+        schemaVersion: 'swe-rebench-v2-evaluator-state.v1',
+        enabled: true,
+        enabledAt: new Date().toISOString(),
+        upstreamRepoDir,
+    };
+    writeJson(consumerStatePath, nextState);
+    if (opts.evidenceDir) {
+        writeJson(join(opts.evidenceDir, 'consumer-evaluator-state.json'), {
+            consumerStatePath,
+            sourceStatePath: producerStatePath,
+            upstreamRepoDir,
+        });
+    }
+    return consumerStatePath;
+}
+function cloneSolverNetsForConsumer(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    const out = {};
+    for (const [name, value] of Object.entries(raw)) {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            continue;
+        const entry = { ...value };
+        const taskGenerator = entry.taskGenerator && typeof entry.taskGenerator === 'object' && !Array.isArray(entry.taskGenerator)
+            ? { ...entry.taskGenerator, enabled: false }
+            : { enabled: false };
+        entry.taskGenerator = taskGenerator;
+        out[name] = entry;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+function sourceName(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value && typeof value === 'object') {
+        const record = value;
+        return asString(record.name) ?? asString(record.source);
+    }
+    return undefined;
+}
+function includesSweRuntimePlugin(plugins) {
+    return Array.isArray(plugins) && plugins.some((plugin) => {
+        const name = sourceName(plugin);
+        return name === 'bundled:swe-rebench-v2-runtime' || name === 'swe-rebench-v2-runtime';
+    });
+}
+function disablesSweRuntime(disabledDefaults) {
+    return Array.isArray(disabledDefaults) && disabledDefaults.some((entry) => entry === 'bundled:swe-rebench-v2-runtime' || entry === 'swe-rebench-v2-runtime');
+}
+function assertConsumerConfiguredForSwe(config, configPath) {
+    const joined = config.joinedSolverNets;
+    const entries = joined && typeof joined === 'object' && !Array.isArray(joined)
+        ? Object.values(joined)
+        : [];
+    const sweEntries = entries.filter((entry) => {
+        const contract = entry.contract;
+        return contract?.id === 'swe-rebench-v2' && contract?.version === 'v1';
+    });
+    const solverEntries = sweEntries.filter((entry) => (Array.isArray(entry.roles) && entry.roles.includes('solver')));
+    const evaluatorEntries = sweEntries.filter((entry) => (Array.isArray(entry.roles) && entry.roles.includes('evaluator')));
+    const joinedRuntimeEnabled = solverEntries.some((entry) => (!disablesSweRuntime(entry.disabledDefaultPlugins) || includesSweRuntimePlugin(entry.plugins)));
+    const solverNets = config.solverNets && typeof config.solverNets === 'object' && !Array.isArray(config.solverNets)
+        ? Object.values(config.solverNets)
+        : [];
+    const legacySweEntries = solverNets.filter((entry) => (entry.enabled !== false && entry.solverType === 'swe-rebench-v2.v1'));
+    const legacyHasSolver = legacySweEntries.some((entry) => (!Array.isArray(entry.roles) || entry.roles.includes('solving')));
+    const legacyHasEvaluator = legacySweEntries.some((entry) => (Array.isArray(entry.roles) && entry.roles.includes('evaluating')));
+    const legacyRuntimeEnabled = legacySweEntries.some((entry) => includesSweRuntimePlugin(entry.plugins));
+    const hasSolver = solverEntries.length > 0 || legacyHasSolver;
+    const hasEvaluator = evaluatorEntries.length > 0 || legacyHasEvaluator;
+    const runtimeEnabled = joinedRuntimeEnabled || legacyRuntimeEnabled;
+    if (!hasSolver || !hasEvaluator || !runtimeEnabled) {
+        fail('consumer_swe_join_required', 'Consumer config is not joined to SWE-rebench v2 for the live donation gate.', {
+            configPath,
+            hasSolver,
+            hasEvaluator,
+            runtimeEnabled,
+            remedy: 'Join SWE-rebench v2 in the app as solver and evaluator with Network Tools plus swe-rebench-v2-runtime enabled, then rerun this gate with --consumer-config or the default isolated consumer home.',
+        });
+    }
+}
+export function resolveConsumerCodexHome(raw) {
+    const explicit = raw?.trim() || process.env['JINN_DONATION_CONSUMER_CODEX_HOME']?.trim();
+    if (explicit)
+        return resolve(explicit);
+    const envHome = process.env['CODEX_HOME']?.trim();
+    if (envHome)
+        return resolve(envHome);
+    const defaultPath = join(homedir(), '.codex');
+    return existsSync(join(defaultPath, 'auth.json')) ? defaultPath : undefined;
+}
+function assertConsumerCodexAuthAvailable(codexHome) {
+    if (process.env['OPENAI_API_KEY']?.trim())
+        return;
+    if (codexHome && existsSync(join(codexHome, 'auth.json')))
+        return;
+    fail('consumer_codex_auth_required', 'Consumer Codex harness auth is missing for the live donation gate.', {
+        codexHome,
+        remedy: 'Set OPENAI_API_KEY, CODEX_HOME, JINN_DONATION_CONSUMER_CODEX_HOME, or pass --consumer-codex-home pointing at a Codex home with auth.json.',
+    });
+}
+export function buildConsumerChildEnv(home, apiToken, codexHome) {
+    const corepackHome = process.env['COREPACK_HOME'] ?? join(homedir(), '.cache', 'node', 'corepack');
+    const env = {
+        ...process.env,
+        HOME: home,
+        XDG_CONFIG_HOME: join(home, '.config'),
+        XDG_DATA_HOME: join(home, '.local', 'share'),
+        XDG_CACHE_HOME: join(home, '.cache'),
+        COREPACK_HOME: corepackHome,
+        DAEMON_API_TOKEN: apiToken,
+        JINN_NO_UI: '1',
+        NO_COLOR: '1',
+    };
+    if (codexHome)
+        env.CODEX_HOME = codexHome;
+    return env;
+}
+function runFundingPreflight(configPath, home, apiToken, evidenceDir, codexHome) {
+    const result = spawnSync(process.execPath, [jinnBinPath, 'fund-requirements', '--json', '--config', configPath], {
+        cwd: clientRoot,
+        env: buildConsumerChildEnv(home, apiToken, codexHome),
+        encoding: 'utf8',
+        stdio: 'pipe',
+    });
+    writeFileSync(join(evidenceDir, 'consumer-fund-requirements.stdout'), result.stdout ?? '', 'utf8');
+    writeFileSync(join(evidenceDir, 'consumer-fund-requirements.stderr'), result.stderr ?? '', 'utf8');
+    if ((result.status ?? 1) !== 0) {
+        fail('consumer_funding_preflight_failed', 'Consumer funding preflight failed.', {
+            status: result.status,
+            configPath,
+            remedy: `Run: HOME=${home} node ${jinnBinPath} fund-requirements --json --config ${configPath}`,
+        });
+    }
+    const lines = (result.stdout ?? '').split('\n').map((line) => line.trim()).filter(Boolean);
+    const jsonLine = lines.reverse().find((line) => line.startsWith('{'));
+    if (!jsonLine)
+        return;
+    const payload = JSON.parse(jsonLine);
+    if (payload.satisfied === false) {
+        fail('consumer_funding_required', 'Consumer operator is not funded enough for the live donation gate.', {
+            fundRequirements: payload,
+            remedy: `Fund the listed addresses, then run: HOME=${home} node ${jinnBinPath} bootstrap --json --config ${configPath}`,
+        });
+    }
+}
+function startConsumerDaemon(opts) {
+    const child = spawn(process.execPath, [
+        jinnBinPath,
+        'run',
+        '--no-ui',
+        '--funding-timeout',
+        '1ms',
+        '--json',
+        '--config',
+        opts.configPath,
+    ], {
+        cwd: clientRoot,
+        env: buildConsumerChildEnv(opts.home, opts.apiToken, opts.codexHome),
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    child.stdout.on('data', (chunk) => {
+        writeFileSync(join(opts.evidenceDir, 'consumer-daemon.stdout'), String(chunk), { flag: 'a' });
+    });
+    child.stderr.on('data', (chunk) => {
+        writeFileSync(join(opts.evidenceDir, 'consumer-daemon.stderr'), String(chunk), { flag: 'a' });
+    });
+    return child;
+}
+function childHasExited(child) {
+    return child.exitCode !== null || child.signalCode !== null;
+}
+function waitForChildExit(child, timeoutMs) {
+    if (childHasExited(child))
+        return Promise.resolve(true);
+    return new Promise((resolvePromise) => {
+        const timer = setTimeout(() => {
+            cleanup();
+            resolvePromise(childHasExited(child));
+        }, timeoutMs);
+        const done = () => {
+            cleanup();
+            resolvePromise(true);
+        };
+        const cleanup = () => {
+            clearTimeout(timer);
+            child.off('exit', done);
+            child.off('error', done);
+        };
+        child.once('exit', done);
+        child.once('error', done);
+    });
+}
+async function stopManagedConsumerDaemon(opts) {
+    const stopResult = spawnSync(process.execPath, [jinnBinPath, 'stop', '--json', '--config', opts.configPath], {
+        cwd: clientRoot,
+        env: buildConsumerChildEnv(opts.home, opts.apiToken, opts.codexHome),
+        encoding: 'utf8',
+        stdio: 'pipe',
+    });
+    writeFileSync(join(opts.evidenceDir, 'consumer-daemon-stop.stdout'), stopResult.stdout ?? '', { flag: 'a' });
+    writeFileSync(join(opts.evidenceDir, 'consumer-daemon-stop.stderr'), stopResult.stderr ?? '', { flag: 'a' });
+    if (!childHasExited(opts.child)) {
+        opts.child.kill('SIGTERM');
+        await waitForChildExit(opts.child, 5_000);
+    }
+    if (!childHasExited(opts.child)) {
+        opts.child.kill('SIGKILL');
+        await waitForChildExit(opts.child, 5_000);
+    }
+    opts.child.stdout?.destroy();
+    opts.child.stderr?.destroy();
+    if (!childHasExited(opts.child)) {
+        fail('consumer_daemon_cleanup_failed', 'Managed consumer daemon did not exit after the live gate completed.', {
+            pid: opts.child.pid,
+            stopStatus: stopResult.status,
+            stdoutPath: join(opts.evidenceDir, 'consumer-daemon-stop.stdout'),
+            stderrPath: join(opts.evidenceDir, 'consumer-daemon-stop.stderr'),
+        });
+    }
+}
+async function waitForStatus(opts) {
+    while (Date.now() < opts.deadline) {
+        const child = opts.consumerProcess;
+        if (child && (child.exitCode !== null || child.signalCode !== null)) {
+            fail('consumer_daemon_exited', 'Consumer daemon exited before it became reachable.', {
+                exitCode: child.exitCode,
+                signalCode: child.signalCode,
+                stdoutPath: opts.evidenceDir ? join(opts.evidenceDir, 'consumer-daemon.stdout') : undefined,
+                stderrPath: opts.evidenceDir ? join(opts.evidenceDir, 'consumer-daemon.stderr') : undefined,
+            });
+        }
+        try {
+            const response = await fetch(new URL('/v1/status', opts.baseUrl));
+            if (response.ok)
+                return;
+        }
+        catch {
+            // not up yet
+        }
+        await boundedPollSleep(opts.deadline, opts.pollMs);
+    }
+    fail('consumer_daemon_unreachable', 'Consumer daemon did not become reachable before timeout.', { consumerUrl: opts.baseUrl });
+}
+async function callMcpTool(opts) {
+    const client = new Client({ name: 'donation-consumption-acceptance', version: '1.0.0' });
+    const transport = new StdioClientTransport({
+        command: process.execPath,
+        args: [mcpServerPath],
+        cwd: clientRoot,
+        env: {
+            ...process.env,
+            STORE_PATH: opts.storePath,
+            DAEMON_API_URL: opts.daemonApiUrl,
+            DAEMON_API_TOKEN: opts.daemonApiToken,
+            JINN_CORPUS_SUBGRAPH_URL: opts.subgraphUrl ?? '',
+            JINN_CORPUS_IPFS_GATEWAY_URL: opts.ipfsGatewayUrl,
+            JINN_CORPUS_RPC_URL: opts.rpcUrl ?? '',
+            JINN_CORPUS_CHAIN_ID: String(opts.chainId),
+            JINN_CORPUS_IDENTITY_REGISTRY_ADDRESS: opts.identityRegistryAddress ?? '',
+            JINN_CORPUS_FROM_BLOCK: opts.fromBlock != null ? String(opts.fromBlock) : '',
+            DESIRED_STATE_ID: 'donation-consumption-acceptance',
+            DESIRED_STATE_DESCRIPTION: 'Verify cross-operator donated SWE execution data consumption.',
+            DESIRED_STATE_ROLE: 'restoration',
+            DESIRED_STATE_SOLVER_TYPE: 'swe-rebench-v2.v1',
+            REQUEST_ID: 'donation-consumption-acceptance',
+        },
+    });
+    try {
+        await client.connect(transport);
+        const result = await client.callTool({ name: opts.name, arguments: opts.args });
+        const content = result.content;
+        const text = content
+            .filter((entry) => entry.type === 'text' && entry.text)
+            .map((entry) => entry.text)
+            .join('\n');
+        try {
+            return JSON.parse(text);
+        }
+        catch (err) {
+            fail('consumer_mcp_non_json_response', `MCP tool ${opts.name} returned non-JSON text.`, {
+                tool: opts.name,
+                text,
+                parseError: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    finally {
+        await client.close();
+    }
+}
+function hasDonatedIpfsSourceArgs(artifact) {
+    const acquisition = artifact.acquisition;
+    const args = acquisition?.arguments;
+    const sources = Array.isArray(args?.sources) ? args.sources : [];
+    return sources.some((source) => source.kind === 'ipfs' && source.encoding === 'jinn.artifact.donation.v1');
+}
+export function findDonatedArtifactRecord(searchResult, proof) {
+    const records = Array.isArray(searchResult.records) ? searchResult.records : [];
+    const matches = [];
+    for (const record of records) {
+        const envelopeRef = record.envelopeRef;
+        if (envelopeRef?.cid !== proof.artifact.envelopeCid)
+            continue;
+        const artifactRefs = Array.isArray(record.artifactRefs) ? record.artifactRefs : [];
+        const artifact = artifactRefs.find((candidate) => candidate.sha256 === proof.artifact.sha256);
+        if (artifact)
+            matches.push(artifact);
+    }
+    const networkAcquisition = matches.find(hasDonatedIpfsSourceArgs);
+    if (networkAcquisition)
+        return networkAcquisition;
+    if (matches[0])
+        return matches[0];
+    fail('consumer_discovery_missing', 'Consumer MCP search_records did not discover the producer donated artifact.', {
+        envelopeCid: proof.artifact.envelopeCid,
+        sha256: proof.artifact.sha256,
+        recordsSeen: records.length,
+    });
+}
+function acquisitionArgsFromArtifact(artifact) {
+    const acquisition = artifact.acquisition;
+    const args = acquisition?.arguments;
+    if (!args) {
+        fail('consumer_acquisition_args_missing', 'Discovered artifact does not include acquire_artifact arguments.', {
+            artifact,
+        });
+    }
+    if (!hasDonatedIpfsSourceArgs(artifact)) {
+        fail('consumer_acquisition_sources_missing', 'Discovered artifact acquisition args do not include donated IPFS sources.', {
+            args,
+        });
+    }
+    return args;
+}
+function proofParticipantSafe(proof) {
+    const participant = proof.envelope.participant;
+    if (participant && typeof participant === 'object' && !Array.isArray(participant)) {
+        const safe = participant.safeAddress;
+        if (typeof safe === 'string' && safe)
+            return safe;
+    }
+    return '';
+}
+function producerTaskCreationTx(proof) {
+    const task = proof.envelope.task;
+    if (!task || typeof task !== 'object' || Array.isArray(task))
+        return undefined;
+    return asString(task.onchainCreationTx);
+}
+function producerTaskCidDigest(proof) {
+    const task = proof.envelope.task;
+    if (!task || typeof task !== 'object' || Array.isArray(task))
+        return undefined;
+    const cid = asString(task.cid);
+    if (!cid)
+        return undefined;
+    if (/^0x[0-9a-fA-F]{64}$/.test(cid))
+        return cid;
+    const rawMultihashPrefix = 'f01551220';
+    if (cid.startsWith(rawMultihashPrefix) && cid.length === rawMultihashPrefix.length + 64) {
+        return `0x${cid.slice(rawMultihashPrefix.length)}`;
+    }
+    return undefined;
+}
+export async function scopeConsumerConfigToProducerTask(opts) {
+    const taskCidDigest = producerTaskCidDigest(opts.proof);
+    if (!taskCidDigest) {
+        fail('producer_task_scope_missing_cid_digest', 'Producer envelope is missing a task CID digest, so the gate cannot scope consumer task discovery.', {
+            envelopeCid: opts.proof.artifact.envelopeCid,
+        });
+    }
+    const createdAtTx = producerTaskCreationTx(opts.proof);
+    const taskId = await querySubgraphTaskIdByTaskCidDigest(opts.subgraphUrl, taskCidDigest);
+    if (!taskId) {
+        fail('producer_task_scope_unresolved', 'Could not resolve the producer on-chain task id from the configured subgraph.', {
+            envelopeCid: opts.proof.artifact.envelopeCid,
+            taskCidDigest,
+            createdAtTx,
+            subgraphUrl: opts.subgraphUrl,
+        });
+    }
+    opts.consumerConfig.taskDiscoveryAllowedTaskIds = [taskId];
+    writeJson(opts.consumerConfigPath, opts.consumerConfig);
+    if (opts.evidenceDir) {
+        writeJson(join(opts.evidenceDir, 'consumer-task-scope.json'), {
+            allowedTaskIds: [taskId],
+            producerEnvelopeCid: opts.proof.artifact.envelopeCid,
+            producerTaskCidDigest: taskCidDigest,
+            producerTaskCreatedAtTx: createdAtTx ?? null,
+            consumerConfigPath: opts.consumerConfigPath,
+        });
+    }
+    return taskId;
+}
+function parseMaybeJson(bytes) {
+    try {
+        const parsed = JSON.parse(bytes.toString('utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function waitForConsumerSolveAndEvaluatorProof(opts) {
+    while (Date.now() < opts.deadline) {
+        const store = new Store(opts.storePath);
+        try {
+            const networkRow = store.getNetworkArtifact(opts.proof.artifact.sha256);
+            const runMatches = (requestId, expectedRole) => {
+                if (!requestId)
+                    return false;
+                const row = store.db.prepare(`
+          SELECT
+            task_id AS taskId,
+            task_role AS taskRole,
+            state,
+            manifest_cid AS manifestCid,
+            delivery_tx_hash AS deliveryTxHash
+          FROM task_runs
+          WHERE request_id = ?
+        `).get(requestId);
+                if (!row)
+                    return false;
+                if (!opts.reuseExisting && opts.allowedTaskId && row.taskId !== opts.allowedTaskId)
+                    return false;
+                return (row.taskRole === expectedRole &&
+                    row.state === 'COMPLETE' &&
+                    typeof row.manifestCid === 'string' &&
+                    row.manifestCid.length > 0 &&
+                    typeof row.deliveryTxHash === 'string' &&
+                    row.deliveryTxHash.length > 0);
+            };
+            const solutionRow = store.listServedArtifactMetadata({
+                artifactType: SWE_SOLUTION_ARTIFACT_TYPE,
+                limit: 50,
+            }).find((row) => ((opts.reuseExisting || Date.parse(row.createdAt) >= opts.acquisitionFinishedAt.getTime()) &&
+                runMatches(row.requestId, 'restoration')));
+            const verdictRow = store.listServedArtifactMetadata({ limit: 100 }).find((row) => {
+                if (!VERDICT_ARTIFACT_TYPES.has(row.artifactType))
+                    return false;
+                return ((opts.reuseExisting || Date.parse(row.createdAt) >= opts.acquisitionFinishedAt.getTime()) &&
+                    runMatches(row.requestId, 'evaluation'));
+            });
+            if (networkRow &&
+                networkRow.envelopeCid === opts.proof.artifact.envelopeCid &&
+                networkRow.sourceEndpoint === `ipfs://${opts.proof.sourceCid}` &&
+                networkRow.sourceOperator === proofParticipantSafe(opts.proof) &&
+                networkRow.paidAmountUsdc === '0' &&
+                (opts.reuseExisting || Date.parse(networkRow.fetchedAt) >= opts.startedAt.getTime()) &&
+                (opts.reuseExisting || Date.parse(networkRow.lastUsedAt) >= opts.acquisitionStartedAt.getTime()) &&
+                solutionRow &&
+                verdictRow) {
+                return {
+                    networkRow: {
+                        sha256: networkRow.sha256,
+                        artifactType: networkRow.artifactType,
+                        envelopeCid: networkRow.envelopeCid,
+                        source: networkRow.source,
+                        sourceOperator: networkRow.sourceOperator,
+                        sourceEndpoint: networkRow.sourceEndpoint,
+                        paidAmountUsdc: networkRow.paidAmountUsdc,
+                        fetchedAt: networkRow.fetchedAt,
+                        lastUsedAt: networkRow.lastUsedAt,
+                    },
+                    solution: {
+                        sha256: solutionRow.sha256,
+                        artifactType: solutionRow.artifactType,
+                        envelopeCid: solutionRow.envelopeCid,
+                        createdAt: solutionRow.createdAt,
+                    },
+                    verdict: {
+                        sha256: verdictRow.sha256,
+                        artifactType: verdictRow.artifactType,
+                        envelopeCid: verdictRow.envelopeCid,
+                        createdAt: verdictRow.createdAt,
+                    },
+                };
+            }
+        }
+        finally {
+            store.close();
+        }
+        await boundedPollSleep(opts.deadline, opts.pollMs);
+    }
+    fail('consumer_solve_evaluate_timeout', 'Consumer did not produce IPFS network cache, SWE solution, and SWE evaluator verdict before timeout.', {
+        sha256: opts.proof.artifact.sha256,
+        envelopeCid: opts.proof.artifact.envelopeCid,
+        sourceCid: opts.proof.sourceCid,
+        allowedTaskId: opts.allowedTaskId,
+        acquisitionStartedAt: opts.acquisitionStartedAt.toISOString(),
+        acquisitionFinishedAt: opts.acquisitionFinishedAt.toISOString(),
+        requiredArtifacts: [SWE_SOLUTION_ARTIFACT_TYPE, ...VERDICT_ARTIFACT_TYPES],
+    });
+}
+function printHelp() {
+    console.log(`Usage: yarn release:donation-consumption [options]
+
+Strict release gate for cross-operator donated SWE execution data consumption.
+
+Options:
+  --producer-config <path>   Producer config (default: ~/.jinn-client/config.json)
+  --consumer-config <path>   Consumer config (default: <consumer-home>/.jinn-client/config.json)
+  --producer-url <url>       Producer daemon URL (default from producer apiPort)
+  --producer-ui-token <tok>  Producer UI token for /v1/operator/artifacts
+  --producer-handshake-key <k>
+                             Exchange daemon handshake key for producer UI auth
+  --consumer-url <url>       Attach to an existing consumer daemon instead of starting one
+  --consumer-home <path>     Isolated consumer HOME (default: client/.acceptance/donation-consumer)
+  --consumer-codex-home <p>  Codex auth/config home for the consumer harness
+                             (default: CODEX_HOME or ~/.codex when auth.json exists)
+  --consumer-port <port>     Consumer daemon port when started by this script (default: 7333)
+  --timeout-ms <ms>          Gate timeout (default: 1800000)
+  --poll-ms <ms>             Poll interval (default: 10000)
+  --evidence-dir <path>      Evidence output directory
+  --reuse-existing           Diagnostics only: allow pre-existing artifacts
+  --help                     Show this help
+
+Release mode requires fresh producer, consumer cache, solution, and evaluator
+evidence created after this command starts. --reuse-existing is not valid
+release evidence. The consumer must be joined to SWE-rebench v2 as solver and
+evaluator with the SWE runtime enabled; the default isolated consumer config
+inherits that SolverNet selection from the producer config while keeping a
+separate HOME, DB, Safe, and agent identity. The Codex harness still requires
+a real Codex/OpenAI credential via OPENAI_API_KEY or a usable CODEX_HOME.
+`);
+}
+async function main() {
+    const parsed = parseArgs({
+        options: {
+            help: { type: 'boolean', default: false },
+            'producer-config': { type: 'string' },
+            'consumer-config': { type: 'string' },
+            'producer-url': { type: 'string' },
+            'producer-ui-token': { type: 'string' },
+            'producer-handshake-key': { type: 'string' },
+            'consumer-url': { type: 'string' },
+            'consumer-home': { type: 'string' },
+            'consumer-codex-home': { type: 'string' },
+            'consumer-port': { type: 'string' },
+            'timeout-ms': { type: 'string' },
+            'poll-ms': { type: 'string' },
+            'evidence-dir': { type: 'string' },
+            'reuse-existing': { type: 'boolean', default: false },
+        },
+        allowPositionals: false,
+    });
+    if (parsed.values.help) {
+        printHelp();
+        return;
+    }
+    if (!existsSync(jinnBinPath) || !existsSync(mcpServerPath)) {
+        fail('release_gate_not_built', 'Donation consumption gate must run from a built client package.', {
+            missing: [
+                ...(!existsSync(jinnBinPath) ? [jinnBinPath] : []),
+                ...(!existsSync(mcpServerPath) ? [mcpServerPath] : []),
+            ],
+            remedy: 'Run `yarn build` before `yarn release:donation-consumption`, or run this command from the published package.',
+        });
+    }
+    const startedAt = new Date();
+    const timeoutMs = asInt(parsed.values['timeout-ms'], 30 * 60 * 1000);
+    const pollMs = asInt(parsed.values['poll-ms'], 10_000);
+    const deadline = Date.now() + timeoutMs;
+    const reuseExisting = Boolean(parsed.values['reuse-existing']);
+    const evidenceDir = resolve(parsed.values['evidence-dir']
+        ?? join(clientRoot, 'acceptance-runs', `${nowSlug(startedAt)}-donation-consumption`));
+    mkdirSync(evidenceDir, { recursive: true });
+    const producerConfigPath = resolveConfigPath(parsed.values['producer-config']);
+    const producerConfig = loadLocalConfig(producerConfigPath);
+    const producerHome = dirname(dirname(producerConfigPath));
+    const producerPort = configApiPort(producerConfig, 7331);
+    const producerUrl = parsed.values['producer-url'] ?? `http://127.0.0.1:${producerPort}`;
+    const producerUiToken = asString(parsed.values['producer-ui-token'])
+        ?? process.env['JINN_DONATION_PRODUCER_UI_TOKEN']?.trim();
+    const producerHandshakeKey = asString(parsed.values['producer-handshake-key'])
+        ?? process.env['JINN_DONATION_PRODUCER_HANDSHAKE_KEY']?.trim();
+    const producerAuth = await resolveProducerAuth({
+        producerUrl,
+        producerUiToken,
+        producerHandshakeKey,
+    });
+    const subgraphUrl = asString(producerConfig.subgraphUrl) ?? DEFAULT_TESTNET_SUBGRAPH_URL;
+    const ipfsGatewayUrl = asString(producerConfig.ipfsGatewayUrl) ?? DEFAULT_IPFS_GATEWAY_URL;
+    const chainId = producerConfig.network === 'mainnet' ? 8453 : 84532;
+    const producerRpcUrl = asString(producerConfig.rpcUrl) ?? defaultRpcUrlForChain(chainId);
+    const corpusFromBlock = Number(DEFAULT_EXECUTION_DISCOVERY_FROM_BLOCK[chainId] ?? 0n);
+    const identityRegistryAddress = DEFAULT_IDENTITY_REGISTRY_BY_CHAIN_ID[chainId];
+    const consumerHome = resolve(parsed.values['consumer-home'] ?? join(clientRoot, '.acceptance', 'donation-consumer'));
+    const consumerCodexHome = resolveConsumerCodexHome(parsed.values['consumer-codex-home']);
+    assertConsumerCodexAuthAvailable(consumerCodexHome);
+    const consumerPort = asInt(parsed.values['consumer-port'], 7333);
+    const consumerConfigPath = resolve(parsed.values['consumer-config'] ?? join(defaultClientHome(consumerHome), 'config.json'));
+    const attachConsumerUrl = parsed.values['consumer-url'];
+    const envToken = process.env['JINN_DONATION_CONSUMER_DAEMON_API_TOKEN']?.trim() || process.env['DAEMON_API_TOKEN']?.trim();
+    if (attachConsumerUrl && !envToken) {
+        fail('consumer_token_required', 'Attached consumer daemon requires JINN_DONATION_CONSUMER_DAEMON_API_TOKEN or DAEMON_API_TOKEN.', {
+            consumerUrl: attachConsumerUrl,
+        });
+    }
+    const consumerApiToken = envToken || `donation-${randomBytes(24).toString('hex')}`;
+    const consumerUrl = attachConsumerUrl ?? `http://127.0.0.1:${consumerPort}`;
+    if (!parsed.values['consumer-config']) {
+        const consumerConfig = buildConsumerConfig({
+            producerConfig,
+            consumerHome,
+            consumerPort,
+            subgraphUrl,
+            ipfsGatewayUrl,
+        });
+        writeJson(consumerConfigPath, consumerConfig);
+    }
+    let consumerConfig = loadLocalConfig(consumerConfigPath);
+    const consumerDbPath = configDbPath(consumerConfig, consumerHome);
+    const consumerEarningDir = configEarningDir(consumerConfig, consumerHome);
+    const archivedConsumerDb = (!attachConsumerUrl && !parsed.values['consumer-config'] && !reuseExisting)
+        ? archiveManagedConsumerDb(consumerDbPath, evidenceDir)
+        : [];
+    assertConsumerConfiguredForSwe(consumerConfig, consumerConfigPath);
+    const consumerEvaluatorStatePath = ensureConsumerSweEvaluatorState({
+        producerConfig,
+        producerHome,
+        consumerConfig,
+        consumerHome,
+        evidenceDir,
+    });
+    writeJson(join(evidenceDir, 'inputs.json'), {
+        startedAt: startedAt.toISOString(),
+        timeoutMs,
+        pollMs,
+        reuseExisting,
+        releaseEvidence: !reuseExisting,
+        producerConfigPath,
+        producerHome,
+        producerUrl,
+        producerAuth: producerAuth.headers ? '<configured>' : '<none>',
+        consumerConfigPath,
+        consumerUrl,
+        consumerHome,
+        consumerCodexHome: consumerCodexHome ?? '<OPENAI_API_KEY>',
+        consumerDbPath,
+        archivedConsumerDb,
+        consumerEarningDir,
+        consumerEvaluatorStatePath,
+        subgraphUrl,
+        ipfsGatewayUrl,
+    });
+    console.log(`[donation-consumption] evidence: ${evidenceDir}`);
+    console.log('[donation-consumption] waiting for producer donated SWE artifact');
+    const producerArtifact = await waitForProducerArtifact({
+        producerUrl,
+        startedAt,
+        deadline,
+        reuseExisting,
+        pollMs,
+        producerAuth,
+    });
+    console.log('[donation-consumption] verifying producer IPFS envelope and canonical index visibility');
+    const donationProof = await verifyDonatedEnvelope(producerArtifact, ipfsGatewayUrl, { subgraphUrl, rpcUrl: producerRpcUrl, chainId }, deadline, pollMs);
+    writeJson(join(evidenceDir, 'producer-proof.json'), {
+        artifact: donationProof.artifact,
+        sourceCid: donationProof.sourceCid,
+        trajectorySourceCid: donationProof.trajectorySourceCid,
+        indexExecution: donationProof.indexExecution,
+    });
+    writeJson(join(evidenceDir, 'producer-envelope-redacted.json'), donationProof.redactedEnvelope);
+    const allowedConsumerTaskId = await scopeConsumerConfigToProducerTask({
+        consumerConfig,
+        consumerConfigPath,
+        proof: donationProof,
+        subgraphUrl,
+        evidenceDir,
+    });
+    consumerConfig = loadLocalConfig(consumerConfigPath);
+    console.log(`[donation-consumption] scoped consumer task discovery to producer task ${allowedConsumerTaskId}`);
+    let consumerProcess = null;
+    if (!attachConsumerUrl) {
+        console.log('[donation-consumption] running consumer funding preflight');
+        runFundingPreflight(consumerConfigPath, consumerHome, consumerApiToken, evidenceDir, consumerCodexHome);
+        console.log('[donation-consumption] starting isolated consumer daemon');
+        consumerProcess = startConsumerDaemon({
+            configPath: consumerConfigPath,
+            home: consumerHome,
+            apiToken: consumerApiToken,
+            evidenceDir,
+            codexHome: consumerCodexHome,
+        });
+    }
+    try {
+        await waitForStatus({
+            baseUrl: consumerUrl,
+            deadline,
+            pollMs,
+            consumerProcess,
+            evidenceDir,
+        });
+        console.log('[donation-consumption] checking consumer MCP discovery');
+        const searchResult = await callMcpTool({
+            name: 'search_records',
+            args: {
+                solverType: 'swe-rebench-v2.v1',
+                role: 'restoration',
+                artifactType: SWE_SOLUTION_ARTIFACT_TYPE,
+                limit: 50,
+            },
+            storePath: consumerDbPath,
+            daemonApiUrl: consumerUrl,
+            daemonApiToken: consumerApiToken,
+            subgraphUrl,
+            ipfsGatewayUrl,
+            rpcUrl: asString(consumerConfig.rpcUrl) ?? producerRpcUrl,
+            chainId,
+            identityRegistryAddress,
+            fromBlock: corpusFromBlock,
+        });
+        writeJson(join(evidenceDir, 'consumer-search-records.json'), searchResult);
+        const discoveredArtifact = findDonatedArtifactRecord(searchResult, donationProof);
+        const acquisitionArgs = acquisitionArgsFromArtifact(discoveredArtifact);
+        writeJson(join(evidenceDir, 'consumer-discovered-artifact.json'), discoveredArtifact);
+        console.log('[donation-consumption] acquiring donated artifact through consumer MCP');
+        const acquisitionStartedAt = new Date();
+        const acquireResult = await callMcpTool({
+            name: 'acquire_artifact',
+            args: acquisitionArgs,
+            storePath: consumerDbPath,
+            daemonApiUrl: consumerUrl,
+            daemonApiToken: consumerApiToken,
+            subgraphUrl,
+            ipfsGatewayUrl,
+            rpcUrl: asString(consumerConfig.rpcUrl) ?? producerRpcUrl,
+            chainId,
+            identityRegistryAddress,
+            fromBlock: corpusFromBlock,
+        });
+        const acquisitionFinishedAt = new Date();
+        writeJson(join(evidenceDir, 'consumer-acquire-artifact.json'), {
+            ...acquireResult,
+            bytes: '<redacted>',
+            acquisitionStartedAt: acquisitionStartedAt.toISOString(),
+            acquisitionFinishedAt: acquisitionFinishedAt.toISOString(),
+        });
+        if (acquireResult.error) {
+            fail('consumer_acquire_failed', 'Consumer MCP acquire_artifact failed.', acquireResult);
+        }
+        if (acquireResult.sha256 !== donationProof.artifact.sha256) {
+            fail('consumer_acquire_wrong_artifact', 'Consumer MCP acquire_artifact returned the wrong sha256.', {
+                expected: donationProof.artifact.sha256,
+                actual: acquireResult.sha256,
+            });
+        }
+        if (!reuseExisting && acquireResult.source !== 'ipfs') {
+            fail('consumer_acquire_not_ipfs', 'Release-mode acquire_artifact did not fetch from the donated IPFS source.', {
+                expected: 'ipfs',
+                actual: acquireResult.source,
+            });
+        }
+        if (acquireResult.paidAmountUsdc !== '0') {
+            fail('consumer_acquire_not_free', 'Donated IPFS acquisition must be free for this release gate.', {
+                paidAmountUsdc: acquireResult.paidAmountUsdc,
+            });
+        }
+        console.log('[donation-consumption] waiting for consumer solve/evaluator evidence after acquisition');
+        const liveProof = await waitForConsumerSolveAndEvaluatorProof({
+            storePath: consumerDbPath,
+            proof: donationProof,
+            allowedTaskId: allowedConsumerTaskId,
+            startedAt,
+            acquisitionStartedAt,
+            acquisitionFinishedAt,
+            reuseExisting,
+            deadline,
+            pollMs,
+        });
+        writeJson(join(evidenceDir, 'consumer-network-artifact.json'), liveProof.networkRow);
+        writeJson(join(evidenceDir, 'consumer-solution-artifact.json'), liveProof.solution);
+        writeJson(join(evidenceDir, 'consumer-evaluator-verdict.json'), liveProof.verdict);
+        const summary = {
+            ok: true,
+            releaseEvidence: !reuseExisting,
+            evidenceDir,
+            producerArtifact: donationProof.artifact,
+            sourceCid: donationProof.sourceCid,
+            trajectorySourceCid: donationProof.trajectorySourceCid,
+            allowedConsumerTaskId,
+            acquisitionStartedAt: acquisitionStartedAt.toISOString(),
+            acquisitionFinishedAt: acquisitionFinishedAt.toISOString(),
+            consumerNetworkArtifact: liveProof.networkRow,
+            consumerSolution: liveProof.solution,
+            consumerVerdict: liveProof.verdict,
+        };
+        writeJson(join(evidenceDir, 'summary.json'), summary);
+        console.log(JSON.stringify(summary, null, 2));
+    }
+    finally {
+        if (consumerProcess) {
+            await stopManagedConsumerDaemon({
+                child: consumerProcess,
+                configPath: consumerConfigPath,
+                home: consumerHome,
+                apiToken: consumerApiToken,
+                evidenceDir,
+                codexHome: consumerCodexHome,
+            });
+        }
+    }
+}
+function isMainModule() {
+    const entrypoint = process.argv[1];
+    if (!entrypoint)
+        return false;
+    const current = fileURLToPath(import.meta.url);
+    try {
+        return realpathSync(entrypoint) === realpathSync(current);
+    }
+    catch {
+        return resolve(entrypoint) === current;
+    }
+}
+if (isMainModule()) {
+    main().catch((err) => {
+        if (err instanceof GateFailure) {
+            console.error(`[donation-consumption] FAILED ${err.code}: ${err.message}`);
+            console.error(JSON.stringify(err.details, null, 2));
+            process.exit(1);
+        }
+        console.error('[donation-consumption] FAILED unexpected error');
+        console.error(err);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=donation-consumption-acceptance.js.map