@jinn-network/client 0.1.8 → 0.1.9-canary.144d87d2

package/dist/solver-types/_jinn-repo-pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_jinn-repo-pool.js","sourceRoot":"","sources":["../../src/solver-types/_jinn-repo-pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEpD,iGAAiG;AACjG,MAAM,CAAC,MAAM,sBAAsB,GAAG,kBAAkB,CAAC,MAAM,CAAC;IAC9D,UAAU,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,EAAG,4CAA4C;IAC3F,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,EAAsB,wDAAwD;CACzG,CAAC,CAAC;AAWH,MAAM,UAAU,UAAU,CAAC,IAAsB;IAC/C,OAAO;QACL,aAAa,EAAE,IAAI,CAAC,aAAa;QACjC,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;KAC1C,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,OAA0B,EAAE;IAC3D,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI,aAAa,CAAC,IAAI,GAAG,CAAC,uBAAuB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3F,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAc,CAAC;IAChE,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACzD,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,IAAwB,EAAE,GAAgB;IAC7E,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC;AACpD,CAAC"}

package/dist/solver-types/_swe-rebench-v2-held-out-slate.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Held-out task slate for the swe-rebench-v2 RL eval harness (issue #817).
+ *
+ * A slate is a versioned, content-addressed set of swe-rebench-v2
+ * `instance_id`s RESERVED from the training pool. The generator excludes
+ * slate instances from the train stream so they never enter training; a
+ * future eval orchestrator runs solvers against the slate to measure
+ * out-of-sample performance. Scores are only comparable *within* a slate
+ * version — a version bump (`v2`, …) is a distinct artifact with a distinct
+ * content hash, never compared against an earlier version.
+ *
+ * The artifact ships as a JSON file under `slates/` next to this module
+ * (`held-out-slate.swe-rebench-v2.<version>.json`). It carries a self-declared
+ * content hash: the loader recomputes a sha256 over the canonicalised,
+ * instance-id-sorted artifact and compares it to the file's `hash` field,
+ * failing loud on mismatch. This guards against accidental drift — a hand-edit
+ * that adds or removes an instance without re-deriving the hash. It is NOT a
+ * tamper-proof anchor: the declared hash lives in the same file it verifies, so
+ * a deliberate edit that also re-derives the hash passes, and the check is
+ * skipped entirely when the `hash` field is absent. A real trust anchor (an
+ * external/on-chain hash) is out of scope here.
+ *
+ * Hashing mirrors `hashVettedPoolArtifact` in `_swe-rebench-v2-validated-pool`:
+ * `sha256(canonicalJson(normalized))` with a `sha256:` prefix.
+ */
+import type { PoolTask } from './_swe-rebench-v2-pool.js';
+export declare const HELD_OUT_SLATE_SCHEMA_VERSION: "held-out-slate.v1";
+export interface HeldOutSlateArtifact {
+    schemaVersion: typeof HELD_OUT_SLATE_SCHEMA_VERSION;
+    solverType: string;
+    version: string;
+    generatedAt: string;
+    instanceIds: string[];
+}
+export interface LoadedHeldOutSlate {
+    version: string;
+    hash: `sha256:${string}`;
+    instanceIds: Set<string>;
+}
+export declare function parseHeldOutSlateArtifact(raw: unknown): HeldOutSlateArtifact;
+export declare function hashHeldOutSlateArtifact(artifact: HeldOutSlateArtifact): `sha256:${string}`;
+/**
+ * Load the held-out slate for `solverType` at `version`. Validates the version
+ * shape, that the file's declared `solverType`/`version` match the request, and
+ * (when a `hash` field is present) that the recomputed content hash matches it —
+ * catching accidental edit-without-rehash drift, not deliberate tampering (see
+ * the module header). Throws if no slate file exists for the requested version
+ * (scores are only comparable within a known version).
+ *
+ * `opts.dir` overrides the slate file directory; it defaults to the
+ * module-relative `slatesDir()`. Production callers omit it (and so resolve the
+ * shipped slates); tests inject a temp dir to drive the fail-loud throw paths
+ * against malformed fixtures.
+ */
+export declare function loadHeldOutSlate(solverType: string, version: string, opts?: {
+    dir?: string;
+}): LoadedHeldOutSlate;
+/**
+ * Drop any pool task whose `instance_id` is in the held-out slate. This is the
+ * single train-stream exclusion (issue #817 AC#2): the generator is the sole
+ * train-stream chokepoint, so a slate instance filtered here is never posted,
+ * never claimable, and never trains.
+ */
+export declare function excludeHeldOutSlate(pool: PoolTask[], slateIds: Set<string>): PoolTask[];
+/**
+ * Slate versions currently used as held-out exams. The generator excludes the
+ * UNION of these from the train stream, so every active exam stays out of
+ * training while non-slate instances of every repo remain trainable. Add a
+ * version here ONLY when its slate file exists (loadHeldOutSlate fails loud on
+ * a missing file).
+ */
+export declare const ACTIVE_HELD_OUT_SLATE_VERSIONS: readonly ["v1", "v2"];
+/** Union of instance ids across the given active slate versions. */
+export declare function loadActiveHeldOutSlateIds(solverType: string, versions: readonly string[], opts?: {
+    dir?: string;
+}): Set<string>;

package/dist/solver-types/_swe-rebench-v2-held-out-slate.js

@@ -0,0 +1,156 @@
+/**
+ * Held-out task slate for the swe-rebench-v2 RL eval harness (issue #817).
+ *
+ * A slate is a versioned, content-addressed set of swe-rebench-v2
+ * `instance_id`s RESERVED from the training pool. The generator excludes
+ * slate instances from the train stream so they never enter training; a
+ * future eval orchestrator runs solvers against the slate to measure
+ * out-of-sample performance. Scores are only comparable *within* a slate
+ * version — a version bump (`v2`, …) is a distinct artifact with a distinct
+ * content hash, never compared against an earlier version.
+ *
+ * The artifact ships as a JSON file under `slates/` next to this module
+ * (`held-out-slate.swe-rebench-v2.<version>.json`). It carries a self-declared
+ * content hash: the loader recomputes a sha256 over the canonicalised,
+ * instance-id-sorted artifact and compares it to the file's `hash` field,
+ * failing loud on mismatch. This guards against accidental drift — a hand-edit
+ * that adds or removes an instance without re-deriving the hash. It is NOT a
+ * tamper-proof anchor: the declared hash lives in the same file it verifies, so
+ * a deliberate edit that also re-derives the hash passes, and the check is
+ * skipped entirely when the `hash` field is absent. A real trust anchor (an
+ * external/on-chain hash) is out of scope here.
+ *
+ * Hashing mirrors `hashVettedPoolArtifact` in `_swe-rebench-v2-validated-pool`:
+ * `sha256(canonicalJson(normalized))` with a `sha256:` prefix.
+ */
+import { readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve as resolvePath, join } from 'node:path';
+import { canonicalJson } from '../harnesses/engine/canonical-json.js';
+export const HELD_OUT_SLATE_SCHEMA_VERSION = 'held-out-slate.v1';
+function isObject(raw) {
+    return typeof raw === 'object' && raw !== null;
+}
+export function parseHeldOutSlateArtifact(raw) {
+    if (!isObject(raw))
+        throw new Error('held-out slate artifact must be an object');
+    if (raw['schemaVersion'] !== HELD_OUT_SLATE_SCHEMA_VERSION) {
+        throw new Error(`held-out slate schemaVersion must be ${HELD_OUT_SLATE_SCHEMA_VERSION}`);
+    }
+    if (typeof raw['solverType'] !== 'string' || raw['solverType'].length === 0) {
+        throw new Error('held-out slate solverType must be a non-empty string');
+    }
+    if (typeof raw['version'] !== 'string' || raw['version'].length === 0) {
+        throw new Error('held-out slate version must be a non-empty string');
+    }
+    if (typeof raw['generatedAt'] !== 'string') {
+        throw new Error('held-out slate generatedAt must be a string');
+    }
+    if (!Array.isArray(raw['instanceIds']) ||
+        raw['instanceIds'].some((id) => typeof id !== 'string' || id.length === 0)) {
+        throw new Error('held-out slate instanceIds must be an array of non-empty strings');
+    }
+    return {
+        schemaVersion: HELD_OUT_SLATE_SCHEMA_VERSION,
+        solverType: raw['solverType'],
+        version: raw['version'],
+        generatedAt: raw['generatedAt'],
+        instanceIds: raw['instanceIds'].slice(),
+    };
+}
+function normalizeHeldOutSlateArtifact(artifact) {
+    return {
+        schemaVersion: HELD_OUT_SLATE_SCHEMA_VERSION,
+        solverType: artifact.solverType,
+        version: artifact.version,
+        generatedAt: artifact.generatedAt,
+        instanceIds: [...artifact.instanceIds].sort((a, b) => a.localeCompare(b)),
+    };
+}
+export function hashHeldOutSlateArtifact(artifact) {
+    const canonical = canonicalJson(normalizeHeldOutSlateArtifact(artifact));
+    return `sha256:${createHash('sha256').update(canonical).digest('hex')}`;
+}
+/**
+ * Resolve the slate file directory. At runtime the compiled module lives at
+ * `dist/solver-types/<this>.js` and the slate JSON at `dist/solver-types/slates/`
+ * (copied during `yarn build`); in dev/test the source module is at
+ * `src/solver-types/<this>.ts` with the slate JSON at `src/solver-types/slates/`.
+ * `./slates` resolves correctly in both layouts.
+ */
+function slatesDir() {
+    return resolvePath(dirname(fileURLToPath(import.meta.url)), 'slates');
+}
+function slateFileName(solverType, version) {
+    if (!/^v\d+$/.test(version)) {
+        throw new Error(`held-out slate version must match /^v\\d+$/ (got ${JSON.stringify(version)})`);
+    }
+    return `held-out-slate.${solverType.replace(/\.v\d+$/, '')}.${version}.json`;
+}
+/**
+ * Load the held-out slate for `solverType` at `version`. Validates the version
+ * shape, that the file's declared `solverType`/`version` match the request, and
+ * (when a `hash` field is present) that the recomputed content hash matches it —
+ * catching accidental edit-without-rehash drift, not deliberate tampering (see
+ * the module header). Throws if no slate file exists for the requested version
+ * (scores are only comparable within a known version).
+ *
+ * `opts.dir` overrides the slate file directory; it defaults to the
+ * module-relative `slatesDir()`. Production callers omit it (and so resolve the
+ * shipped slates); tests inject a temp dir to drive the fail-loud throw paths
+ * against malformed fixtures.
+ */
+export function loadHeldOutSlate(solverType, version, opts = {}) {
+    const path = join(opts.dir ?? slatesDir(), slateFileName(solverType, version));
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch {
+        throw new Error(`held-out slate not found for solverType=${solverType} version=${version} (expected ${path})`);
+    }
+    const parsed = JSON.parse(raw);
+    const artifact = parseHeldOutSlateArtifact(parsed);
+    if (artifact.version !== version) {
+        throw new Error(`held-out slate version mismatch: file declares ${artifact.version}, requested ${version}`);
+    }
+    if (artifact.solverType !== solverType) {
+        throw new Error(`held-out slate solverType mismatch: file declares ${artifact.solverType}, requested ${solverType}`);
+    }
+    const hash = hashHeldOutSlateArtifact(artifact);
+    const declared = parsed['hash'];
+    if (typeof declared === 'string' && declared !== hash) {
+        throw new Error(`held-out slate hash mismatch for ${solverType} ${version}: declared ${declared}, computed ${hash} (artifact was edited without re-deriving the hash)`);
+    }
+    return { version: artifact.version, hash, instanceIds: new Set(artifact.instanceIds) };
+}
+/**
+ * Drop any pool task whose `instance_id` is in the held-out slate. This is the
+ * single train-stream exclusion (issue #817 AC#2): the generator is the sole
+ * train-stream chokepoint, so a slate instance filtered here is never posted,
+ * never claimable, and never trains.
+ */
+export function excludeHeldOutSlate(pool, slateIds) {
+    if (slateIds.size === 0)
+        return pool;
+    return pool.filter((task) => !slateIds.has(task.instance_id));
+}
+/**
+ * Slate versions currently used as held-out exams. The generator excludes the
+ * UNION of these from the train stream, so every active exam stays out of
+ * training while non-slate instances of every repo remain trainable. Add a
+ * version here ONLY when its slate file exists (loadHeldOutSlate fails loud on
+ * a missing file).
+ */
+export const ACTIVE_HELD_OUT_SLATE_VERSIONS = ['v1', 'v2'];
+/** Union of instance ids across the given active slate versions. */
+export function loadActiveHeldOutSlateIds(solverType, versions, opts = {}) {
+    const ids = new Set();
+    for (const version of versions) {
+        for (const id of loadHeldOutSlate(solverType, version, opts).instanceIds)
+            ids.add(id);
+    }
+    return ids;
+}
+//# sourceMappingURL=_swe-rebench-v2-held-out-slate.js.map

package/dist/solver-types/_swe-rebench-v2-held-out-slate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_swe-rebench-v2-held-out-slate.js","sourceRoot":"","sources":["../../src/solver-types/_swe-rebench-v2-held-out-slate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AAGtE,MAAM,CAAC,MAAM,6BAA6B,GAAG,mBAA4B,CAAC;AAgB1E,SAAS,QAAQ,CAAC,GAAY;IAC5B,OAAO,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,CAAC;AACjD,CAAC;AAED,MAAM,UAAU,yBAAyB,CAAC,GAAY;IACpD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;IACjF,IAAI,GAAG,CAAC,eAAe,CAAC,KAAK,6BAA6B,EAAE,CAAC;QAC3D,MAAM,IAAI,KAAK,CAAC,wCAAwC,6BAA6B,EAAE,CAAC,CAAC;IAC3F,CAAC;IACD,IAAI,OAAO,GAAG,CAAC,YAAY,CAAC,KAAK,QAAQ,IAAI,GAAG,CAAC,YAAY,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC5E,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;IACD,IAAI,OAAO,GAAG,CAAC,SAAS,CAAC,KAAK,QAAQ,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtE,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;IACvE,CAAC;IACD,IAAI,OAAO,GAAG,CAAC,aAAa,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC3C,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;IACjE,CAAC;IACD,IACE,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QAClC,GAAG,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,OAAO,EAAE,KAAK,QAAQ,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC,EAC1E,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,kEAAkE,CAAC,CAAC;IACtF,CAAC;IACD,OAAO;QACL,aAAa,EAAE,6BAA6B;QAC5C,UAAU,EAAE,GAAG,CAAC,YAAY,CAAC;QAC7B,OAAO,EAAE,GAAG,CAAC,SAAS,CAAC;QACvB,WAAW,EAAE,GAAG,CAAC,aAAa,CAAC;QAC/B,WAAW,EAAG,GAAG,CAAC,aAAa,CAAc,CAAC,KAAK,EAAE;KACtD,CAAC;AACJ,CAAC;AAED,SAAS,6BAA6B,CAAC,QAA8B;IACnE,OAAO;QACL,aAAa,EAAE,6BAA6B;QAC5C,UAAU,EAAE,QAAQ,CAAC,UAAU;QAC/B,OAAO,EAAE,QAAQ,CAAC,OAAO;QACzB,WAAW,EAAE,QAAQ,CAAC,WAAW;QACjC,WAAW,EAAE,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;KAC1E,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,wBAAwB,CAAC,QAA8B;IACrE,MAAM,SAAS,GAAG,aAAa,CAAC,6BAA6B,CAAC,QAAQ,CAAC,CAAC,CAAC;IACzE,OAAO,UAAU,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;AAC1E,CAAC;AAED;;;;;;GAMG;AACH,SAAS,SAAS;IAChB,OAAO,WAAW,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;AACxE,CAAC;AAED,SAAS,aAAa,CAAC,UAAkB,EAAE,OAAe;IACxD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CACb,oDAAoD,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAC/E,CAAC;IACJ,CAAC;IACD,OAAO,kBAAkB,UAAU,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,IAAI,OAAO,OAAO,CAAC;AAC/E,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAC9B,UAAkB,EAClB,OAAe,EACf,OAAyB,EAAE;IAE3B,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,SAAS,EAAE,EAAE,aAAa,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC;IAC/E,IAAI,GAAW,CAAC;IAChB,IAAI,CAAC;QACH,GAAG,GAAG,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACnC,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,KAAK,CACb,2CAA2C,UAAU,YAAY,OAAO,cAAc,IAAI,GAAG,CAC9F,CAAC;IACJ,CAAC;IACD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAA4B,CAAC;IAC1D,MAAM,QAAQ,GAAG,yBAAyB,CAAC,MAAM,CAAC,CAAC;IACnD,IAAI,QAAQ,CAAC,OAAO,KAAK,OAAO,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CACb,kDAAkD,QAAQ,CAAC,OAAO,eAAe,OAAO,EAAE,CAC3F,CAAC;IACJ,CAAC;IACD,IAAI,QAAQ,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;QACvC,MAAM,IAAI,KAAK,CACb,qDAAqD,QAAQ,CAAC,UAAU,eAAe,UAAU,EAAE,CACpG,CAAC;IACJ,CAAC;IACD,MAAM,IAAI,GAAG,wBAAwB,CAAC,QAAQ,CAAC,CAAC;IAChD,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;IAChC,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QACtD,MAAM,IAAI,KAAK,CACb,oCAAoC,UAAU,IAAI,OAAO,cAAc,QAAQ,cAAc,IAAI,qDAAqD,CACvJ,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,GAAG,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;AACzF,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAgB,EAAE,QAAqB;IACzE,IAAI,QAAQ,CAAC,IAAI,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACrC,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAAC,IAAI,EAAE,IAAI,CAAU,CAAC;AAEpE,oEAAoE;AACpE,MAAM,UAAU,yBAAyB,CACvC,UAAkB,EAClB,QAA2B,EAC3B,OAAyB,EAAE;IAE3B,MAAM,GAAG,GAAG,IAAI,GAAG,EAAU,CAAC;IAC9B,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,KAAK,MAAM,EAAE,IAAI,gBAAgB,CAAC,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC,WAAW;YAAE,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACxF,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/solver-types/_swe-rebench-v2-pool-recovery.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Fresh-volume vetted-pool recovery for the swe-rebench-v2 generator (#957).
+ *
+ * A freshly-deployed operator has an empty disk: no `validated-pool.json`, so
+ * the generator's admission gate hits `admission-required-no-data` and posts 0
+ * tasks. The vetted pool was previously published to IPFS; we recover it via the
+ * indexer (DR-2026-06-02 open-question #4, Option B — read the artifact ref via
+ * the DiscoveryAPI, not on-chain directly):
+ *
+ *   1. `discoveryApi.getMostRecentTaskCidDigest(manifestCid)` → a recent task's
+ *      on-chain `taskCidDigest` (pure indexer/chain read; no IPFS in discovery).
+ *   2. Reconstruct the IPFS task CID (`f01551220 + digestHexWithout0x`, the same
+ *      derivation as `adapters/mech/adapter.ts`) and fetch the task body.
+ *   3. Read the vetted-pool ref from the task's `eligibility.vettedPoolRef`
+ *      (`VETTED_POOL_REF_ELIGIBILITY_KEY`).
+ *   4. Fetch + parse the artifact at `ref.artifactCid`.
+ *   5. SECURITY: verify `hashVettedPoolArtifact(artifact) === ref.artifactHash`.
+ *      A mismatch is REJECTED — no file is written.
+ *   6. Write the scorable entries into `validated-pool.json` via
+ *      `ValidatedPoolStore.record`. After a successful recovery the generator's
+ *      existing `resolvePublishedVettedPool` / pool-load path picks up the now-
+ *      present `validated-pool.json`.
+ *
+ * Never-overwrite: if a local validated pool already exists for the current
+ * `EVAL_SEMANTICS_VERSION`, recovery is a no-op (`local-pool-present`) — the same
+ * "don't clobber newer local data" stance as `resolvePublishedVettedPool`'s
+ * `validatedNewer` guard.
+ *
+ * Fail-closed: every external call is wrapped so any failure returns a structured
+ * `{ recovered: false, reason }`. Recovery NEVER throws — it must fall through to
+ * the existing `admission-required-no-data` path so a recovery failure can never
+ * crash the generator tick.
+ */
+import { ValidatedPoolStore } from './_swe-rebench-v2-validated-pool.js';
+import type { DiscoveryAPI } from '../discovery/types.js';
+export interface RecoverVettedPoolResult {
+    recovered: boolean;
+    /**
+     * Why recovery did not complete (only set when `recovered === false`):
+     *   - `local-pool-present` — a local validated pool already exists; not clobbered.
+     *   - `no-task` — the indexer reports no task for the manifest yet.
+     *   - `no-ref` — the recovered task carries no `vettedPoolRef` eligibility.
+     *   - `hash-mismatch` — the fetched artifact's hash did not match the ref (SECURITY).
+     *   - `error:<msg>` — any external call failed (discovery / IPFS / parse).
+     */
+    reason?: string;
+    /** Count of scorable entries written, on a successful recovery. */
+    entriesRecovered?: number;
+}
+/**
+ * Whether a recovery outcome is TERMINAL — i.e. retrying cannot help, so the
+ * caller should latch permanently and never attempt recovery again:
+ *
+ *   - `recovered === true`        — done; the pool was written.
+ *   - `local-pool-present`        — a local pool already exists; nothing to recover.
+ *
+ * All other outcomes (`no-task`, `no-ref`, `error:*`, `hash-mismatch`) are
+ * TRANSIENT/retryable, so the caller must NOT latch on them (it retries under a
+ * bounded cap instead):
+ *   - `no-task` — a fresh SolverNet may not have posted its first task yet.
+ *   - `no-ref` — the task's eligibility may not yet carry a vettedPoolRef.
+ *   - `error:*` — the indexer / IPFS gateway may be having a transient blip.
+ *   - `hash-mismatch` — the fetched artifact's hash didn't match the ref. This is
+ *     SECURITY-rejected at write time (the bad artifact is NEVER written), and it
+ *     can be transient: a corrupted IPFS-gateway response may fetch cleanly on a
+ *     later attempt, or the launcher may re-publish a corrected ref that a later
+ *     task carries. Retrying re-resolves the most-recent task's ref AND re-fetches
+ *     from IPFS, so a corrected pool is picked up without a restart; the bounded
+ *     retry cap prevents looping on a genuinely-bad ref.
+ */
+export declare function isTerminalRecoveryOutcome(result: RecoverVettedPoolResult): boolean;
+export interface RecoverVettedPoolDeps {
+    stateDir: string;
+    manifestCid: string;
+    discoveryApi: DiscoveryAPI;
+    ipfsGatewayUrl: string;
+    store: ValidatedPoolStore;
+    /** Injected so tests can stub the IPFS round-trip; production passes `fetchFromIpfs`. */
+    fetchFromIpfs: (gatewayUrl: string, cid: string) => Promise<unknown>;
+}
+export declare function recoverVettedPoolFromNetwork(deps: RecoverVettedPoolDeps): Promise<RecoverVettedPoolResult>;

package/dist/solver-types/_swe-rebench-v2-pool-recovery.js

@@ -0,0 +1,116 @@
+/**
+ * Fresh-volume vetted-pool recovery for the swe-rebench-v2 generator (#957).
+ *
+ * A freshly-deployed operator has an empty disk: no `validated-pool.json`, so
+ * the generator's admission gate hits `admission-required-no-data` and posts 0
+ * tasks. The vetted pool was previously published to IPFS; we recover it via the
+ * indexer (DR-2026-06-02 open-question #4, Option B — read the artifact ref via
+ * the DiscoveryAPI, not on-chain directly):
+ *
+ *   1. `discoveryApi.getMostRecentTaskCidDigest(manifestCid)` → a recent task's
+ *      on-chain `taskCidDigest` (pure indexer/chain read; no IPFS in discovery).
+ *   2. Reconstruct the IPFS task CID (`f01551220 + digestHexWithout0x`, the same
+ *      derivation as `adapters/mech/adapter.ts`) and fetch the task body.
+ *   3. Read the vetted-pool ref from the task's `eligibility.vettedPoolRef`
+ *      (`VETTED_POOL_REF_ELIGIBILITY_KEY`).
+ *   4. Fetch + parse the artifact at `ref.artifactCid`.
+ *   5. SECURITY: verify `hashVettedPoolArtifact(artifact) === ref.artifactHash`.
+ *      A mismatch is REJECTED — no file is written.
+ *   6. Write the scorable entries into `validated-pool.json` via
+ *      `ValidatedPoolStore.record`. After a successful recovery the generator's
+ *      existing `resolvePublishedVettedPool` / pool-load path picks up the now-
+ *      present `validated-pool.json`.
+ *
+ * Never-overwrite: if a local validated pool already exists for the current
+ * `EVAL_SEMANTICS_VERSION`, recovery is a no-op (`local-pool-present`) — the same
+ * "don't clobber newer local data" stance as `resolvePublishedVettedPool`'s
+ * `validatedNewer` guard.
+ *
+ * Fail-closed: every external call is wrapped so any failure returns a structured
+ * `{ recovered: false, reason }`. Recovery NEVER throws — it must fall through to
+ * the existing `admission-required-no-data` path so a recovery failure can never
+ * crash the generator tick.
+ */
+import { EVAL_SEMANTICS_VERSION, vettedPoolArtifactRefFromEligibility, parseVettedPoolArtifact, hashVettedPoolArtifact, } from './_swe-rebench-v2-validated-pool.js';
+/**
+ * Whether a recovery outcome is TERMINAL — i.e. retrying cannot help, so the
+ * caller should latch permanently and never attempt recovery again:
+ *
+ *   - `recovered === true`        — done; the pool was written.
+ *   - `local-pool-present`        — a local pool already exists; nothing to recover.
+ *
+ * All other outcomes (`no-task`, `no-ref`, `error:*`, `hash-mismatch`) are
+ * TRANSIENT/retryable, so the caller must NOT latch on them (it retries under a
+ * bounded cap instead):
+ *   - `no-task` — a fresh SolverNet may not have posted its first task yet.
+ *   - `no-ref` — the task's eligibility may not yet carry a vettedPoolRef.
+ *   - `error:*` — the indexer / IPFS gateway may be having a transient blip.
+ *   - `hash-mismatch` — the fetched artifact's hash didn't match the ref. This is
+ *     SECURITY-rejected at write time (the bad artifact is NEVER written), and it
+ *     can be transient: a corrupted IPFS-gateway response may fetch cleanly on a
+ *     later attempt, or the launcher may re-publish a corrected ref that a later
+ *     task carries. Retrying re-resolves the most-recent task's ref AND re-fetches
+ *     from IPFS, so a corrected pool is picked up without a restart; the bounded
+ *     retry cap prevents looping on a genuinely-bad ref.
+ */
+export function isTerminalRecoveryOutcome(result) {
+    if (result.recovered)
+        return true;
+    return result.reason === 'local-pool-present';
+}
+export async function recoverVettedPoolFromNetwork(deps) {
+    const { stateDir: _stateDir, manifestCid, discoveryApi, ipfsGatewayUrl, store, fetchFromIpfs } = deps;
+    void _stateDir; // reserved for symmetry with resolvePublishedVettedPool; store already binds stateDir
+    try {
+        // Never-overwrite guard: a local validated pool already present (operator
+        // validated locally, or a prior recovery ran) → do not clobber it.
+        const existing = await store.getScorableIds(EVAL_SEMANTICS_VERSION);
+        if (existing !== null) {
+            return { recovered: false, reason: 'local-pool-present' };
+        }
+        // 1) Most-recent task digest for the SolverNet (pure indexer/chain read).
+        const recent = await discoveryApi.getMostRecentTaskCidDigest(manifestCid);
+        if (!recent)
+            return { recovered: false, reason: 'no-task' };
+        // 2) Reconstruct the IPFS task CID and fetch the task body. Lowercase the
+        // digest defensively (NIT #7): the on-chain bytes32 is lowercase, but a
+        // future uppercase-emitting indexer must not produce a wrong CID.
+        const taskCid = `f01551220${recent.taskCidDigest.replace(/^0x/, '').toLowerCase()}`;
+        const taskDoc = await fetchFromIpfs(ipfsGatewayUrl, taskCid);
+        // 3) Read the vetted-pool ref from the task's eligibility.
+        const eligibility = taskDoc?.eligibility;
+        const ref = vettedPoolArtifactRefFromEligibility(eligibility);
+        if (ref === null)
+            return { recovered: false, reason: 'no-ref' };
+        // 4) Fetch + parse the artifact.
+        const rawArtifact = await fetchFromIpfs(ipfsGatewayUrl, ref.artifactCid);
+        const artifact = parseVettedPoolArtifact(rawArtifact);
+        // 5) SECURITY: verify the artifact hash against the ref before writing.
+        if (hashVettedPoolArtifact(artifact) !== ref.artifactHash) {
+            return { recovered: false, reason: 'hash-mismatch' };
+        }
+        // 6) Write the scorable entries into validated-pool.json. Record under the
+        // artifact's evalSemanticsVersion so the generator's read path picks them up
+        // for the matching version. Each artifact entry is scorable by construction.
+        for (const entry of artifact.entries) {
+            const poolEntry = {
+                scorable: true,
+                reason: entry.reason,
+                checkedAt: entry.checkedAt,
+                ...(entry.rowHash ? { rowHash: entry.rowHash } : {}),
+                ...(entry.imageName ? { imageName: entry.imageName } : {}),
+                ...(entry.imageDigest ? { imageDigest: entry.imageDigest } : {}),
+                ...(entry.upstreamEvalCommit ? { upstreamEvalCommit: entry.upstreamEvalCommit } : {}),
+            };
+            await store.record(entry.instance_id, poolEntry, artifact.evalSemanticsVersion);
+        }
+        return { recovered: true, entriesRecovered: artifact.entries.length };
+    }
+    catch (err) {
+        // Fail-closed: any failure (discovery, IPFS, parse) must NOT throw — return a
+        // structured result so the generator falls through to admission-required-no-data.
+        const message = err instanceof Error ? err.message : String(err);
+        return { recovered: false, reason: `error:${message}` };
+    }
+}
+//# sourceMappingURL=_swe-rebench-v2-pool-recovery.js.map

package/dist/solver-types/_swe-rebench-v2-pool-recovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_swe-rebench-v2-pool-recovery.js","sourceRoot":"","sources":["../../src/solver-types/_swe-rebench-v2-pool-recovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,EAEL,sBAAsB,EACtB,oCAAoC,EACpC,uBAAuB,EACvB,sBAAsB,GAEvB,MAAM,qCAAqC,CAAC;AAkB7C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,yBAAyB,CAAC,MAA+B;IACvE,IAAI,MAAM,CAAC,SAAS;QAAE,OAAO,IAAI,CAAC;IAClC,OAAO,MAAM,CAAC,MAAM,KAAK,oBAAoB,CAAC;AAChD,CAAC;AAYD,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAChD,IAA2B;IAE3B,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC;IACtG,KAAK,SAAS,CAAC,CAAC,sFAAsF;IAEtG,IAAI,CAAC;QACH,0EAA0E;QAC1E,mEAAmE;QACnE,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,cAAc,CAAC,sBAAsB,CAAC,CAAC;QACpE,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;YACtB,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,oBAAoB,EAAE,CAAC;QAC5D,CAAC;QAED,0EAA0E;QAC1E,MAAM,MAAM,GAAG,MAAM,YAAY,CAAC,0BAA0B,CAAC,WAAW,CAAC,CAAC;QAC1E,IAAI,CAAC,MAAM;YAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;QAE5D,0EAA0E;QAC1E,wEAAwE;QACxE,kEAAkE;QAClE,MAAM,OAAO,GAAG,YAAY,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC;QACpF,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;QAE7D,2DAA2D;QAC3D,MAAM,WAAW,GAAI,OAA4D,EAAE,WAAW,CAAC;QAC/F,MAAM,GAAG,GAAG,oCAAoC,CAAC,WAAW,CAAC,CAAC;QAC9D,IAAI,GAAG,KAAK,IAAI;YAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;QAEhE,iCAAiC;QACjC,MAAM,WAAW,GAAG,MAAM,aAAa,CAAC,cAAc,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC;QACzE,MAAM,QAAQ,GAAG,uBAAuB,CAAC,WAAW,CAAC,CAAC;QAEtD,wEAAwE;QACxE,IAAI,sBAAsB,CAAC,QAAQ,CAAC,KAAK,GAAG,CAAC,YAAY,EAAE,CAAC;YAC1D,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC;QACvD,CAAC;QAED,2EAA2E;QAC3E,6EAA6E;QAC7E,6EAA6E;QAC7E,KAAK,MAAM,KAAK,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;YACrC,MAAM,SAAS,GAAuB;gBACpC,QAAQ,EAAE,IAAI;gBACd,MAAM,EAAE,KAAK,CAAC,MAAM;gBACpB,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBACpD,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC1D,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAChE,GAAG,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAE,kBAAkB,EAAE,KAAK,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aACtF,CAAC;YACF,MAAM,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,EAAE,SAAS,EAAE,QAAQ,CAAC,oBAAoB,CAAC,CAAC;QAClF,CAAC;QAED,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,gBAAgB,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;IACxE,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,8EAA8E;QAC9E,kFAAkF;QAClF,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACjE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,OAAO,EAAE,EAAE,CAAC;IAC1D,CAAC;AACH,CAAC"}

package/dist/solver-types/_swe-rebench-v2-state.d.ts

@@ -33,6 +33,15 @@ export declare class GeneratorStateStore {
     invalidate(): void;
     private save;
     getCounters(instance_id: string): Promise<TaskCounters>;
+    /**
+     * Instance ids this generator has posted at least once — i.e. that entered
+     * the SolverNet train stream. Used by held-out screening (#986) to keep the
+     * exam to the never-posted remainder (a posted task may have been trained on,
+     * so holding it out later would make a trained-checkpoint pass memorization,
+     * not generalization). This is THIS launcher's posting history; complete for a
+     * single-launcher SolverNet.
+     */
+    postedInstanceIds(): Promise<Set<string>>;
     recordPosted(instance_id: string, now?: number): Promise<void>;
     recordSuccess(instance_id: string): Promise<void>;
     recordLastTaskId(instance_id: string, taskId: string): Promise<void>;

package/dist/solver-types/_swe-rebench-v2-state.js

@@ -47,6 +47,20 @@ export class GeneratorStateStore {
         const state = await this.load();
         return state.tasks[instance_id] ?? { posted: 0, successful: 0, last_posted_at: 0 };
     }
+    /**
+     * Instance ids this generator has posted at least once — i.e. that entered
+     * the SolverNet train stream. Used by held-out screening (#986) to keep the
+     * exam to the never-posted remainder (a posted task may have been trained on,
+     * so holding it out later would make a trained-checkpoint pass memorization,
+     * not generalization). This is THIS launcher's posting history; complete for a
+     * single-launcher SolverNet.
+     */
+    async postedInstanceIds() {
+        const state = await this.load();
+        return new Set(Object.entries(state.tasks)
+            .filter(([, c]) => c.posted > 0)
+            .map(([id]) => id));
+    }
     async recordPosted(instance_id, now = Date.now()) {
         const state = await this.load();
         const c = state.tasks[instance_id] ?? { posted: 0, successful: 0, last_posted_at: 0 };

package/dist/solver-types/_swe-rebench-v2-state.js.map

@@ -1 +1 @@
-{"version":3,"file":"_swe-rebench-v2-state.js","sourceRoot":"","sources":["../../src/solver-types/_swe-rebench-v2-state.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"_swe-rebench-v2-state.js","sourceRoot":"","sources":["../../src/solver-types/_swe-rebench-v2-state.ts"],"names":[],"mappings":"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"}

package/dist/solver-types/_swe-rebench-v2-validated-pool.d.ts

@@ -141,6 +141,36 @@ export interface ScorableVettedPoolArtifactEntries {
 export declare function parseVettedPoolArtifact(raw: unknown): SweRebenchV2VettedPoolArtifact;
 export declare function hashVettedPoolArtifact(artifact: SweRebenchV2VettedPoolArtifact): `sha256:${string}`;
 export declare function loadVettedPoolArtifactScorableEntries(raw: unknown): ScorableVettedPoolArtifactEntries;
+/**
+ * Substrate-level held-out exclusion (#986). Returns a copy of the artifact with
+ * the `excludeIds` instances dropped, so the PUBLISHED vetted-pool artifact — the
+ * shared substrate every generator can source its postable set from — never lists
+ * the held-out exam. This moves the exclusion up from each generator's posting
+ * decision (which only a generator running the slate code honours) to the artifact
+ * itself, so a fresh-recovery / independent / unguarded generator that reads the
+ * artifact cannot post the exam tasks either. Pure; never mutates its input. The
+ * caller re-hashes via `hashVettedPoolArtifact`.
+ */
+export declare function excludeFromVettedPoolArtifact(artifact: SweRebenchV2VettedPoolArtifact, excludeIds: ReadonlySet<string>): SweRebenchV2VettedPoolArtifact;
+/**
+ * Republication decision (#986). The published artifact is authoritative and
+ * write-once: it is NOT re-synced to local scorable unless the validated pool is
+ * strictly newer (the prior timestamp-gated behaviour, preserved here). But a
+ * timestamp-only check never fires when the *held-out set* changes while the
+ * validated pool is unchanged — so adding the exclusion in code, or activating a
+ * new slate version (e.g. `v3`), would leave the live artifact stale (still
+ * listing now-held-out instances) indefinitely. The narrow extra trigger:
+ * republish when the existing publication is CONTAMINATED — it still lists a
+ * now-held-out instance. This forces exactly the rollout / slate-bump refresh
+ * and nothing more (it does NOT republish merely because the publication diverges
+ * from local scorable, which would break the write-once / published-authoritative
+ * contract other operators recover against).
+ */
+export declare function shouldRepublishVettedPool(args: {
+    existingIds: ReadonlySet<string> | null;
+    heldOutIds: ReadonlySet<string>;
+    validatedNewer: boolean;
+}): boolean;
 export declare function createVettedPoolArtifactRef(args: {
     manifestCid: string;
     artifactCid: string;

package/dist/solver-types/_swe-rebench-v2-validated-pool.js

@@ -260,6 +260,46 @@ export function loadVettedPoolArtifactScorableEntries(raw) {
     }
     return { ids: new Set(byId.keys()), byId };
 }
+/**
+ * Substrate-level held-out exclusion (#986). Returns a copy of the artifact with
+ * the `excludeIds` instances dropped, so the PUBLISHED vetted-pool artifact — the
+ * shared substrate every generator can source its postable set from — never lists
+ * the held-out exam. This moves the exclusion up from each generator's posting
+ * decision (which only a generator running the slate code honours) to the artifact
+ * itself, so a fresh-recovery / independent / unguarded generator that reads the
+ * artifact cannot post the exam tasks either. Pure; never mutates its input. The
+ * caller re-hashes via `hashVettedPoolArtifact`.
+ */
+export function excludeFromVettedPoolArtifact(artifact, excludeIds) {
+    if (excludeIds.size === 0)
+        return artifact;
+    return { ...artifact, entries: artifact.entries.filter((e) => !excludeIds.has(e.instance_id)) };
+}
+/**
+ * Republication decision (#986). The published artifact is authoritative and
+ * write-once: it is NOT re-synced to local scorable unless the validated pool is
+ * strictly newer (the prior timestamp-gated behaviour, preserved here). But a
+ * timestamp-only check never fires when the *held-out set* changes while the
+ * validated pool is unchanged — so adding the exclusion in code, or activating a
+ * new slate version (e.g. `v3`), would leave the live artifact stale (still
+ * listing now-held-out instances) indefinitely. The narrow extra trigger:
+ * republish when the existing publication is CONTAMINATED — it still lists a
+ * now-held-out instance. This forces exactly the rollout / slate-bump refresh
+ * and nothing more (it does NOT republish merely because the publication diverges
+ * from local scorable, which would break the write-once / published-authoritative
+ * contract other operators recover against).
+ */
+export function shouldRepublishVettedPool(args) {
+    if (!args.existingIds)
+        return true;
+    if (args.validatedNewer)
+        return true;
+    for (const id of args.existingIds) {
+        if (args.heldOutIds.has(id))
+            return true;
+    }
+    return false;
+}
 export function createVettedPoolArtifactRef(args) {
     return {
         schemaVersion: SOLVERNET_ARTIFACT_REF_SCHEMA_VERSION,