@holmes-lab/holmes-kit 0.3.4 → 0.3.6

package/CHANGELOG.md

@@ -4,6 +4,53 @@ 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.3.6] - 2026-09-01
+
+Traceability hardening: comma-listed anchors stop silently losing ids, the claim gate stops
+false-flagging test fixtures, and boilerplate acceptance criteria can no longer be sealed.
+
+### Fixed
+
+- **Comma-listed anchors** (A-SPEC-503.1, field-measured +410 lost rtm edges): all set-semantics
+  anchor consumers — coverage (`extractAnchors`), graph (`implementsSpecs`/wrong-kind warning) and
+  the claim gate — now parse the full `@implements ID, ID, …` list through ONE shared parser. A
+  wrong-kind id in second position is finally visible to the warning; prose mentions after the
+  list stay non-anchors; single-id behavior is value-identical.
+- **Claim-gate preprocessing asymmetry** (A-SPEC-504.1): the gate judged raw text while the
+  scanner stripped string literals, so anchor-shaped FIXTURE strings were refused as unapproved
+  claims (measured twice) — breeding a string-concatenation evasion habit. Both surfaces now share
+  `stripStringLiterals`; a string-anchor is a claim to nobody, exactly as it is an anchor to
+  nobody (no protection lost — pinned as a test).
+
+### Added
+
+- **Acceptance-substance sealing gate** (A-SPEC-505.1, dogfooded: 18 boilerplate-criteria REQs
+  sealed in one day): `spec_approve` now refuses a REQ whose Success Criteria are absent or
+  entirely boilerplate, with cause and remedy in the refusal. Act-time placement — the 154/428
+  legacy approved REQs measured in this repo are untouched. The `spec_slice_init` REQ template no
+  longer generates that very boilerplate (empty Success Criteria scaffold: fill before sealing).
+
+<!-- @implements A-SPEC-209 -->
+## [0.3.5] - 2026-09-01
+
+Two P0 dogfooding fixes: the self-healer no longer breaks what it heals, and Python evidence
+finally flows on venv projects.
+
+### Fixed
+
+- **spec_remediate language-blind `//` injection** (A-SPEC-501.1, dogfooded twice): the anchor is
+  now injected in the file's own comment syntax (`#` for py/yml/sh/toml + Makefile/Dockerfile,
+  `//` for the C family — byte-identical to before, `/* */` for CSS), and a file whose syntax the
+  tool does not know is **refused with guidance** instead of broken. Every injected form is
+  round-trip verified against the real anchor scanner, so injector and scanner can no longer
+  drift apart.
+- **test_run on Python venv projects** (A-SPEC-502.1): the interpreter resolves from evidence —
+  `HOLMES_PYTHON` first, then a `.venv`/`venv` carrying `pyvenv.cfg`, then the old `python3`
+  fallback (byte-identical when no venv exists). A `conftest.py` in the scoped file list widens
+  to its directory (the fixture's actual blast radius) instead of collection-ERRORing the whole
+  run — measured: the same tree passed 1995 cases manually while every scoped run failed.
+
 <!-- @implements A-SPEC-209 -->
 ## [0.3.4] - 2026-09-01
 

package/dist/.build-id

@@ -1 +1 @@
-68b5982-mthe8y11
+c3e5866-mthi2ccn

package/dist/holmes/cpg/cpg-scanner.js

@@ -106,12 +106,8 @@ function isVendorDir(dir) {
         return false;
     }
 }
-const IMPL = /@implements\s+(A-SPEC-\d{3,}(?:\.\d+)?)/g;
-// Well-formed governed-but-non-A-SPEC ids used (wrongly) as an @implements
-// anchor. Deliberately requires the full "KIND-NNN" shape (kind + '-' +
-// 3+ digits) so prose/comments like `@implements A-SPEC refs` (no id number)
-// or a bare word never match — only a genuine wrong-kind spec-id does.
-const WRONG_KIND_IMPL = /@implements\s+((?:REQ|H-SPEC|C-SPEC|T-SPEC)-\d{3,}(?:\.\d+)?)/g;
+// Anchor parsing (incl. wrong-kind detection) moved to the shared comma-list parser in
+// rtm/anchor-ids (A-SPEC-503.1) — the local single-capture regexes dropped every id after a comma.
 /** Single source of truth for which file extensions CpgScanner ingests (REQ-124 gate 2). */
 exports.SCANNABLE_EXTENSIONS = ['.ts', '.mts', '.cts', '.tsx', '.jsx', '.js', '.mjs', '.cjs', '.py', '.cs', '.java', '.go', '.rs', '.cpp', '.cc', '.cxx', '.hpp', '.hh', '.h'];
 const SCANNABLE_RE = /\.(ts|mts|cts|tsx|jsx|js|mjs|cjs|py|cs|java|go|rs|cpp|cc|cxx|hpp|hh|h)$/;
@@ -122,6 +118,7 @@ var test_files_1 = require("./test-files");
 Object.defineProperty(exports, "TEST_FILE_PATTERNS", { enumerable: true, get: function () { return test_files_1.TEST_FILE_PATTERNS; } });
 Object.defineProperty(exports, "isTestFile", { enumerable: true, get: function () { return test_files_1.isTestFile; } });
 const test_files_2 = require("./test-files");
+const anchor_ids_1 = require("../rtm/anchor-ids");
 // .ts/.mts/.cts can contain TS type-assertion syntax (`<T>x`, arrow-generics)
 // that the 'tsx' grammar misreads as JSX, so they must stay on 'typescript'.
 // Everything else in SCANNABLE_EXTENSIONS (.tsx/.jsx/.js/.mjs/.cjs) never uses
@@ -212,8 +209,11 @@ class CpgScanner {
                         // symbol walk, and disambiguating a bare `.h` between C and C++
                         // is out of scope for this slice.
                         const lang = /\.py$/.test(e.name) ? 'python' : (/\.cs$/.test(e.name) ? 'csharp' : (/\.java$/.test(e.name) ? 'java' : (/\.go$/.test(e.name) ? 'go' : (/\.rs$/.test(e.name) ? 'rust' : (/\.(cpp|cc|cxx|hpp|hh|h)$/.test(e.name) ? 'cpp' : (TSX_GRAMMAR_RE.test(e.name) ? 'tsx' : 'typescript'))))));
-                        const implementsSpecs = [...code.matchAll(IMPL)].map(m => m[1]);
-                        const unanchoredImplements = [...code.matchAll(WRONG_KIND_IMPL)].map(m => m[1]);
+                        // @implements A-SPEC-503.1 — comma-listed anchors: the old single-capture regexes
+                        // dropped every id after the first (C12), and a wrong-kind id in second position was
+                        // invisible to the warning. Both consumers now ride the shared list parser.
+                        const implementsSpecs = (0, anchor_ids_1.anchorSpecIds)(code);
+                        const unanchoredImplements = (0, anchor_ids_1.wrongKindAnchorIds)(code);
                         const sourcePath = (0, source_path_1.toSourcePath)(repoRoot, path.resolve(p));
                         // @implements A-SPEC-140.1
                         // The third parse happens only when asked for. `undefined` from the parser (a language

package/dist/holmes/guardrail/anchors.js

@@ -15,9 +15,19 @@ exports.newlyClaimed = newlyClaimed;
  * keeps LLM judgement out of governance. What a change CLAIMS, though, is right there in the text —
  * that is the decidable subset, and this is it.
  */
-const ANCHOR_RE = /@implements\s+([A-Za-z]+-SPEC-[\w.]+)/g;
+// @implements A-SPEC-503.1 — comma-list support with the gate's OWN lenient token grammar kept
+// (any `*-SPEC-*` shape claims; the shared parser's strict kinds must not narrow a gate). The old
+// single capture let the second id of a listed claim slip past `newlyClaimed` unjudged (C12).
+const anchor_ids_1 = require("../rtm/anchor-ids");
+const ANCHOR_TOKEN = String.raw `[A-Za-z]+-SPEC-[\w.]+`;
+const ANCHOR_RE = new RegExp(String.raw `@implements\s+(${ANCHOR_TOKEN}(?:[ \t]*,[ \t]*${ANCHOR_TOKEN})*)`, 'g');
 function claimedAnchors(content) {
-    return [...new Set([...content.matchAll(ANCHOR_RE)].map((m) => m[1]))];
+    // @implements A-SPEC-504.1 — judge on the SAME literal-stripped text the coverage scanner uses:
+    // a string-anchor is an anchor to nobody, so treating it as a claim produced only false-positive
+    // refusals (measured twice on legitimate fixtures) and bred the '@'+'implements' evasion habit.
+    // Losing it costs no protection — there is no "claimed but unjudged" state to protect against.
+    const ids = [...(0, anchor_ids_1.stripStringLiterals)(content).matchAll(ANCHOR_RE)].flatMap((m) => m[1].split(/[ \t]*,[ \t]*/));
+    return [...new Set(ids)];
 }
 /**
  * The anchors this write ADDS, relative to what the file already had.

package/dist/holmes/mcp/handlers.js

@@ -130,6 +130,7 @@ const package_1 = require("../review/package");
 const risk_classifier_1 = require("../guardrail/risk-classifier");
 const risk_gate_1 = require("../guardrail/risk-gate");
 const elicit_approval_1 = require("./elicit-approval");
+const anchor_comment_1 = require("../rtm/anchor-comment");
 const approval_queue_1 = require("../governance/approval-queue");
 const approval_grants_1 = require("../governance/approval-grants");
 const spec_digest_1 = require("../spec/spec-digest");
@@ -1294,6 +1295,16 @@ function makeRawHandlers(store, opts) {
             if (stubs.length > 0) {
                 return { ok: false, reason: (0, approval_blockers_1.placeholderMessage)(stubs) };
             }
+            // @implements A-SPEC-505.1 — acceptance substance, judged at the ACT on the same candidate
+            // the seal would freeze, like the placeholder gate above (154/428 approved REQs here are
+            // non-stated legacy; a validateSpec predicate would brick them all). Judged HERE and not
+            // before the approval channels: an earlier extra read shifts the optimistic-concurrency
+            // window and lets a mid-approval edit get sealed (store-integrity contract: edits win,
+            // approvals lose). The post-grant refusal it costs is the standing property of every
+            // act-time blocker in this block (breaking_change, placeholder) — one ordering, one truth.
+            const unactionable = (0, approval_blockers_1.unactionableCriteriaBlocker)(candidate);
+            if (unactionable)
+                return { ok: false, reason: unactionable };
             // Parents-first: a sealed child snapshotting an unsealed parent would pin nothing. This loop
             // exists to COLLECT the digests; the refusal inside it is now a backstop, because
             // `parentBlockers` above already returns for the same condition with the same sentence. Kept
@@ -2840,7 +2851,6 @@ ${a.objective}
 - Standard project governance rules.
 
 ## Success Criteria
-- Implementation completed and verified by tests.
 
 ## Out of Scope
 - Unrelated feature changes.
@@ -3037,9 +3047,17 @@ depends_on:
             if (a.targetFile && a.aspecId) {
                 const fullPath = path.isAbsolute(a.targetFile) ? a.targetFile : path.join(root, a.targetFile);
                 if (fs.existsSync(fullPath)) {
+                    // @implements A-SPEC-501.1 — BUG-4 (dogfooded twice): the old unconditional
+                    // `// @implements` broke Python/YAML targets outright AND produced anchors the scanner
+                    // could not read. The syntax comes from the one map the scanner is aligned with, an
+                    // unknown syntax is an honest refusal, and the containment check is form-agnostic so a
+                    // `#` anchor is not double-injected.
+                    const anchorTag = (0, anchor_comment_1.anchorLineFor)(fullPath, a.aspecId);
                     const content = fs.readFileSync(fullPath, 'utf8');
-                    const anchorTag = `// @implements ${a.aspecId}`;
-                    if (!content.includes(anchorTag)) {
+                    if (anchorTag === null) {
+                        actionsTaken.push(`앵커 주입 거부: ${path.basename(fullPath)} — 이 확장자의 주석 문법을 모릅니다. 파일 관례에 맞는 주석으로 1행에 '@implements ${a.aspecId}'를 직접 추가하십시오`);
+                    }
+                    else if (!content.includes(`@implements ${a.aspecId}`)) {
                         fs.writeFileSync(fullPath, `${anchorTag}\n${content}`);
                         actionsTaken.push(`Injected ${anchorTag} on line 1 of ${a.targetFile}`);
                     }

package/dist/holmes/review/python-env.d.ts

@@ -0,0 +1,7 @@
+export interface PythonEnvDeps {
+    env: NodeJS.ProcessEnv;
+    exists: (p: string) => boolean;
+    platform: NodeJS.Platform;
+}
+export declare function pythonFor(cwd: string, deps: PythonEnvDeps): string;
+export declare function pytestTargets(files: string[]): string[];

package/dist/holmes/review/python-env.js

@@ -0,0 +1,76 @@
+"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.pythonFor = pythonFor;
+exports.pytestTargets = pytestTargets;
+// @implements A-SPEC-502.1
+/**
+ * The two pure transforms that stand between planTestRun and runPytest's execFileSync — BUG-2,
+ * dogfooded on a real .venv project, where both halves of the evidence system idled:
+ *
+ * WHICH python: PATH's python3 was the system interpreter (no pytest), so last-green was never
+ * recorded and ART-4 debt piled 12 entries deep. The interpreter now resolves from EVIDENCE —
+ * pyvenv.cfg, the same proof containsPyvenvCfg uses in the scanner — never from a directory name,
+ * with HOLMES_PYTHON as the explicit operator escape hatch above all detection.
+ *
+ * WHAT arguments: conftest.py is a legitimate TEST FILE for anchor/coverage purposes, but not a
+ * runnable target — passed verbatim it collection-ERRORs every scoped run (measured: the same
+ * tree's manual `pytest tests/` was green, 1995 cases). A conftest argument WIDENS to its
+ * directory — the fixture's actual blast radius — because dropping it would verify less and
+ * keeping it verbatim verifies nothing.
+ */
+const path = __importStar(require("node:path"));
+function pythonFor(cwd, deps) {
+    const explicit = deps.env.HOLMES_PYTHON;
+    if (typeof explicit === 'string' && explicit.trim() !== '')
+        return explicit;
+    for (const dir of ['.venv', 'venv']) {
+        if (deps.exists(path.join(cwd, dir, 'pyvenv.cfg'))) {
+            return deps.platform === 'win32'
+                ? path.join(cwd, dir, 'Scripts', 'python.exe')
+                : path.join(cwd, dir, 'bin', 'python');
+        }
+    }
+    return 'python3';
+}
+function pytestTargets(files) {
+    const out = [];
+    for (const f of files) {
+        const target = path.basename(f) === 'conftest.py' ? path.dirname(f) : f;
+        if (!out.includes(target))
+            out.push(target);
+    }
+    return out;
+}

package/dist/holmes/review/test-runner.d.ts

@@ -75,6 +75,12 @@ export declare function parseJUnitXmlCounts(xml: string, ext?: string): Record<s
  * there), and a repo with no local jest could never yield meaningful suite evidence anyway.
  */
 export declare function jestEntry(cwd: string): string | null;
+/** Run the pytest half of a plan, taking execution evidence from pytest's built-in JUnit XML. */
+export declare function runPytest(files: string[], mode: TestRunPlan['mode'], cwd: string): {
+    passed: boolean;
+    tail: string;
+    executed: Record<string, number>;
+};
 /**
  * @implements A-SPEC-137.2
  * Executed-test count from `cargo test` text output. cargo prints one `test <name> ... ok|FAILED|

package/dist/holmes/review/test-runner.js

@@ -39,6 +39,7 @@ exports.parseGoTestJson = parseGoTestJson;
 exports.parseExecutedCounts = parseExecutedCounts;
 exports.parseJUnitXmlCounts = parseJUnitXmlCounts;
 exports.jestEntry = jestEntry;
+exports.runPytest = runPytest;
 exports.parseCargoTest = parseCargoTest;
 exports.runCargo = runCargo;
 exports.runGradle = runGradle;
@@ -50,6 +51,7 @@ const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
+const python_env_1 = require("./python-env");
 function planTestRun(scope) {
     if (scope.tier === 'full') {
         return { mode: 'full', testFiles: [], reason: 'full regression — run the entire suite' };
@@ -241,6 +243,7 @@ function runJest(files, mode, cwd) {
     }
 }
 /** Run the pytest half of a plan, taking execution evidence from pytest's built-in JUnit XML. */
+// @implements A-SPEC-502.1 — exported for the wiring test (a fake venv python capturing argv).
 function runPytest(files, mode, cwd) {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'holmes-pytest-'));
     const report = path.join(dir, 'report.xml');
@@ -253,8 +256,12 @@ function runPytest(files, mode, cwd) {
     // attribute per testcase. pytest's default since v6 is xunit2, which carries only `classname` —
     // measured: a green 4-passed/1-skipped run yielded ZERO per-file evidence under the default, so
     // the tier gate would have had nothing to verify against.
+    // @implements A-SPEC-502.1 — BUG-2, both halves: the interpreter resolves from pyvenv.cfg
+    // evidence (HOLMES_PYTHON above all, python3 fallback byte-identical to the old path), and a
+    // conftest.py argument widens to its directory instead of collection-ERRORing the whole run.
     const args = ['-m', 'pytest', '-q', '-o', 'junit_family=xunit1', `--junit-xml=${report}`,
-        ...(mode === 'scoped' ? ['--', ...files] : [])];
+        ...(mode === 'scoped' ? ['--', ...(0, python_env_1.pytestTargets)(files)] : [])];
+    const python = (0, python_env_1.pythonFor)(cwd, { env: process.env, exists: fs.existsSync, platform: process.platform });
     const read = () => {
         try {
             return parseJUnitXmlCounts(fs.readFileSync(report, 'utf8'));
@@ -264,7 +271,7 @@ function runPytest(files, mode, cwd) {
         }
     };
     try {
-        const out = (0, node_child_process_1.execFileSync)('python3', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+        const out = (0, node_child_process_1.execFileSync)(python, args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
         return { passed: true, tail: tailOf(out), executed: read() };
     }
     catch (e) {

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

@@ -0,0 +1,9 @@
+/**
+ * The one comment-syntax truth the anchor INJECTOR shares with the anchor SCANNER. BUG-4
+ * (dogfooded twice): spec_remediate wrote `// @implements` into every file type — a YAML workflow
+ * became a parse error, a Python golden file a SyntaxError, and the anchor was not even legible to
+ * extractAnchors. Every form emitted here matches the scanner's comment prefixes (`//`, `/*`, `#`);
+ * a syntax this map does not know returns null and the caller must REFUSE to write — an honest
+ * refusal beats a broken file, and beats an anchor the gate cannot read.
+ */
+export declare function anchorLineFor(filePath: string, aspecId: string): string | null;

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

@@ -0,0 +1,34 @@
+"use strict";
+// @implements A-SPEC-501.1
+/**
+ * The one comment-syntax truth the anchor INJECTOR shares with the anchor SCANNER. BUG-4
+ * (dogfooded twice): spec_remediate wrote `// @implements` into every file type — a YAML workflow
+ * became a parse error, a Python golden file a SyntaxError, and the anchor was not even legible to
+ * extractAnchors. Every form emitted here matches the scanner's comment prefixes (`//`, `/*`, `#`);
+ * a syntax this map does not know returns null and the caller must REFUSE to write — an honest
+ * refusal beats a broken file, and beats an anchor the gate cannot read.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anchorLineFor = anchorLineFor;
+const SLASH = new Set(['ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs', 'java', 'c', 'h', 'cc', 'cpp',
+    'hpp', 'cs', 'go', 'rs', 'swift', 'kt', 'kts', 'scala', 'dart']);
+const HASH = new Set(['py', 'rb', 'sh', 'bash', 'zsh', 'fish', 'yml', 'yaml', 'toml', 'pl', 'pm',
+    'r', 'jl', 'cmake', 'mk']);
+const CSS = new Set(['css', 'scss', 'less']);
+const HASH_BASENAMES = new Set(['Makefile', 'Dockerfile', 'Rakefile', 'Gemfile']);
+function anchorLineFor(filePath, aspecId) {
+    const basename = filePath.slice(filePath.lastIndexOf('/') + 1);
+    if (HASH_BASENAMES.has(basename))
+        return `# @implements ${aspecId}`;
+    const dot = basename.lastIndexOf('.');
+    if (dot <= 0)
+        return null;
+    const ext = basename.slice(dot + 1).toLowerCase();
+    if (SLASH.has(ext))
+        return `// @implements ${aspecId}`;
+    if (HASH.has(ext))
+        return `# @implements ${aspecId}`;
+    if (CSS.has(ext))
+        return `/* @implements ${aspecId} */`;
+    return null;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * The ONE comma-list grammar for anchor lines — C12, dogfooded: four parsers each captured only
+ * the first id of a comma-listed anchor (`… <marker> A-SPEC-…110, …219`), so every id after the
+ * comma silently vanished from coverage, graph edges (+410 recovered in the field by
+ * hand-normalizing 14 files) and claim gating. The list ends at the comma chain: a prose mention
+ * after the ids (`… (see another id)`) is NOT a claim, which is what keeps this widening from
+ * turning commentary into governance.
+ */
+export declare function stripStringLiterals(text: string): string;
+/** Every anchor-marker occurrence's comma-list, as an array of ids per occurrence. */
+export declare function implementsIdLists(text: string): string[][];
+/** Flattened A-SPEC ids across all lists — the graph/coverage consumers' shape. */
+export declare function anchorSpecIds(text: string): string[];
+/** Flattened wrong-kind ids (a governed id anchored where only A-SPEC belongs) — anywhere in a list. */
+export declare function wrongKindAnchorIds(text: string): string[];

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

@@ -0,0 +1,39 @@
+"use strict";
+// @implements A-SPEC-503.1
+/**
+ * The ONE comma-list grammar for anchor lines — C12, dogfooded: four parsers each captured only
+ * the first id of a comma-listed anchor (`… <marker> A-SPEC-…110, …219`), so every id after the
+ * comma silently vanished from coverage, graph edges (+410 recovered in the field by
+ * hand-normalizing 14 files) and claim gating. The list ends at the comma chain: a prose mention
+ * after the ids (`… (see another id)`) is NOT a claim, which is what keeps this widening from
+ * turning commentary into governance.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripStringLiterals = stripStringLiterals;
+exports.implementsIdLists = implementsIdLists;
+exports.anchorSpecIds = anchorSpecIds;
+exports.wrongKindAnchorIds = wrongKindAnchorIds;
+// @implements A-SPEC-504.1
+// The ONE string-literal preprocessing every anchor-judging surface shares. Measured 2026-09-01:
+// the coverage scanner stripped literals while the claim gate judged raw text, so a legitimate
+// fixture string was refused twice as an "unapproved claim" — and that friction bred the
+// '@'+'implements' evasion habit. A string-anchor is an anchor to nobody and must be a claim to
+// nobody; one definition here keeps the two judgments from drifting apart again.
+const STRINGS_RE = /'(?:\\.|[^'\\\n])*'|"(?:\\.|[^"\\\n])*"|`(?:\\.|[^`\\])*`/g;
+function stripStringLiterals(text) {
+    return text.replace(STRINGS_RE, '""');
+}
+const ID = String.raw `(?:REQ|A-SPEC|H-SPEC|C-SPEC|T-SPEC)-\d{3,}(?:\.\d+)?`;
+const LIST_RE = new RegExp(String.raw `@implements[ \t]+(${ID}(?:[ \t]*,[ \t]*${ID})*)`, 'g');
+/** Every anchor-marker occurrence's comma-list, as an array of ids per occurrence. */
+function implementsIdLists(text) {
+    return [...text.matchAll(LIST_RE)].map((m) => m[1].split(/[ \t]*,[ \t]*/));
+}
+/** Flattened A-SPEC ids across all lists — the graph/coverage consumers' shape. */
+function anchorSpecIds(text) {
+    return [...new Set(implementsIdLists(text).flat().filter((id) => id.startsWith('A-SPEC-')))];
+}
+/** Flattened wrong-kind ids (a governed id anchored where only A-SPEC belongs) — anywhere in a list. */
+function wrongKindAnchorIds(text) {
+    return [...new Set(implementsIdLists(text).flat().filter((id) => !id.startsWith('A-SPEC-')))];
+}

package/dist/holmes/rtm/test-scope.js

@@ -41,6 +41,7 @@ exports.extractAnchors = extractAnchors;
 exports.scanTestAnchors = scanTestAnchors;
 exports.computeTestScope = computeTestScope;
 // @implements A-SPEC-121.2
+const anchor_ids_1 = require("./anchor-ids");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const spec_types_1 = require("../spec/spec-types");
@@ -256,12 +257,22 @@ function countTestCases(source, filePath) {
 // every id merely MENTIONED in it — a live run credited 50 cases to the nonexistent A-SPEC-999 from
 // a fixture string, and injecting one comment into any test file re-credited it to an arbitrary
 // spec). Both the fixture-string and the mid-code-line injection vectors die here.
-const IMPL_LINE_RE = /^[ \t]*(?:\/\/|\/\*|\*|#)[^\n]*?@implements\s+(A-SPEC-\d{3,}(?:\.\d+)?)/gm;
-const STRINGS_RE = /'(?:\\.|[^'\\\n])*'|"(?:\\.|[^"\\\n])*"|`(?:\\.|[^`\\])*`/g;
+// @implements A-SPEC-503.1 — the line must still BE a comment line, but the ids on it come from
+// the shared comma-list parser: the old single-capture regex silently dropped every id after the
+// first comma (C12 — +410 rtm edges recovered in the field only by hand-normalizing 14 files).
+const IMPL_LINE_RE = /^[ \t]*(?:\/\/|\/\*|\*|#)[^\n]*?@implements[ \t]/gm;
 /** A-SPEC ids anchored by a file, counting only standalone comment-line markers outside literals. */
 function extractAnchors(source) {
-    const noStrings = source.replace(STRINGS_RE, '""');
-    return [...new Set([...noStrings.matchAll(IMPL_LINE_RE)].map((m) => m[1]))];
+    // @implements A-SPEC-504.1 — the literal-stripping moved to the shared definition the claim
+    // gate now uses too; a private copy here is how the two judgments drifted apart in the first place.
+    const noStrings = (0, anchor_ids_1.stripStringLiterals)(source);
+    const ids = [];
+    for (const line of noStrings.split('\n')) {
+        IMPL_LINE_RE.lastIndex = 0;
+        if (IMPL_LINE_RE.test(line))
+            ids.push(...(0, anchor_ids_1.anchorSpecIds)(line));
+    }
+    return [...new Set(ids)];
 }
 /**
  * @implements A-SPEC-269

package/dist/holmes/spec/approval-blockers.d.ts

@@ -76,3 +76,13 @@ export declare const blockerClause: (label: string, blockers: string[]) => strin
  * Never throws: a refusal that says less is recoverable, a hook that dies is not.
  */
 export declare function blockerSummary(spec: Spec | undefined, resolve: (id: string) => Spec | null, specId?: string): string | null;
+/**
+ * The acceptance-substance gate, standing at the SEALING ACT like the placeholder gate above and
+ * for that gate's measured reason (A-SPEC-182): a static predicate in validateSpec would turn the
+ * already-approved corpus into violations — measured 2026-09-01, 154/428 approved REQs here are
+ * non-stated legacy — and brick the harness. Dogfooded origin: 18 REQs sealed in one day whose
+ * entire Success Criteria read "implementation completed and verified by tests", while the
+ * detector (acceptanceQuality) sat wired only into the post-hoc analyzer. The detector is
+ * CONSUMED, not copied — one judgment, two surfaces.
+ */
+export declare function unactionableCriteriaBlocker(spec: Spec): string | null;

package/dist/holmes/spec/approval-blockers.js

@@ -5,6 +5,9 @@ exports.placeholderSections = placeholderSections;
 exports.parentBlockers = parentBlockers;
 exports.approvalBlockers = approvalBlockers;
 exports.blockerSummary = blockerSummary;
+exports.unactionableCriteriaBlocker = unactionableCriteriaBlocker;
+// @implements A-SPEC-182
+const acceptance_quality_1 = require("./acceptance-quality");
 const validator_1 = require("./validator");
 const breaking_change_1 = require("./breaking-change");
 const spec_digest_1 = require("./spec-digest");
@@ -245,3 +248,23 @@ function blockerSummary(spec, resolve, specId) {
         return null;
     }
 }
+// @implements A-SPEC-505.1
+/**
+ * The acceptance-substance gate, standing at the SEALING ACT like the placeholder gate above and
+ * for that gate's measured reason (A-SPEC-182): a static predicate in validateSpec would turn the
+ * already-approved corpus into violations — measured 2026-09-01, 154/428 approved REQs here are
+ * non-stated legacy — and brick the harness. Dogfooded origin: 18 REQs sealed in one day whose
+ * entire Success Criteria read "implementation completed and verified by tests", while the
+ * detector (acceptanceQuality) sat wired only into the post-hoc analyzer. The detector is
+ * CONSUMED, not copied — one judgment, two surfaces.
+ */
+function unactionableCriteriaBlocker(spec) {
+    if (spec.type !== 'REQ')
+        return null;
+    const quality = (0, acceptance_quality_1.acceptanceQuality)(spec);
+    if (quality === 'stated')
+        return null;
+    return quality === 'absent'
+        ? `REQ ${spec.id}의 Success Criteria가 비어 있습니다 — 관측 가능한 기준을 채운 뒤 승인하십시오`
+        : `REQ ${spec.id}의 Success Criteria가 전량 보일러플레이트입니다('구현·테스트 완료'는 충족 정의가 아닙니다) — 각 항목이 검증 동사·측정 대상을 갖게 고친 뒤 승인하십시오`;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "//": "@implements A-SPEC-209",
   "name": "@holmes-lab/holmes-kit",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "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",