@jinn-network/jinn-layer 0.1.0

package/dist/bridge-verdict-source.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The bridge's verdict-row source (spec/2026-07-06-distillation-v1.md §8, D10).
+ *
+ * Reads swe-rebench-v2 verdicts from the Ponder indexer's GraphQL — BOTH
+ * polarities (D10): evaluator-confirmed passes (→ pattern-eligible) and
+ * evaluator-confirmed failures (→ lesson-eligible) — and returns them as
+ * `AttemptRef[]` for `bridgeAttempts()`.
+ *
+ * A single paged GraphQL query over `verdictEnvelopeMetas`:
+ *   - filtered to swe-rebench-v2 / enriched-ok;
+ *   - keep only PASS and FAIL polarities (INVALID / INDETERMINATE / UNKNOWN are
+ *     noise, not lessons — dropped, as is any actualPassed/verdict disagreement);
+ *   - carry each verdict row's own `manifestCid` as `verdictManifestCid` — the
+ *     entry point of the VERIFIED verdict→solution join done by
+ *     `bridge-fetch-evidence.ts` (verdict envelope → task doc →
+ *     authoritative verdict → attempt tuple → attemptEnvelopeMeta → solution
+ *     envelope patch).
+ *
+ * The predecessor's `attemptEnvelopeMeta(requestId=verdict.requestId)` join is
+ * gone: probed live (see client/scripts/distill-run-live.ts), that key does not
+ * match, so the join returned empty. The real link runs through the task doc's
+ * chain-indexed verdict/attempt tuple, resolved lazily in the evidence fetcher.
+ *
+ * I/O is injected (`fetchImpl`) so the module is unit-testable without a live
+ * indexer, mirroring `queryCaptureMeta` in ./consume.ts.
+ */
+import type { AttemptRef } from './bridge.js';
+export declare class IncompleteVerdictWalkError extends Error {
+    constructor(message: string);
+}
+export interface VerdictSourceOptions {
+    /** Ponder GraphQL endpoint, e.g. https://my-indexer.example/graphql */
+    graphqlUrl: string;
+    /** Injectable fetch (tests). Defaults to globalThis.fetch. */
+    fetchImpl?: typeof fetch;
+}
+export interface VerdictSource {
+    /** List swe-rebench-v2 verdict rows (both polarities) as `AttemptRef[]`. */
+    list(args?: {
+        limit?: number;
+    }): Promise<AttemptRef[]>;
+}
+/**
+ * Build a verdict-row source over a Ponder GraphQL endpoint. No live I/O until
+ * `list()` is called.
+ */
+export declare function createVerdictSource(opts: VerdictSourceOptions): VerdictSource;

package/dist/bridge-verdict-source.js

@@ -0,0 +1,216 @@
+/**
+ * The bridge's verdict-row source (spec/2026-07-06-distillation-v1.md §8, D10).
+ *
+ * Reads swe-rebench-v2 verdicts from the Ponder indexer's GraphQL — BOTH
+ * polarities (D10): evaluator-confirmed passes (→ pattern-eligible) and
+ * evaluator-confirmed failures (→ lesson-eligible) — and returns them as
+ * `AttemptRef[]` for `bridgeAttempts()`.
+ *
+ * A single paged GraphQL query over `verdictEnvelopeMetas`:
+ *   - filtered to swe-rebench-v2 / enriched-ok;
+ *   - keep only PASS and FAIL polarities (INVALID / INDETERMINATE / UNKNOWN are
+ *     noise, not lessons — dropped, as is any actualPassed/verdict disagreement);
+ *   - carry each verdict row's own `manifestCid` as `verdictManifestCid` — the
+ *     entry point of the VERIFIED verdict→solution join done by
+ *     `bridge-fetch-evidence.ts` (verdict envelope → task doc →
+ *     authoritative verdict → attempt tuple → attemptEnvelopeMeta → solution
+ *     envelope patch).
+ *
+ * The predecessor's `attemptEnvelopeMeta(requestId=verdict.requestId)` join is
+ * gone: probed live (see client/scripts/distill-run-live.ts), that key does not
+ * match, so the join returned empty. The real link runs through the task doc's
+ * chain-indexed verdict/attempt tuple, resolved lazily in the evidence fetcher.
+ *
+ * I/O is injected (`fetchImpl`) so the module is unit-testable without a live
+ * indexer, mirroring `queryCaptureMeta` in ./consume.ts.
+ */
+// ── GraphQL query string ──────────────────────────────────────────────────────
+/**
+ * Paged verdict rows for swe-rebench-v2. Filters mirror
+ * INSTANCE_SUCCESS_COUNTS_QUERY in http.ts, minus the `actualPassed: true`
+ * pin — we source both polarities, so polarity is decided client-side from
+ * `actualPassed` + `evaluatorVerdict`. Each row carries its own `manifestCid`
+ * (the verdict envelope CID) — the entry point of the verdict→solution join.
+ */
+const VERDICTS_QUERY = `
+query BridgeVerdicts($limit: Int!, $after: String) {
+  verdictEnvelopeMetas(
+    where: {
+      solverType_starts_with: "swe-rebench-v2",
+      enrichmentStatus: "ok"
+    },
+    limit: $limit,
+    after: $after,
+    orderBy: "enrichedAtBlock",
+    orderDirection: "asc"
+  ) {
+    items {
+      requestId
+      chainId
+      instanceId
+      actualPassed
+      evaluatorVerdict
+      manifestCid
+    }
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
+  }
+}
+`;
+// ── Constants ──────────────────────────────────────────────────────────────────
+/** Ponder caps plural-query `limit` at 1000. */
+const PAGE_LIMIT = 1000;
+/** Bound on pages walked — 20 × 1000 rows is far beyond any realistic slate. */
+const MAX_PAGES = 20;
+/**
+ * A MetadataSet publisher can project arbitrary enrichment identity. Retain a
+ * finite number of projections for one authoritative request tuple so an
+ * attacker-first row cannot suppress the genuine candidate.
+ */
+const MAX_IDENTITY_CANDIDATES_PER_ATTEMPT = 32;
+export class IncompleteVerdictWalkError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'IncompleteVerdictWalkError';
+    }
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────────
+async function postGql(url, fetchImpl, query, variables) {
+    const response = await fetchImpl(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ query, variables }),
+    });
+    if (!response.ok) {
+        throw new Error(`verdict-source GraphQL HTTP ${response.status} ${response.statusText}`);
+    }
+    const json = (await response.json());
+    if (json.errors?.length) {
+        throw new Error(`verdict-source GraphQL error: ${json.errors.map((e) => e.message ?? 'unknown').join('; ')}`);
+    }
+    if (!json.data) {
+        throw new Error('verdict-source GraphQL response missing data field');
+    }
+    return json.data;
+}
+/**
+ * Map an enriched verdict row to a polarity, or `null` when it is neither a
+ * clean PASS nor a clean FAIL (INVALID / INDETERMINATE / UNKNOWN, or any
+ * disagreement between `actualPassed` and `evaluatorVerdict`) — those are noise,
+ * not lessons, and are dropped.
+ */
+function polarityOf(row) {
+    if (row.actualPassed === true && row.evaluatorVerdict === 'PASS')
+        return 'pass';
+    if (row.actualPassed === false && row.evaluatorVerdict === 'FAIL')
+        return 'fail';
+    return null;
+}
+function requireVerdictsPage(data) {
+    if (typeof data !== 'object' || data === null) {
+        throw new IncompleteVerdictWalkError('incomplete verdict walk: malformed GraphQL data payload');
+    }
+    const verdictEnvelopeMetas = data['verdictEnvelopeMetas'];
+    if (typeof verdictEnvelopeMetas !== 'object' || verdictEnvelopeMetas === null) {
+        throw new IncompleteVerdictWalkError('incomplete verdict walk: missing or malformed verdictEnvelopeMetas');
+    }
+    const items = verdictEnvelopeMetas['items'];
+    if (!Array.isArray(items)) {
+        throw new IncompleteVerdictWalkError('incomplete verdict walk: verdictEnvelopeMetas.items is not an array');
+    }
+    const pageInfo = verdictEnvelopeMetas['pageInfo'];
+    if (typeof pageInfo !== 'object' || pageInfo === null) {
+        throw new IncompleteVerdictWalkError('incomplete verdict walk: missing or malformed verdictEnvelopeMetas.pageInfo');
+    }
+    const hasNextPage = pageInfo['hasNextPage'];
+    const endCursor = pageInfo['endCursor'];
+    if (typeof hasNextPage !== 'boolean'
+        || (endCursor !== null && typeof endCursor !== 'string')) {
+        throw new IncompleteVerdictWalkError('incomplete verdict walk: malformed verdictEnvelopeMetas.pageInfo fields');
+    }
+    return {
+        items: items,
+        pageInfo: { hasNextPage, endCursor },
+    };
+}
+/**
+ * Build a verdict-row source over a Ponder GraphQL endpoint. No live I/O until
+ * `list()` is called.
+ */
+export function createVerdictSource(opts) {
+    const url = opts.graphqlUrl.endsWith('/graphql') ? opts.graphqlUrl : `${opts.graphqlUrl}/graphql`;
+    const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    if (!fetchImpl) {
+        throw new Error('No fetch implementation available; pass fetchImpl in options');
+    }
+    async function list(args = {}) {
+        if (args.limit !== undefined
+            && (!Number.isSafeInteger(args.limit) || args.limit <= 0)) {
+            throw new RangeError('verdict-source limit must be a positive safe integer');
+        }
+        const limit = args.limit ?? Number.POSITIVE_INFINITY;
+        // Page verdict rows (both polarities), dropping non-PASS/FAIL and any row
+        // missing its verdict `manifestCid` (no join entry point → nothing to bridge).
+        const refs = [];
+        const refsByRequestPolarity = new Map();
+        let cursor = null;
+        for (let page = 0; page < MAX_PAGES; page++) {
+            const data = await postGql(url, fetchImpl, VERDICTS_QUERY, {
+                limit: PAGE_LIMIT,
+                after: cursor,
+            });
+            const verdictsPage = requireVerdictsPage(data);
+            for (const row of verdictsPage.items) {
+                const polarity = polarityOf(row);
+                if (polarity === null)
+                    continue; // INVALID/INDETERMINATE/UNKNOWN — dropped.
+                if (!row.manifestCid)
+                    continue; // no verdict envelope CID → no join entry point.
+                const candidateKey = `${row.chainId}:${row.requestId.toLowerCase()}:${polarity}`;
+                const discoveryCandidate = {
+                    instanceId: typeof row.instanceId === 'string' ? row.instanceId : '',
+                    verdictManifestCid: row.manifestCid,
+                };
+                const existing = refsByRequestPolarity.get(candidateKey);
+                if (existing) {
+                    if (existing.discoveryCandidates
+                        && existing.discoveryCandidates.length < MAX_IDENTITY_CANDIDATES_PER_ATTEMPT) {
+                        existing.discoveryCandidates.push(discoveryCandidate);
+                    }
+                    continue;
+                }
+                // `limit` bounds authoritative attempt tuples, not permissionless
+                // candidate rows. Continue walking the bounded result set after the
+                // tuple cap so later candidates for selected tuples survive.
+                if (refs.length >= limit)
+                    continue;
+                const attempt = {
+                    requestId: row.requestId,
+                    chainId: row.chainId,
+                    instanceId: discoveryCandidate.instanceId,
+                    // The attempt-join that once supplied the model is gone; the bridge
+                    // falls back to 'unknown' when model is empty.
+                    model: '',
+                    // Filled by the evidence fetcher's authoritative join off verdictManifestCid.
+                    manifestCid: '',
+                    polarity,
+                    verdictManifestCid: row.manifestCid,
+                    discoveryCandidates: [discoveryCandidate],
+                };
+                refsByRequestPolarity.set(candidateKey, attempt);
+                refs.push(attempt);
+            }
+            const pageInfo = verdictsPage.pageInfo;
+            if (!pageInfo.hasNextPage)
+                return refs;
+            if (!pageInfo.endCursor) {
+                throw new IncompleteVerdictWalkError('incomplete verdict walk: indexer advertised another page without an end cursor');
+            }
+            cursor = pageInfo.endCursor;
+        }
+        throw new IncompleteVerdictWalkError(`incomplete verdict walk: indexer still advertised rows after ${MAX_PAGES} pages`);
+    }
+    return { list };
+}

package/dist/bridge.d.ts

@@ -0,0 +1,247 @@
+/**
+ * The bridge — SolverNet execution ledger → layer-1 evidence
+ * (spec/2026-07-06-distillation-v1.md §8, D5/D10).
+ *
+ * Turns swe-rebench attempts into canonical `jinn.episode.v1` evidence via
+ * the existing `capture()`→`publish()` pipe, scrubbed at the **layer-2
+ * (secret-only) altitude** (D6 — a verified swe-rebench solve is public-repo
+ * work, not raw private-machine activity). It sources **both polarities** (D10):
+ * verified passes → pattern-eligible evidence; evaluator-confirmed failures →
+ * lesson-eligible evidence. Held-out `cap-v0` slate instances are excluded by
+ * `instance_id` AND repo; each `(instance_id, polarity)` is retained up to
+ * `groupCap` attempts (default 1) so the per-instance attempt group survives for
+ * group-relative distillation (#1478).
+ *
+ * This module is the bridge **core + the publish adapter**. The ledger row
+ * source (indexer GraphQL over `verdictEnvelopeMeta`, both polarities) and the
+ * IPFS/corpus evidence fetch are injected ports (`BridgeDeps`) — the production
+ * adapters are thin and wired at run time; the logic here is what carries the
+ * tests.
+ */
+import { type CapturedTask, type PendingEnvelope } from './capture.js';
+import { type HarnessPublishDeps, type ManifestBatchPublishDeps, type ManifestBatchResult, type ManifestBatchSetResult } from './publish.js';
+import { type ScrubPipeline } from '@jinn-network/core/scrub';
+import type { TranscriptSpanInput } from '@jinn-network/core/trajectory';
+/** A verdict row from the execution ledger, one polarity. */
+export interface AttemptRef {
+    requestId: string;
+    chainId: number;
+    /**
+     * Enrichment-projected swe-rebench `instance_id` (owner__repo-N). This is a
+     * discovery hint, never authoritative task identity.
+     */
+    instanceId: string;
+    /** Model the attempt ran under (from `attemptEnvelopeMeta.model`). */
+    model: string;
+    /** The attempt envelope CID — where the solution patch + task descriptor live. */
+    manifestCid: string;
+    /** `pass` = verified solve (→ pattern); `fail` = evaluator-confirmed FAIL (→ lesson). */
+    polarity: 'pass' | 'fail';
+    /**
+     * The VERDICT envelope CID — the entry point of the verified join to the
+     * solver's solution patch. The task document supplies authenticated task
+     * facts only; the chain-scoped verdict → attempt tuple supplies the solution
+     * requestId, which resolves one attemptEnvelopeMeta → solution envelope. The
+     * verdict-source populates it; callers that already carry a resolved
+     * `manifestCid` (e.g. the corpus fetcher) do not need it.
+     */
+    verdictManifestCid?: string;
+    /**
+     * Bounded, permissionless enrichment projections retained for one
+     * `(requestId, chainId, polarity)` tuple. The bridge tries them only to let
+     * the evidence fetcher reach signed task facts; none may drive exclusion,
+     * grouping, or publication identity.
+     */
+    discoveryCandidates?: Array<{
+        instanceId: string;
+        verdictManifestCid: string;
+    }>;
+    /** Echo/lineage key — instances sharing a key are not independent corroboration. */
+    sourceLineageKey?: string;
+    lookupFlagged?: boolean;
+    /** Optional task provenance carried by richer verdict-row sources. */
+    repo?: string;
+    baseCommit?: string;
+}
+/** Evidence fetched for one attempt (the injected IPFS/corpus port). */
+export interface BridgeEvidence {
+    /** The instance problem statement (scrubbed downstream by capture's layer-2 pipeline). */
+    taskSummary: string;
+    /** The unified-diff patch the attempt produced. */
+    patch: string;
+    /**
+     * Authenticated task tuple returned by the source resolver. These remain
+     * optional on the fetch-only transport shape, but all four are mandatory at
+     * the evaluator-verified publication boundary.
+     */
+    repo?: string;
+    baseCommit?: string;
+    taskCreatedAt?: number;
+    instanceId?: string;
+    generatorModel?: CapturedTask['environment']['generatorModel'];
+    distributionClass?: CapturedTask['environment']['distributionClass'];
+    /** Authenticated verifier facts are all-or-nothing; partial facts are never published. */
+    verifier?: {
+        failToPass: string[];
+        passToPass: string[];
+        evalSemanticsVersion: string;
+    };
+    /** Authenticated source artifacts retained for audit and lineage. */
+    verdictEnvelopeCid?: string;
+    solutionEnvelopeCid?: string;
+    rawSnapshotRef?: string;
+    /**
+     * The solver's canonical typed decision-path spans, derived from the raw
+     * harness transcript inside the solution's `system_snapshot` artifact
+     * (`.claude-code/stdout.jsonl` / `.codex-code/stdout.jsonl` — §8, #1472;
+     * `jinn.trajectory.v1` carries no reasoning until #1473). The bridge uses the
+     * same parser implementation as the live path. When absent (Hermes,
+     * missing/corrupt snapshot), the layer-1 record is
+     * tagged `patch-only` (see `toBridgeCapturedTask`) so measurement can
+     * stratify by evidence richness. Rides a step attribute → scrubbed by the
+     * same layer-2 pipeline as every other attribute; it does not bypass scrub.
+     */
+    trajectorySpans?: TranscriptSpanInput[];
+}
+export interface BridgeDeps {
+    /** The held-out `cap-v0` slate instance ids (§12). Repo exclusion is derived from these. */
+    slateInstanceIds: Set<string>;
+    /** Fetch the patch + task descriptor for an attempt (IPFS/corpus). */
+    fetchEvidence: (ref: AttemptRef) => Promise<BridgeEvidence>;
+    /** Publish a constructed CapturedTask as layer-1 evidence; returns the corpus ref. */
+    publishEvidence: (task: CapturedTask, ref: AttemptRef) => Promise<{
+        envelopeRef: string;
+        anchorTx: string | null;
+    }>;
+    /** Bulk batches opt in explicitly; contributed/retrieval records stay per-record by default. */
+    anchorMode?: 'per-record' | 'manifest';
+    /** One shared manifest publication for every surviving task (manifest mode only). */
+    publishManifestBatch?: (candidates: Array<{
+        task: CapturedTask;
+        ref: AttemptRef;
+    }>) => Promise<ManifestBatchSetResult>;
+    /** Weak-suite instance ids (discrimination fail) — excluded from bridge input. */
+    weakSuiteInstanceIds?: Set<string>;
+    /** Lookup-flagged instance ids — excluded from distillation input. */
+    lookupFlaggedInstanceIds?: Set<string>;
+    /**
+     * Attempts retained per `(instance_id, polarity)` — the per-instance attempt
+     * GROUP is the distiller's raw material for group-relative distillation
+     * (#1478). Default 1 keeps the single-exemplar behavior for standalone
+     * callers; the pipeline passes a higher cap so clustering receives the whole
+     * group. Rows beyond the cap are recorded in `BridgeResult.deduped`, and
+     * since refs arrive in a stable order the kept K are deterministic.
+     */
+    groupCap?: number;
+    now?: () => Date;
+}
+export interface BridgeManifestBatch {
+    batchKey?: string;
+    manifestCid: string;
+    memberRefs: string[];
+    root: `0x${string}`;
+    anchorTx: `0x${string}` | null;
+    gasUsed: bigint | null;
+    feeWei: bigint | null;
+    control?: ManifestBatchResult['control'];
+    confirmed: boolean;
+}
+export interface BridgeResult {
+    bridged: Array<{
+        instanceId: string;
+        polarity: 'pass' | 'fail';
+        envelopeRef: string;
+        anchorTx: string | null;
+    }>;
+    excludedHeldOut: Array<{
+        instanceId: string;
+        reason: 'instance_id' | 'repo';
+    }>;
+    /** Attempts dropped because their `(instance_id, polarity)` group already held `groupCap` (#1478). */
+    deduped: Array<{
+        instanceId: string;
+        polarity: 'pass' | 'fail';
+    }>;
+    errors: Array<{
+        requestId: string;
+        error: string;
+    }>;
+    /**
+     * Slate `instance_id`s whose repo could NOT be derived (`repoFromInstanceId`
+     * → null). Repo-axis exclusion (§12) is incomplete for these: a same-repo
+     * sibling of such a slate id would NOT be caught by the derived-repo guard,
+     * only by an exact `instance_id` match. Surfaced (not silently dropped) so an
+     * operator sees the contamination-boundary gap; empty once cap-v0 carries
+     * repos explicitly.
+     */
+    unresolvedSlateIds: string[];
+    /** Shared batch facts, populated only in manifest mode. */
+    manifestCid?: string;
+    /** One observation per manifest partition, including recovery-only anchors. */
+    manifestBatches?: BridgeManifestBatch[];
+    /** Uploaded member refs, retained even when post-anchor local finalization fails. */
+    manifestMemberRefs?: string[];
+    /** Durable recovery identity for the manifest batch, when journaling is active. */
+    manifestBatchKey?: string;
+    anchorTx?: string | null;
+    gasUsed?: bigint | null;
+    feeWei?: bigint | null;
+    control?: ManifestBatchResult['control'];
+    /** False means a tx was broadcast but not confirmed successful. */
+    manifestConfirmed?: boolean;
+}
+/**
+ * Derive `owner/repo` from a SWE-bench `instance_id` (`owner__repo-<pr#>`),
+ * or null when the id does not match the convention. cap-v0 will carry repos
+ * explicitly; until then repo exclusion (§12) is derived here.
+ */
+export declare function repoFromInstanceId(instanceId: string): string | null;
+/**
+ * Construct the layer-1 `CapturedTask` for one attempt (both polarities, D10).
+ *
+ * The full patch goes into the `apply_patch` step attribute. Note: `capture()`
+ * caps step attributes at `MAX_STEP_ATTRIBUTES_BYTES` (16 KiB) and truncates the
+ * largest value with a receipted `…[truncated]` suffix, so a patch over that
+ * bound is stored truncated (inherited from the frozen pipe, D5 — not
+ * re-implemented here). Real SWE-bench patches can exceed 16 KiB; the truncation
+ * is recorded in the envelope's step receipt, not silent.
+ *
+ * Evidence-richness (§8): canonical typed transcript spans are inserted
+ * between the patch and verdict steps. When no usable spans exist, a
+ * `patch-only` tag is appended to `distributionTags`.
+ */
+export declare function toBridgeCapturedTask(ref: AttemptRef, ev: BridgeEvidence, now: Date): CapturedTask;
+/**
+ * Bridge a batch of ledger verdict rows into layer-1 evidence. Permissionless
+ * enrichment projections are used only to discover authenticated evidence.
+ * Exclusion and dedup use the signed task identity returned by `fetchEvidence`.
+ */
+export declare function bridgeAttempts(refs: AttemptRef[], deps: BridgeDeps): Promise<BridgeResult>;
+/**
+ * The production `publishEvidence`: run the CapturedTask through `capture()`
+ * with the **layer-2 (secret-only) pipeline** injected (D6), then `publish()` —
+ * emitting a canonical `jinn.episode.v1` artifact. Reuses the scrubbed pipe; the only
+ * departure from a native capture is the scrub altitude.
+ */
+export declare function buildBridgeEvidencePublisher(deps: HarnessPublishDeps, opts?: {
+    pipeline?: ScrubPipeline;
+}): (task: CapturedTask, ref: AttemptRef) => Promise<{
+    envelopeRef: string;
+    anchorTx: string | null;
+}>;
+/**
+ * Production manifest publisher: capture every bridge task with the shared
+ * layer-2 scrub pipeline, then hand all pending envelopes to the one-anchor
+ * batch publisher with their discovery hints.
+ */
+export declare function buildBridgeManifestPublisher(deps: ManifestBatchPublishDeps, opts?: {
+    pipeline?: ScrubPipeline;
+    measurePerRecordControl?: boolean;
+    onCaptured?: (pending: PendingEnvelope, candidate: {
+        task: CapturedTask;
+        ref: AttemptRef;
+    }) => void;
+}): (candidates: Array<{
+    task: CapturedTask;
+    ref: AttemptRef;
+}>) => Promise<ManifestBatchSetResult>;