@holmes-lab/holmes-kit 0.16.0 → 0.18.0

package/dist/holmes/mcp/spec-id-guard.d.ts

@@ -15,12 +15,4 @@ export type IdVerdict = {
     reason: string;
     nextAvailable: number;
 };
-/**
- * 새 id 의 base 가 코퍼스 max base 를 한 칸 넘게 뛰면 거부한다.
- *
- * - 빈 코퍼스, 또는 base 를 못 뽑는 id → 통과(비교 대상이 없거나, 형태 검증은 별도 소관이라 한 결함에
- *   두 이름을 주지 않는다).
- * - base ≤ maxBase(갭 메우기·체인 완성) 또는 base == maxBase+1(새 체인) → 통과.
- * - base > maxBase+1(leap) → 거부, 다음 가용 번호를 문면과 필드에 댄다.
- */
 export declare function sequentialIdVerdict(newId: string, existingIds: string[]): IdVerdict;

package/dist/holmes/mcp/spec-id-guard.js

@@ -30,11 +30,20 @@ function specIdBase(id) {
  * - base ≤ maxBase(갭 메우기·체인 완성) 또는 base == maxBase+1(새 체인) → 통과.
  * - base > maxBase+1(leap) → 거부, 다음 가용 번호를 문면과 필드에 댄다.
  */
+/** The id's number SPACE. @implements A-SPEC-571.1 — ADR keeps its own sequence so a decision
+ * (jarvis's ADR-0001) neither blocks nor is blocked by the functional chain's max. Everything
+ * else shares one space, exactly as before. */
+function idSpaceOf(id) {
+    return /^ADR-/.test(id.trim()) ? 'ADR' : 'functional';
+}
 function sequentialIdVerdict(newId, existingIds) {
     const base = specIdBase(newId);
     if (base === null)
         return { ok: true };
-    const bases = (existingIds ?? []).map(specIdBase).filter((n) => n !== null);
+    // @implements A-SPEC-571.1 — compare only within the same number space.
+    const space = idSpaceOf(newId);
+    const bases = (existingIds ?? []).filter((id) => idSpaceOf(id) === space)
+        .map(specIdBase).filter((n) => n !== null);
     if (bases.length === 0)
         return { ok: true };
     const maxBase = Math.max(...bases);

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

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

package/dist/holmes/rtm/anchor-density.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_ANCHORS = void 0;
+exports.anchorDensityFindings = anchorDensityFindings;
+exports.appendAnchorDensity = appendAnchorDensity;
+exports.readAnchorDensity = readAnchorDensity;
+// @implements A-SPEC-569.5
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const replica_id_1 = require("../governance/replica-id");
+/** Files below this live-anchor count are never flagged, whatever the distribution — a floor. */
+exports.MIN_ANCHORS = 8;
+/**
+ * FtT files whose live anchor count sits at or above max(MIN_ANCHORS, p90 of the distribution).
+ * p90 is the value at index ceil(0.9·n)-1 of the ascending counts — deterministic, no interpolation.
+ * Pure: same inputs, same findings, in sorted path order.
+ */
+function anchorDensityFindings(fttFiles, counts) {
+    if (counts.length === 0 || fttFiles.length === 0)
+        return [];
+    const sorted = counts.map((c) => c.anchors).sort((a, b) => a - b);
+    const p90 = sorted[Math.ceil(0.9 * sorted.length) - 1];
+    const threshold = Math.max(exports.MIN_ANCHORS, p90);
+    const byPath = new Map(counts.map((c) => [c.sourcePath, c.anchors]));
+    const out = [];
+    for (const f of [...new Set(fttFiles.map((p) => p.replace(/\\/g, '/')))].sort()) {
+        const anchors = byPath.get(f);
+        if (anchors !== undefined && anchors >= threshold)
+            out.push({ path: f, anchors, p90 });
+    }
+    return out;
+}
+const DENSITY_FILE_RE = /^anchor-density\.([^.]+)\.jsonl$/;
+function appendAnchorDensity(root, rec) {
+    try {
+        if (!fs.existsSync(path.join(root, '.ax')))
+            return false;
+        let replica = 'local';
+        try {
+            replica = (0, replica_id_1.resolveReplicaId)(root) || 'local';
+        }
+        catch { /* keep the fallback */ }
+        const file = path.join(root, '.ax', 'ledger', `anchor-density.${replica}.jsonl`);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.appendFileSync(file, `${JSON.stringify({ ...rec, replica })}\n`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readAnchorDensity(root) {
+    const dir = path.join(root, '.ax', 'ledger');
+    let names;
+    try {
+        names = fs.readdirSync(dir).filter((n) => DENSITY_FILE_RE.test(n)).sort();
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of names) {
+        let text;
+        try {
+            text = fs.readFileSync(path.join(dir, name), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        for (const line of text.split('\n')) {
+            const s = line.trim();
+            if (!s)
+                continue;
+            try {
+                const r = JSON.parse(s);
+                if (r && typeof r === 'object' && typeof r.aspec === 'string' && Array.isArray(r.files) && typeof r.ts === 'string') {
+                    out.push(r);
+                }
+            }
+            catch { /* a corrupt line never breaks the read */ }
+        }
+    }
+    return out;
+}

package/dist/holmes/rtm/decision-context.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The DECISION context of a candidate — "why is this the way it is?".
+ *
+ * A person diagnosing a defect asks two questions in order: what broke (the candidates), and then
+ * why this code was left this way (the decision). The graph already answers the second — REQ-571
+ * put store ADRs into the decision population and A-SPEC-293 already builds `constrained_by` from
+ * citations — so this is a lookup, not a new mechanism: no new edge kind, no new tool.
+ *
+ * OBSERVATION ONLY. The context rides beside a candidate; nothing here enters the ranking, the
+ * score, or any gate (the c6 rule — prose informs, it never adjudicates).
+ */
+export interface DecisionContextEntry {
+    adr: string;
+    /** The decision's own sentence, or null when the store carries no summary for it (id stays). */
+    decision: string | null;
+}
+export interface DecisionGraphLike {
+    decisionsConstraining(nodeIds: readonly string[]): string[];
+    summaryOf(id: string): string | null;
+}
+/** How many decisions ride beside one candidate. A prose constant — never a verdict input. */
+export declare const MAX_DECISIONS = 3;
+export declare function decisionContextFor(files: readonly string[], specIdsOf: (file: string) => readonly string[], graph: DecisionGraphLike): Map<string, DecisionContextEntry[]>;

package/dist/holmes/rtm/decision-context.js

@@ -0,0 +1,47 @@
+"use strict";
+// @implements A-SPEC-572.3
+/**
+ * The DECISION context of a candidate — "why is this the way it is?".
+ *
+ * A person diagnosing a defect asks two questions in order: what broke (the candidates), and then
+ * why this code was left this way (the decision). The graph already answers the second — REQ-571
+ * put store ADRs into the decision population and A-SPEC-293 already builds `constrained_by` from
+ * citations — so this is a lookup, not a new mechanism: no new edge kind, no new tool.
+ *
+ * OBSERVATION ONLY. The context rides beside a candidate; nothing here enters the ranking, the
+ * score, or any gate (the c6 rule — prose informs, it never adjudicates).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_DECISIONS = void 0;
+exports.decisionContextFor = decisionContextFor;
+/** How many decisions ride beside one candidate. A prose constant — never a verdict input. */
+exports.MAX_DECISIONS = 3;
+function decisionContextFor(files, specIdsOf, graph) {
+    const out = new Map();
+    for (const file of files) {
+        let adrs = [];
+        try {
+            // The file itself AND the specs it anchors: a person chasing "why" follows both, and the
+            // constraint is often recorded one level up, on the spec rather than on the file.
+            adrs = graph.decisionsConstraining([
+                `FILE:${file}`,
+                ...specIdsOf(file).map((id) => `SPEC:${id}`),
+            ]);
+        }
+        catch {
+            continue;
+        } // an unreadable graph yields no context, never a throw
+        const shown = [...new Set(adrs)].sort().slice(0, exports.MAX_DECISIONS);
+        if (shown.length === 0)
+            continue; // no entry rather than an invented empty list
+        out.set(file, shown.map((adr) => {
+            let decision = null;
+            try {
+                decision = graph.summaryOf(`SPEC:${adr}`);
+            }
+            catch { /* id stays, prose does not */ }
+            return { adr, decision };
+        }));
+    }
+    return out;
+}

package/dist/holmes/rtm/impact-advisory.d.ts

@@ -22,11 +22,15 @@ export interface ImpactAdvisory {
             id: string;
             summary: string | null;
         }>;
+        /** @implements A-SPEC-569.3 — anchors beyond ANCHOR_CAP, counted rather than silently dropped. */
+        anchorsOmitted?: number;
     }>;
     more: number;
     graphAsOf?: string;
 }
 export declare const ADVISORY_CAP = 10;
+/** @implements A-SPEC-569.3 — anchors annotated per advisory file; a prose constant, never a verdict input. */
+export declare const ANCHOR_CAP = 10;
 export declare function declaredImpactGap(fttFiles: string[], graph: GraphLike, readFile: (rel: string) => string | null, opts?: {
     cap?: number;
 }): ImpactAdvisory | null;

package/dist/holmes/rtm/impact-advisory.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ADVISORY_CAP = void 0;
+exports.ANCHOR_CAP = exports.ADVISORY_CAP = void 0;
 exports.declaredImpactGap = declaredImpactGap;
 exports.appendImpactAdvisory = appendImpactAdvisory;
 exports.readImpactAdvisories = readImpactAdvisories;
@@ -43,6 +43,8 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const replica_id_1 = require("../governance/replica-id");
 exports.ADVISORY_CAP = 10;
+/** @implements A-SPEC-569.3 — anchors annotated per advisory file; a prose constant, never a verdict input. */
+exports.ANCHOR_CAP = 10;
 /** The ONLY shape allowed into the ledger: `seg/seg/…` of word characters, dots and dashes —
  * no leading slash, no drive letter, no backslash, no empty or `..` segment. */
 function isRepoRelative(p) {
@@ -99,12 +101,16 @@ function declaredImpactGap(fttFiles, graph, readFile, opts) {
                         ids = anchorsIn(text);
                 }
                 catch { /* anchors stay [] */ }
+                // @implements A-SPEC-569.3 — capped BEFORE the summary lookups, so the omitted tail costs
+                // no SELECTs either; the omission is counted, never silent.
+                const shownIds = ids.slice(0, exports.ANCHOR_CAP);
+                const anchorsOmitted = ids.length - shownIds.length;
                 // @implements A-SPEC-568.2 — the anchor's intent sentence rides BESIDE the id, read from the
                 // graph S1 built. Information only: nothing below this line feeds files/more/ordering, and a
                 // failing lookup downgrades to null rather than killing the finding (an advisory never guesses).
                 return {
                     path,
-                    anchors: ids.map((id) => {
+                    anchors: shownIds.map((id) => {
                         let summary = null;
                         try {
                             summary = graph.summaryOf(`SPEC:${id}`);
@@ -112,6 +118,7 @@ function declaredImpactGap(fttFiles, graph, readFile, opts) {
                         catch { /* summary stays null */ }
                         return { id, summary };
                     }),
+                    ...(anchorsOmitted > 0 ? { anchorsOmitted } : {}),
                 };
             }),
             more: sorted.length - shown.length,

package/dist/holmes/rtm/localize.js

@@ -10,8 +10,10 @@ exports.localizeIssue = localizeIssue;
  * repository's `S-<n>` slice shorthand (which names the whole REQ->T-SPEC chain at that number).
  * The prefix is REQUIRED — a bare `262` in "262 files were rewritten" is a number, not a citation.
  */
-const CITATION = /\b(?:(A-SPEC|H-SPEC|T-SPEC|C-SPEC|REQ)-(\d+(?:\.\d+)?)|S-(\d+(?:\.\d+)?))\b/gi;
-const CITABLE_KINDS = ['REQ', 'H-SPEC', 'A-SPEC', 'T-SPEC', 'C-SPEC'];
+// @implements A-SPEC-571.2 — ADR is citable like any governed id (recognition only; the match
+// SCORING population stays A-SPEC-limited below, so an ADR never admits or reorders a file).
+const CITATION = /\b(?:(A-SPEC|H-SPEC|T-SPEC|C-SPEC|ADR|REQ)-(\d+(?:\.\d+)?)|S-(\d+(?:\.\d+)?))\b/gi;
+const CITABLE_KINDS = ['REQ', 'H-SPEC', 'A-SPEC', 'T-SPEC', 'C-SPEC', 'ADR'];
 /**
  * @implements A-SPEC-273
  * How much a citation is worth, normalized by the file's anchor count exactly as the lexical spec

package/dist/holmes/rtm/rtm-builder.js

@@ -73,6 +73,8 @@ const INTENT_SECTION = {
     'REQ': 'Problem / Need',
     'H-SPEC': 'Intent',
     'A-SPEC': 'Objective',
+    // @implements A-SPEC-571.2 — a decision's intent IS its Decision line.
+    'ADR': 'Decision',
 };
 /** Longest intent sentence carried into the graph — a bound, applied deterministically. */
 const SUMMARY_SENTENCE_CAP = 200;
@@ -91,15 +93,23 @@ function specSummary(s) {
     const text = (section ? (s.sections?.[section] ?? '') : '').replace(/\s+/g, ' ').trim();
     // Measured 2026-09-07 on this store: 20 legacy specs carry title '' — the summary falls back to
     // the sentence alone, then to the id, because SC1 admits no empty summary on any path.
+    let result;
     if (text === '' || text === 'TODO')
-        return title !== '' ? title : s.id;
-    // First sentence: up to the first . ! or ? that ends a word — the lookahead keeps `A-SPEC-129.2`
-    // whole, because its dot is followed by a digit, not by whitespace or the end.
-    const m = /^(.*?[.!?])(?=\s|$)/.exec(text);
-    let sentence = m ? m[1] : text;
-    if (sentence.length > SUMMARY_SENTENCE_CAP)
-        sentence = `${sentence.slice(0, SUMMARY_SENTENCE_CAP)}…`;
-    return title !== '' ? `${title} — ${sentence}` : sentence;
+        result = title !== '' ? title : s.id;
+    else {
+        // First sentence: up to the first . ! or ? that ends a word — the lookahead keeps `A-SPEC-129.2`
+        // whole, because its dot is followed by a digit, not by whitespace or the end.
+        const m = /^(.*?[.!?])(?=\s|$)/.exec(text);
+        let sentence = m ? m[1] : text;
+        if (sentence.length > SUMMARY_SENTENCE_CAP)
+            sentence = `${sentence.slice(0, SUMMARY_SENTENCE_CAP)}…`;
+        result = title !== '' ? `${title} — ${sentence}` : sentence;
+    }
+    // @implements A-SPEC-569.1 — the WHOLE summary folds, title included. The first cut normalized
+    // only the sentence, and a YAML double-quoted title carried \n/\t straight into dumpCanonical,
+    // where graphViewOf parsed the forged row as a real call edge (0.16.0 adversarial reproduction).
+    // Prose must never carry the dump's structural characters.
+    return result.replace(/\s+/g, ' ').trim();
 }
 /**
  * Adds one scanned file's CODE nodes and `implements` edges to the graph,

package/dist/holmes/rtm/rtm-graph.d.ts

@@ -61,6 +61,9 @@ export declare class RtmGraph {
      */
     summaryOf(id: string): string | null;
     addEdge(src: string, dst: string, rel: string, sourcePath?: string, provenance?: Provenance): void;
+    /** @implements A-SPEC-569.1 — does the graph hold this node? SELECT 1, no row materialization:
+     * the approved-only channel filter (A-SPEC-569.2) asks exactly this and nothing more. */
+    hasNode(id: string): boolean;
     /** @implements A-SPEC-281 — how this node got here, or null if the node is unknown. */
     provenanceOfNode(id: string): Provenance | null;
     /** @implements A-SPEC-281 — how this edge got here, or null if the edge is unknown. */
@@ -212,6 +215,15 @@ export declare class RtmGraph {
     clear(): void;
     /** @implements A-SPEC-283 — the journal mode actually in force, so the pragma can be asserted. */
     journalMode(): string;
+    /**
+     * @implements A-SPEC-569.5
+     * Live anchors per source file — distinct SPEC targets of `implements` edges, one GROUP BY.
+     * Feeds the anchor-density OBSERVATION at sealing time; nothing reads it into a verdict.
+     */
+    implementsAnchorCounts(): Array<{
+        sourcePath: string;
+        anchors: number;
+    }>;
     nodeCount(): number;
     edgeCount(): number;
     close(): void;

package/dist/holmes/rtm/rtm-graph.js

@@ -120,7 +120,11 @@ class RtmGraph {
     edgeStmt;
     addNode(id, kind, sourcePath, provenance, summary) {
         this.nodeStmt ??= this.db.prepare(`INSERT OR IGNORE INTO nodes (id,kind,source_path,summary,${PROVENANCE_COLUMNS.join(',')}) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)`);
-        this.nodeStmt.run(id, kind, sourcePath ?? null, summary ?? null, ...provenanceRow(provenance));
+        // @implements A-SPEC-569.1 — the STORAGE boundary folds structural characters too, so a future
+        // caller that never went through specSummary still cannot forge dumpCanonical rows. Second,
+        // independent face of the seal (each face is verified alone).
+        const foldedSummary = summary == null ? null : summary.replace(/\s+/g, ' ').trim();
+        this.nodeStmt.run(id, kind, sourcePath ?? null, foldedSummary, ...provenanceRow(provenance));
     }
     /**
      * @implements A-SPEC-568.1
@@ -137,6 +141,11 @@ class RtmGraph {
         this.edgeStmt ??= this.db.prepare(`INSERT OR IGNORE INTO edges (src,dst,rel,source_path,${PROVENANCE_COLUMNS.join(',')}) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)`);
         this.edgeStmt.run(src, dst, rel, sourcePath ?? null, ...provenanceRow(provenance));
     }
+    /** @implements A-SPEC-569.1 — does the graph hold this node? SELECT 1, no row materialization:
+     * the approved-only channel filter (A-SPEC-569.2) asks exactly this and nothing more. */
+    hasNode(id) {
+        return this.db.prepare('SELECT 1 FROM nodes WHERE id = ?').get(id) !== undefined;
+    }
     /** @implements A-SPEC-281 — how this node got here, or null if the node is unknown. */
     provenanceOfNode(id) {
         return provenanceOf(this.db.prepare('SELECT * FROM nodes WHERE id = ?').get(id));
@@ -364,15 +373,21 @@ class RtmGraph {
         // @implements A-SPEC-281 — provenance is part of the value, so a provenance-only divergence
         // between a full rebuild and an incremental update is caught rather than passing as equal.
         const cols = PROVENANCE_COLUMNS.join(', ');
-        const prov = (r) => PROVENANCE_COLUMNS.map((c) => (r[c] === null || r[c] === undefined ? '' : String(r[c]))).join('\t');
+        // @implements A-SPEC-569.1 (revision) — EVERY text column folds at emission. Sealing columns
+        // one at a time (title → summary) was whack-a-mole: high-effort review found id/depends_on
+        // carrying tabs into these rows and shifting columns under graphViewOf. The dump's structural
+        // characters are the dump's own concern, so this is the single choke point; the row-shape
+        // invariant (exactly 13 cells, structural-char-free) is pinned by test.
+        const fold = (v) => (v === null || v === undefined ? '' : String(v).replace(/[\t\n\r]+/g, ' '));
+        const prov = (r) => PROVENANCE_COLUMNS.map((c) => fold(r[c])).join('\t');
         const nodes = this.db.prepare(`SELECT id, kind, source_path, summary, ${cols} FROM nodes ORDER BY id`).all();
         const edges = this.db.prepare(`SELECT src, dst, rel, source_path, ${cols} FROM edges ORDER BY src, dst, rel`).all();
         return [
             // @implements A-SPEC-568.1 — summary is part of the VALUE (appended last so every positional
             // consumer of the earlier columns is untouched); a summary-only divergence between two builds
             // must fail the convergence comparison rather than pass as equal.
-            ...nodes.map((n) => `N\t${n.id}\t${n.kind}\t${n.source_path ?? ''}\t${prov(n)}\t${n.summary ?? ''}`),
-            ...edges.map((e) => `E\t${e.src}\t${e.dst}\t${e.rel}\t${e.source_path ?? ''}\t${prov(e)}`),
+            ...nodes.map((n) => `N\t${fold(n.id)}\t${fold(n.kind)}\t${fold(n.source_path)}\t${prov(n)}\t${fold(n.summary)}`),
+            ...edges.map((e) => `E\t${fold(e.src)}\t${fold(e.dst)}\t${fold(e.rel)}\t${fold(e.source_path)}\t${prov(e)}`),
         ].join('\n');
     }
     /**
@@ -416,6 +431,16 @@ class RtmGraph {
     journalMode() {
         return String(this.db.pragma('journal_mode', { simple: true }) ?? '');
     }
+    /**
+     * @implements A-SPEC-569.5
+     * Live anchors per source file — distinct SPEC targets of `implements` edges, one GROUP BY.
+     * Feeds the anchor-density OBSERVATION at sealing time; nothing reads it into a verdict.
+     */
+    implementsAnchorCounts() {
+        return this.db.prepare(`SELECT source_path AS sourcePath, COUNT(DISTINCT dst) AS anchors FROM edges
+        WHERE rel='implements' AND source_path IS NOT NULL GROUP BY source_path ORDER BY source_path ASC`)
+            .all();
+    }
     nodeCount() { return this.db.prepare('SELECT COUNT(*) AS c FROM nodes').get().c; }
     edgeCount() { return this.db.prepare('SELECT COUNT(*) AS c FROM edges').get().c; }
     close() { this.db.close(); }

package/dist/holmes/spec/spec-types.d.ts

@@ -1,4 +1,4 @@
-export type SpecType = 'REQ' | 'H-SPEC' | 'A-SPEC' | 'C-SPEC' | 'T-SPEC';
+export type SpecType = 'REQ' | 'H-SPEC' | 'A-SPEC' | 'C-SPEC' | 'T-SPEC' | 'ADR';
 export declare const SPEC_STATUSES: readonly ["draft", "review", "approved", "outdated"];
 export type SpecStatus = (typeof SPEC_STATUSES)[number];
 export interface SpecTypeDef {

package/dist/holmes/spec/spec-types.js

@@ -12,7 +12,9 @@ exports.parentRuleText = parentRuleText;
 // its test's CANON, and the type itself — so adding a status compiled clean while spec_list kept
 // flagging it legacy.
 exports.SPEC_STATUSES = ['draft', 'review', 'approved', 'outdated'];
-exports.SPEC_ORDER = ['REQ', 'H-SPEC', 'A-SPEC', 'C-SPEC', 'T-SPEC'];
+// @implements A-SPEC-571.1 — ADR trails the functional chain: spec_next serves the REQ→…→T-SPEC
+// order first, and a decision is off that critical path.
+exports.SPEC_ORDER = ['REQ', 'H-SPEC', 'A-SPEC', 'C-SPEC', 'T-SPEC', 'ADR'];
 /**
  * Where a requirement came from.
  *
@@ -102,6 +104,17 @@ exports.SPEC_TYPES = {
         requiredFields: ['coverage'],
         requiredSections: ['Normal Cases', 'Corner Cases', 'Negative Cases', 'Boundary Cases'],
     },
+    // @implements A-SPEC-571.1
+    // A DECISION, not a functional contract: a root type (no parent, like REQ) that records why a
+    // choice was made and inherits the store's authoring governance (stub → validate → seal → ledger
+    // → tamper-block). It carries NO T-SPEC/anchor/FtT duty — that is the No-Spec-No-Code chain, a
+    // separate axis. Its number space is its own (see spec-id-guard), so jarvis's ADR-0001 does not
+    // collide with the functional chain's max. 4-digit zero-padded ids are accepted (ADR-0001).
+    'ADR': {
+        type: 'ADR', idRegex: /^ADR-\d{3,}$/, example: 'ADR-0001', folder: '06_adr', parents: [],
+        requiredFields: ['decided', 'decider'],
+        requiredSections: ['Context', 'Decision', 'Consequences', 'Alternatives'],
+    },
 };
 // @implements A-SPEC-100.1
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "//": "@implements A-SPEC-209",
   "name": "@holmes-lab/holmes-kit",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "Holmes-Kit — deterministic Agentic Software Engineering (ASE) harness with causal traceability (spec chain + D-CPG + RTM + phase guardrail)",
   "main": "dist/holmes/mcp/server.js",
   "types": "dist/holmes/mcp/server.d.ts",

package/playbooks/author-slice/PLAYBOOK.md

@@ -82,6 +82,25 @@ Criteria · Non-Functional · Assumptions · Open Questions.** 필수 필드: `r
 부모 REQ의 Success Criteria가 이 설계로 어떻게 달성되는지가 본문이다. Open Questions는 비워두는
 칸이 아니다 — 아직 결정하지 않은 것을 결정하지 않았다고 적는 곳이고, 닫을 때는 근거와 함께 닫는다.
 
+## Files to Touch를 확정하기 전에 — 설계-시점 영향 범위 읽기
+
+A-SPEC의 Files to Touch는 **스코프 선언**이고, 그래프는 그 선언이 무엇을 빠뜨리는지 이미 안다.
+`approval_status(id)`를 부르면 `graphPreview`가 온다:
+
+- `impact` — 선언한 FtT **밖**에서 그 안으로 호출해 들어오는 파일들(1-hop). 각 파일의 앵커 옆에
+  그 스펙의 **의도 문장**이 붙으므로, "무슨 의도가 걸려 있는지"를 스토어를 열지 않고 읽는다.
+- `density` — FtT 안의 **앵커-과밀** 파일(live 앵커가 분포 상위이며 절대치도 큰 것). 새 로직을
+  거기 더할지, 새 파일로 뺄지 판단하는 근거다.
+
+읽고 나서 셋 중 하나를 **선택**한다: ①지목된 밖-파일을 FtT에 넣는다 ②스코프를 좁혀 그 파급이
+생기지 않게 설계를 바꾼다 ③근거를 갖고 그대로 둔다. 어느 쪽이든 선언은 이제 **알고 한 선언**이다.
+
+> [!NOTE]
+> **게이트는 이것을 막지 않는다** — 규율이지 차단이 아니다(하드 게이트 승격은 관측 원장이
+> 오탐률을 답한 뒤의 별도 결정). 다만 읽지 않고 확정하면, 같은 소견이 봉인 뒤에 같은 말을
+> 반복한다 — 실사고 기록: 봉인 소견이 지목한 파일 클러스터에서 회귀 3건이 났고, 그 소견은
+> 설계가 끝난 뒤에야 읽혔다.
+
 ## A-SPEC / T-SPEC에 쓰는 것
 
 A-SPEC 필수 섹션: **Objective · Inputs / Outputs · Behavior · Test Points · Files to Touch · Done

package/playbooks/publish/PLAYBOOK.md

@@ -37,15 +37,24 @@ npm publish 는 **비가역·외부노출**이라 기본은 HITL(사람 승인)
 ---
 
 ### 2.5단계: 문서 정합성 게이트 (Docs Currency Gate) — 배포는 정직한 고지다
-타르볼에 문서가 **포함**됐는지가 아니라 **최신인지**를 diff로 검사한다(이 단계 없이 폐기된 동작이 README에
-현재형으로 남는 사고가 실제로 있었다):
+타르볼에 문서가 **포함**됐는지가 아니라 **최신인지**를 검사한다. 부정직은 두 방향이다: 거짓을
+남기는 것(drift)과 참을 숨기는 것(absence) — 둘 다 차단한다. (사고 이력 둘: 폐기된 동작이
+README 에 현재형으로 남은 사고, 그리고 **0.16.0 — 신기능 3건이 README 기능 목록에 아예 없는데
+"옛 문구 grep 0건"이 통과로 읽혀 그대로 배포된 사고.**)
 1. 직전 릴리스 태그 이후 승인된 스펙 열거: `git log <last-tag>..HEAD --name-only -- .ax/specs/03_a-spec/`.
-2. 각 A-SPEC 중 **사용자-대면**(CLI 명령/플래그, 동작 변경, env 스위치, 게이트 행동)인 것마다:
-   - `CHANGELOG.md` 의 이번 버전 항목이 그 변화를 기술하는가.
-   - `README.md` 의 기능 목록/CLI 치트시트가 새 명령·플래그를 담고, **폐기된 동작을 현재형으로 서술하지
-     않는가**(바뀐 동작의 옛 문구를 `grep` 으로 점검).
+2. 각 A-SPEC 중 **사용자-대면**(CLI 명령/플래그, MCP 응답 필드, 동작 변경, env 스위치, 게이트
+   행동, 신규 원장/아티팩트)인 것마다 — **세 검사를 모두**:
+   - **(2a) 추가-검사(absence)**: `CHANGELOG.md` 이번 버전 항목과 `README.md` 기능 목록에 그
+     변화의 항목이 **존재**하는가. 기능 이름으로 `grep` 해서 **0건이면 그것은 '통과'가 아니라
+     누락 신호다** — 쓴 적 없는 기능은 옛 문구도 없다.
+   - **(2b) drift-검사**: 바뀐 동작의 **옛 문구**를 `grep` 으로 점검 — 폐기된 동작을 현재형으로
+     서술하지 않는가.
+   - **(2c) 스테일 마커**: 기능 섹션 제목 등의 **버전-고정 라벨**("vX.Y.x Features" 류)은 매
+     릴리스 수동 갱신을 요구하는 drift 발생기다 — 발견 즉시 버전-무관 표현으로 제거한다(항목별
+     *(new in X.Y.Z)* 가 시점을 말한다).
 > [!CAUTION]
-> 사용자-대면 변화가 CHANGELOG/README 에 반영되지 않았으면 배포 중단 — 문서 drift 는 거짓 주장이다.
+> 사용자-대면 변화가 CHANGELOG/README 에 반영되지 않았으면 배포 중단 — 문서 drift 도, 문서
+> 누락도 거짓 주장이다.
 
 ---
 

package/playbooks/tdd-slice/PLAYBOOK.md

@@ -69,6 +69,11 @@ holmes는 기계적으로 판별한다: `red-error`로는 red→green 시퀀스
 
 ## 절차
 
+0. **FtT 확정 전** `approval_status(<A-SPEC id>)`의 `graphPreview`로 영향 범위를 읽는다 —
+   `impact`(선언 밖에서 들어오는 1-hop 호출자, 의도 문장 병기)와 `density`(앵커-과밀 파일). 지목된
+   것을 FtT에 넣을지, 스코프를 좁힐지, 근거를 갖고 둘지 **정하고 나서** 아래로 간다. 게이트가
+   **게이트는 이것을 막지 않는다** — 규율이지 차단이 아니다. 다만 읽지 않으면
+   같은 소견을 봉인 뒤에 다시 듣는다(실사고 기록).
 1. `promote-slice`로 대상 A-SPEC과 그 T-SPEC을 승인한다(`[ART-1]` 게이트를 연다).
 2. 커버 테스트를 **먼저** 쓴다. 심볼이 없어 컴파일이 깨지면 틀린-값 스텁을 넣는다.
 3. `test_run` — **red-assertion**을 본다. `red-error`면 그건 아직 RED가 아니다; 스텁으로 고쳐라.