@jinn-network/jinn-layer 0.1.0

package/dist/bridge.js

@@ -0,0 +1,439 @@
+/**
+ * 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 { capture } from './capture.js';
+import { ManifestBatchAnchorError, ManifestBatchPreparationError, ManifestBatchRecordingError, ManifestBatchSetError, publish, publishManifestBatch as publishPendingManifestBatch, } from './publish.js';
+import { buildLayer2ScrubPipeline, } from '@jinn-network/core/scrub';
+/**
+ * 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 function repoFromInstanceId(instanceId) {
+    const m = /^(.+)__(.+)-\d+$/.exec(instanceId);
+    return m ? `${m[1]}/${m[2]}` : null;
+}
+const NANO = (d) => `${d.getTime()}000000`;
+function assertAuthenticatedBridgeEvidence(ref, ev) {
+    const verifier = ev.verifier;
+    const exactStringArray = (value) => Array.isArray(value)
+        && value.every((item) => typeof item === 'string' && item.length > 0);
+    if (!verifier
+        || !exactStringArray(verifier.failToPass)
+        || !exactStringArray(verifier.passToPass)
+        || typeof verifier.evalSemanticsVersion !== 'string'
+        || verifier.evalSemanticsVersion.length === 0) {
+        throw new Error(`bridge evidence for ${ref.instanceId} requires authenticated verifier facts before evaluator-verified publication`);
+    }
+    if (typeof ev.instanceId !== 'string'
+        || ev.instanceId.length === 0
+        || typeof ev.repo !== 'string'
+        || ev.repo.length === 0
+        || typeof ev.baseCommit !== 'string'
+        || ev.baseCommit.length === 0
+        || typeof ev.taskCreatedAt !== 'number'
+        || !Number.isInteger(ev.taskCreatedAt)
+        || ev.taskCreatedAt < 0) {
+        throw new Error(`bridge evidence for ${ref.instanceId} requires an authenticated task provenance tuple`);
+    }
+}
+/**
+ * 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 function toBridgeCapturedTask(ref, ev, now) {
+    assertAuthenticatedBridgeEvidence(ref, ev);
+    const nano = NANO(now);
+    const isPass = ref.polarity === 'pass';
+    const repo = ev.repo;
+    const instanceId = ev.instanceId;
+    const historySteps = (ev.trajectorySpans ?? []).flatMap((span, index) => {
+        const spanKind = span.attributes['jinn.span.kind'];
+        if (spanKind !== 'jinn.agent_turn' && spanKind !== 'jinn.tool_call') {
+            return [];
+        }
+        return [{
+                spanId: `history-${String(index + 1).padStart(6, '0')}`,
+                parentSpanId: null,
+                kind: spanKind,
+                name: span.name,
+                startTimeUnixNano: span.startTimeUnixNano,
+                endTimeUnixNano: span.endTimeUnixNano,
+                attributes: span.attributes,
+                redactedKeys: [],
+                ...(span.events.length > 0 ? { events: span.events } : {}),
+                ...(span.status ? { status: span.status } : {}),
+            }];
+    });
+    const enriched = historySteps.length > 0;
+    return {
+        session: {
+            sessionId: `bridge:${instanceId}:${ref.polarity}:${ref.requestId}`,
+            capturedAt: now.toISOString(),
+        },
+        task: {
+            summary: `swe-rebench ${instanceId}: ${ev.taskSummary}`.slice(0, 500),
+            distributionTags: [
+                'coding',
+                'swe-rebench',
+                `repo:${repo}`.slice(0, 64),
+                ...(enriched ? [] : ['patch-only']),
+            ],
+            repositorySlug: repo,
+            baseCommit: ev.baseCommit,
+            createdAt: ev.taskCreatedAt,
+            instanceId,
+        },
+        environment: {
+            harness: { name: 'jinn-execution-ledger-bridge', version: '0.1.0' },
+            model: ref.model || 'unknown',
+            tools: [],
+            ...(ev.generatorModel ? { generatorModel: ev.generatorModel } : {}),
+            ...(ev.distributionClass ? { distributionClass: ev.distributionClass } : {}),
+            verifier: {
+                type: 'f2p-p2p',
+                failToPass: ev.verifier.failToPass,
+                passToPass: ev.verifier.passToPass,
+                evalSemanticsVersion: ev.verifier.evalSemanticsVersion,
+            },
+        },
+        steps: [
+            {
+                spanId: 'patch',
+                parentSpanId: null,
+                kind: 'jinn.tool_call',
+                name: 'tool:apply_patch',
+                startTimeUnixNano: nano,
+                endTimeUnixNano: nano,
+                attributes: { patch: ev.patch },
+                redactedKeys: [],
+            },
+            ...historySteps,
+            {
+                spanId: 'verdict',
+                parentSpanId: null,
+                kind: 'jinn.tool_call',
+                name: 'evaluator:verdict',
+                startTimeUnixNano: nano,
+                endTimeUnixNano: nano,
+                attributes: { evaluatorVerdict: isPass ? 'PASS' : 'FAIL', actualPassed: isPass },
+                redactedKeys: [],
+            },
+        ],
+        outcome: isPass
+            ? { status: 'completed', verifiabilityTier: 'evaluator-verified' }
+            : {
+                status: 'failed',
+                verifiabilityTier: 'evaluator-verified',
+                summary: 'evaluator-confirmed failure (lesson-eligible)',
+            },
+        cost: { durationMs: 0 },
+        attemptGroup: {
+            groupId: instanceId,
+            attemptId: ref.requestId,
+            relatedAttemptRefs: [
+                ev.verdictEnvelopeCid,
+                ev.solutionEnvelopeCid,
+                ev.rawSnapshotRef,
+            ].filter((value) => value !== undefined),
+        },
+        ...(ev.solutionEnvelopeCid
+            ? { lineage: { episodeId: ev.solutionEnvelopeCid } }
+            : {}),
+        provenance: 'derived-from-history',
+    };
+}
+/**
+ * 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 async function bridgeAttempts(refs, deps) {
+    const now = deps.now?.() ?? new Date();
+    // Derive the slate repos for axis-2 exclusion, and surface any slate id whose
+    // repo cannot be derived — repo-exclusion is incomplete for those (see
+    // BridgeResult.unresolvedSlateIds), rather than silently narrowing the guard.
+    const slateRepos = new Set();
+    const unresolvedSlateIds = [];
+    for (const id of deps.slateInstanceIds) {
+        const r = repoFromInstanceId(id);
+        if (r)
+            slateRepos.add(r);
+        else
+            unresolvedSlateIds.push(id);
+    }
+    const result = { bridged: [], excludedHeldOut: [], deduped: [], errors: [], unresolvedSlateIds };
+    // Retain up to `groupCap` attempts per (instance_id, polarity) — keep the whole
+    // attempt group, not one exemplar (#1478). Kept-K is deterministic (refs arrive
+    // in a stable order); rows beyond the cap are recorded in `deduped`.
+    const groupCap = Math.max(1, deps.groupCap ?? 1);
+    const kept = new Map();
+    const manifestCandidates = [];
+    for (const ref of refs) {
+        const candidates = ref.discoveryCandidates?.length
+            ? ref.discoveryCandidates
+            : [{
+                    instanceId: ref.instanceId,
+                    verdictManifestCid: ref.verdictManifestCid ?? '',
+                }];
+        let selected;
+        let lastError;
+        for (const candidate of candidates) {
+            const candidateRef = {
+                ...ref,
+                instanceId: candidate.instanceId,
+                verdictManifestCid: candidate.verdictManifestCid,
+                discoveryCandidates: undefined,
+            };
+            try {
+                const ev = await deps.fetchEvidence(candidateRef);
+                assertAuthenticatedBridgeEvidence(candidateRef, ev);
+                selected = { ref: candidateRef, evidence: ev };
+                break;
+            }
+            catch (err) {
+                lastError = err;
+            }
+        }
+        // Candidate-level misses are intentionally suppressed when a later
+        // projection reaches the authenticated task. Surface one error only when
+        // the entire bounded candidate set fails.
+        if (!selected) {
+            result.errors.push({
+                requestId: ref.requestId,
+                error: lastError instanceof Error ? lastError.message : String(lastError),
+            });
+            continue;
+        }
+        const ev = selected.evidence;
+        const instanceId = ev.instanceId;
+        const canonicalRef = {
+            ...selected.ref,
+            instanceId,
+            repo: ev.repo,
+            baseCommit: ev.baseCommit,
+        };
+        if (deps.weakSuiteInstanceIds?.has(instanceId)) {
+            result.excludedHeldOut.push({ instanceId, reason: 'instance_id' });
+            continue;
+        }
+        if (deps.lookupFlaggedInstanceIds?.has(instanceId)) {
+            result.deduped.push({ instanceId, polarity: ref.polarity });
+            continue;
+        }
+        if (deps.slateInstanceIds.has(instanceId)) {
+            result.excludedHeldOut.push({ instanceId, reason: 'instance_id' });
+            continue;
+        }
+        if (slateRepos.has(ev.repo)) {
+            result.excludedHeldOut.push({ instanceId, reason: 'repo' });
+            continue;
+        }
+        const key = `${instanceId}:${ref.polarity}`;
+        if ((kept.get(key) ?? 0) >= groupCap) {
+            result.deduped.push({ instanceId, polarity: ref.polarity });
+            continue;
+        }
+        try {
+            const task = toBridgeCapturedTask(canonicalRef, ev, now);
+            if (deps.anchorMode === 'manifest') {
+                kept.set(key, (kept.get(key) ?? 0) + 1);
+                manifestCandidates.push({ task, ref: canonicalRef });
+                continue;
+            }
+            const pub = await deps.publishEvidence(task, canonicalRef);
+            // Count only SUCCESSFUL bridges toward the cap. Publication failures are
+            // surfaced once and never retried through another discovery projection:
+            // a failed publish may already have external side effects.
+            kept.set(key, (kept.get(key) ?? 0) + 1);
+            result.bridged.push({
+                instanceId,
+                polarity: ref.polarity,
+                envelopeRef: pub.envelopeRef,
+                anchorTx: pub.anchorTx,
+            });
+        }
+        catch (err) {
+            result.errors.push({
+                requestId: ref.requestId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    if (deps.anchorMode === 'manifest' && manifestCandidates.length > 0) {
+        const observations = [];
+        const addCompleted = (batches, candidateOffset) => {
+            let cursor = candidateOffset;
+            for (const batch of batches) {
+                observations.push({ ...batch, confirmed: true });
+                for (const memberRef of batch.memberRefs) {
+                    const candidate = manifestCandidates[cursor];
+                    if (!candidate) {
+                        throw new Error('manifest publisher returned more member refs than candidates');
+                    }
+                    result.bridged.push({
+                        instanceId: candidate.ref.instanceId,
+                        polarity: candidate.ref.polarity,
+                        envelopeRef: memberRef,
+                        anchorTx: batch.anchorTx,
+                    });
+                    cursor += 1;
+                }
+            }
+            return cursor;
+        };
+        const addFailedObservation = (error) => {
+            if (error instanceof ManifestBatchRecordingError) {
+                observations.push({ ...error.result, confirmed: true });
+            }
+            else if (error instanceof ManifestBatchAnchorError) {
+                observations.push({
+                    manifestCid: error.manifestCid,
+                    memberRefs: [...error.memberRefs],
+                    root: error.root,
+                    anchorTx: error.txHash,
+                    gasUsed: null,
+                    feeWei: null,
+                    confirmed: false,
+                });
+            }
+        };
+        const finishManifestFacts = (memberRefs) => {
+            result.manifestMemberRefs = [...memberRefs];
+            if (observations.length > 0) {
+                result.manifestBatches = observations;
+                const batchKey = observations.find((batch) => batch.batchKey)?.batchKey;
+                if (batchKey)
+                    result.manifestBatchKey = batchKey;
+                result.control = observations.find((batch) => batch.control)?.control;
+            }
+            if (observations.length === 1) {
+                const only = observations[0];
+                result.manifestCid = only.manifestCid;
+                result.anchorTx = only.anchorTx;
+                result.gasUsed = only.gasUsed;
+                result.feeWei = only.feeWei;
+                result.manifestConfirmed = only.confirmed;
+            }
+        };
+        try {
+            if (!deps.publishManifestBatch) {
+                throw new Error('manifest anchor mode requires publishManifestBatch');
+            }
+            const publication = await deps.publishManifestBatch(manifestCandidates);
+            const flattened = publication.batches.flatMap((batch) => batch.memberRefs);
+            if (publication.memberRefs.length !== manifestCandidates.length ||
+                flattened.length !== publication.memberRefs.length ||
+                flattened.some((ref, index) => ref !== publication.memberRefs[index])) {
+                throw new Error(`manifest publisher returned an inconsistent ${publication.memberRefs.length}-member partition set for ${manifestCandidates.length} candidates`);
+            }
+            addCompleted(publication.batches, 0);
+            finishManifestFacts(publication.memberRefs);
+        }
+        catch (error) {
+            let completedCount = 0;
+            let failed = error;
+            let memberRefs = [];
+            if (error instanceof ManifestBatchSetError) {
+                completedCount = addCompleted(error.completed, 0);
+                failed = error.failed;
+                memberRefs = [...error.memberRefs];
+                if (error.batchKey)
+                    result.manifestBatchKey = error.batchKey;
+                addFailedObservation(failed);
+            }
+            else if (error instanceof ManifestBatchRecordingError) {
+                memberRefs = [...error.result.memberRefs];
+                if (error.batchKey)
+                    result.manifestBatchKey = error.batchKey;
+                addFailedObservation(error);
+            }
+            else if (error instanceof ManifestBatchAnchorError) {
+                memberRefs = [...error.memberRefs];
+                if (error.batchKey)
+                    result.manifestBatchKey = error.batchKey;
+                addFailedObservation(error);
+            }
+            else if (error instanceof ManifestBatchPreparationError) {
+                memberRefs = [...error.memberRefs];
+                if (error.batchKey)
+                    result.manifestBatchKey = error.batchKey;
+            }
+            if (memberRefs.length > 0)
+                finishManifestFacts(memberRefs);
+            const message = failed instanceof Error ? failed.message : String(failed);
+            for (const { ref } of manifestCandidates.slice(completedCount)) {
+                result.errors.push({ requestId: ref.requestId, error: message });
+            }
+        }
+    }
+    return result;
+}
+/**
+ * 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 function buildBridgeEvidencePublisher(deps, opts = {}) {
+    const pipeline = opts.pipeline ?? buildLayer2ScrubPipeline();
+    return async (task) => {
+        const pending = await capture(task, { pipeline });
+        const published = await publish(pending, deps);
+        if (published.vetoed)
+            throw new Error('unexpected veto bridging evidence');
+        return { envelopeRef: published.envelopeRef, anchorTx: published.anchorTx };
+    };
+}
+/**
+ * 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 function buildBridgeManifestPublisher(deps, opts = {}) {
+    const pipeline = opts.pipeline ?? buildLayer2ScrubPipeline();
+    return async (candidates) => {
+        const members = [];
+        for (const { task, ref } of candidates) {
+            const pending = await capture(task, { pipeline });
+            opts.onCaptured?.(pending, { task, ref });
+            members.push({
+                pending,
+                polarity: ref.polarity,
+                instanceId: ref.instanceId,
+                sourceId: ref.requestId,
+            });
+        }
+        return publishPendingManifestBatch(members, deps, {
+            batchKind: 'bridge',
+            ...(opts.measurePerRecordControl ? { measurePerRecordControl: true } : {}),
+        });
+    };
+}

package/dist/capture.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Harness-layer capture path — the privacy surface (spec §5).
+ *
+ * `capture(task, opts)` runs a captured task through the mandatory scrub
+ * pipeline and returns a `PendingEnvelope`: the captured-but-not-yet-consented
+ * state. Per the 2026-07-02 schema review, consent flags on `TraceEnvelopeV0`
+ * are literal `true`, so the pre-consent state cannot BE a `TraceEnvelopeV0` —
+ * the pending wrapper converts to one only at consent (preview renders the
+ * would-be envelope; the Task 4 publish path performs the real conversion).
+ *
+ * Fail-closed: any scrub-stage failure throws `CaptureScrubError` — no
+ * envelope, no partial output, never a silent pass.
+ *
+ * Scrub pipeline: reuses the seller-side pipeline from
+ * `@jinn-network/core/scrub` (key-policy → openredaction →
+ * plain-patterns → secretlint → optional ML PII) via `scrubCaptureSpans()`.
+ * The email/home-path gap-closers this file originally carried graduated
+ * into the shared plain-patterns stage (#1330), so the daemon publish path
+ * and this capture path share one implementation.
+ *
+ * Fitting rule (docs/envelope-v0.md): the conversion MUST produce envelopes
+ * inside the frozen caps. Over-long sessions are head/tail-sampled to
+ * `MAX_STEPS` (never dropped); oversized step attributes are truncated with
+ * the cut keys listed in the step's `truncatedKeys` receipt (never silent —
+ * both surface in the `ScrubReport`).
+ *
+ * Plan: docs/superpowers/plans/2026-07-02-jinn-harness-network-v0-plan.md
+ * Task 3 (issue #1310).
+ */
+import { ScrubPipeline, type KeyPolicy, type PiiDetector } from '@jinn-network/core/scrub';
+import { type TraceEnvelopeV0 } from './envelope.js';
+export { CapturedTaskSchema, parseCapturedTask, type CapturedTask } from '@jinn-network/core';
+import { type CapturedTask } from '@jinn-network/core';
+/**
+ * One entry in the redaction diff. `before` is the original (sensitive)
+ * value: it exists so the operator can audit locally what was removed, and
+ * it must NEVER be persisted or published — display-only.
+ */
+export interface ScrubRedaction {
+    /** Where in the envelope, e.g. `steps[2].attributes["llm.prompt"]`. */
+    field: string;
+    /** Scrub-pipeline stage (`key-policy`, `openredaction`, `secretlint`, …) or `fit`. */
+    stage: string;
+    /** Rule / entity detail when the stage reports one (e.g. `AWS_ACCESS_KEY`). */
+    detail?: string;
+    /** Original value — local display only, never persisted. */
+    before?: unknown;
+    /** Published value; `undefined` when the field was dropped entirely. */
+    after: unknown;
+}
+export declare const PENDING_ENVELOPE_KIND: "jinn.pending-envelope.v0";
+/**
+ * The captured-but-not-yet-consented state. Not a `TraceEnvelopeV0` (the
+ * envelope's consent flags are literal `true`, so an unconsented envelope is
+ * not constructible); it becomes one only at consent — `preview()` renders
+ * the would-be envelope, the Task 4 publish path performs the conversion for
+ * real. Only `capture()` constructs this type; `redactions[].before` values
+ * live in memory for the local preview and must never be written anywhere.
+ */
+export interface PendingEnvelope {
+    kind: typeof PENDING_ENVELOPE_KIND;
+    /** Every TraceEnvelopeV0 field except `consent`, scrubbed and fitted. */
+    draft: Omit<TraceEnvelopeV0, 'consent'>;
+    /** Canonical Episode-only facts that the frozen trace draft cannot carry. */
+    episodeFacts: {
+        session: Pick<CapturedTask['session'], 'kind' | 'parentSessionId'>;
+        task: Pick<CapturedTask['task'], 'repositorySlug' | 'baseCommit' | 'createdAt' | 'instanceId'>;
+        environment: Pick<CapturedTask['environment'], 'skillsLoadout' | 'generatorModel' | 'distributionClass' | 'verifier'>;
+        trajectoryKinds: Array<CapturedTask['steps'][number]['kind']>;
+        trajectoryObservations?: Array<Pick<CapturedTask['steps'][number], 'events' | 'status'>>;
+        attemptGroup?: CapturedTask['attemptGroup'];
+        lineage?: CapturedTask['lineage'];
+    };
+    /** The redaction diff for the local preview. NEVER persisted. */
+    redactions: ScrubRedaction[];
+}
+export interface CaptureOptions {
+    /** Key policy for the base pipeline. Default: DEFAULT_KEY_POLICY. */
+    policy?: KeyPolicy;
+    /** When provided, the base pipeline gains the ML PII (GLiNER) stage. */
+    piiDetector?: PiiDetector;
+    /**
+     * Injectable base pipeline. Production consumer: seed import passes
+     * buildSeedScrubPipeline() (#1409); also used by tests. Overrides
+     * policy/piiDetector.
+     */
+    pipeline?: ScrubPipeline;
+}
+/** A scrub-stage failure. capture() is fail-closed: no envelope was produced. */
+export declare class CaptureScrubError extends Error {
+    constructor(cause: unknown);
+}
+/**
+ * Run the captured task through the scrub pipeline and the fitting rule and
+ * return the pending (pre-consent) envelope plus its redaction diff.
+ * Fail-closed: throws `CaptureScrubError` on any scrub-stage failure.
+ */
+export declare function capture(task: CapturedTask, opts?: CaptureOptions): Promise<PendingEnvelope>;