@jinn-network/jinn-layer 0.1.0

package/dist/snapshot-transcript.js

@@ -0,0 +1,117 @@
+/**
+ * system_snapshot extraction — donation unwrap + ustar read + transcript
+ * lookup (issue #1472, spec §8).
+ *
+ * The engine tars each solve's working dir into a `system_snapshot` artifact
+ * (hand-rolled POSIX ustar + gzip, `client/src/harnesses/engine/packaging.ts`
+ * `createWorkdirTarball`) and publishes it donation-wrapped
+ * (`jinn.artifact.donation.v1`: JSON with base64 `data`). Inside is the
+ * harness's raw stdout transcript (`.claude-code/stdout.jsonl`,
+ * `.codex-code/stdout.jsonl`) — the solve's actual reasoning, which
+ * `jinn.trajectory.v1` does NOT carry (2 artifact.emit spans only; #1473
+ * tracks fixing that at solve time).
+ *
+ * `unwrapDonation` mirrors the module-private `decodeDonationArtifact`
+ * (`@jinn-network/core/corpus-read`) and additionally verifies the decoded
+ * bytes hash to the declared sha256 (tamper check). The ustar reader mirrors
+ * the writer: regular files only, names ≤100 chars, no PAX/GNU extensions —
+ * a malformed header ends iteration rather than throwing. Decompression is
+ * bomb-guarded via zlib's `maxOutputLength`.
+ */
+import { createHash } from 'node:crypto';
+import { gunzipSync } from 'node:zlib';
+import { ClaudeCodeStreamJsonParser, CodexExecJsonParser, } from '@jinn-network/core/trajectory';
+const DONATION_ENCODING = 'jinn.artifact.donation.v1';
+/** Gzip-bomb guard: snapshots observed live are ≤ ~300 KB compressed. */
+export const MAX_SNAPSHOT_DECOMPRESSED_BYTES = 32 * 1024 * 1024;
+/** Transcript locations the learner adapters write under the workingDir. */
+const TRANSCRIPT_PATHS = [
+    { suffix: '.claude-code/stdout.jsonl', harness: 'claude-code' },
+    { suffix: '.codex-code/stdout.jsonl', harness: 'codex' },
+    // .hermes-agent/stdout.log is a ~1KB plain-text log — no decision path; skipped.
+];
+/**
+ * Decode a `jinn.artifact.donation.v1` wrapper to its raw bytes. Throws on a
+ * non-donation shape, a declared-sha mismatch against `expectedSha256`, or
+ * decoded bytes that do not hash to the declared sha (tamper check — parity
+ * plus-one with corpus/acquire.ts `decodeDonationArtifact`).
+ */
+export function unwrapDonation(raw, expectedSha256) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new Error('donation artifact payload is not an object');
+    }
+    const record = raw;
+    if (record['schemaVersion'] !== DONATION_ENCODING || record['encoding'] !== DONATION_ENCODING) {
+        throw new Error('donation artifact payload has unexpected encoding');
+    }
+    if (record['sha256'] !== expectedSha256) {
+        throw new Error('donation artifact sha256 does not match requested artifact');
+    }
+    if (typeof record['data'] !== 'string') {
+        throw new Error('donation artifact payload is missing base64 data');
+    }
+    const bytes = Buffer.from(record['data'], 'base64');
+    const computed = createHash('sha256').update(bytes).digest('hex');
+    if (computed !== expectedSha256) {
+        throw new Error('donation artifact bytes do not hash to the declared sha256');
+    }
+    return bytes;
+}
+/**
+ * Gunzip (bomb-guarded) + read a POSIX ustar archive into entries. Regular
+ * files only; a malformed/truncated header or size field ends iteration
+ * (best-effort read of what is intact, never an infinite loop).
+ */
+export function untarGz(tarGz) {
+    const tar = gunzipSync(tarGz, { maxOutputLength: MAX_SNAPSHOT_DECOMPRESSED_BYTES });
+    const entries = [];
+    let off = 0;
+    while (off + 512 <= tar.length) {
+        const name = tar.subarray(off, off + 100).toString('utf8').replace(/\0.*$/, '');
+        if (!name)
+            break; // end-of-archive zero block
+        const sizeField = tar
+            .subarray(off + 124, off + 136)
+            .toString('utf8')
+            .replace(/\0.*$/, '')
+            .trim();
+        const size = parseInt(sizeField, 8);
+        if (!Number.isFinite(size) || size < 0)
+            break; // malformed header — stop
+        const typeflag = String.fromCharCode(tar[off + 156] ?? 48);
+        const bodyStart = off + 512;
+        const bodyEnd = bodyStart + size;
+        if (bodyEnd > tar.length)
+            break; // truncated body — stop
+        if (typeflag === '0' || typeflag === '\0') {
+            entries.push({ name, bytes: tar.subarray(bodyStart, bodyEnd) });
+        }
+        off = bodyStart + Math.ceil(size / 512) * 512;
+    }
+    return entries;
+}
+/** Locate the solve transcript among snapshot entries, or null if absent. */
+export function findSolveTranscript(entries) {
+    for (const { suffix, harness } of TRANSCRIPT_PATHS) {
+        const entry = entries.find((e) => e.name === suffix || e.name.endsWith(`/${suffix}`));
+        if (entry)
+            return { harness, jsonl: entry.bytes.toString('utf8') };
+    }
+    return null;
+}
+/**
+ * End-to-end: donation wrapper JSON → the solve transcript, or null when the
+ * snapshot carries none (hermes, or transcript-less). Throws on unwrap /
+ * decompression failures — the caller treats any throw as "no enrichment".
+ */
+export function extractSnapshotTranscript(wrapper, expectedSha256) {
+    const bytes = unwrapDonation(wrapper, expectedSha256);
+    return findSolveTranscript(untarGz(bytes));
+}
+/** Parse snapshot stdout with the same canonical typed-span parser as the live path. */
+export function parseSolveTranscript(transcript) {
+    const parser = transcript.harness === 'claude-code'
+        ? new ClaudeCodeStreamJsonParser()
+        : new CodexExecJsonParser();
+    return parser.parseText(transcript.jsonl);
+}

package/dist/three-arm-run.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Three-arm measurement runner (spec/2026-07-06-distillation-v1.md §11).
+ *
+ * Orchestrates the §11 run: for each arm — seeds-only (control), raw-evidence
+ * (the D11 product baseline), distilled — run the held-out slate under that
+ * arm's pre-installed corpus snapshot, collect per-instance pass/fail + cost,
+ * then hand all three to `threeArmMeasurement` for the gate + pilot verdict.
+ *
+ * The per-arm RUN is an injected port (`runArm`). Its production implementation
+ * is the **capability-eval rig (#1416)** — pre-install a content-addressed corpus
+ * snapshot, run the swe-rebench-v2 slate under it, grade in Docker. That rig is a
+ * follow-on; keeping it a port means this orchestration is correct and tested now
+ * and the real runner drops in unchanged. Arms run **sequentially by default** to
+ * bound disk/inference; each is expensive.
+ */
+import { type ArmResult, type ThreeArmResult } from './measurement.js';
+export type ArmName = 'seedsOnly' | 'rawEvidence' | 'distilled';
+export interface ThreeArmRunDeps {
+    /** Run the held-out slate under an arm's pre-installed loadout → per-instance results. */
+    runArm: (arm: ArmName) => Promise<ArmResult[]>;
+    alpha?: number;
+    costMargin?: number;
+    /** Run arms concurrently (default false — arms are disk/inference-heavy, so serialize). */
+    parallel?: boolean;
+    log?: (msg: string) => void;
+}
+export declare function runThreeArm(deps: ThreeArmRunDeps): Promise<ThreeArmResult>;

package/dist/three-arm-run.js

@@ -0,0 +1,41 @@
+/**
+ * Three-arm measurement runner (spec/2026-07-06-distillation-v1.md §11).
+ *
+ * Orchestrates the §11 run: for each arm — seeds-only (control), raw-evidence
+ * (the D11 product baseline), distilled — run the held-out slate under that
+ * arm's pre-installed corpus snapshot, collect per-instance pass/fail + cost,
+ * then hand all three to `threeArmMeasurement` for the gate + pilot verdict.
+ *
+ * The per-arm RUN is an injected port (`runArm`). Its production implementation
+ * is the **capability-eval rig (#1416)** — pre-install a content-addressed corpus
+ * snapshot, run the swe-rebench-v2 slate under it, grade in Docker. That rig is a
+ * follow-on; keeping it a port means this orchestration is correct and tested now
+ * and the real runner drops in unchanged. Arms run **sequentially by default** to
+ * bound disk/inference; each is expensive.
+ */
+import { threeArmMeasurement } from './measurement.js';
+const ARMS = ['seedsOnly', 'rawEvidence', 'distilled'];
+export async function runThreeArm(deps) {
+    const log = deps.log ?? (() => { });
+    let seedsOnly;
+    let rawEvidence;
+    let distilled;
+    if (deps.parallel) {
+        log('running three arms concurrently');
+        [seedsOnly, rawEvidence, distilled] = await Promise.all(ARMS.map((a) => deps.runArm(a)));
+    }
+    else {
+        const out = {};
+        for (const arm of ARMS) {
+            log(`running arm: ${arm}`);
+            out[arm] = await deps.runArm(arm);
+        }
+        seedsOnly = out.seedsOnly;
+        rawEvidence = out.rawEvidence;
+        distilled = out.distilled;
+    }
+    return threeArmMeasurement({ seedsOnly, rawEvidence, distilled }, {
+        ...(deps.alpha !== undefined ? { alpha: deps.alpha } : {}),
+        ...(deps.costMargin !== undefined ? { costMargin: deps.costMargin } : {}),
+    });
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@jinn-network/jinn-layer",
+  "version": "0.1.0",
+  "description": "Standalone Jinn plugin process layer: host contract, local evidence, corpus reads, distillation, and seed import.",
+  "type": "module",
+  "packageManager": "yarn@4.13.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Jinn-Network/mono.git",
+    "directory": "packages/layer"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "bin": {
+    "jinn-distill-mcp": "./dist/bin/jinn-distill-mcp.js",
+    "jinn-layer": "./dist/bin/jinn-layer.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "pack:smoke": "node scripts/pack-smoke.mjs",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@jinn-network/core": "0.1.0",
+    "@jinn-network/plugin": "0.1.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "better-sqlite3": "^12.10.0",
+    "canonicalize": "^3.0.0",
+    "viem": "^2.0.0",
+    "yaml": "^2.8.4",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/node": "^26.1.0",
+    "typescript": "^5.4.0",
+    "vitest": "^4.1.8"
+  },
+  "resolutions": {
+    "@jinn-network/core": "portal:../core",
+    "@jinn-network/plugin": "portal:../plugin"
+  }
+}