@jinn-network/client 0.1.9-canary.5c19fc6d → 0.1.9-canary.5ff3d8cb

package/dist/monitoring/net-liveness.js

@@ -0,0 +1,301 @@
+/**
+ * Net-liveness probe — operator-independent detector for the #1038 silent-stall
+ * class.
+ *
+ * Context: when the shared indexer blips, every operator daemon's discovery
+ * loops can wedge while the indexer-independent loops (jinn-claim, balance-topup)
+ * keep emitting on-chain activity and mask the outage. No single operator can
+ * be trusted to notice, so liveness must be observed from *outside* any daemon.
+ *
+ * This module reads on-chain truth two ways and cross-references them:
+ *   - chain head    — direct RPC `getBlockNumber()` (always live)
+ *   - latest indexed attempt/verdict block — indexer GraphQL
+ *   - indexer head  — indexer `/status` (the indexer's own indexed head)
+ *
+ * The core decision is a pure function (`classifyNetLiveness`). The orchestrator
+ * (`runNetLivenessProbe`) injects all I/O so the whole flow is testable with no
+ * network. Designed to run from a stateless cron entry script
+ * (`scripts/net-liveness-probe.ts`), NOT in-daemon.
+ */
+// ── Pure classifier ─────────────────────────────────────────────────────────
+/**
+ * Base produces ~one block every 2s → 30 blocks per minute. The probe works in
+ * block-space (the schema carries `createdAtBlock`, no timestamp column), so the
+ * minute threshold is converted to blocks with this constant.
+ */
+export const BASE_BLOCKS_PER_MINUTE = 30;
+/** Convert a minute threshold to a Base block-count. */
+export function minutesToThresholdBlocks(minutes) {
+    return minutes * BASE_BLOCKS_PER_MINUTE;
+}
+/**
+ * Decide net-liveness from the four cross-referenced reads. PURE — no I/O.
+ *
+ * Decision order matters: only the `stale` state alerts. Each preceding state is
+ * a confound that would otherwise look like a stall but isn't a *net* stall (a
+ * down/lagging indexer or a halted chain is reported, not alerted).
+ */
+export function classifyNetLiveness(inputs) {
+    const { chainHeadBlock, prevChainHeadBlock, latestActivityBlock, indexerHeadBlock, thresholdBlocks } = inputs;
+    const threshold = BigInt(thresholdBlocks);
+    const rawChainStaleForBlocks = chainHeadBlock - (latestActivityBlock ?? 0n);
+    const chainStaleForBlocks = rawChainStaleForBlocks < 0n ? 0n : rawChainStaleForBlocks;
+    // 1. Indexer unreachable — we have no indexed-activity truth to compare.
+    if (indexerHeadBlock === null) {
+        return {
+            state: 'indexer-down',
+            staleForBlocks: chainStaleForBlocks,
+            reason: 'indexer /status unreachable; cannot cross-reference indexed activity',
+        };
+    }
+    // 2. Indexer reachable but far behind chain head — its activity reads are
+    //    stale-by-construction, so absence of recent activity proves nothing.
+    const indexerLagForBlocks = chainHeadBlock - indexerHeadBlock;
+    if (indexerLagForBlocks > threshold) {
+        return {
+            state: 'indexer-lagging',
+            staleForBlocks: chainStaleForBlocks,
+            reason: `indexer head ${indexerHeadBlock} is ${indexerLagForBlocks} blocks behind chain head ${chainHeadBlock}`,
+        };
+    }
+    // 3. Chain head did not advance between the two reads — a halted chain has no
+    //    new blocks to carry activity, so this is not a net stall.
+    if (prevChainHeadBlock !== null && chainHeadBlock <= prevChainHeadBlock) {
+        return {
+            state: 'chain-halted',
+            staleForBlocks: chainStaleForBlocks,
+            reason: `chain head did not advance (${prevChainHeadBlock} → ${chainHeadBlock})`,
+        };
+    }
+    const rawIndexedStaleForBlocks = indexerHeadBlock - (latestActivityBlock ?? 0n);
+    const staleForBlocks = rawIndexedStaleForBlocks < 0n ? 0n : rawIndexedStaleForBlocks;
+    // 4. Chain advancing + indexer usable, but no recent indexed activity
+    //    relative to the indexed head → the #1038 silent-stall signature. ALERT.
+    if (latestActivityBlock === null || staleForBlocks > threshold) {
+        return {
+            state: 'stale',
+            staleForBlocks,
+            reason: latestActivityBlock === null
+                ? 'no indexed attempt/verdict found at all'
+                : `last indexed activity at block ${latestActivityBlock} is ${staleForBlocks} blocks behind indexer head ${indexerHeadBlock}`,
+        };
+    }
+    // 5. Recent activity within threshold.
+    return {
+        state: 'healthy',
+        staleForBlocks,
+        reason: `last indexed activity ${staleForBlocks} blocks behind indexer head (under ${thresholdBlocks})`,
+    };
+}
+/** Default delay between the two chain-head samples (ms). See headSampleDelayMs. */
+export const DEFAULT_HEAD_SAMPLE_DELAY_MS = 4_000;
+export function parseNetLivenessIntegerEnv(raw, spec) {
+    if (raw === undefined)
+        return spec.defaultValue;
+    const trimmed = raw.trim();
+    const fail = () => {
+        throw new Error(`${spec.name} must be an integer between ${spec.min} and ${spec.max}`);
+    };
+    if (!/^[0-9]+$/.test(trimmed))
+        fail();
+    const value = Number(trimmed);
+    if (!Number.isSafeInteger(value) || value < spec.min || value > spec.max)
+        fail();
+    return value;
+}
+/**
+ * Run one probe: read chain head twice (to detect advancement within the run),
+ * read the indexer head and latest activity (tolerating throws as
+ * indexer-down), classify, and POST an alert only when the state is `stale` and
+ * a webhook is configured. Never throws on a read failure; returns the
+ * classification for the caller to log. Webhook delivery failures still throw
+ * so cron can flag the alert path itself as broken.
+ */
+export async function runNetLivenessProbe(deps) {
+    // Sample the chain head twice, separated by a real delay, so a healthy chain
+    // has time to mint a new block between reads. Without the gap both reads land
+    // in the same block (and viem caches getBlockNumber for ~4s), making the two
+    // samples identical → the classifier would always read `chain-halted` and the
+    // alert branch would be unreachable.
+    const prevChainHeadBlock = await deps.fetchChainHead();
+    await deps.sleep(deps.headSampleDelayMs ?? DEFAULT_HEAD_SAMPLE_DELAY_MS);
+    const chainHeadBlock = await deps.fetchChainHead();
+    // A throw on either indexer read means the indexer is unhealthy — we cannot
+    // cross-reference indexed activity, so the run reports indexer-down rather than
+    // crashing or mistaking an error for a genuine stall. Distinguish a *throw* (the
+    // reader itself failed) from a clean null (the indexer answered "no rows"): only
+    // the former is indexer-down. A failed activity read therefore forces the
+    // indexer head to be treated as unreadable too, so the classifier short-circuits
+    // to indexer-down (decision-order step 1) before it can read the empty activity
+    // as `stale`.
+    const indexerHead = await safeRead(deps.fetchIndexerHeadBlock);
+    const activity = await safeRead(deps.fetchLatestActivityBlock);
+    const indexerHeadBlock = indexerHead.threw || activity.threw ? null : indexerHead.value;
+    const latestActivityBlock = activity.value;
+    const result = classifyNetLiveness({
+        chainHeadBlock,
+        prevChainHeadBlock,
+        latestActivityBlock,
+        indexerHeadBlock,
+        thresholdBlocks: minutesToThresholdBlocks(deps.thresholdMinutes),
+    });
+    if (result.state === 'stale' && deps.postWebhook) {
+        const staleForMinutes = Math.round(Number(result.staleForBlocks) / BASE_BLOCKS_PER_MINUTE);
+        const runAt = deps.now().toISOString();
+        const payload = {
+            text: `Jinn net-liveness alert: no on-chain attempt/verdict indexed for ` +
+                `~${staleForMinutes} min (${result.staleForBlocks} blocks). ` +
+                `Chain head ${chainHeadBlock} is advancing and indexed activity is stale relative to indexer head ${indexerHeadBlock}, ` +
+                `so this is a network stall, not an indexer outage. ${result.reason}`,
+            state: result.state,
+            staleForBlocks: result.staleForBlocks.toString(),
+            staleForMinutes,
+            chainHeadBlock: chainHeadBlock.toString(),
+            latestActivityBlock: latestActivityBlock === null ? null : latestActivityBlock.toString(),
+            runAt,
+        };
+        await deps.postWebhook(payload);
+    }
+    return result;
+}
+async function safeRead(read) {
+    try {
+        return { value: await read(), threw: false };
+    }
+    catch {
+        return { value: null, threw: true };
+    }
+}
+// ── Indexer readers ──────────────────────────────────────────────────────────
+/**
+ * Per-request timeout for every indexer fetch. Mirrors http.ts: a never-settling
+ * fetch (half-open socket mid-redeploy) is bounded so a hang becomes a bounded
+ * failure, not a wedged probe.
+ */
+const FETCH_TIMEOUT_MS = 15_000;
+/**
+ * Read the indexer's own indexed head via Ponder's host-root `/status` endpoint.
+ * `/status` returns `{ <chainName>: { id, block: { number, timestamp } } }`.
+ * Select the monitored chain by explicit name, falling back to chain ID when
+ * the status key does not match. Returns null on failure or shape mismatch —
+ * the probe classifies null as indexer-down.
+ */
+export async function fetchIndexerHeadBlock(args) {
+    const fetchImpl = args.fetchImpl ?? globalThis.fetch;
+    // `/status` is served at the host root, not under `/graphql` (mirror http.ts).
+    const statusUrl = `${args.baseUrl.replace(/\/graphql\/?$/, '').replace(/\/$/, '')}/status`;
+    try {
+        const res = await fetchImpl(statusUrl, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        const chain = body[args.chainName] ??
+            Object.values(body).find((entry) => Number(entry?.id) === args.chainId);
+        return parseBlockNumber(chain?.block?.number);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Read the newest indexed activity block — the max `createdAtBlock` across the
+ * latest verdict and the latest attempt on the monitored chain (NOT task: a
+ * posted-but-unclaimed task is itself the stall condition). Two `limit:1`
+ * descending GraphQL queries. Returns null only when both legs are clean empty
+ * result sets. Throws on transport,
+ * HTTP, GraphQL, or malformed-response failures so the orchestrator can classify
+ * those as indexer-down instead of a false net-stall page.
+ */
+export async function fetchLatestActivityBlock(args) {
+    const [verdict, attempt] = await Promise.all([
+        latestBlockFor(args, 'verdicts'),
+        latestBlockFor(args, 'attempts'),
+    ]);
+    if (verdict === null && attempt === null)
+        return null;
+    return maxNullable(verdict, attempt);
+}
+async function latestBlockFor(args, field) {
+    const fetchImpl = args.fetchImpl ?? globalThis.fetch;
+    const query = `query LatestActivity($chainId: Int!) {
+  ${field}(where: { chainId: $chainId }, orderBy: "createdAtBlock", orderDirection: "desc", limit: 1) {
+    items { createdAtBlock }
+  }
+}`;
+    try {
+        const res = await fetchImpl(args.gqlUrl, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ query, variables: { chainId: args.chainId } }),
+            signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+        });
+        if (!res.ok)
+            throw new Error();
+        const json = (await res.json());
+        if (json.errors?.length)
+            throw new Error();
+        if (!json.data?.[field] || !Array.isArray(json.data[field].items)) {
+            throw new Error();
+        }
+        const items = json.data[field].items;
+        const raw = items[0]?.createdAtBlock;
+        if (raw === undefined || raw === null)
+            return null;
+        return BigInt(raw);
+    }
+    catch {
+        throw new Error(`GraphQL latest activity read failed for ${field}`);
+    }
+}
+function maxNullable(a, b) {
+    if (a === null)
+        return b;
+    if (b === null)
+        return a;
+    return a > b ? a : b;
+}
+function parseBlockNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return BigInt(Math.trunc(value));
+    if (typeof value === 'string' && /^[0-9]+$/.test(value))
+        return BigInt(value);
+    return null;
+}
+// ── Webhook POST helper ──────────────────────────────────────────────────────
+/**
+ * Build the `postWebhook` seam. Returns null when no URL is configured (NO-OP —
+ * the probe still classifies and logs, it just never alerts). The returned
+ * function POSTs the JSON payload to a generic incoming webhook.
+ */
+export function postNetLivenessWebhook(url, fetchImpl = globalThis.fetch) {
+    if (!url)
+        return null;
+    let webhookUrl;
+    try {
+        webhookUrl = new URL(url);
+    }
+    catch {
+        throw new Error('invalid webhook URL');
+    }
+    if (webhookUrl.protocol !== 'https:' && webhookUrl.protocol !== 'http:') {
+        throw new Error('invalid webhook URL');
+    }
+    return async (payload) => {
+        let response;
+        try {
+            response = await fetchImpl(webhookUrl.toString(), {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify(payload),
+                signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+            });
+        }
+        catch {
+            throw new Error('net-liveness webhook delivery failed: transport error');
+        }
+        if (!response.ok) {
+            throw new Error(`net-liveness webhook delivery failed: HTTP ${response.status}`);
+        }
+    };
+}
+//# sourceMappingURL=net-liveness.js.map

package/dist/monitoring/net-liveness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"net-liveness.js","sourceRoot":"","sources":["../../src/monitoring/net-liveness.ts"],"names":[],"mappings":"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"}

package/dist/observability/progress.d.ts

@@ -0,0 +1,11 @@
+export interface ProgressEnvelope {
+    type: 'progress';
+    phase: 'init' | 'bootstrap' | 'daemon';
+    step: string;
+    attempt?: number;
+    blocking?: boolean;
+    nextAction?: string;
+    addresses?: Record<string, string>;
+    estimatedWaitMs?: number;
+}
+export declare function emitProgress(envelope: ProgressEnvelope): void;

package/dist/observability/progress.js

@@ -0,0 +1,16 @@
+/**
+ * --json-progress: emit NDJSON progress envelopes on stdout during long
+ * phases (init, bootstrap, daemon startup). The `jinn run --json-progress`
+ * flag flips JINN_JSON_PROGRESS=1 in run.ts before calling main(); when
+ * unset this is a no-op so tests / non-flag invocations stay silent on
+ * stdout.
+ */
+function progressEnabled() {
+    return process.env['JINN_JSON_PROGRESS'] === '1';
+}
+export function emitProgress(envelope) {
+    if (progressEnabled()) {
+        process.stdout.write(JSON.stringify(envelope) + '\n');
+    }
+}
+//# sourceMappingURL=progress.js.map

package/dist/observability/progress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.js","sourceRoot":"","sources":["../../src/observability/progress.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,SAAS,eAAe;IACtB,OAAO,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,KAAK,GAAG,CAAC;AACnD,CAAC;AAaD,MAAM,UAAU,YAAY,CAAC,QAA0B;IACrD,IAAI,eAAe,EAAE,EAAE,CAAC;QACtB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC;IACxD,CAAC;AACH,CAAC"}

package/dist/pilot/cost.d.ts

@@ -0,0 +1,19 @@
+import type { SolveTokens } from './solve.js';
+export interface RateTable {
+    inputPerM: number;
+    outputPerM: number;
+    cacheReadPerM?: number;
+}
+export declare const DEEPSEEK_V4_FLASH_RATES: RateTable;
+/** gpt-5.4-mini published API rate (used to price Codex-subscription token
+ *  counts at a representative metered cost — the sub bills flat, but the gate
+ *  measures what a metered user would pay). $0.75/M in, $4.50/M out. */
+export declare const GPT_5_4_MINI_RATES: RateTable;
+/** USD for one solve from provider-actual token counts. `output_tokens` already
+ *  INCLUDES `reasoning_tokens` (OpenAI `completion_tokens` semantics, verified
+ *  empirically on the Codex backend), so reasoning is NOT added again — it is
+ *  surfaced separately only for reporting. Likewise `input_tokens` is inclusive
+ *  of `cache_read_tokens`: when a cacheReadPerM rate is supplied, cache-read
+ *  tokens are re-priced at that (discounted) rate and the remaining (fresh)
+ *  input at inputPerM; otherwise all input is inputPerM. */
+export declare function solveCostUsd(tokens: SolveTokens, rates: RateTable): number;

package/dist/pilot/cost.js

@@ -0,0 +1,31 @@
+export const DEEPSEEK_V4_FLASH_RATES = { inputPerM: 0.09, outputPerM: 0.18 };
+/** gpt-5.4-mini published API rate (used to price Codex-subscription token
+ *  counts at a representative metered cost — the sub bills flat, but the gate
+ *  measures what a metered user would pay). $0.75/M in, $4.50/M out. */
+export const GPT_5_4_MINI_RATES = { inputPerM: 0.75, outputPerM: 4.5 };
+/** USD for one solve from provider-actual token counts. `output_tokens` already
+ *  INCLUDES `reasoning_tokens` (OpenAI `completion_tokens` semantics, verified
+ *  empirically on the Codex backend), so reasoning is NOT added again — it is
+ *  surfaced separately only for reporting. Likewise `input_tokens` is inclusive
+ *  of `cache_read_tokens`: when a cacheReadPerM rate is supplied, cache-read
+ *  tokens are re-priced at that (discounted) rate and the remaining (fresh)
+ *  input at inputPerM; otherwise all input is inputPerM. */
+export function solveCostUsd(tokens, rates) {
+    const per = (n, rate) => n * rate * 1e-6;
+    const outputCost = per(tokens.outputTokens, rates.outputPerM);
+    if (typeof rates.cacheReadPerM === 'number') {
+        // The fresh/cache split only matters when a discounted cacheReadPerM rate is
+        // priced. Here the `input ⊇ cache_read` invariant must hold — silently
+        // clamping fresh to 0 would hide a bad token export and mis-price the solve,
+        // so fail loud instead. (The no-cache-rate path below is untouched: it prices
+        // all input at inputPerM and never reads cacheReadTokens.)
+        if (tokens.cacheReadTokens > tokens.inputTokens) {
+            throw new Error(`solveCostUsd: cache_read_tokens (${tokens.cacheReadTokens}) > input_tokens (${tokens.inputTokens}) ` +
+                `violates the input ⊇ cache_read invariant when a cacheReadPerM rate is priced`);
+        }
+        const fresh = tokens.inputTokens - tokens.cacheReadTokens;
+        return per(fresh, rates.inputPerM) + per(tokens.cacheReadTokens, rates.cacheReadPerM) + outputCost;
+    }
+    return per(tokens.inputTokens, rates.inputPerM) + outputCost;
+}
+//# sourceMappingURL=cost.js.map

package/dist/pilot/cost.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cost.js","sourceRoot":"","sources":["../../src/pilot/cost.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,MAAM,uBAAuB,GAAc,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;AACxF;;wEAEwE;AACxE,MAAM,CAAC,MAAM,kBAAkB,GAAc,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,CAAC;AAElF;;;;;;4DAM4D;AAC5D,MAAM,UAAU,YAAY,CAAC,MAAmB,EAAE,KAAgB;IAChE,MAAM,GAAG,GAAG,CAAC,CAAS,EAAE,IAAY,EAAU,EAAE,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;IACjE,MAAM,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,YAAY,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;IAC9D,IAAI,OAAO,KAAK,CAAC,aAAa,KAAK,QAAQ,EAAE,CAAC;QAC5C,6EAA6E;QAC7E,uEAAuE;QACvE,6EAA6E;QAC7E,8EAA8E;QAC9E,2DAA2D;QAC3D,IAAI,MAAM,CAAC,eAAe,GAAG,MAAM,CAAC,WAAW,EAAE,CAAC;YAChD,MAAM,IAAI,KAAK,CACb,oCAAoC,MAAM,CAAC,eAAe,qBAAqB,MAAM,CAAC,WAAW,IAAI;gBACrG,+EAA+E,CAChF,CAAC;QACJ,CAAC;QACD,MAAM,KAAK,GAAG,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC,eAAe,CAAC;QAC1D,OAAO,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,GAAG,UAAU,CAAC;IACrG,CAAC;IACD,OAAO,GAAG,CAAC,MAAM,CAAC,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,GAAG,UAAU,CAAC;AAC/D,CAAC"}

package/dist/pilot/instance.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Solve-side pilot instance fields. The grader's `HfRow` (swe-rebench-v2-evaluator/hf-fetcher.ts)
+ * omits `base_commit` and `problem_statement` — this parses those out of the raw HF row.
+ */
+export interface PilotInstance {
+    instance_id: string;
+    repo: string;
+    base_commit: string;
+    problem_statement: string;
+    /** SWE-rebench-V2 acceptance spec (the API contract the solution must satisfy).
+     *  Optional — fed to BOTH arms when present so it never biases the comparison;
+     *  it is the *spec*, not the hidden test (feeding the test would be cheating). */
+    interface?: string;
+    hf_dataset: string;
+    hf_split: string;
+}
+export declare function parsePilotInstanceRow(row: Record<string, unknown>, ctx: {
+    hf_dataset: string;
+    hf_split: string;
+}): PilotInstance;

package/dist/pilot/instance.js

@@ -0,0 +1,19 @@
+export function parsePilotInstanceRow(row, ctx) {
+    const s = (k) => {
+        const v = row[k];
+        if (typeof v !== 'string' || !v)
+            throw new Error(`pilot instance row missing '${k}'`);
+        return v;
+    };
+    const iface = typeof row['interface'] === 'string' && row['interface'] ? row['interface'] : undefined;
+    return {
+        instance_id: s('instance_id'),
+        repo: s('repo'),
+        base_commit: s('base_commit'),
+        problem_statement: s('problem_statement'),
+        ...(iface ? { interface: iface } : {}),
+        hf_dataset: ctx.hf_dataset,
+        hf_split: ctx.hf_split,
+    };
+}
+//# sourceMappingURL=instance.js.map

package/dist/pilot/instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.js","sourceRoot":"","sources":["../../src/pilot/instance.ts"],"names":[],"mappings":"AAiBA,MAAM,UAAU,qBAAqB,CACnC,GAA4B,EAC5B,GAA6C;IAE7C,MAAM,CAAC,GAAG,CAAC,CAAS,EAAU,EAAE;QAC9B,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;QACjB,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,GAAG,CAAC,CAAC;QACtF,OAAO,CAAC,CAAC;IACX,CAAC,CAAC;IACF,MAAM,KAAK,GAAG,OAAO,GAAG,CAAC,WAAW,CAAC,KAAK,QAAQ,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,CAAE,GAAG,CAAC,WAAW,CAAY,CAAC,CAAC,CAAC,SAAS,CAAC;IAClH,OAAO;QACL,WAAW,EAAE,CAAC,CAAC,aAAa,CAAC;QAC7B,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC;QACf,WAAW,EAAE,CAAC,CAAC,aAAa,CAAC;QAC7B,iBAAiB,EAAE,CAAC,CAAC,mBAAmB,CAAC;QACzC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACtC,UAAU,EAAE,GAAG,CAAC,UAAU;QAC1B,QAAQ,EAAE,GAAG,CAAC,QAAQ;KACvB,CAAC;AACJ,CAAC"}

package/dist/pilot/repo.d.ts

@@ -0,0 +1,31 @@
+/** Git helpers for the pilot orchestrator, factored out so their fail-loud
+ *  behaviour is unit-testable with an injected runner (the orchestrator's own
+ *  I/O is validated by dry-run + smoke, per the pilot plan). */
+export type CmdRunner = (cmd: string, args: string[], opts?: {
+    cwd?: string;
+}) => Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}>;
+/** A git base-checkout step (clone/checkout) exited non-zero. The base repo is
+ *  unusable, so the INSTANCE is ungradeable — it MUST NOT silently proceed into
+ *  an empty repo where both arms score `passed:false` (that mis-attributes an
+ *  environment failure to the agent and understates the resolve rate). Caught at
+ *  run-pilot's per-instance boundary, which skips the instance and continues. */
+export declare class GitStepError extends Error {
+    readonly step: 'clone' | 'checkout';
+    readonly exitCode: number;
+    readonly detail: string;
+    constructor(step: 'clone' | 'checkout', exitCode: number, detail: string);
+}
+/** Clone `repo` into `baseDir` and check out `baseCommit`, FAIL-LOUD on a
+ *  non-zero exit from either step. A 404'd/renamed repo or an unfetchable commit
+ *  must throw here rather than leave an empty/wrong checkout that both arms then
+ *  "solve" into empty patches. */
+export declare function prepareBaseCheckout(run: CmdRunner, repo: string, baseCommit: string, baseDir: string): Promise<void>;
+/** Recover the working-tree patch, INCLUDING new (untracked) files: `git add -A`
+ *  stages everything, then `git diff --cached` emits the full diff. A plain
+ *  `git diff` misses untracked files, so a fix that ADDS a file would look like
+ *  an empty patch (a spurious not-resolved). */
+export declare function recoverPatch(run: CmdRunner, cwd: string): Promise<string>;

package/dist/pilot/repo.js

@@ -0,0 +1,42 @@
+/** Git helpers for the pilot orchestrator, factored out so their fail-loud
+ *  behaviour is unit-testable with an injected runner (the orchestrator's own
+ *  I/O is validated by dry-run + smoke, per the pilot plan). */
+/** A git base-checkout step (clone/checkout) exited non-zero. The base repo is
+ *  unusable, so the INSTANCE is ungradeable — it MUST NOT silently proceed into
+ *  an empty repo where both arms score `passed:false` (that mis-attributes an
+ *  environment failure to the agent and understates the resolve rate). Caught at
+ *  run-pilot's per-instance boundary, which skips the instance and continues. */
+export class GitStepError extends Error {
+    step;
+    exitCode;
+    detail;
+    constructor(step, exitCode, detail) {
+        super(`git ${step} failed (exit ${exitCode})${detail ? `: ${detail}` : ''}`);
+        this.step = step;
+        this.exitCode = exitCode;
+        this.detail = detail;
+        this.name = 'GitStepError';
+    }
+}
+/** Clone `repo` into `baseDir` and check out `baseCommit`, FAIL-LOUD on a
+ *  non-zero exit from either step. A 404'd/renamed repo or an unfetchable commit
+ *  must throw here rather than leave an empty/wrong checkout that both arms then
+ *  "solve" into empty patches. */
+export async function prepareBaseCheckout(run, repo, baseCommit, baseDir) {
+    const clone = await run('git', ['clone', `https://github.com/${repo}.git`, baseDir]);
+    if (clone.exitCode !== 0)
+        throw new GitStepError('clone', clone.exitCode, clone.stderr.trim().slice(0, 300));
+    const checkout = await run('git', ['checkout', baseCommit], { cwd: baseDir });
+    if (checkout.exitCode !== 0)
+        throw new GitStepError('checkout', checkout.exitCode, checkout.stderr.trim().slice(0, 300));
+}
+/** Recover the working-tree patch, INCLUDING new (untracked) files: `git add -A`
+ *  stages everything, then `git diff --cached` emits the full diff. A plain
+ *  `git diff` misses untracked files, so a fix that ADDS a file would look like
+ *  an empty patch (a spurious not-resolved). */
+export async function recoverPatch(run, cwd) {
+    await run('git', ['add', '-A'], { cwd });
+    const diff = await run('git', ['diff', '--cached'], { cwd });
+    return diff.stdout;
+}
+//# sourceMappingURL=repo.js.map

package/dist/pilot/repo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo.js","sourceRoot":"","sources":["../../src/pilot/repo.ts"],"names":[],"mappings":"AAAA;;gEAEgE;AAQhE;;;;iFAIiF;AACjF,MAAM,OAAO,YAAa,SAAQ,KAAK;IAE1B;IACA;IACA;IAHX,YACW,IAA0B,EAC1B,QAAgB,EAChB,MAAc;QAEvB,KAAK,CAAC,OAAO,IAAI,iBAAiB,QAAQ,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAJpE,SAAI,GAAJ,IAAI,CAAsB;QAC1B,aAAQ,GAAR,QAAQ,CAAQ;QAChB,WAAM,GAAN,MAAM,CAAQ;QAGvB,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;IAC7B,CAAC;CACF;AAED;;;kCAGkC;AAClC,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,GAAc,EACd,IAAY,EACZ,UAAkB,EAClB,OAAe;IAEf,MAAM,KAAK,GAAG,MAAM,GAAG,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,sBAAsB,IAAI,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACrF,IAAI,KAAK,CAAC,QAAQ,KAAK,CAAC;QAAE,MAAM,IAAI,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;IAC7G,MAAM,QAAQ,GAAG,MAAM,GAAG,CAAC,KAAK,EAAE,CAAC,UAAU,EAAE,UAAU,CAAC,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,CAAC;IAC9E,IAAI,QAAQ,CAAC,QAAQ,KAAK,CAAC;QAAE,MAAM,IAAI,YAAY,CAAC,UAAU,EAAE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;AAC3H,CAAC;AAED;;;gDAGgD;AAChD,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,GAAc,EAAE,GAAW;IAC5D,MAAM,GAAG,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;IACzC,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;IAC7D,OAAO,IAAI,CAAC,MAAM,CAAC;AACrB,CAAC"}

package/dist/pilot/solve.d.ts

@@ -0,0 +1,22 @@
+export interface Arm {
+    name: 'A' | 'B';
+    skills: string[];
+}
+export interface SolveTokens {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    reasoningTokens: number;
+}
+/** The jinn-agent argv for one solve. Arm A = empty loadout enforced via
+ *  --ignore-rules (no memory/AGENTS.md/preloaded-skill leakage, spike §3.1);
+ *  arm B = arm A + `-s <skill>` for each loadout skill. When `provider`/`model`
+ *  are supplied they pin the inference endpoint for this invocation (e.g.
+ *  `openai-codex` + `gpt-5.4-mini`) without touching the global config default. */
+export declare function buildSolveArgs(arm: Arm, prompt: string, opts: {
+    maxTurns: number;
+    provider?: string;
+    model?: string;
+}): string[];
+export declare function parseSessionTokens(exportLine: string): SolveTokens;
+export declare function extractSessionId(stderr: string): string | null;

package/dist/pilot/solve.js

@@ -0,0 +1,37 @@
+/** The jinn-agent argv for one solve. Arm A = empty loadout enforced via
+ *  --ignore-rules (no memory/AGENTS.md/preloaded-skill leakage, spike §3.1);
+ *  arm B = arm A + `-s <skill>` for each loadout skill. When `provider`/`model`
+ *  are supplied they pin the inference endpoint for this invocation (e.g.
+ *  `openai-codex` + `gpt-5.4-mini`) without touching the global config default. */
+export function buildSolveArgs(arm, prompt, opts) {
+    const base = ['chat', '-q', prompt, '-Q', '--yolo', '--ignore-rules'];
+    const endpoint = [
+        ...(opts.provider ? ['--provider', opts.provider] : []),
+        ...(opts.model ? ['-m', opts.model] : []),
+    ];
+    const skills = arm.skills.flatMap((s) => ['-s', s]);
+    return [...base, ...endpoint, ...skills, '--pass-session-id', '--max-turns', String(opts.maxTurns)];
+}
+export function parseSessionTokens(exportLine) {
+    const o = JSON.parse(exportLine);
+    const num = (k) => {
+        const v = o[k];
+        if (typeof v !== 'number')
+            throw new Error(`session export missing numeric token field '${k}'`);
+        return v;
+    };
+    const optNum = (k) => (typeof o[k] === 'number' ? o[k] : 0);
+    return {
+        inputTokens: num('input_tokens'),
+        outputTokens: num('output_tokens'),
+        cacheReadTokens: optNum('cache_read_tokens'),
+        // Reasoning models (e.g. gpt-5.4-mini) report reasoning tokens separately;
+        // they are billed at the output rate. Absent for non-reasoning models → 0.
+        reasoningTokens: optNum('reasoning_tokens'),
+    };
+}
+export function extractSessionId(stderr) {
+    const m = stderr.match(/session_id:\s*(\S+)/);
+    return m ? m[1] : null;
+}
+//# sourceMappingURL=solve.js.map

package/dist/pilot/solve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solve.js","sourceRoot":"","sources":["../../src/pilot/solve.ts"],"names":[],"mappings":"AAGA;;;;mFAImF;AACnF,MAAM,UAAU,cAAc,CAC5B,GAAQ,EACR,MAAc,EACd,IAA6D;IAE7D,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,gBAAgB,CAAC,CAAC;IACtE,MAAM,QAAQ,GAAG;QACf,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACvD,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;KAC1C,CAAC;IACF,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IACpD,OAAO,CAAC,GAAG,IAAI,EAAE,GAAG,QAAQ,EAAE,GAAG,MAAM,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;AACtG,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,UAAkB;IACnD,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAA4B,CAAC;IAC5D,MAAM,GAAG,GAAG,CAAC,CAAS,EAAU,EAAE;QAChC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACf,IAAI,OAAO,CAAC,KAAK,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,GAAG,CAAC,CAAC;QAChG,OAAO,CAAC,CAAC;IACX,CAAC,CAAC;IACF,MAAM,MAAM,GAAG,CAAC,CAAS,EAAU,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAE,CAAC,CAAC,CAAC,CAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACxF,OAAO;QACL,WAAW,EAAE,GAAG,CAAC,cAAc,CAAC;QAChC,YAAY,EAAE,GAAG,CAAC,eAAe,CAAC;QAClC,eAAe,EAAE,MAAM,CAAC,mBAAmB,CAAC;QAC5C,2EAA2E;QAC3E,2EAA2E;QAC3E,eAAe,EAAE,MAAM,CAAC,kBAAkB,CAAC;KAC5C,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,MAAc;IAC7C,MAAM,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;IAC9C,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AAC1B,CAAC"}

package/dist/pilot/tally.d.ts

@@ -0,0 +1,35 @@
+export interface SolveOutcome {
+    instance_id: string;
+    arm: 'A' | 'B';
+    repeat: number;
+    passed: boolean | null;
+    costUsd: number;
+}
+export interface PilotReport {
+    n: number;
+    armA: {
+        resolveRate: number;
+    };
+    armB: {
+        resolveRate: number;
+    };
+    bothSolveTasks: number;
+    excluded: number;
+    quality: {
+        lowerBound: number;
+        nonInferior: boolean;
+        deltaPP: number;
+    };
+    /** `n` is the both-solve NON-ZERO cost-diff count the Wilcoxon actually uses;
+     *  `underpowered` marks n below its one-sided minimum-rejectable size (~5), so a
+     *  tiny-n verdict is not mistaken for a powered one. */
+    cost: {
+        verdict: 'lower' | 'not-lower' | 'inconclusive';
+        medianDeltaUsd: number;
+        n: number;
+        underpowered: boolean;
+    };
+}
+export declare function tallyPilot(outcomes: SolveOutcome[], opts: {
+    rng: () => number;
+}): PilotReport;