@holmes-lab/holmes-kit 0.15.0 → 0.17.0

package/dist/holmes/hooks/rtm-refresh.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTM_REFRESH_MARKER = exports.RTM_REFRESH_TTL_MS = void 0;
+exports.maybeSpawnRtmRefresh = maybeSpawnRtmRefresh;
+// @implements A-SPEC-566.4
+/**
+ * Graph freshness, kept by the product itself. The impact advisory's quality factor was MEASURED to
+ * be staleness (an 8-day-old graph found 7 advisories; a 1-second reindex found 17), so the Stop
+ * hook — the moment changes exist — spawns a DETACHED reindex behind a TTL gate. The idiom is
+ * A-SPEC-547.2's update refresh verbatim: TTL file, detached child, fail-soft everywhere; the
+ * parent never waits (zero turn latency) and the approval path still only ever REOPENS the graph.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+exports.RTM_REFRESH_TTL_MS = 30 * 60 * 1000;
+exports.RTM_REFRESH_MARKER = path.join('.ax', 'state', 'rtm-refresh-last');
+function maybeSpawnRtmRefresh(opts) {
+    try {
+        if (!fs.existsSync(path.join(opts.root, '.ax')))
+            return; // nothing to refresh
+        const marker = path.join(opts.root, exports.RTM_REFRESH_MARKER);
+        const ttl = opts.ttlMs ?? exports.RTM_REFRESH_TTL_MS;
+        try {
+            const age = opts.now - fs.statSync(marker).mtimeMs;
+            if (age < ttl)
+                return; // one refresh per window
+        }
+        catch { /* absent marker → refresh is due */ }
+        // Touch BEFORE spawning: a burst of Stops inside one window must not stampede children.
+        try {
+            fs.mkdirSync(path.dirname(marker), { recursive: true });
+            fs.writeFileSync(marker, String(opts.now));
+            fs.utimesSync(marker, new Date(opts.now), new Date(opts.now));
+        }
+        catch { /* an unwritable marker is not a reason to skip the refresh itself */ }
+        const child = opts.spawn(opts.execPath, [opts.scriptPath, opts.root], { detached: true, stdio: 'ignore' });
+        child?.unref?.();
+    }
+    catch { /* freshness is maintenance, never a hook failure */ }
+}
+// The child lives in rtm-refresh-child.ts, NOT here: this module is required by the Stop hook, and
+// the gate path must never carry the AST substrate (A-SPEC-510.2 pinned it, and its static check
+// caught the first cut of this slice doing exactly that). The gate side is fs+path only.

package/dist/holmes/hooks/stop.js

@@ -910,6 +910,48 @@ if (require.main === module) {
             const unrecorded = unrecordedApprovals(stopProjectRoot());
             // @implements A-SPEC-455
             const rolledBack = rolledBackLedgers(stopProjectRoot());
+            // @implements A-SPEC-564.2 — the Claude usage enrichment: numbers out of transcript_path into
+            // the session-context ledger, once per session. Capability-declared: Codex/AGY pass no
+            // transcript_path and skip silently. Fail-open around EVERYTHING — observation never touches
+            // the verdict below (Judgments must not be budgeted), and a giant transcript yields a capped
+            // partial sum, never a slow Stop.
+            try {
+                const tPath = input.transcript_path;
+                if (typeof tPath === 'string' && tPath !== '') {
+                    const sc = require('../governance/session-context');
+                    const root = stopProjectRoot();
+                    const already = sc.readSessionContext(root).some((r) => r.kind === 'usage' && r.sessionKey === sessionId);
+                    if (!already) {
+                        // Adversarial round (2026-09-06): a FIFO at transcript_path blocked this read FOREVER,
+                        // wedging every turn end — the queue writer's round-7 lesson, replayed on the observer.
+                        // TYPE BEFORE READ: only a regular file is a transcript; anything else is a silent skip.
+                        if (!fs.lstatSync(tPath).isFile())
+                            throw new Error('not a regular file');
+                        const text = fs.readFileSync(tPath, 'utf8');
+                        const sum = sc.summarizeTranscript(text.split('\n'));
+                        if (sum.turns > 0) {
+                            sc.appendSessionContext(root, {
+                                kind: 'usage', sessionKey: sessionId, models: sum.models, usage: sum.usage,
+                                turns: sum.turns, ...(sum.truncated ? { truncated: true } : {}), ts: new Date().toISOString(),
+                            });
+                        }
+                    }
+                }
+            }
+            catch { /* silent skip — the other harnesses' path, and any read failure, land here */ }
+            // @implements A-SPEC-566.4 — graph freshness rides the same turn boundary, detached and
+            // TTL-gated (A-SPEC-547.2's idiom): staleness was MEASURED to be the advisory's quality
+            // factor (7 findings on an 8-day graph, 17 after a 1s reindex). Never waits, never judges.
+            try {
+                const { maybeSpawnRtmRefresh } = require('./rtm-refresh');
+                const cp = require('node:child_process');
+                maybeSpawnRtmRefresh({
+                    root: stopProjectRoot(), now: Date.now(), execPath: process.execPath,
+                    scriptPath: path.resolve(__dirname, 'rtm-refresh-child.js'),
+                    spawn: (cmd, args, o) => cp.spawn(cmd, args, o),
+                });
+            }
+            catch { /* maintenance, never a hook failure */ }
             let out = evaluateStop(specs, { testCasesByAspec, provenance, executedByAspec, findings, findingsUnreadable, unanchoredChangedSources: unanchored, unrecordedApprovals: unrecorded, rolledBackLedgers: rolledBack, redFirstMode, changedAspecs, outcomesByAspec });
             // @implements A-SPEC-534.4 — track mode records ART-8 findings without blocking: surface them so
             // the operator observes RED-first gaps before an owner promotes the posture to strict.

package/dist/holmes/mcp/handlers.d.ts

@@ -261,23 +261,19 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         reason: string;
         findings?: undefined;
         conflict?: undefined;
-        approved?: undefined;
-        digest?: undefined;
     } | {
         ok: boolean;
         reason: string;
         findings: import("../spec/validator").Finding[];
         conflict?: undefined;
-        approved?: undefined;
-        digest?: undefined;
     } | {
         ok: boolean;
         reason: string;
         conflict: import("../spec/version-conflict").ConflictDetail;
         findings?: undefined;
-        approved?: undefined;
-        digest?: undefined;
     } | {
+        anchorDensity?: import("../rtm/anchor-density").AnchorDensityFinding[] | undefined;
+        impactAdvisory?: import("../rtm/impact-advisory").ImpactAdvisory | undefined;
         approved: string;
         digest: string;
         ok?: undefined;
@@ -535,7 +531,6 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         changed: string[];
     }): Promise<{
         breadthWarning?: string | undefined;
-        impacted: string[];
         rankedImpact: {
             file: string;
             score: number;
@@ -546,6 +541,12 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
             reason: "hub" | "depth";
             inDegree?: number;
         }[] | undefined;
+        summariesOmitted?: number | undefined;
+        impacted: string[];
+        impactedSummaries: {
+            id: string;
+            summary: string | null;
+        }[];
     }>;
     rtm_reindex(a: {
         root: string;

package/dist/holmes/mcp/handlers.js

@@ -151,8 +151,16 @@ const cacheDirFor = (root) => {
 };
 // @implements A-SPEC-283 — bumped whenever the graph's node/edge shape changes, so a store written
 // by an older build is rebuilt rather than read with new assumptions.
-const RTM_GRAPH_SCHEMA = 'rtm-graph/2';
-const RTM_EXTRACTOR_VERSION = 'holmes-rtm/1';
+// @implements A-SPEC-568.1 — /3: nodes gained the intent `summary` column.
+const RTM_GRAPH_SCHEMA = 'rtm-graph/3';
+// @implements A-SPEC-569.3 — how many impacted specs get their intent sentence attached. A prose
+// constant, never a verdict input: the impacted list itself is never truncated.
+const SUMMARY_CAP = 40;
+// @implements A-SPEC-569.1 (revision) — /2: pre-fix 0.16.0 builds could persist forged structural
+// characters in the summary column, and every other basis field would still match after upgrading.
+// A-SPEC-283's own rule applies to us too: an older build's artifact is rebuilt, never read with
+// new assumptions.
+const RTM_EXTRACTOR_VERSION = 'holmes-rtm/2';
 const cachedScan = (root, repoRoot = root) => new cpg_scanner_1.CpgScanner(undefined, new scan_cache_1.ScanFileCache(cacheDirFor(root))).scan(root, repoRoot);
 // @implements A-SPEC-131
 // Same scan, with the skip report kept: the callers that make honesty claims (cpg_scan's surface,
@@ -1684,7 +1692,75 @@ function makeRawHandlers(store, opts) {
             if (approveResolved.source === 'grant' && approveResolved.root && approveResolved.approval.nonce) {
                 (0, approval_grants_1.consumeGrantFile)(approveResolved.root, approveResolved.approval.nonce);
             }
-            return { approved: a.id, digest };
+            // @implements A-SPEC-566.2 — the impact advisory rides the SUCCESS, after the seal is done:
+            // the verdict is already committed, so nothing here can change it (advisory, never gate —
+            // Judgments must not be budgeted). Reuses the persisted graph READ-ONLY; it never scans,
+            // parses or builds (scan:build measured 20~38x — an approval must not pay that), and every
+            // failure below degrades to "no advisory field" on an otherwise identical response.
+            let impactAdvisory;
+            let anchorDensity;
+            try {
+                if (spec.type === 'A-SPEC' && a.root) {
+                    const dbPath = path.join(a.root, '.ax', 'rtm.sqlite');
+                    if (fs.existsSync(dbPath)) {
+                        const { declaredImpactGap, appendImpactAdvisory } = require('../rtm/impact-advisory');
+                        const { filesToTouch } = require('../spec/compat-impact');
+                        const { RtmGraph } = require('../rtm/rtm-graph');
+                        // Closed in finally (high-effort review F4): this handler lives in a long-running MCP
+                        // server, and an unclosed native handle per approval accumulates for the process
+                        // lifetime — and on Windows can hold rtm.sqlite locked against the next rebuild.
+                        const graph = new RtmGraph(dbPath);
+                        try {
+                            const ftt = filesToTouch(candidate);
+                            const gap = declaredImpactGap(ftt, graph, (rel) => { try {
+                                return fs.readFileSync(path.join(a.root, rel), 'utf8');
+                            }
+                            catch {
+                                return null;
+                            } });
+                            if (gap) {
+                                const graphAsOf = (() => { try {
+                                    return fs.statSync(dbPath).mtime.toISOString();
+                                }
+                                catch {
+                                    return undefined;
+                                } })();
+                                impactAdvisory = { ...gap, ...(graphAsOf ? { graphAsOf } : {}) };
+                                appendImpactAdvisory(a.root, {
+                                    aspec: a.id, files: gap.files.map((f) => f.path), more: gap.more,
+                                    ...(graphAsOf ? { graphAsOf } : {}), ts: new Date().toISOString(),
+                                });
+                            }
+                            // @implements A-SPEC-569.5 — anchor-density OBSERVATION, same reopened graph, same
+                            // no-scan contract, same lifecycle as the advisory above (observe → ledger → measure
+                            // before anyone proposes promotion). Never a verdict input: the seal is already done,
+                            // and its own failure degrades to "no field" on an otherwise identical response.
+                            try {
+                                const { anchorDensityFindings, appendAnchorDensity } = require('../rtm/anchor-density');
+                                const findings = anchorDensityFindings(ftt, graph.implementsAnchorCounts());
+                                if (findings.length > 0) {
+                                    anchorDensity = findings;
+                                    appendAnchorDensity(a.root, {
+                                        aspec: a.id, files: findings.map((f) => ({ path: f.path, anchors: f.anchors })),
+                                        p90: findings[0].p90, ts: new Date().toISOString(),
+                                    });
+                                }
+                            }
+                            catch {
+                                anchorDensity = undefined;
+                            }
+                        }
+                        finally {
+                            graph.close();
+                        }
+                    }
+                }
+            }
+            catch {
+                impactAdvisory = undefined;
+                anchorDensity = undefined;
+            }
+            return { approved: a.id, digest, ...(impactAdvisory ? { impactAdvisory } : {}), ...(anchorDensity ? { anchorDensity } : {}) };
         },
         async spec_list(a) {
             assertSpecStoreReachable('spec_list', store, a.root); // @implements A-SPEC-419
@@ -2205,6 +2281,9 @@ function makeRawHandlers(store, opts) {
             // (cached vectors only, set fixed, covered hits move, why-line attached). Any missing
             // signal — no tier, no key, cold cache, embed failure — leaves the report untouched;
             // localization itself never fails because of the semantic layer.
+            //
+            // A spec-intent-vector assist (REQ-568 S3) was wired ahead of localizeIssue here and REVERTED
+            // on its pre-registered replay — see rtm/localize.ts at the matchedSpecs join for the numbers.
             try {
                 if (report.hits.length > 1
                     && (0, localize_1.citationsIn)(a.issue, new Set(governed.map((s) => s.id))).cited.length === 0) {
@@ -2470,7 +2549,14 @@ function makeRawHandlers(store, opts) {
             // was asked. Bind the derivation and use it.
             const root = projectRootOf(a.root);
             const scanned = cachedScan(root);
-            const specs = await store.list();
+            // @implements A-SPEC-569.2 — the impact/advisory graph is APPROVED-ONLY. A draft needs no
+            // approval to exist, and the 0.16.0 adversarial round showed one reaching the agent-visible
+            // channels (impacted closure, advisory anchor summaries) — the trust boundary for those
+            // channels is the act of approval. NOT filterGoverned: that predicate passes drafts (it only
+            // drops outdated/legacy), which is exactly what let this in. Diagnosis (rtm_check) and
+            // matching (issue_localize / maintenance_analyze) keep their own populations — the replay
+            // pins were measured on them.
+            const specs = (await store.list()).filter((s) => s.status === 'approved');
             // @implements A-SPEC-283
             // Reuse the persisted graph when its basis still holds. Measured: on the warm path the graph
             // build is ~81% of the cost and reopening is ~0ms. `scanDigest` is the field that makes this
@@ -2497,7 +2583,12 @@ function makeRawHandlers(store, opts) {
                 // explainImpact, not impactedBy: the bounds and the breadth signal must reach the caller.
                 // An impact set is not just a list — a broad one means "review the contract", and a consumer
                 // that cannot tell the difference will try to bundle two hundred call sites.
-                const { specs: impacted, reachedByDepth, stoppedAt, seedIsHub } = (0, rtm_builder_1.explainImpact)(g, a.changed);
+                const { specs: impactedRaw, reachedByDepth, stoppedAt, seedIsHub } = (0, rtm_builder_1.explainImpact)(g, a.changed);
+                // @implements A-SPEC-569.2 — the closure walks EDGES, and an implements edge is owned by
+                // the code file, so an anchor naming a draft (or a spec nobody wrote) still emits one —
+                // deliberately, for rtm_check's dangling diagnosis. The CHANNEL filter is node existence:
+                // approved-only specs were given nodes above, so only sealed intent reaches the caller.
+                const impacted = impactedRaw.filter((id) => g.hasNode(id));
                 // @implements A-SPEC-469 — the graded FILE surface beside the spec closure, same code path
                 // as the S-484 measurement (identity, not reimplementation). Seeds are the changed symbols'
                 // nodes; the files that own them are excluded — a prediction naming the change itself is
@@ -2508,8 +2599,26 @@ function makeRawHandlers(store, opts) {
                     .map((id) => (id.includes('@') ? id.slice(id.lastIndexOf('@') + 1) : ''))
                     .filter((f) => f !== ''));
                 const rankedImpact = (0, assoc_arm_1.pprImpactRanked)((0, assoc_arm_1.graphViewOf)(g.dumpCanonical()), riSeeds, riExclude, assoc_arm_1.RANKED_IMPACT_K, assoc_arm_1.RANKED_IMPACT_CONFIG);
+                // @implements A-SPEC-568.2 — the intent sentence beside every impacted spec id, same order
+                // as `impacted` (which stays a bare id list for its existing consumers). Information only:
+                // nothing reads it back into the walk, the ranking or any gate.
+                // @implements A-SPEC-569.3 — capped: measured on this repository, uncapped summaries were
+                // 94% of a 104,706-byte response (a hub-grade impact of 339 specs). The omission is COUNTED,
+                // never silent, and `impacted` itself stays complete — only the annotation is bounded.
+                const shownSummaries = impacted.slice(0, SUMMARY_CAP);
+                const impactedSummaries = shownSummaries.map((id) => {
+                    let summary = null;
+                    try {
+                        summary = g.summaryOf(id);
+                    }
+                    catch { /* summary stays null */ }
+                    return { id, summary };
+                });
+                const summariesOmitted = impacted.length - shownSummaries.length;
                 return {
                     impacted,
+                    impactedSummaries,
+                    ...(summariesOmitted > 0 ? { summariesOmitted } : {}),
                     rankedImpact,
                     reachedByDepth,
                     bounded: stoppedAt.length > 0 ? stoppedAt.slice(0, 20) : undefined,

package/dist/holmes/mcp/server.js

@@ -42,6 +42,17 @@ const handlers = (0, handlers_1.makeHandlers)(store, {
         return 'unknown';
     } },
 });
+// @implements A-SPEC-564.1 — the session-context stamp: WHO attached, name AND version (the version
+// was received and dropped for months). Written HERE because the server is the one place all three
+// harnesses pass through; lazy-once via the call path (clientInfo exists only after initialize, and
+// the ledger's root arrives with the first rooted call). Fail-open by construction.
+const { makeSessionStamper } = require('../governance/session-context');
+const stampSession = makeSessionStamper(() => { try {
+    return server.getClientVersion();
+}
+catch {
+    return undefined;
+} });
 // @implements A-SPEC-259 — the advertised version is the package's own, not a literal that froze at
 // 0.1.0: a hardcoded serverInfo.version blinds any client-side drift diagnosis.
 const PKG_VERSION = (() => {
@@ -109,6 +120,7 @@ const TOOLS = Object.keys(handlers)
 });
 server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({ tools: TOOLS }));
 server.setRequestHandler(types_js_1.CallToolRequestSchema, async (req) => {
+    stampSession(req.params.arguments?.root);
     // @implements A-SPEC-189
     // The server is the first consumer of its own advertised schemas. Before this check, 15 of 26
     // handlers threw raw internal errors at `{}` over the wire, and a one-key typo in reverse_anchor

package/dist/holmes/mcp/tool-schemas.js

@@ -330,7 +330,7 @@ exports.TOOL_SCHEMAS = {
         },
     },
     rtm_impact: {
-        description: 'Given changed symbol qualified-names, return the impacted SPEC node ids reachable through @implements/depends_on edges ({ impacted }).',
+        description: 'Given changed symbol qualified-names, return the impacted SPEC node ids reachable through @implements/depends_on edges ({ impacted, impactedSummaries: [{id, summary}] — the spec intent sentence beside each id, informational only }).',
         inputSchema: {
             type: 'object',
             properties: {

package/dist/holmes/review/judgement-bundle.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The judgement bundle: what the reviewing agent RECEIVES, split by epistemic kind.
+ *
+ * The owner's correction is the whole design: this is a TECHNICAL graph, and technical facts are
+ * crisp — a symbol is defined in one file or it is not. Every measured failure of graded tools on
+ * crisp facts (the ranker deleting its own answer, anchor noise, the 0.25-constant confidence)
+ * says the same thing, and the S0 misjudgement decomposition (revision 7) named the exact shapes:
+ * 17% of false picks were facts a single crisp query would have refuted (symbol ownership, surface
+ * presence), and the other 83% — target attribution — are best treated with HISTORY facts
+ * (git log -S is deterministic), not with more similarity.
+ *
+ * So: FACT results carry a verdict, the query that produced it, and the tree it was true of. There
+ * is no field for a similarity or a score — the type is the wall (the QueueEventLite idiom).
+ * Candidates stay labeled 'candidate' and never get promoted. One self-evaluation, one optional
+ * reinforcement, bounded by structure.
+ */
+export interface FactResult {
+    kind: 'symbol-owner' | 'surface-presence' | 'feature-history';
+    query: string;
+    verdict: boolean | string[];
+    basis: string;
+    asOf: string;
+}
+export interface GitFacts {
+    /** Files defining the named symbol (assignment/def/class shapes) in the pinned tree. */
+    grepOwners(name: string): string[];
+    /** Does the file already carry any of these terms, in the pinned tree? */
+    grepInFile(file: string, terms: string[]): boolean;
+    /** Files last touching this term/feature across pre-pin history (git log -S shape). */
+    logTouched(term: string): string[];
+    /** The pinned tree these answers are true of. */
+    asOf(): string;
+}
+export interface JudgementBundle {
+    header: string;
+    facts: FactResult[];
+    reinforced: boolean;
+    candidates: Array<{
+        file: string;
+        excerpt: string;
+        label: 'candidate';
+    }>;
+}
+export declare const MAX_FACT_QUERIES = 8;
+export declare const BUNDLE_HEADER: string;
+export declare function buildJudgementBundle(subject: string, candidates: Array<{
+    file: string;
+    excerpt: string;
+}>, facts: GitFacts): JudgementBundle;

package/dist/holmes/review/judgement-bundle.js

@@ -0,0 +1,108 @@
+"use strict";
+// @implements A-SPEC-567.1
+/**
+ * The judgement bundle: what the reviewing agent RECEIVES, split by epistemic kind.
+ *
+ * The owner's correction is the whole design: this is a TECHNICAL graph, and technical facts are
+ * crisp — a symbol is defined in one file or it is not. Every measured failure of graded tools on
+ * crisp facts (the ranker deleting its own answer, anchor noise, the 0.25-constant confidence)
+ * says the same thing, and the S0 misjudgement decomposition (revision 7) named the exact shapes:
+ * 17% of false picks were facts a single crisp query would have refuted (symbol ownership, surface
+ * presence), and the other 83% — target attribution — are best treated with HISTORY facts
+ * (git log -S is deterministic), not with more similarity.
+ *
+ * So: FACT results carry a verdict, the query that produced it, and the tree it was true of. There
+ * is no field for a similarity or a score — the type is the wall (the QueueEventLite idiom).
+ * Candidates stay labeled 'candidate' and never get promoted. One self-evaluation, one optional
+ * reinforcement, bounded by structure.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUNDLE_HEADER = exports.MAX_FACT_QUERIES = void 0;
+exports.buildJudgementBundle = buildJudgementBundle;
+exports.MAX_FACT_QUERIES = 8;
+exports.BUNDLE_HEADER = 'fact 는 검증된 참/거짓(조회식·기준 트리 동봉), candidate 는 미검증 후보다. 조회가 기억을 이긴다 — '
+    + 'fact 와 충돌하는 전제는 버려라. 기존 소유 파일이 후보에 없으면 신규-파일 가설(빈 선택)을 고려하라.';
+/** Decidable subquery tokens out of a subject line: quoted strings, identifier-shaped words and
+ * feature tags — deterministic order, capped. Whatever cannot be extracted stays EVIDENCE-only. */
+function extractTokens(subject) {
+    const out = [];
+    const push = (t) => { if (t.length >= 3 && !out.includes(t))
+        out.push(t); };
+    for (const m of subject.matchAll(/"([^"]+)"|'([^']+)'/g))
+        push(m[1] ?? m[2]);
+    for (const m of subject.matchAll(/\b([A-Za-z_][A-Za-z0-9_]*(?:_[A-Za-z0-9_]+)+|[A-Z]{2,}[A-Z0-9_]*)\b/g))
+        push(m[1]);
+    for (const m of subject.matchAll(/\bF\d{3}\b/g))
+        push(m[0]);
+    return out.slice(0, exports.MAX_FACT_QUERIES);
+}
+function buildJudgementBundle(subject, candidates, facts) {
+    const asOf = (() => { try {
+        return facts.asOf();
+    }
+    catch {
+        return 'unknown';
+    } })();
+    const results = [];
+    const candidateFiles = new Set(candidates.map((c) => c.file));
+    const tokens = extractTokens(subject);
+    let historyRan = false;
+    let reinforced = false;
+    // Decidable-first: close what a crisp query CAN close. Each answer carries the query that made it
+    // and the tree it is true of — an unanswerable (throwing) query is silently absent, never guessed.
+    for (const tok of tokens) {
+        try {
+            const owners = facts.grepOwners(tok);
+            if (owners.length > 0) {
+                results.push({ kind: 'symbol-owner', query: tok, verdict: owners,
+                    basis: `git grep -l '${tok} =' | def/class — 정의 소유 파일`, asOf });
+            }
+        }
+        catch { /* absent, not guessed */ }
+    }
+    for (const c of candidates) {
+        try {
+            if (tokens.length > 0 && facts.grepInFile(c.file, tokens)) {
+                results.push({ kind: 'surface-presence', query: `${c.file} ∋ {${tokens.slice(0, 3).join(',')}}`,
+                    verdict: true, basis: 'git grep — 후보가 해당 표면을 이미 보유', asOf });
+            }
+        }
+        catch { /* absent, not guessed */ }
+    }
+    const featureTag = tokens.find((t) => /^F\d{3}$/.test(t)) ?? tokens[0];
+    if (featureTag !== undefined) {
+        try {
+            const touched = facts.logTouched(featureTag);
+            historyRan = true;
+            if (touched.length > 0) {
+                results.push({ kind: 'feature-history', query: featureTag, verdict: touched,
+                    basis: `git log -S '${featureTag}' — 이 피처를 마지막으로 만진 파일들`, asOf });
+                // Self-evaluation, once: owners entirely OUTSIDE the candidate set is the S0 shape that
+                // misled the judge (c0/c17/c25 …) — reinforce with ONE more history probe on the next token.
+                if (!touched.some((f) => candidateFiles.has(f))) {
+                    reinforced = true;
+                    const second = tokens.find((t) => t !== featureTag);
+                    if (second !== undefined) {
+                        try {
+                            const more = facts.logTouched(second);
+                            if (more.length > 0) {
+                                results.push({ kind: 'feature-history', query: second, verdict: more,
+                                    basis: `git log -S '${second}' — 보강 1회(소유 파일이 후보 밖)`, asOf });
+                            }
+                        }
+                        catch { /* the reinforcement is best-effort too */ }
+                    }
+                }
+            }
+        }
+        catch {
+            void historyRan;
+        }
+    }
+    return {
+        header: exports.BUNDLE_HEADER,
+        facts: results,
+        reinforced,
+        candidates: candidates.map((c) => ({ ...c, label: 'candidate' })),
+    };
+}

package/dist/holmes/review/run-replay.d.ts

@@ -203,6 +203,9 @@ export declare function runReplay(corpus: ReplayCorpus, limit: number, opts?: {
     contentVerify?: boolean;
     /** @implements A-SPEC-485 — holdout window start; default 0 is the pinned main window. */
     offset?: number;
+    /** @implements A-SPEC-567.2 — attach the judgement bundle (FACT channel + labels) to each
+     * caseDump row. Absent = the row is byte-identical to the pre-option shape. */
+    judgementBundle?: boolean;
     /**
      * @implements A-SPEC-487 — per-case dump for the blind judgment protocol. The pins stay on
      * the 1-pass result; the dump carries the 2-pass (semantic-injected) output when
@@ -225,6 +228,8 @@ export declare function runReplay(corpus: ReplayCorpus, limit: number, opts?: {
         truthFiles: string[];
         /** @implements A-SPEC-489 — present only when dumpBodies was asked. */
         bodies?: Record<string, string>;
+        /** @implements A-SPEC-567.2 — present only when judgementBundle was asked. */
+        judgementBundle?: import('./judgement-bundle').JudgementBundle;
     }) => void;
     /** @implements A-SPEC-487 — 2-pass semantic injection for the dump only, never the pins. */
     productSemantic?: {

package/dist/holmes/review/run-replay.js

@@ -42,6 +42,7 @@ exports.semanticCaseRanking = semanticCaseRanking;
 // @implements A-SPEC-378
 // @implements A-SPEC-402
 const fs = __importStar(require("node:fs"));
+const node_child_process_1 = require("node:child_process");
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const cpg_scanner_1 = require("../cpg/cpg-scanner");
@@ -275,12 +276,43 @@ async function runReplay(corpus, limit, opts = {}) {
                             catch { /* unreadable candidate: omitted */ }
                         }
                     }
+                    // @implements A-SPEC-567.2 — the FACT channel reads the PARENT tree and pre-case history
+                    // only (git object queries by sha — deterministic, and the case commit itself is never
+                    // consulted, so the blind protocol survives). Every query failure is a silent absence.
+                    let judgementBundle;
+                    if (opts.judgementBundle === true) {
+                        try {
+                            const { buildJudgementBundle } = require('./judgement-bundle');
+                            const gitQ = (args) => {
+                                try {
+                                    return (0, node_child_process_1.execFileSync)('git', ['-C', corpus.root, ...args], { encoding: 'utf8', stdio: 'pipe' });
+                                }
+                                catch {
+                                    return '';
+                                }
+                            };
+                            const stripRef = (line) => line.replace(/^[^:]*:/, '');
+                            const gitFacts = {
+                                grepOwners: (name) => [...new Set(gitQ(['grep', '-l', '-E', `(^|[^A-Za-z0-9_])${name}\\s*=|def ${name}|class ${name}`, parent, '--', ...corpus.sourcePathspec])
+                                        .split('\n').filter(Boolean).map(stripRef))].slice(0, 5),
+                                grepInFile: (file, terms) => gitQ(['grep', '-c', '-E', terms.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), parent, '--', file]).trim() !== '',
+                                logTouched: (term) => [...new Set(gitQ(['log', '-S', term, '--name-only', '--format=', '-n', '8', parent, '--', ...corpus.sourcePathspec])
+                                        .split('\n').filter((f) => f && corpus.isSource(f)))].slice(0, 5),
+                                asOf: () => parent,
+                            };
+                            judgementBundle = buildJudgementBundle(c.subject, dumpResult.candidates.map((x) => ({ file: x.file, excerpt: bodies?.[x.file] ?? '' })), gitFacts);
+                        }
+                        catch {
+                            judgementBundle = undefined;
+                        }
+                    }
                     opts.caseDump({
                         commit: c.commit, subject: c.subject,
                         candidates: dumpResult.candidates,
                         rankedImpact: dumpResult.impacts?.rankedImpact ?? [],
                         truthFiles: c.files,
                         ...(bodies !== undefined ? { bodies } : {}),
+                        ...(judgementBundle !== undefined ? { judgementBundle } : {}),
                     });
                 }
                 // Same case, same truth, same `topN` the product used — an arm scored against a different

package/dist/holmes/rtm/anchor-density.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Anchor-density advisory — OBSERVATION ONLY, never a gate.
+ *
+ * The measured ground: anchor density taxes localization precision (authoring ONE spec moved
+ * replay recall 0.5476→0.5060; A-SPEC-270's √-dilution exists because a 113-anchor file brushes
+ * some spec for almost any request). A count GATE was considered and REFUSED (position-dependent
+ * refusals, an incentive to stop anchoring, mechanical file splits) — so this surfaces the fact at
+ * sealing time and records it, and the observation ledger decides any future promotion, exactly
+ * the impactAdvisory lifecycle. The thresholds below are prose constants: nothing reads them into
+ * a verdict (judgments must not be budgeted).
+ */
+export interface AnchorDensityFinding {
+    path: string;
+    anchors: number;
+    p90: number;
+}
+/** Files below this live-anchor count are never flagged, whatever the distribution — a floor. */
+export declare const MIN_ANCHORS = 8;
+/**
+ * FtT files whose live anchor count sits at or above max(MIN_ANCHORS, p90 of the distribution).
+ * p90 is the value at index ceil(0.9·n)-1 of the ascending counts — deterministic, no interpolation.
+ * Pure: same inputs, same findings, in sorted path order.
+ */
+export declare function anchorDensityFindings(fttFiles: string[], counts: Array<{
+    sourcePath: string;
+    anchors: number;
+}>): AnchorDensityFinding[];
+/**
+ * The observation ledger — paths and integers only, no prose, no secrets: what a future
+ * promotion/rejection judgment will be measured on.
+ */
+export interface AnchorDensityRecord {
+    aspec: string;
+    files: Array<{
+        path: string;
+        anchors: number;
+    }>;
+    p90: number;
+    ts: string;
+    replica?: string;
+}
+export declare function appendAnchorDensity(root: string, rec: AnchorDensityRecord): boolean;
+export declare function readAnchorDensity(root: string): AnchorDensityRecord[];