@holmes-lab/holmes-kit 0.23.1 → 0.23.3

package/CHANGELOG.md

@@ -5,6 +5,101 @@ 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.23.3] - 2026-09-18
+
+A suite that takes half as long, a build that admits when it is stale, and a CI matrix that stopped
+reporting its own noise as a verdict.
+
+### Fixed
+- **The Files-to-Touch declarations that were anchored, and the ones that were not** (A-SPEC-670,
+  A-SPEC-665, A-SPEC-672, A-SPEC-674). Five trace gaps that REQ-670's parser fix uncovered are
+  closed: `A-SPEC-495`, `A-SPEC-549.3` and `A-SPEC-549.4` declared scanned production files and
+  carried no anchor in any of them. Every one of the six places was checked before it was claimed —
+  an anchor is an assertion, not a metric — and all six were true. Unlinked approved specs 52 → 49,
+  `codeLinkedPct` 91.95 → 92.41, trace gaps 5 → 0.
+- **The CI matrix was reporting its own noise as a verdict** (A-SPEC-664, A-SPEC-674). Measured over
+  22 runs: **every one was red**, and the reds were dominated by two suites this repository knows as
+  load gauges (`dashboard.test` 20/22, `entity-store-boundaries` 12/22). The cause was contention —
+  the Linux VM takes 11 of the host's 12 cores and ran jest with default workers. A signal that is
+  always red cannot separate a regression from itself. With the worker cap below, both canaries went
+  green on Linux for the first time in 23 runs, and the matrix immediately produced its first real
+  finding.
+- **A dead lock holder could stop the matrix for ever, silently** (A-SPEC-674). The runner's lock was
+  released by `trap ... EXIT`, which SIGKILL and a process-group teardown skip; one such lock stood
+  for 95 minutes while nine commits went unjudged. The lock now names its holder and liveness is
+  judged by PID, never by elapsed time — calling a slow run dead would start a second run on the
+  same machine. A skipped run also leaves a `skipped` row now: REQ-664's rule is that no row means
+  "not run", so a silent skip erased the skip itself.
+
+### Added
+- **The Stop hook says when `dist/` no longer represents the source** (A-SPEC-673). Thirty suites
+  load `dist/` while they run and nothing asserted it was current; only the release gate compared the
+  build id to HEAD, and only at publish time. A stale build does not go red — it verifies old code
+  and returns green. The judgement is built on the build id and **not** on mtime, measured: this
+  tree's `.build-id` had a newer mtime than every source while naming a commit nine behind, and two
+  changed sources were missing from `dist` entirely. Five states, of which `fresh` and `absent` say
+  nothing at all, and the two unjudgeable ones say **the check could not run** rather than passing
+  quietly. Non-blocking, on the `tracked` channel, and silent in a workspace that does not build.
+
+### Changed
+- **The test suite runs in 353s instead of 505s** (A-SPEC-672). The wall clock equalled the longest
+  single file to the decimal, so more workers could not help. Splitting the two heaviest files alone
+  moved it 505s → 493s while the serial total rose 2,836s → 5,109s: four heavy suites running at once
+  contended hard enough to swallow the win. Measured 2x2, the split and a worker cap **interact** —
+  alone they are worth 12s and 44s, together 132s. `jest.maxWorkers` is now `"50%"`, a proportion
+  rather than a number, because a fixed count means something else on a machine with a different core
+  count. Cases are preserved exactly, per-spec execution counts included.
+
+## [0.23.2] - 2026-09-18
+
+Three rules that existed only in prose, and the one number a broken parser had published.
+
+### Fixed
+- **The Files-to-Touch parser reads every declared path** (A-SPEC-670). It took only the **first word
+  of a list item**, so measured over all 678 approved specs here, **88 specs declared 172 paths that
+  were never read** — 24 of them parsed to zero while naming files plainly. Five forms accounted for
+  every miss: several paths on one line (71), an indented continuation line (39), the second path on a
+  line whose first was read (32), a Korean first word (22), and a prose paragraph instead of a list (5).
+  A slashed path is now read wherever it sits; a bare `name.ext` keeps the old position rule, because
+  the root-file predicate accepts any extension and without it `module.exports` and a prose `b.ts`
+  become declared files. A declared path that does not exist but is the suffix of exactly one
+  repository file is reported as `abbreviated` rather than a defect (measured: unique in all 8 cases),
+  and two candidates stays an ambiguity where nothing is guessed. Cost over the whole corpus: **zero**
+  new `missing` findings, zero new `moved`, 26 abbreviations resolved.
+- **A number 0.23.0 published was the parser's, not the corpus's** (A-SPEC-665, corrected). The
+  declaration census read `scanned-source 0 / no-declaration 4` for this repository's 52 unlinked
+  specs, and the README said the remaining 8.1% of `codeLinkedPct` was therefore not a missing anchor.
+  With the parser fixed the same census reads **3 and 0**: `A-SPEC-495`, `A-SPEC-549.3` and
+  `A-SPEC-549.4` declare scanned production files that carry no anchor, and **five real trace gaps**
+  were behind them. The 665 chain was unsealed leaf-first and corrected, and its pin no longer names
+  spec ids — pinning those ids pinned the defect. Its own rule ("assert the sum and the property, not
+  the numbers") is what kept the fix from looking like a violation.
+- **The shipped instruction says how a spec body is written** (A-SPEC-671). `init` wrote into every
+  consumer's `AGENTS.md` that specs are authored with four MCP tools, and **none of the 44 tools takes
+  section text**. Authoring here means editing the scaffolded markdown, which the same rule read as
+  forbidden — and the collision is guaranteed, not occasional: of the four documents `spec_slice_init`
+  scaffolds, exactly one section is left blank (the REQ's `Success Criteria`) and that blank is
+  precisely what approval refuses. An agent in another workspace hit this, refused to break the rule,
+  and asked for a tool that does not exist; its judgement was correct. Rule 1 now separates the two
+  acts the tools perform (**scaffold** and **seal**), states that a body is written by editing the
+  generated markdown, and says the Success Criteria is empty on purpose. The empty-criteria refusal
+  now names the file and the heading. No new tool and no loosened gate: taking bodies as tool
+  arguments is a worse authoring surface, and auto-filling the stub would restore the pass nobody
+  earned that A-SPEC-505.1 exists to prevent.
+
+### Added
+- **The publish gate reads the docs** (A-SPEC-669). `playbooks/publish/PLAYBOOK.md` step 2.5 has
+  demanded a documentation pass since 0.16.0 with nothing enforcing it, and it failed four times —
+  0.16.0, and 0.21.0/0.22.0/0.23.0, which shipped with the README feature list stuck at 0.20.0.
+  `verify-release.js` now refuses a missing CHANGELOG entry for the version being published, and an
+  entry carrying `### Added` while `README.md` has not changed since the previous release. Validated
+  against eight releases before it was written: it refuses exactly 0.21.0, 0.22.0 and 0.23.0 and
+  passes the other five. Uncited sealed specs and version-pinned README headings are **reported only**
+  — measured poor gates, since 0.20.0 cited none of its 57 sealed specs and was an honest release. The
+  drift question (is the old wording still true?) is judgement and is deliberately not automated: a
+  machine imitating it would produce a pass nobody earned, which is the 0.16.0 incident itself. With no
+  previous tag the README rule is **skipped and says so**.
+
 ## [0.23.1] - 2026-09-18
 
 A release that could not be published, and the documentation that had fallen three versions behind.

package/README.md

@@ -16,9 +16,12 @@
 
 ### 🛡️ Currently Supported Features (Production Features)
 
+- 🧱 **A stale build is told, not discovered** *(new in 0.23.3)*: thirty suites in this project load `dist/` while they run, and nothing asserted that it still represented the source — only the release gate compared the build id to HEAD, and only at publish time. A stale build does not go red; it verifies old code and returns green. The Stop hook now reports it on the non-blocking `tracked` channel, judged by the **build id and never by mtime**: measured here, `.build-id` had a newer mtime than every source file while naming a commit nine behind HEAD, with two changed sources missing from `dist` entirely. A workspace that does not build hears nothing, `fresh` says nothing, and the two states that cannot be judged say **that** rather than passing quietly.
+- 📐 **Declarations are read as written** *(new in 0.23.2)*: `Files to Touch` is where a spec declares the files it will touch, and three things read it — fulfilment advisories, the declaration census and the approval impact note. The parser took only the **first word of a list item**, so measured over 678 approved specs here, **88 specs and 172 paths were declared and never read**; 24 of them parsed to zero while naming files plainly. Several paths on one line, an indented continuation, a Korean first word, a prose paragraph — all invisible. They are read now, wherever they sit, and a bare `name.ext` keeps its old position rule so a property access like `module.exports` is still not a file. A declared path that does not exist but is the suffix of exactly one repository file is reported as an abbreviation rather than a defect; two candidates stays an ambiguity and nothing is guessed. Cost, measured across the whole corpus: **zero** new `missing` findings.
+- 📄 **The publish gate reads the docs** *(new in 0.23.2)*: the publish playbook has demanded "bring README and CHANGELOG up to this release" since 0.16.0 and only prose enforced it, so it failed four times — including 0.21.0, 0.22.0 and 0.23.0, which each shipped with a feature list frozen at 0.20.0. The release gate now refuses two things it can decide: a missing CHANGELOG entry for the version being published, and an entry with `### Added` while `README.md` has not changed since the previous release. Replayed over eight releases it refuses exactly the three that were stale and passes the other five. What needs judgement — is the old wording still true? — stays with the person and is **reported**, never faked; a check that could not run says so instead of reading as a pass.
 - 🧩 **Your config files survive a re-wire** *(new in 0.23.0)*: `init --agent antigravity` and `init --agent codex` used to replace `.agents/mcp_config.json`, `.agents/hooks.json` and `marketplace.json` **whole**. Measured with a real `--dry-run` before the fix: a neighbour MCP server, a neighbour hook namespace, a neighbour plugin, a marketplace's own name and an operator's `disabled` flag all survived a re-wire at a rate of **zero**. They now survive — only the holmes-kit entry is refreshed, and `init` names what it kept. A `disabled` you set stays set (and `init` says the gate will not run while it stands, rather than switching it back on silently); an existing file that is not readable JSON is refused with a reason instead of being replaced. The Claude wiring already merged; the other two harnesses now have the same discipline.
 - 🫀 **The MCP supervisor notices a child that died** *(new in 0.23.0)*: under `HOLMES_MCP_AUTORELOAD` the supervisor had no exit handler, so a crashed child left it writing to a dead pipe — its in-flight count never returned to zero, the swap that would have replaced the child never fired, and the server went **permanently deaf** (observed twice in one session, then reproduced on demand against the real class). It now answers every outstanding request with a JSON-RPC error **first** (a client must never wait for ever), then resets, respawns and replays the opening exchange. A child that dies having never answered spends a restart budget, so a broken build stops quickly while one crash under load restarts freely; an intentional swap or shutdown is not counted as an accident.
-- 🧮 **Coverage you can explain** *(new in 0.23.0)*: the RTM census already said *where* an unlinked spec is anchored; it now also says *what it declared* — `scanned-source`, `file-anchor-target`, `test-target`, `unreachable-target`, `no-declaration` — plus how many specs declare a path no anchor mechanism can read. On this repository, of 52 unlinked approved specs **zero** declare a file the scanner parses, so the remaining 8.1% of `codeLinkedPct` is not a missing anchor. Bucket names state the fact; whether one is a defect stays `traceGaps`'s answer.
+- 🧮 **Coverage you can explain** *(new in 0.23.0, corrected in 0.23.2)*: the RTM census already said *where* an unlinked spec is anchored; it now also says *what it declared* — `scanned-source`, `file-anchor-target`, `test-target`, `unreachable-target`, `no-declaration` — plus how many specs declare a path no anchor mechanism can read. Bucket names state the fact; whether one is a defect stays `traceGaps`'s answer. **0.23.0 published a wrong number here**: it read "of 52 unlinked specs, zero declare a file the scanner parses, so the remaining 8.1% is not a missing anchor". That zero was the Files-to-Touch parser's, not the corpus's — see the 0.23.2 entry. The same census now reads three, and five real trace gaps were behind it.
 - 🤖 **A CI matrix that judges every commit, and never reads silence as green** *(new in 0.22.0)*: a maintainer-side runner takes one commit onto a Linux VM (clone → install → build → full suite) and appends exactly one row to a `ci-runs` ledger — for every outcome, including the ones where the run could not judge (`clone-failed`, `install-failed`, `vm-unreachable`). A launchd agent triggers it per commit. The Stop hook reports the matrix's last word and `doctor` gains a `ci matrix` check; a missing row reads as **"not run"**, never as a pass. Workspaces that never adopted the matrix hear nothing about it.
 - 🔁 **Advisories learn what happened next** *(new in 0.22.0)*: every finding — impact, anchor density, Files-to-Touch fulfilment, trace gap, `kills`-unapplicable — now carries a deterministic id. Sealing records it as `issued`; the next `approval_status` re-runs the **same** 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]`; an unknown id comes back in `dismissUnknown` rather than inventing a row. `rtm_dashboard`'s census gains the per-kind tallies. This is the numerator every "promote to a hard gate once we know the false-positive rate" sentence was missing.
 - 🧪 **`kills` that cannot apply say so** *(new in 0.22.0)*: `test_run --mutate` reports mutations that never applied as `unapplied`, separately from `survivors`. Measured here, all 22 `kills` entries in this repository wrote `where` as a file path and `mutate` as prose, so the literal-replacement engine applied **none** of them while the response still read `survivors: []` — the shape of a clean run. Sealing a T-SPEC now reports entries whose `where` is absent from the A-SPEC's anchored source, and the authoring playbook shows the grammar.

package/dist/.build-id

@@ -1 +1 @@
-d2304488-mu6dv817
+970ee6cf-mu6tt9oo

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

@@ -70,6 +70,7 @@ export declare function shortPathIfSpaced(p: string): string;
  * space, or win32 where 8.3 resolved it).
  */
 export declare function antigravityHookWarnings(packageRoot: string): string[];
+export declare const AGENTS_MD: (enforced: boolean) => string;
 export declare const MANAGED_BEGIN = "<!-- holmes-kit:managed:begin -->";
 export declare const MANAGED_END = "<!-- holmes-kit:managed:end -->";
 /**

package/dist/holmes/cli/agents.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MANAGED_END = exports.MANAGED_BEGIN = exports.CODEX_MARKETPLACE = exports.CODEX_PLUGIN_DIR = exports.HARNESS_ENFORCES = exports.AGENTS = void 0;
+exports.MANAGED_END = exports.MANAGED_BEGIN = exports.AGENTS_MD = exports.CODEX_MARKETPLACE = exports.CODEX_PLUGIN_DIR = exports.HARNESS_ENFORCES = exports.AGENTS = void 0;
 exports.antigravityHookCommand = antigravityHookCommand;
 exports.shortPathIfSpaced = shortPathIfSpaced;
 exports.antigravityHookWarnings = antigravityHookWarnings;
@@ -201,7 +201,9 @@ This repository operates under **No Spec, No Code** governance. An approved spec
 
 1. **Tool-First Principle (NO Workaround Scripts)**:
    - Creating or mutating \`.ax/specs\` or governance ledgers via arbitrary temporary scripts (\`/tmp/*.js\`) is strictly forbidden.
-   - Use only \`spec_slice_init\`, \`spec_slice_approve\`, \`spec_create\`, and \`spec_approve\` MCP tools to author and seal specs.
+   - \`spec_slice_init\` and \`spec_create\` SCAFFOLD spec documents; \`spec_slice_approve\` and \`spec_approve\` SEAL them. Use these tools for those two acts — never a script.
+   - **Writing the body is editing the file.** After scaffolding, fill the \`TODO\` placeholders by editing the generated spec markdown in \`.ax/specs/\` with your normal editor. This is the expected authoring path, not a workaround — no MCP tool takes section text.
+   - A REQ's \`## Success Criteria\` is scaffolded EMPTY on purpose, because a generator must not invent what "satisfied" means. Approval is refused until you write observable criteria there.
 
 2. **Anchor-First Principle (Mandatory Code Anchors)**:
    - When creating or modifying source code and test files, line 1 MUST include an explicit anchor comment: \`// @\` + \`implements A-SPEC-XXX\`.
@@ -212,7 +214,7 @@ This repository operates under **No Spec, No Code** governance. An approved spec
 
 ## Procedure
 
-1. Run \`spec_slice_init\` or \`spec_create\` to author REQ -> H-SPEC -> A-SPEC.
+1. Run \`spec_slice_init\` or \`spec_create\` to scaffold REQ -> H-SPEC -> A-SPEC, then edit the generated markdown to replace every \`TODO\` and to write the REQ's Success Criteria.
 2. Approve specs via \`spec_slice_approve\` or \`spec_approve\`.
 3. **Before editing source**, run \`maintenance_analyze({ root, request, persist: true })\` and keep the digest it returns — that persisted analysis is what the pre-edit evidence gate checks.
 4. **Write tests first** and verify failure (RED stage).
@@ -227,6 +229,7 @@ ${enforced
     ? `Gates are **enforced**. Tool calls that write un-anchored code or target unapproved specifications will be denied. Unresolved critical findings block completion.`
     : `This harness does not have measured **hook enforcement points**. Holmes-Kit provides tools and guidance here without active gate blocking.`}
 `;
+exports.AGENTS_MD = AGENTS_MD;
 exports.MANAGED_BEGIN = '<!-- holmes-kit:managed:begin -->';
 exports.MANAGED_END = '<!-- holmes-kit:managed:end -->';
 const PRESERVED_NOTE = '<!-- kept from this file by holmes-kit init — holmes-kit does not write below this line -->';
@@ -415,7 +418,7 @@ function agentFiles(agent, opts) {
             return [
                 { path: path.join(target, '.agents', 'hooks.json'), content: hooksJson(packageRoot) },
                 { path: path.join(target, '.agents', 'mcp_config.json'), content: mcpConfig(packageRoot, specsDir, opts.launcher) },
-                { path: path.join(target, 'AGENTS.md'), content: AGENTS_MD(exports.HARNESS_ENFORCES.antigravity) },
+                { path: path.join(target, 'AGENTS.md'), content: (0, exports.AGENTS_MD)(exports.HARNESS_ENFORCES.antigravity) },
             ];
         case 'codex':
             // @implements A-SPEC-442 (was A-SPEC-266, A-SPEC-441) — Codex plugin, at the layout Codex reads:
@@ -480,7 +483,7 @@ function agentFiles(agent, opts) {
                         },
                     }, null, 2)}\n`,
                 },
-                { path: path.join(target, 'AGENTS.md'), content: AGENTS_MD(exports.HARNESS_ENFORCES.codex) },
+                { path: path.join(target, 'AGENTS.md'), content: (0, exports.AGENTS_MD)(exports.HARNESS_ENFORCES.codex) },
             ];
         default:
             // 모르는 하네스를 조용히 건너뛰면 "배선했다"는 보고와 실제가 어긋난다.

package/dist/holmes/cli/approve.js

@@ -48,6 +48,8 @@ exports.renderRefusals = renderRefusals;
 exports.renderNonTtyHint = renderNonTtyHint;
 exports.runInteractive = runInteractive;
 // @implements A-SPEC-246, A-SPEC-626
+// @implements A-SPEC-549.4 — renderPending and renderNonTtyHint in this file are the English CLI
+// surface the Hangul-absence guard reads.
 const execution_context_1 = require("../project/execution-context");
 const root_1 = require("../project/root");
 const fs = __importStar(require("node:fs"));

package/dist/holmes/hooks/pre-tool-use.js

@@ -46,6 +46,8 @@ exports.wiredSpecsDir = wiredSpecsDir;
 exports.evaluateHook = evaluateHook;
 exports.readSpecsSync = readSpecsSync;
 // @implements A-SPEC-278
+// @implements A-SPEC-549.3 — the hook's deny reasons are English here; hooks-english.test.ts drives
+// evaluateHook in this file to prove it.
 // @implements A-SPEC-643
 // @implements A-SPEC-642
 // @implements A-SPEC-194, A-SPEC-195

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

@@ -3,7 +3,9 @@ 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';
+import { type DistVerdict } from '../project/dist-freshness';
 export declare function collectKnownDefects(root: string, now: Date): KnownDefectJudgement | undefined;
+export declare function collectDistFreshness(root: string): DistVerdict | undefined;
 export declare function collectCiVerdicts(root: string, now?: Date): CiVerdict[];
 /**
  * @implements A-SPEC-100.2
@@ -38,6 +40,11 @@ export interface StopEvidence {
      * hook could not look; a `not-run` verdict when it looked and found no row (never silence).
      */
     ci?: CiVerdict[];
+    /**
+     * @implements A-SPEC-673 — whether `dist/` still represents the source. Absent when the workspace
+     * does not build at all; a `no-build-id`/`unknown` verdict when it looked and could not judge.
+     */
+    dist?: DistVerdict;
     /** 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.collectDistFreshness = collectDistFreshness;
 exports.collectCiVerdicts = collectCiVerdicts;
 exports.changedAnchoredAspecs = changedAnchoredAspecs;
 exports.unanchoredChangedSources = unanchoredChangedSources;
@@ -55,6 +56,8 @@ exports.guardCountOrZero = guardCountOrZero;
 exports.readGuardCount = readGuardCount;
 exports.writeGuardCount = writeGuardCount;
 const fs = __importStar(require("node:fs"));
+// @implements A-SPEC-549.3 — evaluateStop's messages are English here; the Hangul-absence guard
+// calls into this file.
 // @implements A-SPEC-645
 // @implements A-SPEC-642
 const npx_bin_1 = require("../project/npx-bin");
@@ -81,6 +84,7 @@ 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");
+const dist_freshness_1 = require("../project/dist-freshness");
 // @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
@@ -128,6 +132,32 @@ function collectKnownDefects(root, now) {
         return undefined;
     }
 }
+// @implements A-SPEC-673 — the I/O half of the build-freshness line: read `dist/.build-id` and ask
+// git how far that commit sits behind HEAD. A workspace that does not build hears nothing; a build
+// that cannot be judged says so rather than passing quietly.
+function collectDistFreshness(root) {
+    if (!(0, dist_freshness_1.hasDist)(root))
+        return undefined;
+    const buildId = (0, dist_freshness_1.distBuildId)(root);
+    let head = null;
+    try {
+        head = (0, node_child_process_1.execFileSync)('git', ['rev-parse', '--short', 'HEAD'], { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], env: (0, root_1.cleanSubprocessEnv)() }).trim();
+    }
+    catch {
+        head = null;
+    }
+    let behind = null;
+    if (buildId && head) {
+        try {
+            const n = Number((0, node_child_process_1.execFileSync)('git', ['rev-list', '--count', `${buildId}..HEAD`], { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], env: (0, root_1.cleanSubprocessEnv)() }).trim());
+            behind = Number.isFinite(n) ? n : null;
+        }
+        catch {
+            behind = null;
+        }
+    }
+    return (0, dist_freshness_1.distFreshness)({ distExists: true, buildId, head, behind });
+}
 // @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.
@@ -529,6 +559,7 @@ const TRACK_LABELS = {
     'ART-2': 'code-graph cycles',
     'ART-9': 'known-defect debt',
     'CI': 'matrix',
+    'DIST': 'build freshness',
 };
 /**
  * One line per ARTICLE, each under its own name.
@@ -602,6 +633,14 @@ function evaluateStop(specs, evidence) {
         const t = evidence.ci.map((v) => ({ article: 'CI', detail: (0, ci_runs_1.ciStatusLine)(v) }));
         tracked = [...(tracked ?? []), ...t];
     }
+    // @implements A-SPEC-673 — a build that no longer represents the source. Thirty suites load `dist/`
+    // while they run, so a stale one does not go red: it verifies old code and returns green. `fresh`
+    // and `absent` produce no line, because a line is spent only on something the reader can act on.
+    if (evidence?.dist) {
+        const detail = (0, dist_freshness_1.distStatusLine)(evidence.dist);
+        if (detail)
+            tracked = [...(tracked ?? []), { article: 'DIST', detail }];
+    }
     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.
@@ -1194,7 +1233,15 @@ if (require.main === module) {
             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-673 — the build-freshness line rides the same non-blocking channel.
+            let dist;
+            try {
+                dist = collectDistFreshness(stopProjectRoot());
+            }
+            catch {
+                dist = undefined;
+            }
+            let out = evaluateStop(specs, { testCasesByAspec, provenance, executedByAspec, findings, findingsUnreadable, unanchoredChangedSources: unanchored, unrecordedApprovals: unrecorded, rolledBackLedgers: rolledBack, redFirstMode, changedAspecs, outcomesByAspec, ...(knownDefects ? { knownDefects } : {}), ...(ci ? { ci } : {}), ...(dist ? { dist } : {}) });
             // @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/tool-schemas.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TOOL_SCHEMAS = exports.HOOK_ENFORCED_TOOLS = void 0;
 // @implements A-SPEC-629, A-SPEC-628, A-SPEC-623, A-SPEC-277, A-SPEC-624, A-SPEC-627
+// @implements A-SPEC-495 — the maintenance_analyze description carries the semantic-evidence
+// consumer contract (sem-verify / semCos / semanticAlternates) beside the anti-prediction warning.
 // @implements A-SPEC-642
 // @implements A-SPEC-641
 // @implements A-SPEC-639

package/dist/holmes/project/ci-lock.d.ts

@@ -0,0 +1,20 @@
+export interface CiLockHolder {
+    pid: number;
+    host: string;
+    rev: string;
+    at: string;
+}
+export type CiLockState = 'free' | 'held' | 'dead' | 'unknown';
+export interface CiLockInput {
+    holder: CiLockHolder | null;
+    thisHost: string;
+    alive: boolean;
+}
+/** Null for every shape we cannot trust — including the legacy empty directory. */
+export declare function readCiLock(lockDir: string): CiLockHolder | null;
+/**
+ * A holder written by ANOTHER host is `unknown`, not dead: we cannot ask that machine about its
+ * pids, and guessing would hand two runners the same VM. Unknown is respected like `held`.
+ */
+export declare function ciLockState(input: CiLockInput): CiLockState;
+export declare function ciLockLine(state: CiLockState, holder: CiLockHolder | null, now?: Date): string;

package/dist/holmes/project/ci-lock.js

@@ -0,0 +1,111 @@
+"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.readCiLock = readCiLock;
+exports.ciLockState = ciLockState;
+exports.ciLockLine = ciLockLine;
+// @implements A-SPEC-674
+/**
+ * Who holds the CI runner's lock, and is that holder still alive.
+ *
+ * The runner serialises itself with a `mkdir` lock — atomic, and that atomicity is the whole reason
+ * it works — released by `trap ... EXIT`. SIGKILL and launchd tearing down the process group skip
+ * that trap. Measured 2026-09-18: one such lock survived 95 minutes while the matrix judged nothing
+ * and nine commits went unjudged, with zero jest processes in the VM and a load of 0.57.
+ *
+ * The lock used to be an EMPTY directory, so it could not say who held it — and a lock that cannot
+ * name its holder cannot be asked whether that holder is alive. It now carries a holder file, and
+ * the judgement below is about liveness, never about elapsed time: calling a slow run dead would
+ * start a second run on the same VM, which is a worse failure than waiting.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+/** Null for every shape we cannot trust — including the legacy empty directory. */
+function readCiLock(lockDir) {
+    let raw;
+    try {
+        raw = fs.readFileSync(path.join(lockDir, 'holder.json'), 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    const h = parsed;
+    if (typeof h?.pid !== 'number' || !Number.isFinite(h.pid))
+        return null;
+    if (typeof h.host !== 'string' || typeof h.rev !== 'string' || typeof h.at !== 'string')
+        return null;
+    return { pid: h.pid, host: h.host, rev: h.rev, at: h.at };
+}
+/**
+ * A holder written by ANOTHER host is `unknown`, not dead: we cannot ask that machine about its
+ * pids, and guessing would hand two runners the same VM. Unknown is respected like `held`.
+ */
+function ciLockState(input) {
+    const { holder, thisHost, alive } = input;
+    if (!holder)
+        return 'free';
+    if (holder.host !== thisHost)
+        return 'unknown';
+    return alive ? 'held' : 'dead';
+}
+const elapsed = (at, now) => {
+    const t = Date.parse(at);
+    if (!Number.isFinite(t))
+        return null;
+    const mins = Math.floor((now.getTime() - t) / 60000);
+    // A clock that runs backwards is a fact about the clock, not about the holder; never report it as
+    // negative time.
+    return mins < 0 ? null : `${mins} min`;
+};
+function ciLockLine(state, holder, now = new Date()) {
+    if (state === 'free' || !holder)
+        return '';
+    const held = elapsed(holder.at, now);
+    const forHow = held ? ` for ${held}` : '';
+    if (state === 'dead') {
+        return `ci lock holder pid ${holder.pid} is gone (held${forHow}, rev ${holder.rev}) — reclaiming it; the matrix judges nothing while a dead holder stands`;
+    }
+    if (state === 'unknown') {
+        return `ci lock was taken by ${holder.host} (rev ${holder.rev}${forHow}) — this host cannot judge another machine's pids, so it is respected`;
+    }
+    return `ci lock is held by pid ${holder.pid} running rev ${holder.rev}${forHow}`;
+}

package/dist/holmes/project/dist-freshness.d.ts

@@ -0,0 +1,30 @@
+export type DistState = 'fresh' | 'behind' | 'absent' | 'no-build-id' | 'unknown';
+export interface DistVerdict {
+    state: DistState;
+    buildId: string | null;
+    head: string | null;
+    behind: number | null;
+}
+export interface DistInput {
+    distExists: boolean;
+    buildId: string | null;
+    head: string | null;
+    /** Commits from the build id to HEAD, or null when it could not be obtained. */
+    behind: number | null;
+}
+/**
+ * The adoption predicate: existence, never contents. A workspace that does not build has no build
+ * freshness to report, and telling it about one would be noise it can do nothing with (the same
+ * reasoning REQ-664 used for the CI ledger).
+ */
+export declare function hasDist(root: string): boolean;
+/** The commit the artefact came from — the part before the dash `npm run build` writes. */
+export declare function distBuildId(root: string): string | null;
+/**
+ * Five states because each calls for something different: `behind` means build, `absent` means
+ * nothing at all to this workspace, and the two unjudgeable ones mean the check did not run — which
+ * must never be reported as a check that passed.
+ */
+export declare function distFreshness(input: DistInput): DistVerdict;
+/** Empty when there is nothing to say. A line is spent only on a fact the reader can act on. */
+export declare function distStatusLine(v: DistVerdict): string;

package/dist/holmes/project/dist-freshness.js

@@ -0,0 +1,114 @@
+"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.hasDist = hasDist;
+exports.distBuildId = distBuildId;
+exports.distFreshness = distFreshness;
+exports.distStatusLine = distStatusLine;
+// @implements A-SPEC-673
+/**
+ * Whether the built artefact still represents the source.
+ *
+ * Thirty suites in this repository load `dist/` while they run — they spawn it or require it — and
+ * nothing asserted that it was current. `scripts/verify-release.js` compares the build id to HEAD,
+ * but only at publish time, so during development a stale build does not go red: it quietly verifies
+ * old code and returns green. This repository has already paid for that once.
+ *
+ * The judgement is built on the BUILD ID, never on mtime, for a measured reason. On 2026-09-18 this
+ * tree's `dist` was nine commits behind HEAD and two changed sources were missing from it entirely,
+ * while `find src -newer dist/.build-id` answered zero — the marker's mtime had been touched without
+ * a rebuild. mtime lies. The build id says which commit the artefact actually came from.
+ *
+ * This module only JUDGES. It never rebuilds: a hook does not change the operator's tree in silence.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+/**
+ * The adoption predicate: existence, never contents. A workspace that does not build has no build
+ * freshness to report, and telling it about one would be noise it can do nothing with (the same
+ * reasoning REQ-664 used for the CI ledger).
+ */
+function hasDist(root) {
+    try {
+        return fs.statSync(path.join(root, 'dist')).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** The commit the artefact came from — the part before the dash `npm run build` writes. */
+function distBuildId(root) {
+    let raw;
+    try {
+        raw = fs.readFileSync(path.join(root, 'dist', '.build-id'), 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const id = raw.trim().split('-')[0];
+    // A shape we do not recognise falls through to a judgement we cannot make, never to a pass.
+    return /^[0-9a-f]{7,40}$/.test(id) ? id : null;
+}
+/**
+ * Five states because each calls for something different: `behind` means build, `absent` means
+ * nothing at all to this workspace, and the two unjudgeable ones mean the check did not run — which
+ * must never be reported as a check that passed.
+ */
+function distFreshness(input) {
+    const { distExists, buildId, head, behind } = input;
+    const base = { buildId: buildId ?? null, head: head ?? null, behind: typeof behind === 'number' ? behind : null };
+    if (!distExists)
+        return { state: 'absent', ...base };
+    if (!buildId)
+        return { state: 'no-build-id', ...base };
+    if (!head || typeof behind !== 'number' || !Number.isFinite(behind) || behind < 0)
+        return { state: 'unknown', ...base };
+    return { state: behind === 0 ? 'fresh' : 'behind', ...base };
+}
+/** Empty when there is nothing to say. A line is spent only on a fact the reader can act on. */
+function distStatusLine(v) {
+    if (v.state === 'fresh' || v.state === 'absent')
+        return '';
+    if (v.state === 'no-build-id') {
+        return 'dist/.build-id is missing or unreadable — the build could not be judged against the source; `npm run build` writes it';
+    }
+    if (v.state === 'unknown') {
+        return `dist was built from ${v.buildId ?? 'an unknown commit'} and the distance to HEAD could not be obtained — the build could not be judged`;
+    }
+    // No invented threshold: one commit is reported like nine, because which commits matter is a
+    // question the reader can answer and this function cannot.
+    const n = v.behind ?? 0;
+    return `dist is ${n} commit${n === 1 ? '' : 's'} behind HEAD (built from ${v.buildId}) — suites that load dist are verifying that build, not this tree; \`npm run build\``;
+}

package/dist/holmes/rtm/ftt-fulfilment.d.ts

@@ -19,6 +19,14 @@ export interface FttFulfilment {
         path: string;
         line: string;
     }>;
+    /**
+     * @implements A-SPEC-670 — a declared path that does not exist but is the suffix of exactly ONE
+     * repository file is the same file written short, not a defect — reported, never counted as one.
+     */
+    abbreviated?: Array<{
+        path: string;
+        resolvedTo: string;
+    }>;
 }
 export interface FulfilmentRecord {
     aspec: string;
@@ -29,9 +37,22 @@ export interface FulfilmentRecord {
     replica?: string;
 }
 /**
- * List items only, first word only — the REQ-654 token rule (a slashed path or an item-shaped
- * root filename; prose is nothing). Globs and extension-less paths (directories) are not items:
- * their fulfilment is not a single file's existence.
+ * @implements A-SPEC-670
+ * Every path-shaped token in the section, wherever it sits on the line.
+ *
+ * REQ-654 read only the first word of a list item. Measured over all 678 A-SPECs on 2026-09-18,
+ * that lost 172 declared paths across 88 specs — 24 of which parsed to zero while naming files
+ * plainly, so the census called them "no declaration" and one wrong conclusion was published from
+ * it. Five forms accounted for every miss: several paths on one line, an indented continuation
+ * line, the second path on a line whose first was read, a Korean first word, and a prose paragraph
+ * written instead of a list.
+ *
+ * The widened rule is safe because of WHERE it reads: this is the Files-to-Touch section, whose
+ * whole purpose is declaration. One line in the entire corpus carries a negation word, and the path
+ * on it is a declaration too — so there is no measured population of "mentioned but not declared".
+ *
+ * What REQ-654 excluded stays excluded, for its original reason: globs and extension-less paths
+ * (directories) are not items, because their fulfilment is not one file's existence.
  */
 export declare function fttItems(fttText: string): FttItem[];
 export declare function fttFulfilment(fttText: string, exists: (rel: string) => boolean, locate: (basename: string) => string[]): FttFulfilment | null;

package/dist/holmes/rtm/ftt-fulfilment.js

@@ -57,30 +57,62 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const scope_judgment_1 = require("../guardrail/scope-judgment");
 const replica_id_1 = require("../governance/replica-id");
-const ITEM_RE = /^\s*[-*]\s+(.*)$/;
 const NEW_RE = /\((신규|new)\)/i;
 const ALT_RE = /또는|\bor\b/;
 const SLASHED = /^[\w@.-]+(?:\/[\w@.-]+)+$/;
 const HAS_EXT = /\.[A-Za-z][A-Za-z0-9]*$/;
+/** Token boundaries as the corpus actually writes them: backticks, quotes, brackets, `·`, commas. */
+const TOKEN_SPLIT = /[`'"()[\]{}<>,;·、，\s]+/;
 /**
- * List items only, first word only — the REQ-654 token rule (a slashed path or an item-shaped
- * root filename; prose is nothing). Globs and extension-less paths (directories) are not items:
- * their fulfilment is not a single file's existence.
+ * @implements A-SPEC-670
+ * Every path-shaped token in the section, wherever it sits on the line.
+ *
+ * REQ-654 read only the first word of a list item. Measured over all 678 A-SPECs on 2026-09-18,
+ * that lost 172 declared paths across 88 specs — 24 of which parsed to zero while naming files
+ * plainly, so the census called them "no declaration" and one wrong conclusion was published from
+ * it. Five forms accounted for every miss: several paths on one line, an indented continuation
+ * line, the second path on a line whose first was read, a Korean first word, and a prose paragraph
+ * written instead of a list.
+ *
+ * The widened rule is safe because of WHERE it reads: this is the Files-to-Touch section, whose
+ * whole purpose is declaration. One line in the entire corpus carries a negation word, and the path
+ * on it is a declaration too — so there is no measured population of "mentioned but not declared".
+ *
+ * What REQ-654 excluded stays excluded, for its original reason: globs and extension-less paths
+ * (directories) are not items, because their fulfilment is not one file's existence.
  */
 function fttItems(fttText) {
     const out = [];
+    const seen = new Set();
     for (const raw of String(fttText ?? '').replace(/\\/g, '/').split('\n')) {
-        const m = ITEM_RE.exec(raw);
-        if (!m)
+        const isListItem = /^\s*[-*]\s+/.test(raw);
+        const line = raw.replace(/^\s*[-*]\s+/, '').trim();
+        if (line === '')
             continue;
-        const line = m[1].trim();
-        const word = (line.split(/\s+/)[0] ?? '').replace(/^[`'"]+|[`'"]+$/g, '').replace(/^`?([^`]*?)`?\(/, '$1(');
-        const token = word.replace(/\(.*$/, ''); // `src/b.ts`(new) → src/b.ts
-        if (!token || token.includes('*') || !HAS_EXT.test(token))
-            continue;
-        if (!(SLASHED.test(token) || (0, scope_judgment_1.isRootFileToken)(token)))
-            continue;
-        out.push({ path: token, line, isNew: NEW_RE.test(line), alternative: ALT_RE.test(line) });
+        const isNew = NEW_RE.test(line);
+        const alternative = ALT_RE.test(line);
+        // Splitting on backticks leaves an empty first piece for `` `a.ts` ``, so "first" counts real
+        // words, not array slots — otherwise every backticked root filename loses its position.
+        const pieces = line.split(TOKEN_SPLIT).filter((w) => w !== '');
+        for (let i = 0; i < pieces.length; i += 1) {
+            // Trailing sentence punctuation is not part of a path; a leading `./` is not part of its identity.
+            const token = pieces[i].replace(/^\.\//, '').replace(/[.,;:]+$/, '');
+            if (!token || token.includes('*') || !HAS_EXT.test(token))
+                continue;
+            // A SLASHED path is admitted wherever it sits — that is the whole point of REQ-670, and a
+            // slash makes it unmistakably a path. A bare `name.ext` is NOT: `isRootFileToken` accepts any
+            // extension, so mid-line it would swallow `module.exports` and a prose `b.ts` (both measured
+            // in A-SPEC-656's pins). Root-file tokens therefore keep REQ-654's position exactly: the first
+            // word of a LIST ITEM. Measured: dropping the list condition admitted `semanticArm.gates` from
+            // a continuation line in A-SPEC-488 — one new false "missing" across the whole corpus, and the
+            // only one. With the condition restored the widening adds 172 declarations and no new finding.
+            if (!SLASHED.test(token) && !(isListItem && i === 0 && (0, scope_judgment_1.isRootFileToken)(token)))
+                continue;
+            if (seen.has(token))
+                continue;
+            seen.add(token);
+            out.push({ path: token, line, isNew, alternative });
+        }
     }
     return out;
 }
@@ -91,6 +123,7 @@ function fttFulfilment(fttText, exists, locate) {
     const missing = [];
     const moved = [];
     const alternatives = [];
+    const abbreviated = [];
     for (const it of items) {
         if (it.alternative) {
             alternatives.push({ path: it.path, line: it.line });
@@ -100,14 +133,25 @@ function fttFulfilment(fttText, exists, locate) {
             continue;
         const base = it.path.slice(it.path.lastIndexOf('/') + 1);
         const foundAt = [...new Set(locate(base))].filter((p) => p !== it.path).sort();
+        // @implements A-SPEC-670 — `project/root.ts` beside `src/holmes/project/root.ts` is the same
+        // file written short, measured 8 times in this corpus and unique every time. Only a UNIQUE
+        // suffix match earns this: two candidates is an ambiguity, and a guess there would invent a
+        // fact. Anything else keeps its old verdict, so the rule swallows no real absence.
+        const suffixHits = foundAt.filter((p) => p.endsWith(`/${it.path}`));
+        if (suffixHits.length === 1) {
+            abbreviated.push({ path: it.path, resolvedTo: suffixHits[0] });
+            continue;
+        }
         if (foundAt.length > 0)
             moved.push({ path: it.path, foundAt });
         else
             missing.push({ path: it.path, isNew: it.isNew });
     }
-    if (missing.length === 0 && moved.length === 0 && alternatives.length === 0)
+    if (missing.length === 0 && moved.length === 0 && alternatives.length === 0 && abbreviated.length === 0)
         return null;
-    return { declared: items.length, missing, moved, alternatives };
+    // Present only when it has something to say: an always-there empty array would change the shape
+    // every existing caller and pin reads, for a fact that is not there.
+    return { declared: items.length, missing, moved, alternatives, ...(abbreviated.length > 0 ? { abbreviated } : {}) };
 }
 const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', '.ax']);
 /** One walk, then O(1) lookups. Unreadable directories are skipped, never reported as empty. */

package/dist/holmes/semantic/credentials.js

@@ -37,6 +37,8 @@ exports.resolveSemanticKey = resolveSemanticKey;
 exports.storeSemanticKey = storeSemanticKey;
 exports.removeSemanticKey = removeSemanticKey;
 // @implements A-SPEC-592
+// @implements A-SPEC-549.4 — declared by that spec's Files to Touch and carries no Hangul; note that
+// the guard's own SOURCES list does not cover this file (reported, not fixed here).
 // @implements A-SPEC-477
 /**
  * The cloud tier's credential: WHERE the consent lives, and in what order it is looked up.

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

@@ -272,7 +272,11 @@ function unactionableCriteriaBlocker(spec) {
     const quality = (0, acceptance_quality_1.acceptanceQuality)(spec);
     if (quality === 'stated')
         return null;
+    // @implements A-SPEC-671 — the refusal now says WHERE. It named what was wrong and stopped, and on
+    // 2026-09-18 an agent in another workspace read the shipped AGENTS.md rule ("author with these
+    // four tools"), found no tool that writes a section body, and halted rather than break the rule.
+    // The section is filled by editing the file, so the refusal hands over the file and the heading.
     return quality === 'absent'
-        ? `REQ ${spec.id}의 Success Criteria가 비어 있습니다 — 관측 가능한 기준을 채운 뒤 승인하십시오`
+        ? `REQ ${spec.id}의 Success Criteria가 비어 있습니다 — \`.ax/specs/01_req/${spec.id}.md\` 의 \`## 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.23.1",
+  "version": "0.23.3",
   "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",
@@ -62,7 +62,8 @@
     "testTimeout": 30000,
     "setupFilesAfterEnv": [
       "<rootDir>/src/holmes/test-support/jest-timeouts-setup.ts"
-    ]
+    ],
+    "maxWorkers": "50%"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",