@holmes-lab/holmes-kit 0.20.2 → 0.22.0

package/dist/holmes/mcp/handlers/graph-operations.js

@@ -45,6 +45,7 @@ const root_1 = require("../../project/root");
 const rtm_builder_1 = require("../../rtm/rtm-builder");
 const graph_store_1 = require("../../rtm/graph-store");
 const assoc_arm_1 = require("../../assoc/assoc-arm");
+const trace_gaps_1 = require("../../rtm/trace-gaps");
 // @implements A-SPEC-478 — the semantic tier runtime stays at the async reindex edge.
 const tier_1 = require("../../semantic/tier");
 const vector_cache_1 = require("../../semantic/vector-cache");
@@ -119,7 +120,8 @@ function createGraphOperationsHandlers(context) {
             // 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 context.listSpecs()).filter((s) => s.status === 'approved');
+            const specsAll = await context.listSpecs();
+            const specs = specsAll.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
@@ -181,11 +183,26 @@ function createGraphOperationsHandlers(context) {
                     return { id, summary };
                 });
                 const summariesOmitted = impacted.length - shownSummaries.length;
+                // @implements A-SPEC-658 — the specs the graph CANNOT see for these changes: approved,
+                // anchored by no production source, and declaring a changed symbol's file. Information
+                // beside the closure, never inside it; unresolved symbols yield no files and therefore no
+                // guess.
+                const changedFiles = a.changed.flatMap((qn) => g.codeNodeIds(qn))
+                    .map((id) => id.slice(id.lastIndexOf('@') + 1)).filter((f) => f !== '');
+                const gaps = changedFiles.length > 0
+                    ? (0, trace_gaps_1.traceGaps)(changedFiles, (0, trace_gaps_1.unlinkedApproved)(specsAll, scanned), (id) => { try {
+                        return g.summaryOf(id);
+                    }
+                    catch {
+                        return null;
+                    } })
+                    : [];
                 answered = true;
                 return {
                     impacted,
                     impactedSummaries,
                     ...(summariesOmitted > 0 ? { summariesOmitted } : {}),
+                    ...(gaps.length > 0 ? { traceGaps: gaps } : {}),
                     rankedImpact,
                     reachedByDepth,
                     bounded: stoppedAt.length > 0 ? stoppedAt.slice(0, 20) : undefined,

package/dist/holmes/mcp/handlers/maintenance-evidence.d.ts

@@ -1,8 +1,12 @@
+import type { Spec } from '../../spec/spec-parser';
+import type { ScannedFile } from '../../cpg/cpg-scanner';
 interface MaintenanceEvidenceContext {
     foreignRootReason(root: string): string | null;
     projectRootOf(root: string): string;
     refusal(reason: string): Error;
     fileDigestOf(root: string, relativePath: string): string | null;
+    listSpecs(): Promise<Spec[]>;
+    cachedScan(root: string): ScannedFile[];
 }
 /** Raw handlers: the public facade attaches basis exactly once. */
 export declare function createMaintenanceEvidenceHandlers(context: MaintenanceEvidenceContext): {

package/dist/holmes/mcp/handlers/maintenance-evidence.js

@@ -41,6 +41,7 @@ const node_child_process_1 = require("node:child_process");
 const maintenance_evidence_1 = require("../maintenance-evidence");
 const impact_gate_1 = require("../../guardrail/impact-gate");
 const root_1 = require("../../project/root");
+const trace_gaps_1 = require("../../rtm/trace-gaps");
 /** Raw handlers: the public facade attaches basis exactly once. */
 function createMaintenanceEvidenceHandlers(context) {
     return {
@@ -77,11 +78,25 @@ function createMaintenanceEvidenceHandlers(context) {
                     throw context.refusal(`이 프로젝트에 저장된 분석이 아닙니다: ${a.digest}`);
                 artifact = JSON.parse(fs.readFileSync(file, 'utf8'));
             }
+            const target = a.target.replace(/\\/g, '/');
+            // @implements A-SPEC-658 — approved specs that declare this file but anchor nothing: the graph
+            // cannot see them, so the gate must not read their silence as "no impact". A failed lookup
+            // drops the input (information lost, verdict unchanged) rather than inventing a gap.
+            let gaps;
+            try {
+                const found = (0, trace_gaps_1.traceGaps)([target], (0, trace_gaps_1.unlinkedApproved)(await context.listSpecs(), context.cachedScan(root)));
+                if (found.length > 0)
+                    gaps = found.map(({ id, file }) => ({ id, file }));
+            }
+            catch {
+                gaps = undefined;
+            }
             return (0, impact_gate_1.evaluateEditEvidence)({
-                target: a.target.replace(/\\/g, '/'),
+                target,
                 artifact,
                 currentHead: head,
                 currentTargetDigest: context.fileDigestOf(root, a.target),
+                ...(gaps ? { traceGaps: gaps } : {}),
             });
         },
         // @implements A-SPEC-268

package/dist/holmes/mcp/handlers/operator-inspection.d.ts

@@ -15,6 +15,11 @@ export interface OperatorInspectionContext {
         reason: string;
     };
     fetchJson(url: string): Promise<any>;
+    /** A-SPEC-663 — the production scan, for the trace-gap finding (same closure test_run uses). */
+    cachedScan?(root: string, repoRoot?: string): Array<{
+        path: string;
+        implementsSpecs?: string[];
+    }>;
     /** A-SPEC-642 — the shared approval channel and queue hint, for the reconciliation act. */
     resolveHandlerApproval(root: string | undefined, approval: Approval | undefined, action: {
         kind: string;
@@ -46,6 +51,10 @@ export declare function createOperatorInspectionHandlers(context: OperatorInspec
         ok: boolean;
         reason: string;
     } | {
+        advisoryHistory?: import("../../rtm/advisory-outcomes").AdvisoryState[] | undefined;
+        advisoryIds?: Partial<Record<string, string>> | undefined;
+        killsAdvisory?: import("../../review/kills-check").KillsAdvisory | undefined;
+        fttFulfilment?: import("../../rtm/ftt-fulfilment").FttFulfilment | undefined;
         graphPreview?: {
             impact?: import("../../rtm/impact-advisory").ImpactAdvisory;
             density?: Array<import("../../rtm/anchor-density").AnchorDensityFinding>;
@@ -161,7 +170,25 @@ export declare function createOperatorInspectionHandlers(context: OperatorInspec
         ok: boolean;
         url: string;
         running: boolean;
-        census: import("../../server/dashboard-launcher").DashboardCensus;
+        census: {
+            advisoryOutcomes?: import("../../rtm/advisory-outcomes").AdvisoryCensus | undefined;
+            codeLinkedPct: number;
+            codeLinkedCount: number;
+            unlinkedCount: number;
+            unlinkedByReason: Record<import("../../rtm/link-census").UnlinkedReason, number>;
+            excluded: {
+                total: number;
+                retired: number;
+                unmapped: number;
+                nonSpec: number;
+            };
+            reqCount: number;
+            pipelineCount: number;
+            coveredCount: number;
+            coveragePct: number;
+            retiredCount: number;
+            findingsScanned: boolean;
+        };
         reason?: undefined;
     }>;
 };

package/dist/holmes/mcp/handlers/operator-inspection.js

@@ -190,7 +190,80 @@ function createOperatorInspectionHandlers(context) {
             catch {
                 graphPreview = undefined;
             }
-            return { ok: true, ...(0, approval_status_1.describeApproval)(cur.spec, context.resolver(all)), ...(graphPreview ? { graphPreview } : {}) };
+            // @implements A-SPEC-656 — the same promised-but-absent finding sealing will report, delivered
+            // BEFORE sealing (REQ-572: delivery time was the gap, not the calculation) and without a ledger
+            // write (a query must not pollute the observation denominator). Same pure function as the seal.
+            let fttFulfilment;
+            try {
+                if (cur.spec.type === 'A-SPEC' && a.root) {
+                    const root = a.root;
+                    const { fttFulfilment: compute, locateByBasename } = require('../../rtm/ftt-fulfilment');
+                    const exists = (rel) => {
+                        const abs = path.resolve(root, rel);
+                        return abs.startsWith(root + path.sep) && fs.existsSync(abs);
+                    };
+                    const found = compute(String(cur.spec.sections?.['Files to Touch'] ?? ''), exists, locateByBasename(root));
+                    if (found)
+                        fttFulfilment = found;
+                }
+            }
+            catch {
+                fttFulfilment = undefined;
+            }
+            // @implements A-SPEC-662 — the same kills-applicability finding sealing will report, delivered
+            // before sealing and without any write. Same pure function as the seal.
+            let killsAdvisory;
+            try {
+                if (cur.spec.type === 'T-SPEC' && a.root) {
+                    const { parseKills } = require('../../spec/kills');
+                    const check = require('../../review/kills-check');
+                    const kills = parseKills(cur.spec.frontmatter);
+                    const aspecId = cur.spec.dependsOn[0];
+                    if (kills.length > 0 && aspecId) {
+                        const found = check.killsAdvisory(cur.spec.id, aspecId, kills, check.anchoredSourceTexts(a.root, aspecId));
+                        if (found)
+                            killsAdvisory = found;
+                    }
+                }
+            }
+            catch {
+                killsAdvisory = undefined;
+            }
+            // @implements A-SPEC-663 — the same findings, re-judged: a finding the seal issued that this read
+            // no longer produces is `resolved`; one still produced is `persisted` (once per day). The query
+            // writes only reaction rows, never issues a finding the seal did not — the observation
+            // denominator (REQ-572) stays the seal's.
+            let advisoryIds;
+            let advisoryHistory;
+            try {
+                if (a.root) {
+                    const ao = require('../../rtm/advisory-outcomes');
+                    let traceGap = null;
+                    if (cur.spec.type === 'A-SPEC' && cur.spec.status === 'approved' && context.cachedScan) {
+                        try {
+                            traceGap = ao.traceGapFor(a.id, cur.spec, context.cachedScan(a.root, a.root), a.root);
+                        }
+                        catch {
+                            traceGap = null;
+                        }
+                    }
+                    const impactAdvisory = graphPreview?.impact ?? null;
+                    const anchorDensity = graphPreview?.density ?? null;
+                    const { keys, ids } = ao.currentAdvisoryKeys(a.id, { impactAdvisory, anchorDensity, fttFulfilment, killsAdvisory, traceGap });
+                    const r = ao.recordAdvisoryOutcomes(a.root, a.id, keys, (s) => s.aspec === a.id, ao.gitHeadOf(a.root), [], new Date().toISOString(), { issue: false });
+                    if (keys.length > 0)
+                        advisoryIds = ids;
+                    if (r.history.length > 0)
+                        advisoryHistory = r.history;
+                }
+            }
+            catch {
+                advisoryIds = undefined;
+                advisoryHistory = undefined;
+            }
+            return { ok: true, ...(0, approval_status_1.describeApproval)(cur.spec, context.resolver(all)), ...(graphPreview ? { graphPreview } : {}),
+                ...(fttFulfilment ? { fttFulfilment } : {}), ...(killsAdvisory ? { killsAdvisory } : {}),
+                ...(advisoryIds ? { advisoryIds } : {}), ...(advisoryHistory ? { advisoryHistory } : {}) };
         },
         /**
          * @implements A-SPEC-538.3
@@ -270,11 +343,26 @@ function createOperatorInspectionHandlers(context) {
                 return { ok: false, reason: dest.reason };
             try {
                 const { startDashboardServer } = await Promise.resolve().then(() => __importStar(require('../../server/dashboard')));
-                const { ensureDashboard, dashboardCensus } = await Promise.resolve().then(() => __importStar(require('../../server/dashboard-launcher')));
+                // @implements A-SPEC-655 — the census carries the code-link axis beside pipeline coverage.
+                const { ensureDashboard, dashboardCensusExtended } = await Promise.resolve().then(() => __importStar(require('../../server/dashboard-launcher')));
                 const launch = await ensureDashboard(dest.root, a.port, (opts) => startDashboardServer(opts));
                 const rtm = await context.fetchJson(`${launch.url}/api/rtm`);
                 const heatmap = await context.fetchJson(`${launch.url}/api/rtm/heatmap`);
-                return { ok: true, url: launch.url, running: launch.running, census: dashboardCensus(rtm, heatmap) };
+                // @implements A-SPEC-663 — the whole-store trace-gap judgement and the reaction census: how many
+                // findings of each kind were issued, and how many stand resolved / persisted / dismissed now.
+                let advisoryOutcomes;
+                try {
+                    const ao = require('../../rtm/advisory-outcomes');
+                    if (context.cachedScan) {
+                        const keys = ao.traceGapAdvisories(await context.listSpecs(), context.cachedScan(dest.root, dest.root), dest.root);
+                        ao.recordAdvisoryOutcomes(dest.root, '*', keys, (s) => s.kind === 'trace-gap', ao.gitHeadOf(dest.root));
+                    }
+                    advisoryOutcomes = ao.advisoryCensus(ao.readAdvisoryOutcomes(dest.root));
+                }
+                catch {
+                    advisoryOutcomes = undefined;
+                }
+                return { ok: true, url: launch.url, running: launch.running, census: { ...dashboardCensusExtended(rtm, heatmap), ...(advisoryOutcomes ? { advisoryOutcomes } : {}) } };
             }
             catch (err) {
                 return { ok: false, reason: `대시보드 기동 실패: ${err?.message ?? String(err)}` };

package/dist/holmes/mcp/handlers/spec-approval.d.ts

@@ -41,6 +41,7 @@ export declare function createSpecApprovalHandlers(context: SpecApprovalContext)
     spec_approve(a: {
         root?: string;
         id: string;
+        dismiss?: string[];
     }): Promise<{
         ok: false;
         reason: string;
@@ -57,6 +58,11 @@ export declare function createSpecApprovalHandlers(context: SpecApprovalContext)
         reason: string;
         conflict: import("../../spec/version-conflict").ConflictDetail;
     } | {
+        dismissUnknown?: string[] | undefined;
+        advisoryHistory?: import("../../rtm/advisory-outcomes").AdvisoryState[] | undefined;
+        advisoryIds?: Partial<Record<string, string>> | undefined;
+        killsAdvisory?: import("../../review/kills-check").KillsAdvisory | undefined;
+        fttFulfilment?: import("../../rtm/ftt-fulfilment").FttFulfilment | undefined;
         impactAdvisoryUnavailable?: "empty" | "unreadable" | undefined;
         impactGraph?: {
             status: "current" | "stale" | "unverified";

package/dist/holmes/mcp/handlers/spec-approval.js

@@ -415,8 +415,94 @@ function createSpecApprovalHandlers(context) {
                 impactGraph = undefined;
                 impactAdvisoryUnavailable = undefined;
             }
+            // @implements A-SPEC-656 — the promised-but-absent side of the declaration, filesystem only,
+            // independent of the graph block above (no rtm.sqlite needed). Advisory: the seal is already
+            // done. The finding rides the response and lands in its own observation ledger so its
+            // false-positive rate can be measured before anyone proposes a gate; a failed read drops the
+            // field rather than inventing a finding. Parsing, buckets and the walk live in the pure module.
+            let fttFulfilment;
+            try {
+                if (spec.type === 'A-SPEC' && a.root) {
+                    const root = a.root;
+                    const { fttFulfilment: compute, locateByBasename, appendFttFulfilment } = require('../../rtm/ftt-fulfilment');
+                    const exists = (rel) => {
+                        const abs = path.resolve(root, rel);
+                        return abs.startsWith(root + path.sep) && fs.existsSync(abs);
+                    };
+                    const found = compute(String(candidate.sections?.['Files to Touch'] ?? ''), exists, locateByBasename(root));
+                    if (found) {
+                        fttFulfilment = found;
+                        appendFttFulfilment(root, {
+                            aspec: a.id, declared: found.declared, missing: found.missing.map((m) => m.path),
+                            moved: found.moved.map((m) => m.path), ts: new Date().toISOString(),
+                        });
+                    }
+                }
+            }
+            catch {
+                fttFulfilment = undefined;
+            }
+            // @implements A-SPEC-662 — the `kills` whose `where` will never apply, reported when the T-SPEC
+            // seals (measured 2026-09-17: 22/22 entries were paths and prose; nothing said so). Advisory:
+            // the seal is done, the field appears only when something is wrong, a failed walk drops it.
+            // No ledger here — the reaction ledger for every advisory kind is REQ-663's.
+            let killsAdvisory;
+            try {
+                if (spec.type === 'T-SPEC' && a.root) {
+                    const { parseKills } = require('../../spec/kills');
+                    const check = require('../../review/kills-check');
+                    const kills = parseKills(candidate.frontmatter);
+                    const aspecId = candidate.dependsOn[0];
+                    if (kills.length > 0 && aspecId) {
+                        const found = check.killsAdvisory(a.id, aspecId, kills, check.anchoredSourceTexts(a.root, aspecId));
+                        if (found)
+                            killsAdvisory = found;
+                    }
+                }
+            }
+            catch {
+                killsAdvisory = undefined;
+            }
+            // @implements A-SPEC-663 — the REACTION ledger. Every finding this seal just reported gets a
+            // deterministic id; the ledger learns `issued` now and, from the next approval_status on, whether
+            // it was resolved, persisted or dismissed. Measured 2026-09-18: 153 issue rows across two
+            // advisory ledgers and no row anywhere saying what happened next — the numerator every "promote
+            // once the false-positive rate is known" sentence lacked. Advisory: failures drop the fields.
+            let advisoryIds;
+            let advisoryHistory;
+            let dismissUnknown;
+            try {
+                if (a.root) {
+                    const ao = require('../../rtm/advisory-outcomes');
+                    let traceGap = null;
+                    if (spec.type === 'A-SPEC') {
+                        try {
+                            traceGap = ao.traceGapFor(a.id, candidate, cachedScan(a.root, a.root), a.root);
+                        }
+                        catch {
+                            traceGap = null;
+                        }
+                    }
+                    const { keys, ids } = ao.currentAdvisoryKeys(a.id, { impactAdvisory, anchorDensity, fttFulfilment, killsAdvisory, traceGap });
+                    const head = ao.gitHeadOf(a.root);
+                    const r = ao.recordAdvisoryOutcomes(a.root, a.id, keys, (s) => s.aspec === a.id, head, a.dismiss ?? []);
+                    if (keys.length > 0)
+                        advisoryIds = ids;
+                    if (r.history.length > 0)
+                        advisoryHistory = r.history;
+                    if (a.dismiss && r.dismissUnknown.length > 0)
+                        dismissUnknown = r.dismissUnknown;
+                }
+            }
+            catch {
+                advisoryIds = undefined;
+                advisoryHistory = undefined;
+                dismissUnknown = a.dismiss;
+            }
             return { approved: a.id, digest, ...(impactAdvisory ? { impactAdvisory } : {}), ...(anchorDensity ? { anchorDensity } : {}),
-                ...(impactGraph ? { impactGraph } : {}), ...(impactAdvisoryUnavailable ? { impactAdvisoryUnavailable } : {}) };
+                ...(impactGraph ? { impactGraph } : {}), ...(impactAdvisoryUnavailable ? { impactAdvisoryUnavailable } : {}),
+                ...(fttFulfilment ? { fttFulfilment } : {}), ...(killsAdvisory ? { killsAdvisory } : {}),
+                ...(advisoryIds ? { advisoryIds } : {}), ...(advisoryHistory ? { advisoryHistory } : {}), ...(dismissUnknown ? { dismissUnknown } : {}) };
         },
         /**
          * Pin a REQ's citations: compute the content digest of every cited source that resolves inside

package/dist/holmes/mcp/handlers/test-execution.d.ts

@@ -44,6 +44,10 @@ export declare function createTestExecutionHandlers(context: TestExecutionContex
                 reason?: undefined;
             })[];
             survivors: import("../../spec/kills").Mutation[];
+            unapplied: {
+                where: string;
+                reason: string;
+            }[];
         };
     } | {
         calibrationClosed?: string[] | undefined;

package/dist/holmes/mcp/handlers/test-execution.js

@@ -49,6 +49,7 @@ const scope_1 = require("../../review/scope");
 const test_runner_1 = require("../../review/test-runner");
 const kills_1 = require("../../spec/kills");
 const mutate_1 = require("../../review/mutate");
+const kills_check_1 = require("../../review/kills-check");
 const test_evidence_1 = require("../../review/test-evidence");
 const test_outcomes_1 = require("../../review/test-outcomes");
 const maintenance_evidence_1 = require("../maintenance-evidence");
@@ -122,8 +123,11 @@ function createTestExecutionHandlers(context) {
                     const r = (0, mutate_1.runKillsOnFile)(src, m, coveringFiles, (files) => (0, test_runner_1.runJestOutcomes)(files, root));
                     return { mutation: m, ...r };
                 });
-                const survivors = results.filter((r) => r.verdict === 'survived').map((r) => r.mutation);
-                return { mutate: { tspec: a.mutate, aspec: aspecId, coveringFiles, results, survivors } };
+                // @implements A-SPEC-662 — a mutation that never applied is UNAPPLIED, not a survivor: measured
+                // 2026-09-17, 22/22 entries here failed to apply and the response read `survivors: []` — the
+                // shape of a clean run. The pair (unapplied, survivors) now says "unverified" when it is.
+                const { survivors, unapplied } = (0, kills_check_1.partitionMutateResults)(results);
+                return { mutate: { tspec: a.mutate, aspec: aspecId, coveringFiles, results, survivors, unapplied } };
             }
             const g = new rtm_graph_1.RtmGraph();
             let testScope;

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

@@ -410,6 +410,7 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
             reason: "hub" | "depth";
             inDegree?: number;
         }[] | undefined;
+        traceGaps?: import("../rtm/trace-gaps").TraceGap[] | undefined;
         summariesOmitted?: number | undefined;
         impacted: string[];
         impactedSummaries: {
@@ -770,6 +771,10 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         ok: boolean;
         reason: string;
     } | {
+        advisoryHistory?: import("../rtm/advisory-outcomes").AdvisoryState[] | undefined;
+        advisoryIds?: Partial<Record<string, string>> | undefined;
+        killsAdvisory?: import("../review/kills-check").KillsAdvisory | undefined;
+        fttFulfilment?: import("../rtm/ftt-fulfilment").FttFulfilment | undefined;
         graphPreview?: {
             impact?: import("../rtm/impact-advisory").ImpactAdvisory;
             density?: Array<import("../rtm/anchor-density").AnchorDensityFinding>;
@@ -822,12 +827,31 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         ok: boolean;
         url: string;
         running: boolean;
-        census: import("../server/dashboard-launcher").DashboardCensus;
+        census: {
+            advisoryOutcomes?: import("../rtm/advisory-outcomes").AdvisoryCensus | undefined;
+            codeLinkedPct: number;
+            codeLinkedCount: number;
+            unlinkedCount: number;
+            unlinkedByReason: Record<import("../rtm/link-census").UnlinkedReason, number>;
+            excluded: {
+                total: number;
+                retired: number;
+                unmapped: number;
+                nonSpec: number;
+            };
+            reqCount: number;
+            pipelineCount: number;
+            coveredCount: number;
+            coveragePct: number;
+            retiredCount: number;
+            findingsScanned: boolean;
+        };
         reason?: undefined;
     }>;
     spec_approve: (a: {
         root?: string;
         id: string;
+        dismiss?: string[];
     }) => Promise<{
         ok: false;
         reason: string;
@@ -844,6 +868,11 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         reason: string;
         conflict: import("../spec/version-conflict").ConflictDetail;
     } | {
+        dismissUnknown?: string[] | undefined;
+        advisoryHistory?: import("../rtm/advisory-outcomes").AdvisoryState[] | undefined;
+        advisoryIds?: Partial<Record<string, string>> | undefined;
+        killsAdvisory?: import("../review/kills-check").KillsAdvisory | undefined;
+        fttFulfilment?: import("../rtm/ftt-fulfilment").FttFulfilment | undefined;
         impactAdvisoryUnavailable?: "empty" | "unreadable" | undefined;
         impactGraph?: {
             status: "current" | "stale" | "unverified";
@@ -1025,6 +1054,10 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
                 reason?: undefined;
             })[];
             survivors: import("../spec/kills").Mutation[];
+            unapplied: {
+                where: string;
+                reason: string;
+            }[];
         };
     } | {
         calibrationClosed?: string[] | undefined;

package/dist/holmes/mcp/handlers.js

@@ -859,6 +859,7 @@ function makeRawHandlers(store, opts) {
         resolver,
         resolveLedgerRoot,
         fetchJson,
+        cachedScan, // @implements A-SPEC-663
         resolveHandlerApproval: (root, approval, action, now) => resolveHandlerApproval(root, store, approval, action, now),
         refusalQueueHint: (root, request) => refusalQueueHint(root, store, request),
     });
@@ -919,6 +920,10 @@ function makeRawHandlers(store, opts) {
             projectRootOf,
             refusal: reason => new HandlerRefusal(reason),
             fileDigestOf,
+            // @implements A-SPEC-658 — the impact gate reads trace gaps from the same store and scan the
+            // graph handlers use.
+            listSpecs: () => store.list(),
+            cachedScan,
         }),
         // @implements A-SPEC-642 — placed in the one slot no public-key-order pin covers (the handler suites pin
         // spec_create..spec_upgrade, spec_retire..spec_unseal, spec_unseal+5, spec_approve+4, spec_next+3,

package/dist/holmes/mcp/maintenance-analyze.js

@@ -4,6 +4,7 @@ exports.ANALYZE_TEXT_CAP = exports.ANALYZE_LIST_CAP = exports.PRIMARY_TIER_WIDTH
 exports.unquoteGitPath = unquoteGitPath;
 exports.analyzeMaintenance = analyzeMaintenance;
 exports.boundAnalysis = boundAnalysis;
+// @implements A-SPEC-310
 // @implements A-SPEC-295
 // @implements A-SPEC-294
 // @implements A-SPEC-293

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

@@ -204,6 +204,7 @@ exports.TOOL_SCHEMAS = {
             properties: {
                 root: str('Optional when the server is bound to a file store — the ledger location is derived from the store itself; if supplied it must resolve to the SAME project, otherwise the approval is refused before anything is written.'),
                 id: str('Id of the spec to approve and seal.'),
+                dismiss: { type: 'array', items: { type: 'string' }, description: 'A-SPEC-663 — advisory ids (from approval_status.advisoryIds) the author judged not useful; recorded as `dismissed` in the reaction ledger, never blocking. Unknown ids are echoed back in `dismissUnknown`.' },
             },
             required: ['id'],
         },

package/dist/holmes/project/ci-runs.d.ts

@@ -0,0 +1,46 @@
+export type CiStatus = 'green' | 'red' | 'clone-failed' | 'checkout-failed' | 'install-failed' | 'build-failed' | 'jest-crashed' | 'vm-unreachable';
+export interface CiRun {
+    rev: string;
+    os: string;
+    arch?: string;
+    machine?: string;
+    node?: string;
+    status: CiStatus | string;
+    suites: number;
+    tests: number;
+    failed: string[];
+    durationMs: number;
+    at: string;
+    note?: string;
+}
+export interface CiVerdict {
+    os: string;
+    state: 'green' | 'red' | 'failed' | 'not-run';
+    rev?: string;
+    at?: string;
+    behind?: number;
+    failed: string[];
+    status?: string;
+}
+/**
+ * @implements A-SPEC-664 — the ADOPTION predicate: does this workspace use the CI matrix at all?
+ *
+ * Existence, not contents. A `ci-runs.<host>.jsonl` that exists but is empty means a run was
+ * attempted here, so silence about a commit is a signal worth saying out loud. No file at all means
+ * nobody ever ran the matrix in this workspace — and the runner script is not in the shipped package
+ * (`files` carries bin/, dist/, grammars/, playbooks/, scripts/install.ps1, docs/, CHANGELOG), so
+ * advising every consumer to run it would be advising a path they do not have. Measured 2026-09-18
+ * on a consumer-shaped tree: the Stop hook printed that advice every turn.
+ */
+export declare function hasCiLedger(root: string): boolean;
+export declare function readCiRuns(root: string): CiRun[];
+/** The most recent run for an OS, by `at`. */
+export declare function latestCiRun(runs: CiRun[], os?: string): CiRun | undefined;
+/**
+ * What the matrix says about `head`. `behind(rev)` is the injected git distance from that rev to
+ * head (commits), or undefined when git cannot answer. No run → `not-run`; an infrastructure
+ * status (clone/install/build failed, VM unreachable) → `failed`, which is not red and not green.
+ */
+export declare function ciVerdict(runs: CiRun[], os: string, head: string | undefined, behind: (rev: string) => number | undefined): CiVerdict;
+/** One line for the Stop hook's tracked channel or doctor. Never says green without a green row. */
+export declare function ciStatusLine(v: CiVerdict): string;