@mmnto/totem 1.67.1 → 1.69.0

package/dist/spine/extract.js

@@ -0,0 +1,227 @@
+// ─── ADR-111 Stage-1 Extract (slice 2; slice 5a resolution gate): review-thread → draft DSL ──
+//
+// The miner's deterministic Extract stage. It iterates the frozen split's TRAIN
+// slice ONLY, fetches each PR's review thread through an injected port, applies
+// the resolution-eligibility gate (slice 5a: drop resolved/outdated threads,
+// mmnto-ai/totem#2201), runs a completeness check (≥1 HUMAN review comment on
+// the surviving threads), drafts zero-or-more lesson-markdown DSL bodies through
+// an injected `DraftExtractor` port, and either carries a transient
+// `DraftCandidate` or loud-drops to the drop ledger with a reason code. It writes
+// the drop + API-usage ledgers and the in-run seed-blindness fact.
+//
+// ZERO real LLM lives here: the `DraftExtractor` is a port, mocked in tests (the
+// #2188 mock-first discipline); the live LLM adapter rides a later slice. Core
+// stays network-free + LLM-free + deterministic — IO (GitHub fetch, the LLM
+// call) is the CLI layer's, injected as ports (the `Stage4VerifierDeps` DI
+// pattern).
+//
+// ADR-111 boundaries this module enforces:
+//   §1 unverified-only       — Extract mints nothing; `DraftCandidate` is a
+//                              transient stage-internal value, never the §3
+//                              `CandidateRuleRecord` (minted in slice 3).
+//   §6 fail-loud, no degrade  — every content/provenance/draft failure is a LOUD
+//                              drop-ledger entry, never a thinner extraction.
+//   §6 train-only fetch       — held-out / control / excluded PRs are NEVER
+//                              fetched (FM h); `heldOutFetchCount` is recomputed
+//                              from the frozen split, not trusted.
+//   §7 seed-blindness         — the extractor is never handed a seed class (FM f);
+//                              the fact is carried here, serialized into the
+//                              emission ledger in slice 3 (single home, Tenet 20).
+//   FM(i) (slice-2 half)      — every `trainPr` has draftCount + dropCount >= 1;
+//                              none silently skipped.
+//
+// lesson-markdown is the DSL *syntax* (ADR-058 Pipeline 1/3 target), NOT a
+// Pipeline-1 trust class: every draft body is `unverified` and Stage-4-gated by
+// the slice-4 compiler, never a manual-rule trust bypass.
+import { ProvenanceRecordSchema } from '../compiler-schema.js';
+import { TotemParseError } from '../errors.js';
+import { extractManualPattern } from '../lesson-pattern.js';
+import { isBotIdentity } from './selection-rule.js';
+// ── Helpers ──────────────────────────────────────────────────────────────────
+/**
+ * Count HUMAN review comments (fold 5): bot comments (CodeRabbit / Greptile /
+ * Renovate / dependabot, via the shared `isBotIdentity`) and empty/whitespace
+ * bodies do NOT count toward §6's "≥1 review comment" threshold — a bot-only or
+ * empty thread is content-thin and must take the loud-drop path, never seed a
+ * hallucinated draft.
+ */
+function humanCommentCount(threads) {
+    let count = 0;
+    for (const thread of threads) {
+        for (const comment of thread.comments) {
+            if (comment.body.trim().length > 0 && !isBotIdentity(comment.author))
+                count++;
+        }
+    }
+    return count;
+}
+/**
+ * The resolution-eligibility gate (slice 5a, mmnto-ai/totem#2201). A thread is
+ * INELIGIBLE if the author resolved it OR its diff hunk went outdated — either
+ * marks it as superseded review discussion, contamination the miner must not
+ * draft from. The adapter SURFACES `isResolved`/`isOutdated` (it never
+ * pre-filters); core decides here so the rejection is ledgered (§8). Returns the
+ * eligible (surviving) threads only.
+ */
+function eligibleThreads(threads) {
+    return threads.filter((t) => !t.isResolved && !t.isOutdated);
+}
+/**
+ * Syntactic preflight (fold 4): a draft is a usable lesson-markdown DSL body iff
+ * `extractManualPattern` yields a manual pattern (a flat `**Pattern:**` or a
+ * compound yaml rule). Empty/whitespace, non-empty-but-no-usable-pattern, and an
+ * authoring-error throw (yaml fence + non-`ast-grep` engine) all fail → the
+ * draft is dropped `unparseable`, never carried as a "successful" candidate
+ * merely for being non-empty.
+ */
+function isUsableDsl(dslSource) {
+    if (dslSource.trim().length === 0)
+        return false;
+    try {
+        return extractManualPattern(dslSource) !== null;
+    }
+    catch (err) {
+        // A TotemParseError is the EXPECTED authoring-error signal (e.g. a yaml fence
+        // under a non-ast-grep engine) → the draft is simply not usable DSL. Any OTHER
+        // error is an unexpected parser bug and must fail loud (Tenet 4).
+        if (err instanceof TotemParseError)
+            return false;
+        throw err;
+    }
+}
+/**
+ * Build the candidate's provenance tuple, or report why it is incomplete. `pr`
+ * and the review-thread ref are always available (we iterate the train slice and
+ * synthesize a canonical per-PR thread ref); the realistic failure is a missing
+ * or malformed merge-commit SHA, validated against `ProvenanceRecordSchema`
+ * (lowercase 40-hex). A candidate that cannot produce a complete tuple is
+ * dropped `incomplete-provenance`, never emitted partial (FM a / Tenet 4).
+ */
+function buildProvenance(pr, content) {
+    const parsed = ProvenanceRecordSchema.safeParse({
+        mergedPr: pr,
+        reviewThread: `pulls/${pr}/comments`,
+        commitSha: content.mergeCommitSha,
+    });
+    if (!parsed.success) {
+        return {
+            ok: false,
+            reason: parsed.error.issues.map((issue) => issue.message).join('; '),
+        };
+    }
+    return { ok: true, value: parsed.data };
+}
+// ── The Extract stage ─────────────────────────────────────────────────────────
+/**
+ * Run the deterministic Stage-1 Extract over a frozen split. Deterministic given
+ * its deps: identical `split` + deps → identical drafts, drops, and ledgers (the
+ * train slice is awaited sequentially, so ordering is stable). The
+ * live LLM and GitHub IO are injected ports, so this orchestration is fully
+ * CI-locked with a fixture extractor + a strict-spy fetch source.
+ *
+ * Per train PR (and ONLY train PRs): log the fetch → fetch → on unreachable /
+ * unparseable-at-source, loud-drop → resolution-eligibility gate (slice 5a: drop
+ * `resolved-rejected` when the resolution gate empties an otherwise-human thread,
+ * else `truncated` when thin to begin with) → completeness-check (≥1 human
+ * comment on the survivors) → build provenance → draft zero-or-more bodies from
+ * the SURVIVING threads only → preflight each → carry a `DraftCandidate` or
+ * loud-drop. Every train PR ends with at least one draft or one drop (FM i,
+ * slice-2 half).
+ */
+export async function runExtractStage(split, deps) {
+    const trainSet = new Set(split.trainPrs);
+    const drafts = [];
+    const dropEntries = [];
+    const apiEntries = [];
+    const drop = (sourcePr, reasonCode, detail) => {
+        dropEntries.push({ sourcePr, reasonCode, detail });
+    };
+    // Iterate the TRAIN slice ONLY — held-out / control / excluded PRs are never
+    // fetched (§6 / FM h). Deterministic ascending order.
+    const trainPrs = [...trainSet].sort((a, b) => a - b);
+    for (const pr of trainPrs) {
+        // Every attempted content fetch is logged as a train-slice fetch (the audit
+        // surface FM h reads). We only ever target train PRs, so this is always
+        // `slice: 'train'`.
+        apiEntries.push({ targetPr: pr, slice: 'train', fetchKind: 'review-thread' });
+        const result = await deps.source.fetch(pr);
+        if (result.kind === 'unreachable') {
+            drop(pr, 'unreachable', result.detail ?? `review thread unreachable for train PR #${pr}`);
+            continue;
+        }
+        if (result.kind === 'unparseable') {
+            drop(pr, 'unparseable', result.detail ?? `review thread unparseable for train PR #${pr}`);
+            continue;
+        }
+        const content = result.content;
+        // Content-identity guard: the fetched content MUST be for the requested train
+        // PR. A source adapter that returns mismatched content would otherwise mint a
+        // draft attributed to the wrong PR — a provenance-integrity failure → loud drop.
+        if (content.pr !== pr) {
+            drop(pr, 'incomplete-provenance', `fetched content PR #${content.pr} does not match requested train PR #${pr}`);
+            continue;
+        }
+        // Resolution-eligibility gate (slice 5a, mmnto-ai/totem#2201) — BEFORE the
+        // completeness check. The adapter surfaced per-thread `isResolved`/`isOutdated`
+        // (it never pre-filters); core decides + ledgers here so every resolution
+        // rejection is auditable (§8). Filter to eligible (non-resolved, non-outdated)
+        // threads and recount human comments on the SURVIVORS only.
+        const preFilterHumanCount = humanCommentCount(content.threads);
+        const survivingThreads = eligibleThreads(content.threads);
+        const survivorHumanCount = humanCommentCount(survivingThreads);
+        if (survivorHumanCount < 1) {
+            if (preFilterHumanCount >= 1) {
+                // The thread carried human content, but the resolution gate is what
+                // emptied it → `resolved-rejected` (an eligibility rejection, not thin
+                // content). Carry the concrete resolution evidence in the detail.
+                const ineligible = content.threads.length - survivingThreads.length;
+                drop(pr, 'resolved-rejected', `${ineligible} of ${content.threads.length} threads resolved/outdated; ${survivorHumanCount} eligible human comments remain`);
+            }
+            else {
+                // Thin to begin with (0 human comments BEFORE the resolution gate) — the
+                // existing `truncated` path, NOT a resolution rejection.
+                drop(pr, 'truncated', 'no non-empty human review comment after bot filtering');
+            }
+            continue;
+        }
+        // Provenance must be complete or the PR is dropped, never partial (FM a).
+        const provenance = buildProvenance(pr, content);
+        if (!provenance.ok) {
+            drop(pr, 'incomplete-provenance', provenance.reason);
+            continue;
+        }
+        // Draft from the SURVIVING (eligible) threads ONLY — resolved/outdated threads
+        // are excluded from the extractor's input so no draft can be seeded from
+        // superseded review discussion (the `content.pr`/`mergeCommitSha` provenance
+        // is preserved). Zero-or-more DSL bodies (fold 1, list-shaped). Per the port's
+        // error contract the extractor returns [] on a per-PR failure (the CLI adapter
+        // catches its own LLM/network errors) — so the core needs no swallowing catch
+        // (Tenet 4). An empty list is a loud drop below, not a silent skip.
+        const eligibleContent = { ...content, threads: survivingThreads };
+        const draftBodies = await deps.extractor.draft(eligibleContent);
+        if (draftBodies.length === 0) {
+            // A complete thread that yields no draft is a loud drop (keeps the train PR
+            // creditable under FM i), not a silent skip.
+            drop(pr, 'unparseable', 'extractor produced no draft from a complete thread');
+            continue;
+        }
+        for (const body of draftBodies) {
+            if (!isUsableDsl(body)) {
+                drop(pr, 'unparseable', 'draft is empty or carries no usable **Pattern:**/yaml DSL');
+                continue;
+            }
+            drafts.push({ provenance: provenance.value, dslSource: body });
+        }
+    }
+    // Recompute the held-out-fetch count from the frozen split rather than trust a
+    // self-declared label (fold 6): any logged fetch whose target is not in the
+    // train slice is a violation. 0 by construction here.
+    const heldOutFetchCount = apiEntries.filter((entry) => !trainSet.has(entry.targetPr)).length;
+    return {
+        drafts,
+        dropLedger: { entries: dropEntries },
+        apiUsageLedger: { entries: apiEntries, heldOutFetchCount },
+        seedBlindness: { seedClassesProvided: deps.seedClassesProvided },
+    };
+}
+//# sourceMappingURL=extract.js.map

package/dist/spine/extract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.js","sourceRoot":"","sources":["../../src/spine/extract.ts"],"names":[],"mappings":"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"}

package/dist/spine/extract.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=extract.test.d.ts.map

package/dist/spine/extract.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.test.d.ts","sourceRoot":"","sources":["../../src/spine/extract.test.ts"],"names":[],"mappings":""}

package/dist/spine/extract.test.js

@@ -0,0 +1,382 @@
+import { describe, expect, it } from 'vitest';
+import { runExtractStage, } from './extract.js';
+import { SplitArtifactSchema } from './split.js';
+// ─── Helpers ──────────────────────────────────────────────────────────────
+const sha = (n) => String(n).padStart(40, '0');
+function split(overrides) {
+    return SplitArtifactSchema.parse({
+        asOfCommit: sha(100),
+        trainPrs: [1, 2],
+        heldOutPrs: [3, 4],
+        excludedPrs: [],
+        positiveControlPrs: [3],
+        negativeControlPrs: [4],
+        splitRule: { predicate: 'code-touching non-bot', cutIndex: 2 },
+        ...overrides,
+    });
+}
+/** A usable lesson-markdown body (flat `**Pattern:**`) — passes the preflight. */
+const USABLE_DSL = '**Pattern:** foo';
+/** Non-empty, but no usable `**Pattern:**` — fails the preflight → `unparseable`. */
+const NO_PATTERN_DSL = 'This is just prose with no pattern field.';
+/**
+ * Non-empty, but makes `extractManualPattern` THROW a TotemParseError (a yaml
+ * `**Pattern:**` fence under a non-`ast-grep` engine). The preflight's catch
+ * converts that to a drop, never a propagated throw.
+ */
+const PARSER_THROW_DSL = [
+    '**Pattern:**',
+    '```yaml',
+    'rule:',
+    '  pattern: foo',
+    '```',
+    '**Engine:** regex',
+].join('\n');
+function content(pr, overrides) {
+    return {
+        pr,
+        mergeCommitSha: sha(pr),
+        threads: [
+            {
+                path: 'packages/core/src/x.ts',
+                comments: [{ author: 'Jane Doe', body: 'a real review note' }],
+                isResolved: false,
+                isOutdated: false,
+            },
+        ],
+        ...overrides,
+    };
+}
+/** A review thread with explicit resolution flags (default: eligible). */
+function thread(author, body, flags) {
+    return {
+        path: 'packages/core/src/x.ts',
+        comments: [{ author, body }],
+        isResolved: flags?.isResolved ?? false,
+        isOutdated: flags?.isOutdated ?? false,
+    };
+}
+/**
+ * Strict-spy fetch source (fold 6): throws if asked for a non-train PR, records
+ * what it fetched, and serves a per-PR `FetchResult` (default: ok with a
+ * standard thread). Async — mirrors the network-IO port shape.
+ */
+function spySource(trainPrs, results) {
+    const trainSet = new Set(trainPrs);
+    const fetched = [];
+    return {
+        fetched,
+        async fetch(pr) {
+            if (!trainSet.has(pr)) {
+                throw new Error(`[Totem Error] Extractor violated train boundary: fetched non-train PR ${pr}`);
+            }
+            fetched.push(pr);
+            return results?.get(pr) ?? { kind: 'ok', content: content(pr) };
+        },
+    };
+}
+/** Fixture extractor: per-PR draft bodies from a map (default: one usable body). Async. */
+function fixtureExtractor(byPr) {
+    return {
+        async draft(c) {
+            return byPr?.get(c.pr) ?? [USABLE_DSL];
+        },
+    };
+}
+const deps = (source, extractor, seedClassesProvided = false) => ({
+    source,
+    extractor,
+    seedClassesProvided,
+});
+const coveredPrs = (r) => new Set([
+    ...r.drafts.map((d) => d.provenance.mergedPr),
+    ...r.dropLedger.entries.map((e) => e.sourcePr),
+]);
+const dropsFor = (r, pr) => r.dropLedger.entries.filter((e) => e.sourcePr === pr);
+// A single-train-PR split (PR 1), the rest held-out — for per-drop-code fixtures.
+const solo = () => split({ trainPrs: [1], heldOutPrs: [2, 3, 4], positiveControlPrs: [3], negativeControlPrs: [4] });
+// ─── Happy path ─────────────────────────────────────────────────────────────
+describe('runExtractStage — happy path', () => {
+    it('emits one draft per train PR with complete provenance and clean ledgers', async () => {
+        const r = await runExtractStage(split(), deps(spySource([1, 2]), fixtureExtractor()));
+        expect(r.drafts).toHaveLength(2);
+        expect(r.drafts.map((d) => d.provenance.mergedPr).sort()).toEqual([1, 2]);
+        expect(r.drafts[0].provenance).toEqual({
+            mergedPr: 1,
+            reviewThread: 'pulls/1/comments',
+            commitSha: sha(1),
+        });
+        expect(r.drafts[0].dslSource).toBe(USABLE_DSL);
+        expect(r.dropLedger.entries).toEqual([]);
+        expect(r.apiUsageLedger.entries).toHaveLength(2);
+        expect(r.apiUsageLedger.entries.every((e) => e.slice === 'train')).toBe(true);
+        expect(r.apiUsageLedger.heldOutFetchCount).toBe(0);
+    });
+    it('iterates the train slice in deterministic ascending order', async () => {
+        const source = spySource([2, 1]); // train listed out of order
+        await runExtractStage(split({ trainPrs: [2, 1], heldOutPrs: [3, 4] }), deps(source, fixtureExtractor()));
+        expect(source.fetched).toEqual([1, 2]);
+    });
+});
+// ─── Drop reason codes (one red fixture per code) ────────────────────────────
+describe('runExtractStage — drop reason codes', () => {
+    it('unreachable: source reports the thread never fetched', async () => {
+        const r = await runExtractStage(solo(), deps(spySource([1], new Map([[1, { kind: 'unreachable' }]])), fixtureExtractor()));
+        expect(dropsFor(r, 1)).toEqual([
+            expect.objectContaining({ sourcePr: 1, reasonCode: 'unreachable' }),
+        ]);
+        expect(r.drafts).toEqual([]);
+    });
+    it('unparseable (at source): a fetched-but-unparseable thread', async () => {
+        const r = await runExtractStage(solo(), deps(spySource([1], new Map([[1, { kind: 'unparseable' }]])), fixtureExtractor()));
+        expect(dropsFor(r, 1)[0].reasonCode).toBe('unparseable');
+    });
+    it('truncated: an empty thread (no comments)', async () => {
+        const r = await runExtractStage(solo(), deps(spySource([1], new Map([[1, { kind: 'ok', content: content(1, { threads: [] }) }]])), fixtureExtractor()));
+        expect(dropsFor(r, 1)[0].reasonCode).toBe('truncated');
+    });
+    it('truncated: a bot-only thread does not satisfy ≥1 human comment (fold 5)', async () => {
+        const botThread = content(1, {
+            threads: [
+                {
+                    path: 'x.ts',
+                    comments: [{ author: 'coderabbitai[bot]', body: 'nit: rename this' }],
+                    isResolved: false,
+                    isOutdated: false,
+                },
+            ],
+        });
+        const r = await runExtractStage(solo(), deps(spySource([1], new Map([[1, { kind: 'ok', content: botThread }]])), fixtureExtractor()));
+        expect(dropsFor(r, 1)[0].reasonCode).toBe('truncated');
+    });
+    it('truncated: a whitespace-only human comment counts as no comment', async () => {
+        const wsThread = content(1, {
+            threads: [
+                {
+                    path: 'x.ts',
+                    comments: [{ author: 'Jane Doe', body: '   ' }],
+                    isResolved: false,
+                    isOutdated: false,
+                },
+            ],
+        });
+        const r = await runExtractStage(solo(), deps(spySource([1], new Map([[1, { kind: 'ok', content: wsThread }]])), fixtureExtractor()));
+        expect(dropsFor(r, 1)[0].reasonCode).toBe('truncated');
+    });
+    it('incomplete-provenance: a malformed merge-commit SHA', async () => {
+        const badSha = content(1, { mergeCommitSha: 'NOTASHA' });
+        const r = await runExtractStage(solo(), deps(spySource([1], new Map([[1, { kind: 'ok', content: badSha }]])), fixtureExtractor()));
+        expect(dropsFor(r, 1)[0].reasonCode).toBe('incomplete-provenance');
+        expect(r.drafts).toEqual([]);
+    });
+    it('incomplete-provenance: fetched content for the wrong PR is a loud drop (CR-3)', async () => {
+        const mismatched = content(2); // content says PR 2, but PR 1 was requested
+        const r = await runExtractStage(solo(), deps(spySource([1], new Map([[1, { kind: 'ok', content: mismatched }]])), fixtureExtractor()));
+        expect(dropsFor(r, 1)[0].reasonCode).toBe('incomplete-provenance');
+        expect(dropsFor(r, 1)[0].detail).toContain('does not match');
+        expect(r.drafts).toEqual([]);
+    });
+    it('unparseable: a non-empty draft with no usable **Pattern:** (fold 4 preflight)', async () => {
+        const r = await runExtractStage(solo(), deps(spySource([1]), fixtureExtractor(new Map([[1, [NO_PATTERN_DSL]]]))));
+        expect(dropsFor(r, 1)[0].reasonCode).toBe('unparseable');
+        expect(r.drafts).toEqual([]);
+    });
+    it('unparseable: a draft that makes the parser throw is converted to a drop, not propagated (CR-2)', async () => {
+        const r = await runExtractStage(solo(), deps(spySource([1]), fixtureExtractor(new Map([[1, [PARSER_THROW_DSL]]]))));
+        expect(dropsFor(r, 1)[0].reasonCode).toBe('unparseable');
+        expect(r.drafts).toEqual([]);
+    });
+    it('unparseable: the extractor produced no draft from a complete thread', async () => {
+        const r = await runExtractStage(solo(), deps(spySource([1]), fixtureExtractor(new Map([[1, []]]))));
+        expect(dropsFor(r, 1)[0].reasonCode).toBe('unparseable');
+    });
+    it('a contract-violating extractor throw propagates (fail-loud, not swallowed)', async () => {
+        // The port contract is: return [] on a per-PR failure (the CLI adapter catches
+        // its own IO errors). A throw VIOLATES that contract and must NOT be silently
+        // swallowed — it propagates (Tenet 4). Per-PR resilience is the adapter's job;
+        // the []-returns path is covered by "extractor produced no draft" above.
+        const throwingExtractor = {
+            async draft(c) {
+                if (c.pr === 1)
+                    throw new Error('boom');
+                return [USABLE_DSL];
+            },
+        };
+        await expect(runExtractStage(split(), deps(spySource([1, 2]), throwingExtractor))).rejects.toThrow('boom');
+    });
+});
+// ─── FM(i) slice-2 half: N-draft / M-drop accounting (fold 1) ─────────────────
+describe('runExtractStage — FM(i) slice-2 accounting (at-least-one, list-shaped)', () => {
+    it('a single PR may yield N drafts', async () => {
+        const r = await runExtractStage(solo(), deps(spySource([1]), fixtureExtractor(new Map([[1, [USABLE_DSL, USABLE_DSL]]]))));
+        expect(r.drafts).toHaveLength(2);
+        expect(r.drafts.every((d) => d.provenance.mergedPr === 1)).toBe(true);
+    });
+    it('a single PR may yield a draft AND a drop', async () => {
+        const r = await runExtractStage(solo(), deps(spySource([1]), fixtureExtractor(new Map([[1, [USABLE_DSL, NO_PATTERN_DSL]]]))));
+        expect(r.drafts).toHaveLength(1);
+        expect(dropsFor(r, 1)).toHaveLength(1);
+        expect(dropsFor(r, 1)[0].reasonCode).toBe('unparseable');
+    });
+    it('every train PR is creditable: draftCount + dropCount >= 1 (none silently skipped)', async () => {
+        // PR 1 drafts, PR 2 is unreachable (drop-only) — both covered.
+        const r = await runExtractStage(split(), deps(spySource([1, 2], new Map([[2, { kind: 'unreachable' }]])), fixtureExtractor()));
+        expect(coveredPrs(r)).toEqual(new Set([1, 2]));
+    });
+    it('the coverage check has teeth — a PR in neither drafts nor drops is detectable', async () => {
+        const r = await runExtractStage(split(), deps(spySource([1, 2]), fixtureExtractor()));
+        expect(coveredPrs(r)).toEqual(new Set([1, 2]));
+        // Simulate a silent skip of PR 2; the FM(i) coverage check flags it.
+        const doctored = {
+            ...r,
+            drafts: r.drafts.filter((d) => d.provenance.mergedPr !== 2),
+            dropLedger: { entries: r.dropLedger.entries.filter((e) => e.sourcePr !== 2) },
+        };
+        const missing = [1, 2].filter((pr) => !coveredPrs(doctored).has(pr));
+        expect(missing).toEqual([2]);
+    });
+});
+// ─── Train-only fetch boundary (FM h, fold 6) ─────────────────────────────────
+describe('runExtractStage — train-only fetch boundary', () => {
+    it('the spy source hard-fails if a non-train PR is fetched', async () => {
+        const source = spySource([1, 2]);
+        await expect(source.fetch(3)).rejects.toThrow(/non-train PR 3/);
+    });
+    it('never fetches a held-out / control / excluded PR; heldOutFetchCount stays 0', async () => {
+        const source = spySource([1, 2]);
+        const r = await runExtractStage(split({ trainPrs: [1, 2], heldOutPrs: [3, 4], excludedPrs: [] }), deps(source, fixtureExtractor()));
+        expect(source.fetched).toEqual([1, 2]); // only train PRs touched
+        expect(r.apiUsageLedger.entries.map((e) => e.targetPr).sort()).toEqual([1, 2]);
+        expect(r.apiUsageLedger.heldOutFetchCount).toBe(0);
+    });
+    it('heldOutFetchCount is derived from the frozen split, not a trusted label', async () => {
+        // Every logged entry targets a train PR → recomputed count is 0 regardless.
+        const r = await runExtractStage(split(), deps(spySource([1, 2]), fixtureExtractor()));
+        const recomputed = r.apiUsageLedger.entries.filter((e) => ![1, 2].includes(e.targetPr)).length;
+        expect(recomputed).toBe(r.apiUsageLedger.heldOutFetchCount);
+    });
+});
+// ─── Seed-blindness (FM f, carried in-run) ────────────────────────────────────
+describe('runExtractStage — seed-blindness', () => {
+    it('carries seedClassesProvided=false through to the result', async () => {
+        const r = await runExtractStage(split(), deps(spySource([1, 2]), fixtureExtractor(), false));
+        expect(r.seedBlindness.seedClassesProvided).toBe(false);
+    });
+    it('faithfully carries a violated attestation (slice 3 / the harness asserts it)', async () => {
+        const r = await runExtractStage(split(), deps(spySource([1, 2]), fixtureExtractor(), true));
+        expect(r.seedBlindness.seedClassesProvided).toBe(true);
+    });
+});
+// ─── Resolution-eligibility gate (slice 5a, mmnto-ai/totem#2201) ──────────────
+/** A fixture extractor that records the content it was handed (to assert filtering). */
+function recordingExtractor(byPr) {
+    const seen = [];
+    return {
+        seen,
+        async draft(c) {
+            seen.push(c);
+            return byPr?.get(c.pr) ?? [USABLE_DSL];
+        },
+    };
+}
+describe('runExtractStage — resolution-eligibility gate (slice 5a)', () => {
+    it('all-resolved-but-had-human-content drops resolved-rejected (not truncated)', async () => {
+        const allResolved = content(1, {
+            threads: [
+                thread('Jane Doe', 'a real review note', { isResolved: true }),
+                thread('John Roe', 'another note', { isOutdated: true }),
+            ],
+        });
+        const r = await runExtractStage(solo(), deps(spySource([1], new Map([[1, { kind: 'ok', content: allResolved }]])), fixtureExtractor()));
+        expect(dropsFor(r, 1)[0].reasonCode).toBe('resolved-rejected');
+        expect(r.drafts).toEqual([]);
+    });
+    it('the resolved-rejected drop detail carries concrete resolution evidence', async () => {
+        const allResolved = content(1, {
+            threads: [
+                thread('Jane Doe', 'a real review note', { isResolved: true }),
+                thread('John Roe', 'another note', { isOutdated: true }),
+            ],
+        });
+        const r = await runExtractStage(solo(), deps(spySource([1], new Map([[1, { kind: 'ok', content: allResolved }]])), fixtureExtractor()));
+        const detail = dropsFor(r, 1)[0].detail ?? '';
+        expect(detail).toContain('2 of 2 threads resolved/outdated');
+        expect(detail).toContain('0 eligible human comments remain');
+    });
+    it('thin-to-begin-with (0 human comments before the gate) stays truncated, not resolved-rejected', async () => {
+        // A resolved thread that ALSO had no human comment — the resolution gate is
+        // not what emptied it; it was already thin. Keep the existing truncated path.
+        const botResolved = content(1, {
+            threads: [thread('coderabbitai[bot]', 'nit: rename this', { isResolved: true })],
+        });
+        const r = await runExtractStage(solo(), deps(spySource([1], new Map([[1, { kind: 'ok', content: botResolved }]])), fixtureExtractor()));
+        expect(dropsFor(r, 1)[0].reasonCode).toBe('truncated');
+    });
+    it('partial resolution: survivors are processed; resolved threads excluded from the draft input', async () => {
+        const mixed = content(1, {
+            threads: [
+                thread('Jane Doe', 'eligible note A'),
+                thread('John Roe', 'resolved note B', { isResolved: true }),
+                thread('Kate Poe', 'outdated note C', { isOutdated: true }),
+            ],
+        });
+        const extractor = recordingExtractor();
+        const r = await runExtractStage(solo(), deps(spySource([1], new Map([[1, { kind: 'ok', content: mixed }]])), extractor));
+        // The PR is processed (a draft, no drop).
+        expect(r.drafts).toHaveLength(1);
+        expect(dropsFor(r, 1)).toEqual([]);
+        // The extractor only saw the ONE eligible thread — resolved/outdated excluded.
+        expect(extractor.seen).toHaveLength(1);
+        const seenThreads = extractor.seen[0].threads;
+        expect(seenThreads).toHaveLength(1);
+        expect(seenThreads[0].comments[0].body).toBe('eligible note A');
+        expect(seenThreads.every((t) => !t.isResolved && !t.isOutdated)).toBe(true);
+    });
+    it('partial resolution: resolved threads do not count toward the human-comment threshold', async () => {
+        // The single eligible thread is bot-only; the resolved thread is the only one
+        // with a human comment. Survivors have 0 human comments → resolved-rejected.
+        const mixed = content(1, {
+            threads: [
+                thread('coderabbitai[bot]', 'nit: rename', { isResolved: false }),
+                thread('Jane Doe', 'a real human note', { isResolved: true }),
+            ],
+        });
+        const r = await runExtractStage(solo(), deps(spySource([1], new Map([[1, { kind: 'ok', content: mixed }]])), fixtureExtractor()));
+        expect(dropsFor(r, 1)[0].reasonCode).toBe('resolved-rejected');
+        expect(r.drafts).toEqual([]);
+    });
+    it('a fully-eligible thread is unaffected by the gate (no regression)', async () => {
+        const r = await runExtractStage(solo(), deps(spySource([1]), fixtureExtractor()));
+        expect(r.drafts).toHaveLength(1);
+        expect(dropsFor(r, 1)).toEqual([]);
+    });
+});
+// ─── Determinism ──────────────────────────────────────────────────────────────
+describe('runExtractStage — determinism', () => {
+    it('identical inputs + fixed deps produce identical output', async () => {
+        const run = () => runExtractStage(split(), deps(spySource([1, 2], new Map([[2, { kind: 'unreachable' }]])), fixtureExtractor(new Map([[1, [USABLE_DSL, NO_PATTERN_DSL]]]))));
+        expect(await run()).toEqual(await run());
+    });
+    it('identical inputs are deterministic across the resolution gate (drafts + drops + ledgers)', async () => {
+        // PR 1: a partial-resolution mix (one eligible survivor → a draft).
+        // PR 2: all-resolved-but-had-human-content → a resolved-rejected drop.
+        const pr1 = content(1, {
+            threads: [
+                thread('Jane Doe', 'eligible note', { isResolved: false }),
+                thread('John Roe', 'resolved note', { isResolved: true }),
+            ],
+        });
+        const pr2 = content(2, {
+            threads: [thread('Kate Poe', 'a real note', { isOutdated: true })],
+        });
+        const run = () => runExtractStage(split(), deps(spySource([1, 2], new Map([
+            [1, { kind: 'ok', content: pr1 }],
+            [2, { kind: 'ok', content: pr2 }],
+        ])), fixtureExtractor()));
+        const a = await run();
+        const b = await run();
+        expect(a).toEqual(b);
+        expect(dropsFor(a, 2)[0].reasonCode).toBe('resolved-rejected');
+    });
+});
+//# sourceMappingURL=extract.test.js.map