@jinn-network/jinn-layer 0.1.0

package/dist/bin/jinn-layer.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * jinn-layer CLI entry. Delegates to cli.ts.
+ *
+ * Run from an installed package: `jinn-layer corpus search "<query>"`.
+ */
+export {};

package/dist/bin/jinn-layer.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * jinn-layer CLI entry. Delegates to cli.ts.
+ *
+ * Run from an installed package: `jinn-layer corpus search "<query>"`.
+ */
+import { runJinnLayerCli } from '../cli.js';
+runJinnLayerCli(process.argv.slice(2))
+    .then((code) => {
+    process.exitCode = code;
+})
+    .catch((err) => {
+    console.error(`[jinn-layer] ${err instanceof Error ? err.message : String(err)}`);
+    process.exitCode = 1;
+});

package/dist/bridge-fetch-evidence.d.ts

@@ -0,0 +1,102 @@
+/**
+ * The bridge's `fetchEvidence` adapter (spec/2026-07-06-distillation-v1.md §8, D5).
+ *
+ * Implements the VERIFIED verdict→solution join that reaches
+ * the SOLVER's coding patch — the reference implementation is `fetchEvidence` in
+ * client/scripts/distill-run-live.ts:
+ *
+ *   verdict(ref.requestId, ref.chainId) → authoritative (taskId, attemptIndex, evaluator)
+ *     + bounded verdictEnvelopeMeta candidates → historical publisher,
+ *       participant, signed-hash, request, and polarity binding
+ *     → authenticated evaluation wrapper → signed original task CID
+ *     → TaskCreated task-CID / creator / manifest commitments
+ *     → authenticated original task (description + verifier facts)
+ *     → attempt(taskId, attemptIndex, chainId) → the SOLVE request
+ *     → bounded attemptEnvelopeMeta candidates → publisher + signed-hash binding
+ *     → authenticated solution envelope (IPFS) → .payload.patch (the coding diff)
+ *   problem statement = authenticated original task description
+ *   typed history (hop 4, best-effort, #1472/#1473) = the solution's system_snapshot
+ *     artifact → donation unwrap → gunzip+untar → the harness stdout
+ *     transcript → canonical core stream parser → typed trajectory spans
+ *
+ * The predecessor selected the solution with the task document's mutable
+ * `restorationRequestId`. That allowed an otherwise-valid signed task to be
+ * relabelled onto another solution. The selection path now comes exclusively
+ * from chain-indexed verdict + attempt rows. Any outer task copy is only a
+ * consistency assertion and can never select the patch.
+ *
+ * All I/O and authentication boundaries are injected ports so this stays
+ * unit-testable. Production uses the Autonolas gateway, Ponder GraphQL,
+ * canonical envelope verification, and an IdentityRegistry wallet read; tests
+ * inject fakes. The returned function is directly usable as
+ * `BridgeDeps.fetchEvidence`.
+ */
+import { type AttemptRef, type BridgeEvidence } from './bridge.js';
+export interface AuthenticatedExecutionEnvelope {
+    solverType: string;
+    role: 'solution' | 'verdict' | 'capture' | 'restoration';
+    task?: unknown;
+    participant: {
+        safeAddress: string;
+        agentEoa: string;
+    };
+    signature: {
+        hash: string;
+        signer: string;
+        sig: string;
+        algo: string;
+    };
+    payload: Record<string, unknown>;
+    executor?: unknown;
+    artifacts?: unknown[];
+    distributionClass?: 'open' | 'restricted-tos' | 'unknown';
+}
+export type ExecutionEnvelopeAuthenticator = (value: unknown, sourceName: string) => Promise<AuthenticatedExecutionEnvelope>;
+export type PublisherSafeResolver = (chainId: number, publisherAgentId: string, publishedAtBlock: bigint) => Promise<string>;
+export interface AuthenticatedTaskProvenance {
+    solverType: string;
+    instanceId: string;
+    repo: string;
+    baseCommit: string;
+    createdAt: number;
+    originalTaskCid: string;
+    creatorSafe: string;
+    manifestDigest: string;
+    description: string;
+}
+export interface AuthoritativeTaskBinding {
+    taskId: string;
+    chainId: number;
+    taskCidDigest: string;
+    manifestDigest: string;
+    creatorSafe: string;
+    evaluatorSafe: string;
+}
+export interface VerifierFacts {
+    failToPass: string[];
+    passToPass: string[];
+    evalSemanticsVersion: string;
+    task: AuthenticatedTaskProvenance;
+}
+export type VerifierFactsResolver = (taskDoc: unknown, expectedInstanceId: string, authority: AuthoritativeTaskBinding) => Promise<unknown>;
+export interface EvidenceFetcherPorts {
+    /**
+     * Fetch + JSON-parse an IPFS object by CID (autonolas gateway in production).
+     * Callers that authenticate smaller artifacts may request a tighter ceiling.
+     */
+    ipfs: (cid: string, maxBytes?: number) => Promise<any>;
+    /** Run a GraphQL query against the Ponder indexer, returning `data`. */
+    gql: (query: string, variables?: Record<string, unknown>) => Promise<any>;
+    /** Parse and cryptographically authenticate one raw execution envelope. */
+    authenticateEnvelope: ExecutionEnvelopeAuthenticator;
+    /** Resolve the Safe owned by an ERC-8004 publisher agent at the event block. */
+    resolvePublisherSafe: PublisherSafeResolver;
+    /** Resolve one atomic, authenticated verifier proof for an identified SWE task. */
+    resolveVerifierFacts?: VerifierFactsResolver;
+}
+/**
+ * Build the bridge's `fetchEvidence`. Consumes injected `ipfs` / `gql` ports
+ * (fakes in tests; a gateway + indexer in production). Throws a clear error at
+ * each missing hop so a per-instance miss is diagnosable and skipped, not silent.
+ */
+export declare function createEvidenceFetcher(ports: EvidenceFetcherPorts): (ref: AttemptRef) => Promise<BridgeEvidence>;