@jinn-network/client 0.1.5 → 0.1.6-canary.0b4ff7f9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jinn-network/client",
-  "version": "0.1.5",
+  "version": "0.1.6-canary.0b4ff7f9",
   "description": "Jinn protocol client — headless daemon for the restoration training loop",
   "type": "module",
   "packageManager": "yarn@4.13.0",
@@ -40,11 +40,12 @@
   },
   "scripts": {
     "postinstall": "node dist/scripts/fix-node-pty.mjs 2>/dev/null || node scripts/fix-node-pty.mjs 2>/dev/null || true",
-    "e2e:full-cycle": "tsx test/e2e/claude-code-learner-full-cycle.ts",
+    "e2e:cold-start-builder": "vitest run --config vitest.acceptance.config.ts",
+    "e2e:full-cycle": "tsx test/e2e/learner-full-cycle.ts",
     "jinn": "tsx src/bin/jinn.ts",
     "dev": "yarn build && node dist/bin/jinn.js",
     "build:sdk": "yarn --cwd ../packages/sdk install --immutable && yarn --cwd ../packages/sdk build",
-    "build": "yarn build:sdk && yarn build:spa && tsc && chmod +x dist/bin/jinn.js && rm -rf dist/dashboard && mkdir -p dist/dashboard && cp -R src/dashboard/spa/dist/. dist/dashboard/ && rm -rf dist/templates && cp -R templates dist/templates && mkdir -p dist/scripts && cp scripts/fix-node-pty.mjs dist/scripts/ && node scripts/vendor-sdk.mjs && node scripts/write-dist-build-meta.mjs",
+    "build": "yarn build:sdk && yarn build:spa && tsc && chmod +x dist/bin/jinn.js && rm -rf dist/dashboard && mkdir -p dist/dashboard && cp -R src/dashboard/spa/dist/. dist/dashboard/ && rm -rf dist/templates && cp -R templates dist/templates && mkdir -p dist/scripts && cp scripts/fix-node-pty.mjs scripts/swe-rebench-v2-seed-pool.json scripts/swe-rebench-v2-known-bad.json dist/scripts/ && node scripts/vendor-sdk.mjs && node scripts/write-dist-build-meta.mjs",
     "typecheck": "yarn build:sdk && tsc --noEmit",
     "test": "yarn build:sdk && vitest run",
     "test:watch": "vitest",
@@ -68,9 +69,12 @@
     "e2e:task-first-local": "tsx test/e2e/task-first-local.ts",
     "e2e:claude-code-learner": "tsx test/e2e/claude-code-learner-portfolio-v0.ts",
     "e2e:prediction": "tsx test/e2e/prediction-v1.ts",
+    "e2e:corpus": "yarn build:sdk && tsx test/e2e/corpus-x402.ts",
     "e2e:freeze-mode": "tsx test/e2e/freeze-mode.test.ts",
     "e2e:checkpoint-flow": "tsx test/e2e/checkpoint-flow.test.ts",
     "e2e:swe-rebench-v2": "tsx test/e2e/swe-rebench-v2.test.ts",
+    "e2e:hermes": "tsx test/e2e/hermes-agent-full-cycle.ts",
+    "e2e:daemon-harness": "tsx test/e2e/daemon-harness-cycle.ts",
     "e2e:capture": "tsx scripts/e2e-capture-validate.ts",
     "staking": "tsx test/e2e/staking.ts",
     "stolas": "tsx test/e2e/stolas.ts",
@@ -118,6 +122,7 @@
     "semver": "^7.7.4",
     "viem": "^2.0.0",
     "ws": "^8.20.0",
+    "yaml": "^2.8.4",
     "zod": "^3.22.0"
   },
   "optionalDependencies": {

package/plugins/swe-rebench-v2-diffmin/.claude-plugin/plugin.json

@@ -0,0 +1,5 @@
+{
+  "name": "swe-rebench-v2-diffmin",
+  "version": "0.1.0",
+  "description": "Minimal-diff + test-mapping skills for swe-rebench-v2.v1."
+}

package/plugins/swe-rebench-v2-diffmin/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "diff-stats": {
+      "command": "node",
+      "args": ["${CLAUDE_PLUGIN_ROOT}/mcp/diff-stats-server.mjs"]
+    }
+  }
+}

package/plugins/swe-rebench-v2-diffmin/README.md

@@ -0,0 +1,69 @@
+# swe-rebench-v2-diffmin
+
+Minimal-diff discipline and PASS\_TO\_PASS test-mapping skills for the
+`swe-rebench-v2.v1` SolverNet. This plugin competes on a different vertical
+than `swe-rebench-v2-runtime`: where the runtime plugin teaches the solver to
+orient and plan, this plugin constrains how the solver patches — keeping diffs
+small, renames absent, and PASS\_TO\_PASS coverage explicit before the first
+line of code is written.
+
+## What the skills do
+
+- **`swe-rebench-v2-diffmin`** — Minimal-diff discipline. Heuristics: single-hunk
+  preference, single-file preference, no-rename rule, function-scope
+  containment, dead-code-deletion last resort. Includes a worked
+  `unidata/netcdf-c-1925` example. Uses the bundled `diff_stats` MCP tool
+  (`mcp__diff-stats__diff_stats`) to validate hunk count, file count, and
+  rename absence before submitting.
+
+- **`swe-rebench-v2-test-map`** — PASS\_TO\_PASS test mapping. Greps test names
+  to source files, computes test-to-source coverage ratios, pre-loads the call
+  graph for the function under fix. Produces an edit-constraint list before
+  the Execute phase begins.
+
+Both skills reference real SWE-rebench v2 mechanics (`FAIL_TO_PASS`,
+`PASS_TO_PASS`, `base_commit`, `instance_id`, `goal.spec`). They read like a
+Hermes-migrator can use them on day 1.
+
+## Already shipping a Hermes skill?
+
+Drop it under `skills/<name>/SKILL.md`, add a `jinn.plugin.json` like this
+one, `yarn pack`, `jinn solver-plugins publish`. Your existing skill becomes
+discoverable and attributable on the SolverNet — no other changes required.
+
+## Stacking with swe-rebench-v2-runtime
+
+The two plugins are designed to stack. An operator loads both and the solver
+gets the full set of skills:
+
+| Plugin | Skills |
+|--------|--------|
+| `swe-rebench-v2-runtime` | `supports: ["swe-rebench-v2.v1"]` — orient, plan |
+| `swe-rebench-v2-diffmin` | `supports: ["swe-rebench-v2.v1"]` — diffmin, test-map |
+
+The harness loads skills from all plugins that declare `swe-rebench-v2.v1`
+support. Adding this plugin alongside the runtime plugin gives the solver four
+complementary skills for a single task: orient → plan → test-map → diffmin.
+
+## Bundled MCP tool: diff_stats
+
+The `.mcp.json` in this package declares one MCP server, `diff-stats`, with one
+tool `diff_stats(patch: string)`. It parses a unified diff and returns:
+
+```json
+{
+  "hunks": 1,
+  "filesTouched": 1,
+  "addedLines": 3,
+  "removedLines": 2,
+  "hasRenames": false
+}
+```
+
+The diffmin skill calls this tool before submitting. The server is a ~50-line
+pure Node.js script with no runtime dependencies — it starts in under 50 ms
+and does not touch the network.
+
+## License
+
+MIT.

package/plugins/swe-rebench-v2-diffmin/jinn.plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "swe-rebench-v2-diffmin",
+  "version": "0.1.0",
+  "jinn": {
+    "supports": ["swe-rebench-v2.v1"],
+    "skills": [
+      "skills/diffmin/SKILL.md",
+      "skills/test-map/SKILL.md"
+    ],
+    "description": "Minimal-diff discipline + PASS_TO_PASS test-mapping skills for swe-rebench-v2.v1. Complementary to swe-rebench-v2-runtime's orient/plan skills; the two stack."
+  }
+}

package/plugins/swe-rebench-v2-diffmin/mcp/diff-stats-server.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+/**
+ * diff-stats MCP server — exposes one tool, diff_stats(patch: string),
+ * that parses a unified diff and returns hunk/line/file/rename statistics.
+ *
+ * Designed to be invoked as a stdio MCP server by Claude Code or any other
+ * MCP-compatible host. No runtime dependencies beyond @modelcontextprotocol/sdk
+ * (already present in @jinn-network/client's node_modules).
+ */
+import { pathToFileURL } from 'node:url';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { computeDiffStats } from './diff-stats.mjs';
+
+const DiffArgsShape = {
+  patch: z.string().min(1).describe(
+    'A unified diff string (git-format or standard format). ' +
+    'Pass the complete diff including --- and +++ headers and @@ hunk markers.',
+  ),
+};
+
+function ok(data) {
+  return {
+    content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+  };
+}
+
+function toolErr(code, message) {
+  return {
+    content: [{ type: 'text', text: JSON.stringify({ error: true, code, message }) }],
+    isError: true,
+  };
+}
+
+export function createDiffStatsServer() {
+  const server = new McpServer({ name: 'diff-stats', version: '0.1.0' });
+
+  server.tool(
+    'diff_stats',
+    'Parse a unified diff and return statistics: hunks, filesTouched, addedLines, removedLines, hasRenames. ' +
+    'Call this before submitting a patch to verify it meets minimal-diff discipline (hunks <= 3, filesTouched <= 2, hasRenames === false).',
+    DiffArgsShape,
+    async (args) => {
+      try {
+        const stats = computeDiffStats(args.patch);
+        return ok(stats);
+      } catch (err) {
+        return toolErr('DIFF_PARSE_FAILED', err instanceof Error ? err.message : String(err));
+      }
+    },
+  );
+
+  return server;
+}
+
+export async function startMcpServer() {
+  const server = createDiffStatsServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  await new Promise((resolve) => {
+    process.stdin.on('close', resolve);
+    process.stdin.on('end', resolve);
+  });
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  startMcpServer().catch((err) => {
+    console.error(err instanceof Error ? err.stack ?? err.message : String(err));
+    process.exit(1);
+  });
+}

package/plugins/swe-rebench-v2-diffmin/mcp/diff-stats.mjs

@@ -0,0 +1,48 @@
+/**
+ * diff-stats library — parse a unified diff into per-file statistics.
+ *
+ * Pure function, no dependencies. Usable directly in tests and by the
+ * diff-stats-server.mjs MCP server.
+ */
+
+/**
+ * @typedef {{ hunks: number; filesTouched: number; addedLines: number; removedLines: number; hasRenames: boolean }} DiffStats
+ */
+
+/**
+ * Parse a unified diff string and return statistics.
+ *
+ * @param {string} patch - A unified diff string (git-format or standard format).
+ * @returns {DiffStats}
+ * @throws {Error} if patch is empty.
+ */
+export function computeDiffStats(patch) {
+  if (typeof patch !== 'string' || patch.trim().length === 0) {
+    throw new Error('empty patch — pass a unified diff string');
+  }
+
+  const lines = patch.split('\n');
+  let hunks = 0;
+  let addedLines = 0;
+  let removedLines = 0;
+  let hasRenames = false;
+  const files = new Set();
+
+  for (const line of lines) {
+    if (line.startsWith('@@ ')) {
+      hunks++;
+    } else if (line.startsWith('+++') && !line.startsWith('+++ /dev/null')) {
+      // Match both `+++ b/path` (git format) and `+++ path` (standard format)
+      const m = /^\+{3}\s+(?:b\/)?(.+)$/.exec(line);
+      if (m) files.add(m[1].trim());
+    } else if (line.startsWith('rename from ') || line.startsWith('rename to ')) {
+      hasRenames = true;
+    } else if (line.startsWith('+') && !line.startsWith('+++')) {
+      addedLines++;
+    } else if (line.startsWith('-') && !line.startsWith('---')) {
+      removedLines++;
+    }
+  }
+
+  return { hunks, filesTouched: files.size, addedLines, removedLines, hasRenames };
+}

package/plugins/swe-rebench-v2-diffmin/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "swe-rebench-v2-diffmin",
+  "version": "0.1.0",
+  "type": "module",
+  "private": true,
+  "description": "Reference competing plug-in for swe-rebench-v2.v1 — minimal-diff + test-mapping angle.",
+  "files": [
+    "jinn.plugin.json",
+    ".claude-plugin/",
+    ".mcp.json",
+    "skills/",
+    "mcp/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "vitest run"
+  },
+  "license": "MIT"
+}

package/plugins/swe-rebench-v2-diffmin/skills/diffmin/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: swe-rebench-v2-diffmin
+description: Bias the patch toward the smallest change that flips FAIL_TO_PASS without disturbing PASS_TO_PASS. Use diff_stats to validate hunk count, file count, and rename absence before submitting.
+---
+
+# Minimal-diff discipline for SWE-rebench v2
+
+This skill keeps your patch as small as possible. Smaller diffs are easier to
+verify, less likely to introduce regressions, and align with how maintainers
+actually ship fixes. Apply it after the Orient phase has identified the root
+cause and before writing the patch in the Execute phase.
+
+## Core heuristics
+
+### 1. Single-hunk preference
+
+Prefer a patch that touches one contiguous code block in one file. A single
+hunk means the diff is self-contained: reviewers can read it in isolation and
+test runners can bisect it easily. If you find yourself adding a second hunk,
+stop and ask whether the second change is strictly required to flip
+`FAIL_TO_PASS`. Often the first hunk is the fix; the second hunk is cleanup
+that can be deferred.
+
+### 2. Single-file preference
+
+When the root cause is clearly in one file, do not touch other files to make
+tests pass. Fixes that spread across files indicate either (a) the root cause
+analysis was incomplete, or (b) a larger refactor is being smuggled in. Neither
+belongs in a minimal-diff submission.
+
+If two files genuinely must change (e.g. a struct definition and one call
+site), verify that both changes are causally required: remove one and confirm
+that `FAIL_TO_PASS` fails again.
+
+### 3. No-rename rule
+
+Never rename functions, variables, or files to fix a bug. Renames change every
+call site and inflate the diff with changes that are semantically neutral to
+the failing test but risky for `PASS_TO_PASS` tests. If you feel a rename
+would help, file a note in the solution cost field and ship the fix without the
+rename.
+
+### 4. Function-scope containment
+
+Limit edits to the function or method that the failing test exercises. Check
+the call graph: if the test calls `parse_netcdf_header()`, your change should
+live inside `parse_netcdf_header()` or a helper it directly calls — not in a
+shared utility ten layers up that happens to also be called by unrelated code.
+
+### 5. Dead-code deletion last resort
+
+Deleting dead code (unreachable branches, commented-out blocks) is tempting
+but risky: it inflates the diff with changes unrelated to `FAIL_TO_PASS` and
+can break `PASS_TO_PASS` if the "dead" code was actually reachable in some
+path. Delete dead code only when it is the direct cause of the failing test
+(e.g. an always-false guard that prevents a required code path from running).
+
+## Using the diff_stats MCP tool
+
+Before submitting, call `mcp__diff-stats__diff_stats` with your complete
+unified diff string. The tool returns:
+
+```json
+{
+  "hunks": 1,
+  "filesTouched": 1,
+  "addedLines": 3,
+  "removedLines": 2,
+  "hasRenames": false
+}
+```
+
+Reject and revise your patch if:
+- `hunks > 3` — almost always indicates scope creep
+- `filesTouched > 2` — consider whether both files are causally required
+- `hasRenames === true` — strip the rename and fix in place
+- `addedLines + removedLines > 50` — verify against single-hunk and single-file rules
+
+Accept the patch if all checks pass and `FAIL_TO_PASS` flips while
+`PASS_TO_PASS` stays green.
+
+## Worked example: unidata/netcdf-c-1925
+
+**Instance:** `unidata__netcdf-c-1925`
+**Problem:** `nc_get_var_string()` returns garbage when the variable has a
+fill value because `NC_EEMPTY` was tested with `!=` instead of `==`.
+
+**Bad patch (17 hunks, 3 files, 200 lines):**
+Refactors the fill-value handling layer to share a common helper, moves the
+check into a new function, renames `nc_fill_string` to `nc_fill_str`. Correct
+in intent but violates every heuristic.
+
+**Minimal patch (1 hunk, 1 file, 2 lines):**
+```diff
+--- a/libsrc/var.c
++++ b/libsrc/var.c
+@@ -402,7 +402,7 @@ nc_get_var_string(int ncid, int varid, char **sp)
+-    if (stat != NC_EEMPTY) {
++    if (stat == NC_EEMPTY) {
+```
+`diff_stats` returns `{ hunks: 1, filesTouched: 1, addedLines: 1, removedLines: 1, hasRenames: false }`.
+All checks pass. The `FAIL_TO_PASS` test now sees a proper empty string
+instead of garbage; `PASS_TO_PASS` tests are untouched.
+
+## Integration with the Plan skill
+
+The `swe-rebench-v2-plan` skill from `swe-rebench-v2-runtime` sketches the
+edit list. Run this diffmin skill after Plan and before submitting:
+
+1. Plan produces: "change line 402 in `libsrc/var.c` from `!=` to `==`."
+2. Execute writes the patch.
+3. **This skill validates:** call `mcp__diff-stats__diff_stats` on the patch,
+   confirm `hunks: 1, filesTouched: 1, hasRenames: false`.
+4. Submit via `submit_typed_payload` only after validation passes.
+
+If validation fails, trim the patch and re-validate before submitting.

package/plugins/swe-rebench-v2-diffmin/skills/test-map/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: swe-rebench-v2-test-map
+description: Walk PASS_TO_PASS test names to their source files via repo grep, identify the test-to-source ratio, and pre-load the relevant call graph into context before writing the patch.
+---
+
+# PASS_TO_PASS test mapping for SWE-rebench v2
+
+Before writing a single line of fix code, map the test names you must preserve
+(`PASS_TO_PASS`) to their source files. This gives you an accurate picture of
+the call graph your patch must not disturb, which is the information needed to
+apply minimal-diff discipline correctly.
+
+## Why this matters
+
+`PASS_TO_PASS` names are the regressions you cannot afford. A patch that fixes
+`FAIL_TO_PASS` but breaks five `PASS_TO_PASS` tests scores zero on the
+`brier-loss.v1` evaluator. The test map shows you exactly which functions,
+structs, and files are exercised by those tests — a constraint that shapes
+where you can safely edit.
+
+## Steps
+
+### Step 1: Extract PASS_TO_PASS names from the task spec
+
+The task body includes `goal.spec.PASS_TO_PASS`, a list of test identifiers
+in the form `<module>::<function>` or `<file>::<class>::<method>`. Example:
+
+```
+goal.spec.PASS_TO_PASS = [
+  "test_nc_get_var_string::test_basic_string_read",
+  "test_fill_value::test_default_fill",
+  "test_fill_value::test_custom_fill"
+]
+```
+
+### Step 2: Grep test names to source files
+
+For each `PASS_TO_PASS` test name, grep the repo for the function or class
+definition. Use the filesystem tools or bash to run:
+
+```bash
+grep -r "test_basic_string_read" <repo_root> --include="*.c" --include="*.py" -l
+```
+
+Build a map: `test name → test file → source file under test`.
+
+Identify the source file by reading the test: find the `#include`, `import`,
+or `open()` call that loads the module under test. This is the source file your
+patch may not break.
+
+### Step 3: Compute the test-to-source ratio
+
+Count the number of `PASS_TO_PASS` test functions that exercise each source
+file. A high ratio (e.g. 8 tests → 1 source file) means the file is heavily
+covered and every edit carries regression risk. A low ratio means fewer hidden
+dependencies.
+
+Annotate your edit plan: "source file `libsrc/var.c` is exercised by 3
+PASS_TO_PASS tests; edits must not change the function signature or remove any
+branch reachable from `test_fill_value`."
+
+### Step 4: Pre-load the call graph for the affected function
+
+Read the function you intend to edit (identified by the Orient skill). Trace:
+- Which sub-functions does it call?
+- Which of those sub-functions appear in the PASS_TO_PASS test map?
+
+If a sub-function appears in the test map, your patch must not change its
+behaviour. If it does not appear, it may be safe to touch — confirm with
+step 3's ratio.
+
+### Step 5: Write the edit constraint list
+
+Output a structured list before starting Execute:
+
+```
+Edit constraint list:
+- File: libsrc/var.c
+- Function: nc_get_var_string
+- Lines: 400-410
+- PASS_TO_PASS coverage: 3 tests depend on this function
+- Sub-functions NOT to touch: nc_fill_string (covered by test_fill_value::test_default_fill)
+- Safe to change: local variable stat comparison on line 402
+```
+
+Pass this list to the Plan/Execute phase.
+
+## Worked example: org__repo-42 (fictional)
+
+**Instance:** `org__repo-42`
+**FAIL_TO_PASS:** `test_parser::test_malformed_json`
+**PASS_TO_PASS:** `test_parser::test_valid_json`, `test_parser::test_empty_object`, `test_roundtrip::test_encode_decode`
+
+**Step 1:** Extract names — three tests to preserve.
+
+**Step 2:** Grep reveals:
+- `test_valid_json` and `test_empty_object` live in `tests/test_parser.py`, which imports `src/parser.py`.
+- `test_encode_decode` lives in `tests/test_roundtrip.py`, which imports both `src/parser.py` and `src/encoder.py`.
+
+**Step 3:** Ratio for `src/parser.py`: 3 tests. Ratio for `src/encoder.py`: 1 test. `src/parser.py` is more risky.
+
+**Step 4:** The function to fix is `parse_json()` in `src/parser.py`. It calls `_tokenize()` and `_validate_token()`. `_validate_token()` appears in `test_valid_json` (it is called on valid JSON). Do not change `_validate_token()`; it is covered. `_tokenize()` does not appear — lower risk.
+
+**Step 5:** Edit constraint list:
+```
+- File: src/parser.py
+- Function: parse_json
+- PASS_TO_PASS coverage: 3 tests via parse_json + _validate_token
+- Sub-functions NOT to touch: _validate_token (PASS_TO_PASS coverage)
+- Sub-functions safe to touch: _tokenize (no direct PASS_TO_PASS coverage)
+- Preferred: fix on lines 88-92 where malformed JSON triggers early return
+```
+
+This constraint list feeds directly into the diffmin skill's heuristics: one
+hunk, one file, no renames, no changes to `_validate_token`.
+
+## Integration with the diffmin skill
+
+Run this test-map skill in parallel with the Orient skill. By the time Plan
+begins, you should have:
+1. The Orient summary (hypothesis + target function).
+2. The test-map constraint list (which sub-functions are covered by PASS_TO_PASS).
+
+Both feed into the Plan phase. After Execute produces the patch, run
+`mcp__diff-stats__diff_stats` via the diffmin skill to confirm the diff
+satisfies the hunk and file count constraints before submitting.

package/plugins/swe-rebench-v2-diffmin/test/diff-stats.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest';
+import { computeDiffStats } from '../mcp/diff-stats.mjs';
+
+const ONE_LINE_FIX = `--- a/src/foo.c
++++ b/src/foo.c
+@@ -1 +1 @@
+-broken
++fixed
+`;
+
+const MULTI_HUNK_TWO_FILES = `--- a/src/foo.c
++++ b/src/foo.c
+@@ -1,3 +1,3 @@
+ line1
+-bad
++good
+ line3
+@@ -10 +10 @@
+-also bad
++also good
+--- a/test/test_foo.c
++++ b/test/test_foo.c
+@@ -5 +5 @@
+-old
++new
+`;
+
+const RENAME_PATCH = `diff --git a/src/old.c b/src/new.c
+similarity index 90%
+rename from src/old.c
+rename to src/new.c
+--- a/src/old.c
++++ b/src/new.c
+@@ -1 +1 @@
+-old
++new
+`;
+
+describe('computeDiffStats (r83r diff-stats library)', () => {
+  it('returns 1 hunk / 1 file / 1 add / 1 remove for the one-line fix', () => {
+    expect(computeDiffStats(ONE_LINE_FIX)).toEqual({
+      hunks: 1, filesTouched: 1, addedLines: 1, removedLines: 1, hasRenames: false,
+    });
+  });
+
+  it('returns 3 hunks / 2 files for the multi-hunk patch', () => {
+    const s = computeDiffStats(MULTI_HUNK_TWO_FILES);
+    expect(s.hunks).toBe(3);
+    expect(s.filesTouched).toBe(2);
+    expect(s.addedLines).toBe(3);
+    expect(s.removedLines).toBe(3);
+    expect(s.hasRenames).toBe(false);
+  });
+
+  it('flags hasRenames: true when a rename header is present', () => {
+    expect(computeDiffStats(RENAME_PATCH).hasRenames).toBe(true);
+  });
+
+  it('rejects an empty patch with a sensible error', () => {
+    expect(() => computeDiffStats('')).toThrow(/empty patch/i);
+  });
+});

package/plugins/swe-rebench-v2-diffmin/test/manifest.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect } from 'vitest';
+import { existsSync, readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadSolverPluginManifest } from '../../../src/plugins/manifest.js';
+import { digestDirectory } from '../../../src/plugins/digest.js';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+
+describe('swe-rebench-v2-diffmin manifest (r83r)', () => {
+  it('has a valid jinn.plugin.json that loadSolverPluginManifest parses', () => {
+    const { manifest } = loadSolverPluginManifest(ROOT);
+    expect(manifest.name).toBe('swe-rebench-v2-diffmin');
+    expect(manifest.jinn.supports).toContain('swe-rebench-v2.v1');
+    expect(manifest.jinn.skills?.length ?? 0).toBeGreaterThanOrEqual(2);
+  });
+
+  it('passes the SolverType-plugin validator (no jinn.runtime in supports)', () => {
+    const { manifest } = loadSolverPluginManifest(ROOT);
+    // SolverType mode: supports must not include 'jinn.runtime'
+    expect(manifest.jinn.supports).not.toContain('jinn.runtime');
+    // Every entry must be a SolverType identifier
+    for (const entry of manifest.jinn.supports) {
+      expect(typeof entry).toBe('string');
+      expect(entry.length).toBeGreaterThan(0);
+    }
+  });
+
+  it('declares an .mcp.json that points at the bundled diff-stats server', () => {
+    const mcp = JSON.parse(readFileSync(join(ROOT, '.mcp.json'), 'utf8'));
+    expect(mcp.mcpServers).toBeDefined();
+    expect(mcp.mcpServers['diff-stats']).toBeDefined();
+    expect(mcp.mcpServers['diff-stats'].command).toBe('node');
+    expect(mcp.mcpServers['diff-stats'].args?.[0]).toContain('mcp/diff-stats-server.mjs');
+  });
+
+  it('every declared skill file exists with non-empty frontmatter', () => {
+    const manifest = JSON.parse(readFileSync(join(ROOT, 'jinn.plugin.json'), 'utf8'));
+    for (const skill of manifest.jinn.skills) {
+      const p = join(ROOT, skill);
+      expect(existsSync(p), `missing skill file: ${skill}`).toBe(true);
+      const body = readFileSync(p, 'utf8');
+      expect(body, `empty skill: ${skill}`).toMatch(/^---[\s\S]+name:\s*\S+[\s\S]+description:\s*\S+[\s\S]+---/);
+      // Reject placeholder content — this plug-in must be real.
+      expect(body, `placeholder content in ${skill}`).not.toMatch(/Replace this body|placeholder/i);
+    }
+  });
+
+  it('digestDirectory produces a stable sha256 for the package contents', () => {
+    const digest = digestDirectory(ROOT);
+    expect(digest).toMatch(/^[0-9a-f]{64}$/);
+  });
+});

package/plugins/swe-rebench-v2-diffmin/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "target": "ES2022",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["node", "vitest/globals"]
+  },
+  "include": ["test/**/*.ts", "mcp/**/*.mjs"]
+}

package/plugins/swe-rebench-v2-runtime/README.md

@@ -9,3 +9,16 @@ This plugin bundles two skills:
 The plugin is loaded automatically when an operator's daemon has the `swe-rebench-v2.v1` SolverNet enabled, per the SDK's `defaultRuntimePlugins: ['bundled:swe-rebench-v2-runtime']`.
 
 License: MIT.
+
+## See also
+
+- `client/plugins/swe-rebench-v2-diffmin/` — complementary minimal-diff +
+  test-mapping skills. Stacks with this plug-in: a daemon can load both for
+  the same SolverNet. The two plug-ins cover different angles:
+  `swe-rebench-v2-runtime` orients + plans; `swe-rebench-v2-diffmin` enforces
+  minimal-diff discipline and pre-loads the PASS_TO_PASS call-graph.
+
+Already shipping a Hermes skill? Drop it under `skills/<name>/SKILL.md`, add
+a `jinn.plugin.json` targeting `swe-rebench-v2.v1`, `yarn pack`, then
+`jinn solver-plugins publish`. See `swe-rebench-v2-diffmin/README.md` for
+the Hermes-migrator quickstart.