@holmes-lab/holmes-kit 0.21.0 → 0.23.1

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

@@ -210,8 +210,60 @@ function createOperatorInspectionHandlers(context) {
             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 } : {}) };
+                ...(fttFulfilment ? { fttFulfilment } : {}), ...(killsAdvisory ? { killsAdvisory } : {}),
+                ...(advisoryIds ? { advisoryIds } : {}), ...(advisoryHistory ? { advisoryHistory } : {}) };
         },
         /**
          * @implements A-SPEC-538.3
@@ -296,7 +348,21 @@ function createOperatorInspectionHandlers(context) {
                 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: dashboardCensusExtended(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,10 @@ 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?: {

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

@@ -442,9 +442,67 @@ function createSpecApprovalHandlers(context) {
             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 } : {}),
-                ...(fttFulfilment ? { fttFulfilment } : {}) };
+                ...(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

@@ -771,6 +771,9 @@ 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;
@@ -824,12 +827,33 @@ declare function makeRawHandlers(store: SpecStore, opts?: ElicitOpts): {
         ok: boolean;
         url: string;
         running: boolean;
-        census: import("../server/dashboard-launcher").DashboardCensusExtended;
+        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;
+            };
+            declaredScopeByScope: Record<import("../rtm/declared-scope").DeclaredScope, number>;
+            unreachableDeclaringCount: 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;
@@ -846,6 +870,10 @@ 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?: {
@@ -1028,6 +1056,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),
     });

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/supervisor.d.ts

@@ -1,5 +1,12 @@
 /** Opt-in switch. Absent means the entry point behaves exactly as it did before this existed. */
 export declare const AUTORELOAD_ENV = "HOLMES_MCP_AUTORELOAD";
+/**
+ * @implements A-SPEC-666 — how many times a child may die WITHOUT ever answering before the
+ * supervisor stops replacing it. A server that worked and then died once has not spent this budget;
+ * only a child that produced nothing in its whole life counts, so "a broken build that dies on every
+ * spawn" stops quickly while "one OOM under load" restarts freely.
+ */
+export declare const MAX_CONSECUTIVE_SILENT_DEATHS = 5;
 export declare function autoreloadEnabled(env: NodeJS.ProcessEnv): boolean;
 /**
  * Whether the child may be replaced right now.
@@ -63,10 +70,38 @@ export declare class Supervisor {
      * supervisor makes, that the connection does not drop.
      */
     private handshake;
+    /**
+     * @implements A-SPEC-666 — WHICH requests are unanswered, not merely how many. `inflight` counts
+     * for the swap decision and its counter is contracted to count without identifying (A-SPEC-516.1);
+     * answering a death needs identity, so it is tracked separately rather than by widening that one.
+     */
+    private pending;
+    /** True while an exit we caused (a swap, a stop) is expected — not every death is an accident. */
+    private expectedExit;
+    /** Consecutive children that died having never answered anything. Reset by any answer. */
+    private silentDeaths;
+    private answeredSinceSpawn;
+    /** True once the limit is reached: the supervisor stops replacing and says so. */
+    private givenUp;
     constructor(repoRoot: string, onSwap?: ((from: string, to: string, replayed: number) => void) | undefined);
     start(stdin: NodeJS.ReadableStream, stdout: NodeJS.WritableStream): void;
     private forward;
     private swap;
     private spawnChild;
+    /**
+     * @implements A-SPEC-666
+     * Drop the ids of every COMPLETE response line from `pending`; return the unfinished tail so a
+     * reply split across chunks is not lost. A line with neither `result` nor `error` is a
+     * notification, not an answer, and retires nothing.
+     */
+    private retireAnsweredIds;
+    /**
+     * @implements A-SPEC-666
+     * The child is gone. Measured 2026-09-18: without this, `this.child` kept pointing at the corpse,
+     * every later request was written to a dead pipe, `inflight` never returned to zero and
+     * `shouldSwap`'s `inflight === 0` therefore never fired — the server was deaf for the rest of the
+     * session, twice in one day. Order matters: free the client first, then decide about a replacement.
+     */
+    private onChildGone;
     stop(): void;
 }

package/dist/holmes/mcp/supervisor.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Supervisor = exports.AUTORELOAD_ENV = void 0;
+exports.Supervisor = exports.MAX_CONSECUTIVE_SILENT_DEATHS = exports.AUTORELOAD_ENV = void 0;
 exports.autoreloadEnabled = autoreloadEnabled;
 exports.shouldSwap = shouldSwap;
 exports.createResponseCounter = createResponseCounter;
@@ -43,6 +43,13 @@ const path = __importStar(require("node:path"));
 const basis_1 = require("./basis");
 /** Opt-in switch. Absent means the entry point behaves exactly as it did before this existed. */
 exports.AUTORELOAD_ENV = 'HOLMES_MCP_AUTORELOAD';
+/**
+ * @implements A-SPEC-666 — how many times a child may die WITHOUT ever answering before the
+ * supervisor stops replacing it. A server that worked and then died once has not spent this budget;
+ * only a child that produced nothing in its whole life counts, so "a broken build that dies on every
+ * spawn" stops quickly while "one OOM under load" restarts freely.
+ */
+exports.MAX_CONSECUTIVE_SILENT_DEATHS = 5;
 function autoreloadEnabled(env) {
     const v = env[exports.AUTORELOAD_ENV];
     return typeof v === 'string' && v.trim() !== '';
@@ -144,6 +151,19 @@ class Supervisor {
      * supervisor makes, that the connection does not drop.
      */
     handshake = [];
+    /**
+     * @implements A-SPEC-666 — WHICH requests are unanswered, not merely how many. `inflight` counts
+     * for the swap decision and its counter is contracted to count without identifying (A-SPEC-516.1);
+     * answering a death needs identity, so it is tracked separately rather than by widening that one.
+     */
+    pending = new Set();
+    /** True while an exit we caused (a swap, a stop) is expected — not every death is an accident. */
+    expectedExit = false;
+    /** Consecutive children that died having never answered anything. Reset by any answer. */
+    silentDeaths = 0;
+    answeredSinceSpawn = false;
+    /** True once the limit is reached: the supervisor stops replacing and says so. */
+    givenUp = false;
     constructor(repoRoot, onSwap) {
         this.repoRoot = repoRoot;
         this.onSwap = onSwap;
@@ -165,12 +185,14 @@ class Supervisor {
     forward(line, stdout) {
         const trimmed = line.trim();
         let isRequest = false;
+        let requestId;
         if (trimmed.startsWith('{')) {
             try {
                 const msg = JSON.parse(trimmed);
                 if (msg.method === 'initialize' || msg.method === 'notifications/initialized')
                     this.handshake.push(line);
                 isRequest = msg.id !== undefined;
+                requestId = msg.id;
             }
             catch { /* unparseable input is relayed untouched; the child owns protocol errors */ }
         }
@@ -181,12 +203,16 @@ class Supervisor {
         const disk = (0, basis_1.loadedBuildId)(this.repoRoot);
         if (shouldSwap(this.loaded, disk, this.inflight))
             this.swap(disk, stdout);
-        if (isRequest)
+        if (isRequest) {
             this.inflight++;
+            if (requestId !== undefined)
+                this.pending.add(requestId); // @implements A-SPEC-666
+        }
         this.child?.stdin.write(line);
     }
     swap(to, stdout) {
         const from = this.loaded;
+        this.expectedExit = true; // @implements A-SPEC-666 — we are replacing it on purpose
         this.child?.kill();
         this.loaded = to;
         this.spawnChild(stdout);
@@ -217,6 +243,10 @@ class Supervisor {
         // @implements A-SPEC-516.1 — one counter per child: a half-read line from the process being
         // replaced must not be finished by its successor's first chunk.
         const counter = createResponseCounter();
+        // @implements A-SPEC-666 — a fresh child has answered nothing yet; the silent-death budget is
+        // spent only by children that stay silent for their whole life.
+        this.answeredSinceSpawn = false;
+        let idCarry = '';
         child.stdout.on('data', (d) => {
             const text = d.toString();
             // Relay FIRST. Counting is an observation and must never delay or alter the bytes.
@@ -226,9 +256,82 @@ class Supervisor {
             // count would let a swap happen mid-request, which is the mis-delivered answer this whole
             // mechanism defers swaps to avoid.
             this.inflight = Math.max(0, this.inflight - counter.push(text));
+            // @implements A-SPEC-666 — and separately, WHICH ids were answered, so a death can reply to
+            // the rest. Its own line assembly: the counter above is contracted to count, not to identify.
+            idCarry = this.retireAnsweredIds(idCarry + text);
         });
+        child.on('exit', () => this.onChildGone(stdout));
+        child.on('error', () => this.onChildGone(stdout));
+    }
+    /**
+     * @implements A-SPEC-666
+     * Drop the ids of every COMPLETE response line from `pending`; return the unfinished tail so a
+     * reply split across chunks is not lost. A line with neither `result` nor `error` is a
+     * notification, not an answer, and retires nothing.
+     */
+    retireAnsweredIds(buffered) {
+        const parts = buffered.split('\n');
+        const tail = parts.pop() ?? '';
+        for (const line of parts) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith('{'))
+                continue;
+            try {
+                const msg = JSON.parse(trimmed);
+                if (msg.id === undefined)
+                    continue;
+                if (msg.result === undefined && msg.error === undefined)
+                    continue;
+                if (this.pending.delete(msg.id))
+                    this.answeredSinceSpawn = true;
+                else
+                    this.answeredSinceSpawn = true; // an answer we did not track is still an answer
+            }
+            catch { /* a partial or malformed line retires nothing */ }
+        }
+        return tail;
+    }
+    /**
+     * @implements A-SPEC-666
+     * The child is gone. Measured 2026-09-18: without this, `this.child` kept pointing at the corpse,
+     * every later request was written to a dead pipe, `inflight` never returned to zero and
+     * `shouldSwap`'s `inflight === 0` therefore never fired — the server was deaf for the rest of the
+     * session, twice in one day. Order matters: free the client first, then decide about a replacement.
+     */
+    onChildGone(stdout) {
+        if (this.expectedExit) {
+            this.expectedExit = false;
+            return;
+        } // a swap or a stop, not an accident
+        if (this.givenUp)
+            return;
+        // 1. Answer what the dead child never will. A request without a reply is a client waiting for ever.
+        for (const id of this.pending) {
+            stdout.write(`${JSON.stringify({
+                jsonrpc: '2.0', id,
+                error: { code: -32603, message: 'holmes-kit MCP child process exited before answering this request' },
+            })}\n`);
+        }
+        const orphaned = this.pending.size;
+        this.pending.clear();
+        this.inflight = 0;
+        // 2. A child that produced nothing in its whole life spends the budget; one that worked does not.
+        this.silentDeaths = this.answeredSinceSpawn ? 0 : this.silentDeaths + 1;
+        if (this.silentDeaths >= exports.MAX_CONSECUTIVE_SILENT_DEATHS) {
+            this.givenUp = true;
+            this.child = undefined;
+            process.stderr.write(`[holmes-kit] MCP child died ${this.silentDeaths} times without answering — stopped restarting it. Check the build (\`npm run build\`) and restart the server.\n`);
+            return;
+        }
+        // 3. Replace it and re-send the opening exchange, exactly as a swap does.
+        process.stderr.write(`[holmes-kit] MCP child exited unexpectedly; restarting (${orphaned} unanswered request(s) failed).\n`);
+        this.spawnChild(stdout);
+        for (const line of this.handshake)
+            this.child?.stdin.write(line);
     }
     stop() {
+        this.expectedExit = true; // @implements A-SPEC-666 — a shutdown is not an accident
+        this.givenUp = true; // ... and nothing may respawn after it
         this.child?.kill();
     }
 }

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;