@holmes-lab/holmes-kit 0.21.0 → 0.22.0

package/CHANGELOG.md

@@ -5,6 +5,58 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 <!-- @implements A-SPEC-209 -->
+## [0.22.0] - 2026-09-18
+
+The advisories learn what happened next. Until now this repository issued findings and recorded that
+it had issued them; nothing recorded whether anyone acted. That missing half is the numerator every
+"promote this to a hard gate once we know the false-positive rate" sentence needed.
+
+### Added
+- **Advisory reaction ledger** (A-SPEC-663). Every finding — impact-advisory, anchor-density,
+  Files-to-Touch fulfilment, trace-gap, kills-unapplicable — now has a deterministic id (kind + spec +
+  canonical payload). `spec_approve` records it as `issued` and answers with `advisoryIds`; the next
+  `approval_status` re-runs the SAME finding functions and records `resolved` when the cause is gone or
+  `persisted` when it is not, at most one row per finding per day. An author who judges a finding
+  unhelpful passes `dismiss: [id]` to `spec_approve`; an id the ledger does not know comes back in
+  `dismissUnknown` rather than inventing a row. `rtm_dashboard`'s census gains `advisoryOutcomes`
+  (issued / resolved / persisted / dismissed per kind) and `approval_status` gains `advisoryHistory`.
+  Rows live in `.ax/ledger/advisory-outcomes.<replica>.jsonl` and carry ids, spec ids, outcome words and
+  commit hashes only. Queries never issue a finding the seal did not, so the observation denominator
+  stays the seal's.
+- **`kills` applicability** (A-SPEC-662). `test_run --mutate` now reports mutations that never applied
+  as `unapplied`, separately from `survivors` — measured here, all 22 `kills` entries in this repository
+  write `where` as a file path and `mutate` as prose, so the literal-replacement engine applied none of
+  them and the response still read `survivors: []`, the shape of a clean run. Sealing a T-SPEC (and
+  previewing it with `approval_status`) reports entries whose `where` literal is absent from the
+  A-SPEC's anchored production source as a `kills-unapplicable` finding. Never blocking. The
+  author-slice playbook now shows the grammar.
+- **CI matrix, minimal form** (A-SPEC-664). `scripts/ci-orb-linux.sh` runs one commit's full suite on an
+  OrbStack Linux machine and appends exactly one row to `.ax/ledger/ci-runs.<host>.jsonl` — for every
+  outcome, including the ones where the run could not judge (`clone-failed`, `install-failed`,
+  `vm-unreachable`). A watch script and a launchd agent trigger it. The Stop hook reports the matrix's
+  last word on a tracked line and `doctor` gains a `ci matrix` check, and neither ever reads a missing
+  row as green: absence is "not run". The scripts are maintainer tools and are not shipped; a workspace
+  with no `ci-runs` ledger hears nothing about the matrix at all.
+
+### Fixed
+- **Trace-gap anchors: 21 approved specs joined the graph.** Each declared a scanned production file in
+  its Files to Touch while anchoring only tests, so `rtm_impact` could not see them. Their anchors now
+  sit in the files they declared. Unlinked approved specs fell from 73 to 52 and trace gaps from 21 to
+  0; `codeLinkedPct` rose from 88.6 to 91.9. The remaining 52 declare no scanned production file — they
+  are test- and document-only specs, not gaps.
+- **The runner counted focused suites as failures.** jest reports a suite that used `test.only` with
+  status `focused`; filtering on `!== 'passed'` made five healthy suites look red in the first two
+  Linux rows. Only `failed` counts now.
+
+### Measured
+- macOS: 524 suites / 6,581 passed / 11 skipped; every slice recorded red-assertion → green; official
+  `test_run` green at each step.
+- Linux (OrbStack Ubuntu 24.04 arm64, Node 22): five recorded runs, the last one unattended via launchd.
+  The residual reds are load-dependent suites (`dashboard.test`, `entity-store-boundaries`,
+  `entity-git-snapshot`) that pass when run alone; the host was running other agents' work at the time.
+- First reaction rows in this repository: 22 trace-gap findings issued, 22 resolved by the anchor move.
+- Windows: not re-run for this release; no Windows-specific change landed.
+
 ## [0.21.0] - 2026-09-17
 
 The backlog-hardening cycle: the RTM stops claiming coverage it cannot see, sealing reports what a

package/dist/.build-id

@@ -1 +1 @@
-bdbd4f85-mu4ywfad
+71586207-mu68mv0a

package/dist/holmes/cli/agents.js

@@ -40,6 +40,7 @@ exports.antigravityHookWarnings = antigravityHookWarnings;
 exports.mergeAgentsMd = mergeAgentsMd;
 exports.agentFiles = agentFiles;
 exports.agentLinks = agentLinks;
+// @implements A-SPEC-202, A-SPEC-250, A-SPEC-341
 // @implements A-SPEC-442
 // @implements A-SPEC-193
 const path = __importStar(require("node:path"));

package/dist/holmes/cli/doctor.d.ts

@@ -171,6 +171,7 @@ export declare function wiringSpawnCheck(command: string, args: string[], timeou
  * the same honest-diagnosis lineage as the codex-wiring WARN (never a gate).
  */
 export declare function pushGateCheck(target: string): Check | null;
+export declare function ciMatrixCheck(target: string): Check | null;
 export declare function formatChecks(checks: Check[]): string;
 /**
  * Prove that EVERY wired harness can actually start a server, not merely that its file parses.

package/dist/holmes/cli/doctor.js

@@ -47,10 +47,12 @@ exports.resolveWiringPath = resolveWiringPath;
 exports.runDoctor = runDoctor;
 exports.wiringSpawnCheck = wiringSpawnCheck;
 exports.pushGateCheck = pushGateCheck;
+exports.ciMatrixCheck = ciMatrixCheck;
 exports.formatChecks = formatChecks;
 exports.wiringHandshakeChecks = wiringHandshakeChecks;
 exports.semanticTierVerdict = semanticTierVerdict;
 exports.detectTreeKeyTemporary = detectTreeKeyTemporary;
+// @implements A-SPEC-264, A-SPEC-423, A-SPEC-549.1, A-SPEC-590
 // @implements A-SPEC-594
 // @implements A-SPEC-592
 // @implements A-SPEC-591
@@ -65,6 +67,7 @@ const native_deps_1 = require("./native-deps");
 const tier_1 = require("../semantic/tier");
 const probe_process_1 = require("./probe-process");
 const npx_cache_check_1 = require("./npx-cache-check");
+const ci_runs_1 = require("../project/ci-runs");
 const path = __importStar(require("node:path"));
 const role_policy_1 = require("../governance/role-policy");
 const blind_spots_1 = require("../guardrail/blind-spots");
@@ -1261,6 +1264,9 @@ async function runDoctor(packageRoot, target, opts, extraChecks) {
         const pg = pushGateCheck(target ?? process.cwd());
         if (pg)
             checks.push(pg);
+        const ci = ciMatrixCheck(target ?? process.cwd()); // @implements A-SPEC-664
+        if (ci)
+            checks.push(ci);
     }
     if (extraChecks) {
         checks.push(...extraChecks);
@@ -1554,6 +1560,42 @@ function pushGateCheck(target) {
         return null;
     } // diagnosis must never crash doctor
 }
+// @implements A-SPEC-664
+// The CI matrix as doctor sees it: PASS only for a green row at HEAD; everything else is a WARN that
+// says exactly what the ledger says — "not run" when there is no row, the failed suites when red,
+// the infrastructure status when the run could not judge. Never a FAIL: the matrix informs.
+function ciMatrixCheck(target) {
+    try {
+        if (!fs.existsSync(path.join(target, '.ax')))
+            return null;
+        if (!(0, ci_runs_1.hasCiLedger)(target))
+            return null; // @implements A-SPEC-664 — same adoption predicate as the hook
+        const runs = (0, ci_runs_1.readCiRuns)(target);
+        let head;
+        try {
+            head = (0, node_child_process_1.execFileSync)('git', ['rev-parse', 'HEAD'], { cwd: target, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        }
+        catch {
+            head = undefined;
+        }
+        const behind = (rev) => {
+            try {
+                return Number((0, node_child_process_1.execFileSync)('git', ['rev-list', '--count', `${rev}..HEAD`], { cwd: target, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim());
+            }
+            catch {
+                return undefined;
+            }
+        };
+        const v = (0, ci_runs_1.ciVerdict)(runs, 'linux', head, behind);
+        const detail = (0, ci_runs_1.ciStatusLine)(v);
+        if (v.state === 'green' && v.behind === 0)
+            return { name: 'ci matrix', level: 'PASS', detail };
+        return { name: 'ci matrix', level: 'WARN', detail, fix: 'Run scripts/ci-orb-linux.sh HEAD (or install the launchd agent: scripts/ci-orb-linux-install.sh)' };
+    }
+    catch {
+        return null;
+    } // diagnosis must never crash doctor
+}
 function formatChecks(checks) {
     const lines = checks.map((c) => {
         const head = `${c.level.padEnd(4)} ${c.name} — ${c.detail}`;

package/dist/holmes/cli/index.js

@@ -37,6 +37,7 @@ exports.isBrokenPipe = void 0;
 exports.packageRoot = packageRoot;
 exports.main = main;
 exports.installPipeGuard = installPipeGuard;
+// @implements A-SPEC-549.2
 // @implements A-SPEC-591, A-SPEC-626
 const cli_execution_1 = require("./cli-execution");
 // @implements A-SPEC-100.2

package/dist/holmes/cli/init.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.settingsPathOf = exports.MATCHERS = exports.SERVER_NAME = void 0;
 exports.buildHookPlan = buildHookPlan;
 exports.runInit = runInit;
+// @implements A-SPEC-340
 // @implements A-SPEC-100.2
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));

package/dist/holmes/cpg/language-parser-walk.js

@@ -1,3 +1,4 @@
+// @implements A-SPEC-302
 'use strict';
 // Single source of truth for the per-language symbol/edge tree-walking
 // logic. Called from BOTH the inline (production) parse path and the

package/dist/holmes/hooks/stop.d.ts

@@ -2,7 +2,9 @@ import { PendingRequest } from '../governance/approval-queue';
 import { Spec } from '../spec/spec-parser';
 import type { TestOutcome } from '../review/test-runner';
 import { type KnownDefectJudgement } from '../rtm/known-defects';
+import { type CiVerdict } from '../project/ci-runs';
 export declare function collectKnownDefects(root: string, now: Date): KnownDefectJudgement | undefined;
+export declare function collectCiVerdicts(root: string, now?: Date): CiVerdict[];
 /**
  * @implements A-SPEC-100.2
  * Stop-hook governance gate (Phase-2 #1: push, not pull).
@@ -31,6 +33,11 @@ export interface StopEvidence {
      * `undefined` is no signal — a walk that could not run must not read as marker-free.
      */
     knownDefects?: KnownDefectJudgement;
+    /**
+     * @implements A-SPEC-664 — what the CI matrix last said about this tree, per OS. Absent when the
+     * hook could not look; a `not-run` verdict when it looked and found no row (never silence).
+     */
+    ci?: CiVerdict[];
     /** Provenance-chain verification result (CLI-supplied). A broken chain blocks the stop. */
     provenance?: {
         ok: boolean;

package/dist/holmes/hooks/stop.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAX_CONSECUTIVE_BLOCKS = void 0;
 exports.collectKnownDefects = collectKnownDefects;
+exports.collectCiVerdicts = collectCiVerdicts;
 exports.changedAnchoredAspecs = changedAnchoredAspecs;
 exports.unanchoredChangedSources = unanchoredChangedSources;
 exports.dependencyReappraisals = dependencyReappraisals;
@@ -79,6 +80,7 @@ const constitution_debt_1 = require("../governance/constitution-debt");
 const root_1 = require("../project/root");
 const known_defects_1 = require("../rtm/known-defects");
 const test_files_1 = require("../cpg/test-files");
+const ci_runs_1 = require("../project/ci-runs");
 // @implements A-SPEC-660 — the I/O half of the known-defect marker: walk the workspace's test files
 // (the same directory rule and test predicate ART-4's anchor scan uses), parse each for markers,
 // judge them against the injected clock. A walk that cannot START is NO SIGNAL (undefined) — never
@@ -126,6 +128,40 @@ function collectKnownDefects(root, now) {
         return undefined;
     }
 }
+// @implements A-SPEC-664 — the I/O half of the CI line: read the ci-runs ledger, judge Linux (always)
+// and any other OS that has a row, with git measuring how far each judged commit sits behind HEAD.
+// A tree without a ledger yields a `not-run` verdict — a line, not an absence.
+function collectCiVerdicts(root, now = new Date()) {
+    void now;
+    // @implements A-SPEC-664 — a workspace that never ran the matrix hears nothing about it. Past this
+    // line the matrix IS adopted here, so a missing row is reported rather than passed over in silence.
+    if (!(0, ci_runs_1.hasCiLedger)(root))
+        return [];
+    let runs = [];
+    try {
+        runs = (0, ci_runs_1.readCiRuns)(root);
+    }
+    catch {
+        runs = [];
+    }
+    let head;
+    try {
+        head = (0, node_child_process_1.execFileSync)('git', ['rev-parse', 'HEAD'], { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], env: (0, root_1.cleanSubprocessEnv)() }).trim();
+    }
+    catch {
+        head = undefined;
+    }
+    const behind = (rev) => {
+        try {
+            return Number((0, node_child_process_1.execFileSync)('git', ['rev-list', '--count', `${rev}..HEAD`], { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], env: (0, root_1.cleanSubprocessEnv)() }).trim());
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const oses = ['linux', ...[...new Set(runs.map((r) => r.os))].filter((o) => o !== 'linux').sort()];
+    return oses.map((os) => (0, ci_runs_1.ciVerdict)(runs, os, head, behind));
+}
 /**
  * @implements A-SPEC-534.4
  * ART-8 evidence (I/O half): the A-SPECs whose DIRTY source files carry an @implements anchor. git is
@@ -492,6 +528,7 @@ const TRACK_LABELS = {
     'ART-8': 'RED-first',
     'ART-2': 'code-graph cycles',
     'ART-9': 'known-defect debt',
+    'CI': 'matrix',
 };
 /**
  * One line per ARTICLE, each under its own name.
@@ -557,6 +594,14 @@ function evaluateStop(specs, evidence) {
         const t = evidence.knownDefects.unexpired.map((k) => ({ article: 'ART-9', detail: `${k.file}:${k.line}: known defect "${k.reason}" until ${k.expires}` }));
         tracked = [...(tracked ?? []), ...t];
     }
+    // @implements A-SPEC-664 — the CI matrix's last word, one tracked line per OS. Never a block: a
+    // red Linux run is information for the person closing the turn, and "not run" is said out loud
+    // because the alternative — silence — reads as green (measured 2026-09-17: 136 environmental reds
+    // surfaced only because someone ran the suite by hand before a release).
+    if (evidence?.ci && evidence.ci.length > 0) {
+        const t = evidence.ci.map((v) => ({ article: 'CI', detail: (0, ci_runs_1.ciStatusLine)(v) }));
+        tracked = [...(tracked ?? []), ...t];
+    }
     const problems = violations.map((x) => `[${x.article}] ${x.detail}`);
     // @implements A-SPEC-247 — structured list so the caller can ask acknowledgeStop which of these
     // are waiting on an owner. Mirrors `problems` exactly, including the two synthesized below.
@@ -1141,7 +1186,15 @@ if (require.main === module) {
             catch { /* maintenance, never a hook failure */ }
             // @implements A-SPEC-660 — the marker walk: no signal when it cannot run (never a clean verdict).
             const knownDefects = collectKnownDefects(stopProjectRoot(), new Date());
-            let out = evaluateStop(specs, { testCasesByAspec, provenance, executedByAspec, findings, findingsUnreadable, unanchoredChangedSources: unanchored, unrecordedApprovals: unrecorded, rolledBackLedgers: rolledBack, redFirstMode, changedAspecs, outcomesByAspec, ...(knownDefects ? { knownDefects } : {}) });
+            // @implements A-SPEC-664 — the CI matrix line rides beside the constitution's verdict.
+            let ci;
+            try {
+                ci = collectCiVerdicts(stopProjectRoot());
+            }
+            catch {
+                ci = undefined;
+            }
+            let out = evaluateStop(specs, { testCasesByAspec, provenance, executedByAspec, findings, findingsUnreadable, unanchoredChangedSources: unanchored, unrecordedApprovals: unrecorded, rolledBackLedgers: rolledBack, redFirstMode, changedAspecs, outcomesByAspec, ...(knownDefects ? { knownDefects } : {}), ...(ci ? { ci } : {}) });
             // @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.
             // @implements A-SPEC-559.2 — spec-evolution trigger (observe-first, NEVER blocks): a dirty

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,9 @@ 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;
@@ -162,7 +170,25 @@ export declare function createOperatorInspectionHandlers(context: OperatorInspec
         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;
+            };
+            reqCount: number;
+            pipelineCount: number;
+            coveredCount: number;
+            coveragePct: number;
+            retiredCount: number;
+            findingsScanned: boolean;
+        };
         reason?: undefined;
     }>;
 };

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,31 @@ 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;
+            };
+            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 +868,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 +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),
     });

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