@holmes-lab/holmes-kit 0.12.0 → 0.12.1

package/CHANGELOG.md

@@ -5,6 +5,32 @@ 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.12.1] - 2026-09-05
+
+Finishes the RTM dashboard's CFG/PDG story and fixes fresh-project spec numbering. Additive and
+backward-compatible.
+
+### Added
+
+- **CFG/PDG graph-view drilldown** (REQ-545): drilling into a symbol in the graph tab now renders that
+  function's **control-flow graph as a layered DAG** with **program-dependence overlays** — control
+  flow, data dependence, and control dependence drawn as three distinct edge styles, unreachable
+  blocks dimmed, with a legend. `/api/cfg` gains a server-computed `layout` (deterministic
+  `layoutCfg`: BFS layers from entry, cycle-safe, unreachable blocks trailing) so the client only
+  paints. This completes REQ-545 (2D matrix · auto-launch · CFG endpoint · CFG render).
+
+### Fixed
+
+- **Fresh-project spec numbering starts at REQ-100, not REQ-201** (REQ-546): `spec_slice_init` hard-coded
+  a `maxId = 200` floor, so a brand-new project's first slice leapt to 201. It now shares the same id
+  allocator as the reverse-draft path (`nextIdBase`, floor 100). **Backward-compatible**: the next id
+  is always `max(existing)+1`, so a repo already numbering from 201 keeps the identical sequence and
+  no existing id is renamed; the change only lowers the *first* number in an empty (or sub-100-max)
+  project. Numbering past 999 yields 4-digit ids with no collision.
+- **ADR references recognise four-digit ids** (REQ-546): the citation matcher was `\bADR-\d{3}\b`
+  (exactly three digits), so `ADR-1000+` was invisible. Extracted to a pure `adrRefsIn` and widened to
+  `\d{3,}` — three-digit matching and ordering are preserved, four-digit ADRs are now cited.
+
 ## [0.12.0] - 2026-09-05
 
 World-top-tier RTM dashboard, in flight. The `holmes-kit serve` dashboard stops being a table of

package/README.md

@@ -20,7 +20,8 @@
 - 🔴 **Inbuilt TDD — RED-first, enforced not asked** *(new in 0.9.0)*: the test-first discipline is a holmes-installed `holmes-tdd-slice` skill **and** a new constitution article **ART-8**. A changed A-SPEC must show a recorded `red-assertion → green` sequence in the ledger; a `red-error` (a test that could not run) is not a valid RED, so "the covering test failed *correctly*" is judged mechanically, not on trust. `test_run` classifies each covered file (`red-assertion`/`red-error`/`green`) and records per-A-SPEC outcomes the Stop hook reads. Ships at `redFirstEvidence: track` (observe-first, non-blocking; `strict`/`off` per repo), evidence-gated and jest-only for now. A T-SPEC may also declare `kills:` mutations and `test_run --mutate` reports which SURVIVED (a coverage gap). Where superpowers *asks* for RED-first and discriminating power, holmes-kit *proves* them.
 - 🧰 **Governance UX tools** *(new in 0.10.0)*: `spec_unseal` (the inverse of `spec_approve` — return a sealed spec to editable `draft` in one act, out-of-band approval required, refuses approved dependents), `approval_status` and `ledger_timeline` (read-only observability into a spec's seal state and the governance history), and a structured `conflict` on `spec_approve`'s optimistic-concurrency refusal (read vs. current version + retry). See CHANGELOG for details.
 - ⬆️ **Zero-config upgrades** *(new in 0.11.0)*: `holmes-kit upgrade` moves **every** wired workspace to the latest in one command — plan → confirm → install → re-pin all recorded workspaces (`--dry-run`/`--yes` supported). Preparation is automatic (each `init` records the workspace; a session whose pin is behind nudges you to upgrade); the re-pin **write** stays your explicit choice, never a silent auto-install. Opt out of the nudge with `HOLMES_NO_AUTO_REPIN`.
-- 📊 **World-top-tier RTM dashboard** *(new in 0.12.0, in flight)*: `holmes-kit serve` — ask to *see* the RTM heatmap and the `rtm_dashboard` MCP tool launches the server idempotently and hands back the URL plus an honesty **census** (requirement/pipeline counts, coverage %, what's excluded). The heatmap is now a real **2D coverage matrix** (requirements × pipeline stages, rows seriated by completeness, sequential-ramp cells with the percent printed in each), and `/api/cfg?file=&symbol=` serves a function's **CFG + PDG** (control-flow blocks + data/control dependence) from the same engine the taint lane uses — a non-CFG language is named, never faked. Tokenised palette + light/dark; graph-view rendering of CFG/PDG lands next.
+- 📊 **World-top-tier RTM dashboard** *(new in 0.12.0–0.12.1)*: `holmes-kit serve` — ask to *see* the RTM heatmap and the `rtm_dashboard` MCP tool launches the server idempotently and hands back the URL plus an honesty **census** (requirement/pipeline counts, coverage %, what's excluded). The heatmap is a real **2D coverage matrix** (requirements × pipeline stages, rows seriated by completeness, sequential-ramp cells with the percent printed in each). Drilling into a symbol renders that function's **CFG as a layered DAG** with **PDG (data/control-dependence) colour overlays**, served by `/api/cfg?file=&symbol=` from the same engine the taint lane uses — a non-CFG language is named, never faked. Tokenised palette (sequential ramp, status colours, UI/mono pairing) with light/dark.
+- 🔢 **Sensible spec numbering** *(new in 0.12.1)*: a brand-new project's first slice is now **REQ-100**, not REQ-201 — `spec_slice_init` shares the same id allocator as the reverse-draft path (`nextIdBase`, floor 100). Existing projects are untouched: the next id is always `max(existing)+1`, so a repo already numbering from 201 keeps the exact same sequence. Numbering past 999 yields 4-digit ids cleanly, and ADR references now recognise 4-digit ADRs (`ADR-1000+`).
 - 🤖 **Autonomous Approval** *(new in 0.8.0)*: with the out-of-band `HOLMES_AUTONOMOUS_APPROVAL` switch on, an agent seals **low/mid-risk** specs itself (ledgered under an `autonomous:<client>` actor) — while `gate-behavior` changes, architecture/gate/taint files, and every upstream `REQ`/`H-SPEC`/`C-SPEC` still ask a human through the in-session TUI. The switch is env-only; a session cannot set it (blocked like `HOLMES_ROLE`). Off = byte-identical to before. *(new in 0.10.0)* Set **`HOLMES_ELICIT=off`** to skip the in-session prompt entirely and route every decision to the out-of-band `holmes-kit approve` queue instead — one decision surface that behaves identically across Claude Code / Antigravity / Codex.
 - 🪧 **Session Banner + Update Notice** *(new in 0.8.0)*: every session start emits an English intro (version + governance rule + npm URL) to both the human transcript and the agent context (SessionStart hook + MCP `instructions`); when a newer published version is cached, an install-mode-aware update command is appended. Registry check is detached, fail-silent, and opts out via `HOLMES_NO_UPDATE_CHECK`/`CI`.
 - 🧱 **Deterministic Gate, Hardened** *(new in 0.8.0)*: shell writes are judged at the segment's **effective working directory** (`cd sub && cat > ../src/x.ts` is sealed, legitimate out-of-tree scratch writes are freed); the governing anchor is the **whole set**, not the first match. Every gate change ships with two consecutive clean adversarial rounds.

package/dist/.build-id

@@ -1 +1 @@
-85d7b53-mtnr6dpp
+3b23a9b-mtnx2lfo

package/dist/holmes/mcp/handlers.js

@@ -241,6 +241,7 @@ const ignore_1 = require("../project/ignore");
 // @implements A-SPEC-126
 const scan_1 = require("../reverse/scan");
 const draft_1 = require("../reverse/draft");
+const adr_refs_1 = require("../spec/adr-refs");
 const spec_id_guard_1 = require("./spec-id-guard");
 const anchor_1 = require("../reverse/anchor");
 // @implements A-SPEC-128
@@ -693,10 +694,10 @@ function collectDecisions(root, scanned, specs) {
         return { decisions: [], citations: [] };
     }
     const ids = new Set(decisions.map((d) => d.id));
+    // @implements A-SPEC-546.1 — recognise ADR-\d{3,} (4-digit ADRs no longer invisible), via a pure fn.
     const cite = (text, from, out) => {
-        for (const m of text.matchAll(/\bADR-\d{3}\b/g))
-            if (ids.has(m[0]))
-                out.push({ from, adr: m[0] });
+        for (const adr of (0, adr_refs_1.adrRefsIn)(text, ids))
+            out.push({ from, adr });
     };
     const citations = [];
     for (const f of scanned) {
@@ -3248,13 +3249,10 @@ function makeRawHandlers(store, opts) {
             const root = a.root ? (0, root_2.resolveProjectRoot)(a.root).root : process.cwd();
             const specsDir = path.join(root, '.ax', 'specs');
             const existing = await store.list();
-            let maxId = 200;
-            for (const s of existing) {
-                const num = parseInt(s.id.split('.')[0].replace(/\D/g, ''), 10);
-                if (!isNaN(num) && num > maxId)
-                    maxId = num;
-            }
-            const nextId = maxId + 1;
+            // @implements A-SPEC-546.1 — align with the sibling reverse-draft path (nextIdBase, floor 100)
+            // instead of a hard-coded 200 floor, so a fresh project starts at REQ-100, not REQ-201. Existing
+            // projects are unchanged: nextIdBase returns max(existing)+1, which dominates the floor.
+            const nextId = (0, draft_1.nextIdBase)(existing.map((s) => s.id));
             const reqId = `REQ-${nextId}`;
             const hspecId = `H-SPEC-${nextId}`;
             const aspecId = `A-SPEC-${nextId}`;

package/dist/holmes/server/cfg-view.d.ts

@@ -43,3 +43,27 @@ export declare function buildCfgView(cfg: Cfg | {
 }, ast: PersistedAst, source: string): CfgView | {
     unsupported: string;
 };
+export declare const CFG_COL_W = 220;
+export declare const CFG_ROW_H = 120;
+export interface CfgLayoutNode {
+    id: number;
+    layer: number;
+    col: number;
+    x: number;
+    y: number;
+    line: number;
+    label: string;
+    unreachable: boolean;
+}
+export interface CfgLayout {
+    nodes: CfgLayoutNode[];
+    width: number;
+    height: number;
+}
+/**
+ * @implements A-SPEC-545.5
+ * Pure & deterministic layered layout of a CFG: layer = BFS shortest depth from entry (cycle-safe,
+ * blocks visited in id order); unreachable blocks trail after the reachable ones. col = order within
+ * a layer. Same input ⇒ same layout.
+ */
+export declare function layoutCfg(view: CfgView): CfgLayout;

package/dist/holmes/server/cfg-view.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CFG_ROW_H = exports.CFG_COL_W = void 0;
 exports.lineAtByte = lineAtByte;
 exports.buildCfgView = buildCfgView;
+exports.layoutCfg = layoutCfg;
 /**
  * @implements A-SPEC-545.4
  * Pure: 1-based line number of a byte offset (count of newlines in [0, offset) + 1). Clamped.
@@ -55,3 +57,51 @@ function buildCfgView(cfg, pdg, ast, source) {
     }
     return { entry: cfg.entry, exit: cfg.exit, blocks, edges, ctrlDeps, dataDeps };
 }
+exports.CFG_COL_W = 220;
+exports.CFG_ROW_H = 120;
+/**
+ * @implements A-SPEC-545.5
+ * Pure & deterministic layered layout of a CFG: layer = BFS shortest depth from entry (cycle-safe,
+ * blocks visited in id order); unreachable blocks trail after the reachable ones. col = order within
+ * a layer. Same input ⇒ same layout.
+ */
+function layoutCfg(view) {
+    if (view.blocks.length === 0)
+        return { nodes: [], width: 0, height: 0 };
+    const succ = new Map();
+    for (const e of view.edges)
+        succ.set(e.from, [...(succ.get(e.from) ?? []), e.to]);
+    const layer = new Map();
+    const start = view.blocks.some((b) => b.id === view.entry) ? view.entry : Math.min(...view.blocks.map((b) => b.id));
+    let queue = [start];
+    layer.set(start, 0);
+    while (queue.length) {
+        const next = [];
+        for (const id of queue) {
+            const depth = layer.get(id);
+            for (const to of (succ.get(id) ?? []).slice().sort((a, b) => a - b)) {
+                if (!layer.has(to)) {
+                    layer.set(to, depth + 1);
+                    next.push(to);
+                } // BFS: cycle-safe (visit once)
+            }
+        }
+        queue = next;
+    }
+    const reachMax = layer.size ? Math.max(...layer.values()) : 0;
+    // Unreachable blocks trail after every reachable block, in id order.
+    const unreached = view.blocks.filter((b) => !layer.has(b.id)).sort((a, b) => a.id - b.id);
+    unreached.forEach((b, i) => layer.set(b.id, reachMax + 1 + i));
+    // col = order within a layer, by ascending block id (deterministic).
+    const perLayer = new Map();
+    const byId = [...view.blocks].sort((a, b) => a.id - b.id);
+    const nodes = byId.map((b) => {
+        const ly = layer.get(b.id);
+        const col = perLayer.get(ly) ?? 0;
+        perLayer.set(ly, col + 1);
+        return { id: b.id, layer: ly, col, x: col * exports.CFG_COL_W, y: ly * exports.CFG_ROW_H, line: b.line, label: b.label, unreachable: b.unreachable };
+    });
+    const maxCol = nodes.reduce((m, n) => Math.max(m, n.col), 0);
+    const maxLayer = nodes.reduce((m, n) => Math.max(m, n.layer), 0);
+    return { nodes, width: (maxCol + 1) * exports.CFG_COL_W, height: (maxLayer + 1) * exports.CFG_ROW_H };
+}

package/dist/holmes/server/dashboard.js

@@ -271,8 +271,10 @@ async function startDashboardServer(options) {
                     res.end(JSON.stringify({ ok: true, file, symbol, lang, unsupported: view.unsupported }));
                     return;
                 }
+                // @implements A-SPEC-545.5 — server-computed layered layout so the client only paints (no
+                // duplicated layout logic to drift from the tested one).
                 res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: true, file, symbol, lang, cfg: view }));
+                res.end(JSON.stringify({ ok: true, file, symbol, lang, cfg: view, layout: (0, cfg_view_1.layoutCfg)(view) }));
             }
             catch (err) {
                 if (!res.headersSent) {
@@ -654,6 +656,20 @@ function renderDashboardHtml() {
     .tool-btn { background: #1e293b; color: #f8fafc; border: 1px solid #334155; width: 38px; height: 38px; border-radius: 6px; font-weight: bold; font-size: 14px; cursor: pointer; display: flex; align-items: center; justify-content: center; transition: all 0.15s ease; }
     .tool-btn:hover { background: #3b82f6; border-color: #3b82f6; color: #fff; transform: scale(1.05); }
     .ux-hint-banner { background: #1e293b; border-left: 4px solid #ec4899; color: #cbd5e1; padding: 10px 14px; border-radius: 6px; font-size: 12px; margin-bottom: 12px; display: flex; align-items: center; justify-content: space-between; }
+
+    /* @implements A-SPEC-545.5 — CFG/PDG drilldown: control-flow blocks + program-dependence overlays */
+    .cfg-block rect { fill: var(--surface-2); stroke: var(--border); stroke-width: 1.5; rx: 8; }
+    .cfg-block.entry rect { stroke: var(--ok); stroke-width: 2.5; }
+    .cfg-block.exitb rect { stroke: var(--accent); stroke-width: 2.5; }
+    .cfg-block.unreachable rect { opacity: 0.4; stroke-dasharray: 4 3; }
+    .cfg-block .cfg-line { font-family: var(--font-mono); font-size: 10px; fill: var(--ink-2); }
+    .cfg-block .cfg-label { font-family: var(--font-mono); font-size: 12px; fill: var(--ink-0); }
+    .cfg-edge-flow { stroke: var(--ink-1); stroke-width: 2; fill: none; marker-end: url(#cfg-arrow-flow); }
+    .cfg-edge-data { stroke: var(--accent); stroke-width: 2; fill: none; opacity: 0.85; marker-end: url(#cfg-arrow-data); }
+    .cfg-edge-ctrl { stroke: var(--warn); stroke-width: 2; fill: none; stroke-dasharray: 6 4; opacity: 0.85; marker-end: url(#cfg-arrow-ctrl); }
+    .cfg-legend { display: flex; gap: 18px; align-items: center; font-family: var(--font-ui); font-size: 12px; color: var(--ink-1); flex-wrap: wrap; }
+    .cfg-legend .swatch { display: inline-block; width: 22px; height: 0; border-top-width: 2px; border-top-style: solid; vertical-align: middle; margin-right: 6px; }
+    .cfg-banner { font-family: var(--font-ui); color: var(--ink-1); background: var(--surface-1); border: 1px solid var(--border); border-radius: 10px; padding: 16px 18px; }
   </style>
 </head>
 <body>
@@ -1168,12 +1184,84 @@ function renderDashboardHtml() {
 
     async function focusSpecInGraph(specId) {
       switchTab('graph');
+      // @implements A-SPEC-545.5 — a symbol id (file#name) drills into that function's CFG/PDG;
+      // every other id keeps the existing spec-graph traversal untouched.
+      if (typeof specId === 'string' && specId.indexOf('#') !== -1) {
+        const hash = specId.indexOf('#');
+        const file = specId.slice(0, hash);
+        const symbol = specId.slice(hash + 1);
+        try {
+          const res = await fetch('/api/cfg?file=' + encodeURIComponent(file) + '&symbol=' + encodeURIComponent(symbol));
+          renderCfgDrilldown(await res.json(), file, symbol);
+        } catch (err) {
+          document.getElementById('graphScopeNotice').textContent = 'Failed to load CFG: ' + (err && err.message || err);
+        }
+        return;
+      }
       if (!graphData) {
         await loadGraphCanvas();
       }
       selectAndTraverseNode(specId);
     }
 
+    // @implements A-SPEC-545.5 — paint the server-computed layered CFG + PDG overlays into the canvas.
+    function renderCfgDrilldown(resp, file, symbol) {
+      const svg = document.getElementById('graphSvg');
+      const notice = document.getElementById('graphScopeNotice');
+      if (!resp || resp.ok === false) {
+        svg.innerHTML = '';
+        notice.innerHTML = '<div class="cfg-banner">No CFG for <strong>' + escapeHtml(symbol) + '</strong> in ' + escapeHtml(file) + (resp && resp.reason ? ' — ' + escapeHtml(resp.reason) : '') + '</div>';
+        return;
+      }
+      if (resp.unsupported) {
+        svg.innerHTML = '';
+        notice.innerHTML = '<div class="cfg-banner">CFG is not built for <strong>' + escapeHtml(resp.unsupported) + '</strong> — this view is honest about the languages it cannot analyse.</div>';
+        return;
+      }
+      const cfg = resp.cfg, layout = resp.layout;
+      const pos = {};
+      layout.nodes.forEach(n => { pos[n.id] = n; });
+      const CW = 180, CH = 60;
+      const cx = (id) => pos[id] ? pos[id].x + CW / 2 : 0;
+      const top = (id) => pos[id] ? pos[id].y : 0;
+      const bot = (id) => pos[id] ? pos[id].y + CH : 0;
+      const line = (x1, y1, x2, y2, cls) => '<path class="' + cls + '" d="M' + x1 + ' ' + y1 + ' L' + x2 + ' ' + y2 + '"></path>';
+
+      let edges = '';
+      (cfg.edges || []).forEach(e => { edges += line(cx(e.from), bot(e.from), cx(e.to), top(e.to), 'cfg-edge-flow'); });
+      (cfg.dataDeps || []).forEach(d => { edges += line(cx(d.from) + 12, top(d.from), cx(d.to) + 12, bot(d.to), 'cfg-edge-data'); });
+      (cfg.ctrlDeps || []).forEach(c => { edges += line(cx(c.ctrl) - 12, top(c.ctrl), cx(c.dep) - 12, bot(c.dep), 'cfg-edge-ctrl'); });
+
+      let blocks = '';
+      layout.nodes.forEach(n => {
+        const cls = 'cfg-block' + (n.id === cfg.entry ? ' entry' : '') + (n.id === cfg.exit ? ' exitb' : '') + (n.unreachable ? ' unreachable' : '');
+        const lbl = n.label ? escapeHtml(n.label) : (n.id === cfg.entry ? 'ENTRY' : n.id === cfg.exit ? 'EXIT' : 'B' + n.id);
+        blocks += '<g class="' + cls + '" transform="translate(' + n.x + ',' + n.y + ')">'
+          + '<rect width="' + CW + '" height="' + CH + '" rx="8"></rect>'
+          + '<text class="cfg-line" x="10" y="18">' + (n.line ? ('L' + n.line) : ('#' + n.id)) + '</text>'
+          + '<text class="cfg-label" x="10" y="38">' + lbl.slice(0, 26) + '</text>'
+          + '</g>';
+      });
+
+      const defs = '<defs>'
+        + '<marker id="cfg-arrow-flow" markerWidth="8" markerHeight="8" refX="7" refY="3" orient="auto"><path d="M0 0 L7 3 L0 6 z" fill="var(--ink-1)"></path></marker>'
+        + '<marker id="cfg-arrow-data" markerWidth="8" markerHeight="8" refX="7" refY="3" orient="auto"><path d="M0 0 L7 3 L0 6 z" fill="var(--accent)"></path></marker>'
+        + '<marker id="cfg-arrow-ctrl" markerWidth="8" markerHeight="8" refX="7" refY="3" orient="auto"><path d="M0 0 L7 3 L0 6 z" fill="var(--warn)"></path></marker>'
+        + '</defs>';
+      const W = Math.max(layout.width, CW) + 40, H = Math.max(layout.height, CH) + 40;
+      svg.setAttribute('viewBox', '-20 -20 ' + W + ' ' + H);
+      svg.innerHTML = defs + edges + blocks;
+
+      notice.innerHTML = '<div style="display:flex; justify-content:space-between; align-items:center; gap:16px; flex-wrap:wrap;">'
+        + '<span style="font-family:var(--font-ui); color:var(--ink-0); font-weight:700;">CFG · ' + escapeHtml(symbol) + '() <span style="color:var(--ink-2); font-weight:400;">' + escapeHtml(file) + '</span></span>'
+        + '<span class="cfg-legend">'
+        + '<span><span class="swatch" style="border-top-color:var(--ink-1);"></span>control flow</span>'
+        + '<span><span class="swatch" style="border-top-color:var(--accent);"></span>data dep</span>'
+        + '<span><span class="swatch" style="border-top-color:var(--warn); border-top-style:dashed;"></span>control dep</span>'
+        + '<span style="color:var(--ink-2);">' + layout.nodes.length + ' blocks</span>'
+        + '</span></div>';
+    }
+
     document.getElementById('searchInput').addEventListener('input', (e) => {
       const q = e.target.value.toLowerCase();
       const filtered = allSpecs.filter(s => s.id.toLowerCase().includes(q) || (s.title && s.title.toLowerCase().includes(q)));

package/dist/holmes/spec/adr-refs.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @implements A-SPEC-546.1
+ * Pure: the ADR references cited in `text` that exist in `known`, in appearance order (duplicates
+ * preserved, matching the prior cite behaviour). Recognises `ADR-` followed by 3-OR-MORE digits at a
+ * word boundary, so four-digit ADRs (ADR-1000+) are no longer invisible.
+ */
+export declare function adrRefsIn(text: string, known: ReadonlySet<string>): string[];

package/dist/holmes/spec/adr-refs.js

@@ -0,0 +1,17 @@
+"use strict";
+// @implements A-SPEC-546.1
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adrRefsIn = adrRefsIn;
+/**
+ * @implements A-SPEC-546.1
+ * Pure: the ADR references cited in `text` that exist in `known`, in appearance order (duplicates
+ * preserved, matching the prior cite behaviour). Recognises `ADR-` followed by 3-OR-MORE digits at a
+ * word boundary, so four-digit ADRs (ADR-1000+) are no longer invisible.
+ */
+function adrRefsIn(text, known) {
+    const out = [];
+    for (const m of text.matchAll(/\bADR-\d{3,}\b/g))
+        if (known.has(m[0]))
+            out.push(m[0]);
+    return out;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "//": "@implements A-SPEC-209",
   "name": "@holmes-lab/holmes-kit",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "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",
@@ -35,6 +35,9 @@
     "spec-driven",
     "rtm",
     "cpg",
+    "cfg",
+    "pdg",
+    "dashboard",
     "traceability",
     "mcp",
     "guardrail"