@holmes-lab/holmes-kit 0.1.9 → 0.1.10

package/dist/holmes/spec/nonfunctional.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNonFunctional = parseNonFunctional;
+exports.caseObligationTags = caseObligationTags;
+exports.unmetObligations = unmetObligations;
+// @implements A-SPEC-234
+const spec_types_1 = require("./spec-types");
+/**
+ * `- [tag] text` — the whole grammar.
+ *
+ * WHY THIS SPELLING. Measured 2026-08-22 across the approved corpus: a leading `- [tag]` appears in
+ * 0 of the 174 `## Non-Functional` lines and 0 of the 1,511 T-SPEC case lines. The obvious
+ * alternative, `- name: text`, already appears 21 times (13%) — adopting it would have invented 21
+ * false obligations on the day it shipped, breaking the rule this repository keeps: the first rule
+ * applied must be one that is ALREADY TRUE.
+ *
+ * The tag is only recognised at the START of a line. Eleven approved T-SPEC case lines contain
+ * brackets mid-prose (`[f1]`, `[V]`, `[REQ-007]`) and every one is a code fragment; counting those
+ * would invent coverage nobody wrote.
+ */
+const OBLIGATION = /^\[([A-Za-z][A-Za-z0-9-]*)\]\s+(\S.*)$/;
+/** A line that reaches for the grammar: `- [` … and then gets it wrong. */
+const IMITATES = /^\[/;
+const clean = (s) => s.replace(/`/g, '').trim().replace(/\s+/g, ' ');
+/**
+ * Read the obligations out of a `## Non-Functional` section.
+ *
+ * @implements A-SPEC-234
+ * A malformed list item is RETURNED, never dropped. A typo that silently parses to nothing reads as
+ * "the rule passed" — the shape this repository has paid for in A-SPEC-191 §17, §29 and again in
+ * A-SPEC-222.2. Prose and blank lines are neither: a section is allowed to explain itself.
+ *
+ * THE TAG VOCABULARY IS NOT FIXED, AND THAT IS THE POINT. A closed set of allowed tags becomes a
+ * thing to maintain and then falls behind — the enumeration-chasing this repository already rejected
+ * for tool names (`write-target.ts`). Whatever the author writes IS the vocabulary; the machine
+ * judges CORRESPONDENCE between an H-SPEC tag and a T-SPEC tag, never meaning.
+ *
+ * WHAT THIS DOES NOT SEE. Whether the obligation is a good one. Whether the case tagged with it
+ * actually exercises it — a case reading `- [perf] Given nothing When nothing Then nothing` counts
+ * as met. Obligations written as prose without a tag (the other 105 documents). Those are human
+ * judgements, and simulating them would recreate the "documented but unenforced" state this slice
+ * exists to remove.
+ */
+function parseNonFunctional(section) {
+    const obligations = [];
+    const malformed = [];
+    if (typeof section !== 'string')
+        return { obligations, malformed };
+    for (const raw of section.split('\n')) {
+        const line = raw.trim();
+        if (!line.startsWith('- '))
+            continue; // prose, blank, or a non-list line
+        const body = clean(line.slice(2));
+        const m = OBLIGATION.exec(body);
+        if (m) {
+            obligations.push({ tag: m[1].toLowerCase(), text: m[2].trim(), line });
+            continue;
+        }
+        // Only lines that REACH for the grammar are errors. Every other list item is ordinary prose and
+        // reporting it would bury the real typos in noise.
+        if (IMITATES.test(body))
+            malformed.push(line);
+    }
+    return { obligations, malformed };
+}
+/**
+ * The obligation tags a T-SPEC's CASES carry.
+ *
+ * @implements A-SPEC-234
+ * Only the four case sections count, and the section names are read from the type table rather than
+ * spelled here — a second spelling of a location is a second thing to keep in step, and this
+ * repository has already paid for that twice (`isTestFile` drifted into two copies; a restated
+ * section-splitting regex returned an empty section while the check using it went green).
+ *
+ * A tag anywhere else in the document states an INTENTION. Only a case is evidence that something
+ * was tested.
+ */
+function caseObligationTags(sections) {
+    const tags = new Set();
+    if (!sections || typeof sections !== 'object')
+        return tags;
+    const map = sections;
+    for (const name of spec_types_1.SPEC_TYPES['T-SPEC'].requiredSections) {
+        const body = map[name];
+        if (typeof body !== 'string')
+            continue;
+        for (const raw of body.split('\n')) {
+            const line = raw.trim();
+            if (!line.startsWith('- '))
+                continue;
+            const m = OBLIGATION.exec(clean(line.slice(2)));
+            if (m)
+                tags.add(m[1].toLowerCase());
+        }
+    }
+    return tags;
+}
+/**
+ * Obligations an H-SPEC declares that no child T-SPEC case answers.
+ *
+ * @implements A-SPEC-234
+ * Matching is EXACT after lower-casing. A prefix match would let `perf` be satisfied by
+ * `performance`, and a false "met" is a gate switched off that says nothing — the same asymmetry
+ * that made `call` targets exact in `forbidden-edges.ts`.
+ *
+ * `malformed` lines are NOT reported here. Flagging syntax errors and judging fulfilment are
+ * different questions; mixed together, one typo invents an obligation nobody declared.
+ */
+function unmetObligations(nonFunctional, tspecSections) {
+    const { obligations } = parseNonFunctional(nonFunctional);
+    if (obligations.length === 0)
+        return [];
+    const covered = new Set();
+    for (const s of Array.isArray(tspecSections) ? tspecSections : []) {
+        for (const t of caseObligationTags(s))
+            covered.add(t);
+    }
+    return obligations.filter((o) => !covered.has(o.tag));
+}

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

@@ -7,6 +7,31 @@ export interface Spec {
     dependsOn: string[];
     frontmatter: Record<string, unknown>;
     sections: Record<string, string>;
+    /**
+     * Body text before the first `##`, or `''`.
+     *
+     * @implements A-SPEC-221
+     * `splitSections` keys on `## ` because the heading IS the key, which is right — but serialization
+     * rebuilt the body from those sections alone, so a legacy document's opening `# 개요` section was
+     * dropped on every write. Captured separately so it can be put back without changing what a
+     * section means.
+     *
+     * Optional so the four call sites that BUILD a Spec (reverse drafts, the conformance fixture,
+     * spec_create) need no change: they have no preamble, and serialization treats absent and empty
+     * identically. `parseSpec` always sets it.
+     */
+    preamble?: string;
 }
+/**
+ * Read `depends_on` in every spelling the corpus contains, keeping what cannot be represented.
+ *
+ * @implements A-SPEC-221
+ * Three forms exist: the current array, a bare string, and the legacy `ID:digest` string. Only the
+ * first was understood; the other two silently became no parents at all.
+ */
+export declare function parseDependsOn(raw: unknown): {
+    ids: string[];
+    legacy: string | null;
+};
 export declare function parseSpec(input: string): Spec;
 export declare function serializeSpec(spec: Spec): string;

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

@@ -33,9 +33,38 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDependsOn = parseDependsOn;
 exports.parseSpec = parseSpec;
 exports.serializeSpec = serializeSpec;
 const yaml = __importStar(require("js-yaml"));
+const legacy_format_1 = require("./legacy-format");
+/**
+ * Read `depends_on` in every spelling the corpus contains, keeping what cannot be represented.
+ *
+ * @implements A-SPEC-221
+ * Three forms exist: the current array, a bare string, and the legacy `ID:digest` string. Only the
+ * first was understood; the other two silently became no parents at all.
+ */
+function parseDependsOn(raw) {
+    if (Array.isArray(raw))
+        return { ids: raw, legacy: null };
+    if (typeof raw !== 'string' || raw.length === 0)
+        return { ids: [], legacy: null };
+    const colon = raw.indexOf(':');
+    // The id ends at the FIRST colon — `REQ-001:sha256:abcd` names REQ-001, not `REQ-001:sha256`.
+    const id = colon === -1 ? raw : raw.slice(0, colon);
+    if (id.length === 0)
+        return { ids: [], legacy: null };
+    return { ids: [id], legacy: colon === -1 ? null : raw };
+}
+function splitPreamble(body) {
+    const idx = body.search(/^##\s+/m);
+    const head = idx === -1 ? body : body.slice(0, idx);
+    // Whitespace is not a preamble. The frontmatter delimiter is followed by a blank line, so nearly
+    // every document has a stray newline here; treating it as content would add one blank line to the
+    // file on every single write, forever.
+    return head.trim().length === 0 ? '' : head;
+}
 function splitSections(body) {
     const out = {};
     const lines = body.split('\n');
@@ -89,18 +118,33 @@ function parseSpec(input) {
     const m = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(raw);
     const fm = ((m ? yaml.load(m[1]) : {}) ?? {});
     const body = m ? m[2] : raw;
+    const deps = parseDependsOn(fm.depends_on);
+    // @implements A-SPEC-221 — never overwrite an existing preservation: a second round trip must not
+    // chew up what the first one saved, the same rule `legacy_status` follows.
+    if (deps.legacy !== null && fm[legacy_format_1.LEGACY_DEPENDS_FIELD] === undefined) {
+        fm[legacy_format_1.LEGACY_DEPENDS_FIELD] = deps.legacy;
+    }
     return {
         id: String(fm.id ?? ''),
         type: fm.type,
         title: String(fm.title ?? ''),
         status: (fm.status ?? 'draft'),
-        dependsOn: Array.isArray(fm.depends_on) ? fm.depends_on : [],
+        dependsOn: deps.ids,
         frontmatter: fm,
         sections: splitSections(body),
+        preamble: splitPreamble(body),
     };
 }
 function serializeSpec(spec) {
     const fm = { ...spec.frontmatter, id: spec.id, type: spec.type, title: spec.title, status: spec.status, depends_on: spec.dependsOn };
     const body = Object.entries(spec.sections).map(([h, t]) => `## ${h}\n${t}\n`).join('\n');
-    return `---\n${yaml.dump(fm)}---\n\n${body}`;
+    // @implements A-SPEC-221 — an empty preamble must contribute NOTHING, and a non-empty one must
+    // contribute the SAME thing every time. The delimiter below already supplies the blank line, so
+    // emitting the preamble's own leading newlines on top of it grew the file by one line on every
+    // write — measured: 2 → 3 → 4 → 5 blank lines over three round trips, unbounded. Trimming the
+    // leading whitespace makes serialization idempotent; the trailing blank line is restored so the
+    // preamble stays separated from the first section.
+    const head = (spec.preamble ?? '').replace(/^\s+/, '');
+    const preamble = head ? `${head.replace(/\s+$/, '')}\n\n` : '';
+    return `---\n${yaml.dump(fm)}---\n\n${preamble}${body}`;
 }

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

@@ -97,7 +97,8 @@ export declare const SPEC_TYPES: Record<SpecType, SpecTypeDef>;
  * The GOVERNED set is defined by the modern spec format: a spec is governed
  * iff it carries a `type` field naming a known SpecType. This deliberately
  * excludes (a) pre-`type` legacy specs retained only as archived history, and
- * (b) the `06_job/JOB-*` runtime ledger, which is not a governed spec type.
+ * (b) any document that is not a governed spec type. `06_job/JOB-*` was the historical case and
+ * was removed under REQ-223; `spec-store-boundary.test.ts` now fails the build if another appears.
  * Validation and RTM integrity checks operate on the governed set — validating
  * archived legacy or runtime-ledger entries is a category error (audit C1).
  * Generic over `{ type?: SpecType }` to stay free of an import cycle with the
@@ -113,9 +114,11 @@ export declare const SPEC_TYPES: Record<SpecType, SpecTypeDef>;
 export declare function specTypeDef(type: string | undefined | null): SpecTypeDef | undefined;
 export declare function isGoverned(spec: {
     type?: SpecType;
+    status?: SpecStatus;
 }): boolean;
 export declare function filterGoverned<T extends {
     type?: SpecType;
+    status?: SpecStatus;
 }>(specs: T[]): T[];
 /**
  * @implements A-SPEC-174

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

@@ -106,7 +106,8 @@ exports.SPEC_TYPES = {
  * The GOVERNED set is defined by the modern spec format: a spec is governed
  * iff it carries a `type` field naming a known SpecType. This deliberately
  * excludes (a) pre-`type` legacy specs retained only as archived history, and
- * (b) the `06_job/JOB-*` runtime ledger, which is not a governed spec type.
+ * (b) any document that is not a governed spec type. `06_job/JOB-*` was the historical case and
+ * was removed under REQ-223; `spec-store-boundary.test.ts` now fails the build if another appears.
  * Validation and RTM integrity checks operate on the governed set — validating
  * archived legacy or runtime-ledger entries is a category error (audit C1).
  * Generic over `{ type?: SpecType }` to stay free of an import cycle with the
@@ -127,6 +128,17 @@ function specTypeDef(type) {
         : undefined;
 }
 function isGoverned(spec) {
+    // @implements A-SPEC-222.1 — a retired document is the canonical form of "archived", which the
+    // comment above already excludes as a category error. The rule was expressed as `type` alone only
+    // because no document had ever carried `outdated`: it was in SPEC_STATUSES with nothing able to
+    // write it. Measured the day retirement shipped — moving 23 legacy REQs to `outdated` surfaced 24
+    // constitution violations, among them `missing section: ## Success Criteria` and
+    // `root-has-parent`. Demanding those of a retired document is demanding that history be rewritten,
+    // and `root-has-parent` was not a violation at all under the 2026-04 model the document was
+    // written in. Retirement has to mean removal from the ACTIVE graph, or it means nothing beyond a
+    // changed string.
+    if (spec.status === 'outdated')
+        return false;
     return specTypeDef(spec.type) !== undefined;
 }
 function filterGoverned(specs) {

package/dist/holmes/testing/effects.d.ts

@@ -0,0 +1,54 @@
+/**
+ * What a function actually touched while it ran.
+ *
+ * @implements A-SPEC-238
+ * WHY OBSERVATION RATHER THAN SOURCE READING. Sixteen approved H-SPECs claim "순수", "I/O 없음",
+ * "파일시스템 접근 0". Measured 2026-08-23, every one of those claims is TRUE — but nothing held
+ * them true, and the `[purity]` cases written earlier in this session were weak in a specific way:
+ *
+ *     expect(fn.toString()).not.toMatch(/readFileSync/)   // reads the function's TEXT
+ *     expect(input).toEqual(copy)                         // proves only that input is unchanged
+ *
+ * Both ask how the function is WRITTEN, not what it DOES. One helper call into another module and
+ * the first passes; a file-reading function that mutates nothing passes the second. This session has
+ * corrected that same shape twice already — ADR-016's off-switch check guessed at flag names and
+ * missed its mutation, and A-SPEC-237's `[symmetry]` check grepped for `try` and passed before the
+ * fix existed.
+ */
+export interface ObservedEffects {
+    /** Names of the filesystem methods called, in order. */
+    fs: string[];
+    /** How many times the clock was read. */
+    clock: number;
+    /** How many times randomness was drawn. */
+    random: number;
+    /** What the body threw, if anything — returned rather than propagated. */
+    threw?: unknown;
+    /**
+     * Read methods that could NOT be wrapped, so the caller knows the observation has holes.
+     *
+     * Silence about what a tool could not watch is the same defect as a gate that passes because it
+     * saw nothing. Under normal Node this is empty; it is reported rather than assumed.
+     */
+    unwatched: string[];
+}
+/**
+ * Run `fn` and report what it touched.
+ *
+ * @implements A-SPEC-238
+ * The body's exception is RETURNED in `threw`, not re-thrown. "Why did it fail" and "what did it
+ * touch" are different pieces of information and a caller usually needs both; re-throwing would
+ * restore the globals but discard the observation.
+ *
+ * WHAT THIS DOES NOT SEE. Network calls and child processes — no claim in this repository's
+ * `## Non-Functional` sections mentions them, and offering coverage would recreate the
+ * "documented but unenforced" state. Asynchronous work that lands after `fn` returns: every function
+ * making a purity claim here is synchronous. Reads through a handle obtained before observation
+ * began. And a grammar loaded once per process — measured 2026-08-23, `extractSymbols` performs 26
+ * filesystem calls on the FIRST call in a process and zero on every call after, including the first
+ * call for a different language. That is one-time lazy loading, not per-call I/O, and this tool
+ * cannot tell them apart: warm the callee first.
+ */
+export declare function observeEffects(fn: () => unknown): ObservedEffects;
+/** Assert that `fn` touched nothing, naming what it touched when it did. */
+export declare function expectPure(fn: () => unknown): void;

package/dist/holmes/testing/effects.js

@@ -0,0 +1,107 @@
+"use strict";
+// @implements A-SPEC-238
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.observeEffects = observeEffects;
+exports.expectPure = expectPure;
+/**
+ * Every filesystem READ surface, found by prefix rather than listed by name.
+ *
+ * Enumerating method names would let a new one through, and a pass reads as "no access". Judging the
+ * surface whole is the direction this repository has already taken three times: tool names in
+ * `write-target.ts`, shell verbs in `risk-classifier.ts`, and dependency declaration surfaces in
+ * `project/dependencies.ts`. Prefix matching also means a future Node release's new read method is
+ * covered the day it appears.
+ */
+const READ_PREFIXES = /^(read|stat|lstat|fstat|exists|open|access|opendir|realpath|watch|glob)/;
+/**
+ * The CommonJS `fs` module object, NOT an `import * as fs` namespace.
+ *
+ * The namespace an ES import produces exposes getter-only properties: assigning to one throws
+ * `TypeError: Cannot set property access of #<Object> which has only a getter`. Measured while
+ * writing this — the standalone probe worked because it used `require`, and the first version of
+ * this module did not, so every case failed at the first patch. The module object is what the code
+ * under test actually calls through.
+ */
+const fsModule = () => 
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+require('node:fs');
+/**
+ * Run `fn` and report what it touched.
+ *
+ * @implements A-SPEC-238
+ * The body's exception is RETURNED in `threw`, not re-thrown. "Why did it fail" and "what did it
+ * touch" are different pieces of information and a caller usually needs both; re-throwing would
+ * restore the globals but discard the observation.
+ *
+ * WHAT THIS DOES NOT SEE. Network calls and child processes — no claim in this repository's
+ * `## Non-Functional` sections mentions them, and offering coverage would recreate the
+ * "documented but unenforced" state. Asynchronous work that lands after `fn` returns: every function
+ * making a purity claim here is synchronous. Reads through a handle obtained before observation
+ * began. And a grammar loaded once per process — measured 2026-08-23, `extractSymbols` performs 26
+ * filesystem calls on the FIRST call in a process and zero on every call after, including the first
+ * call for a different language. That is one-time lazy loading, not per-call I/O, and this tool
+ * cannot tell them apart: warm the callee first.
+ */
+function observeEffects(fn) {
+    const target = fsModule();
+    const surface = Object.keys(target).filter((k) => READ_PREFIXES.test(k) && typeof target[k] === 'function');
+    const originals = {};
+    const unwatched = [];
+    const calls = [];
+    for (const name of surface) {
+        const original = target[name];
+        try {
+            target[name] = function (...args) {
+                calls.push(name);
+                return original.apply(target, args);
+            };
+            // Assignment can silently no-op on a non-writable property, which would look like a wrapped
+            // method that never fires. Confirm it took.
+            if (target[name] === original) {
+                unwatched.push(name);
+                continue;
+            }
+            originals[name] = original;
+        }
+        catch {
+            unwatched.push(name);
+        }
+    }
+    const realNow = Date.now;
+    const realRandom = Math.random;
+    let clock = 0;
+    let random = 0;
+    Date.now = function () { clock++; return realNow.call(Date); };
+    Math.random = function () { random++; return realRandom.call(Math); };
+    let threw;
+    let didThrow = false;
+    try {
+        fn();
+    }
+    catch (e) {
+        threw = e;
+        didThrow = true;
+    }
+    finally {
+        // Restoration is in `finally` because a tool that patches globals and fails to put them back
+        // poisons every test that runs afterwards — and that poisoning surfaces far from its cause.
+        for (const name of Object.keys(originals))
+            target[name] = originals[name];
+        Date.now = realNow;
+        Math.random = realRandom;
+    }
+    const out = { fs: calls, clock, random, unwatched };
+    return didThrow ? { ...out, threw } : out;
+}
+/** Assert that `fn` touched nothing, naming what it touched when it did. */
+function expectPure(fn) {
+    const e = observeEffects(fn);
+    const touched = [
+        ...e.fs.map((m) => `fs.${m}`),
+        ...(e.clock ? [`Date.now ×${e.clock}`] : []),
+        ...(e.random ? [`Math.random ×${e.random}`] : []),
+    ];
+    if (touched.length > 0) {
+        throw new Error(`expected no effects, observed: ${[...new Set(touched)].join(', ')}`);
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "//": "@implements A-SPEC-209",
   "name": "@holmes-lab/holmes-kit",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "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",
@@ -23,7 +23,8 @@
     "test": "npm run typecheck && jest",
     "mcp": "node bin/holmes-mcp.js",
     "release": "npm run build && node scripts/make-release.js",
-    "typecheck": "tsc --noEmit -p tsconfig.test.json"
+    "typecheck": "tsc --noEmit -p tsconfig.test.json",
+    "prepublishOnly": "node scripts/verify-release.js"
   },
   "keywords": [
     "ase",

package/playbooks/promote-slice/PLAYBOOK.md

@@ -107,6 +107,25 @@ depends_on:
 승인 후에 발견된 것은 **새 리비전**이지 승인 취소가 아니다. 되돌리는 비용이 승인을 미루게 만들면,
 게이트는 품질 장치가 아니라 지연 장치가 된다.
 
+## 문서를 물리는 법 — `spec_retire`
+
+승인이 권한을 주는 행위라면 폐기는 거두는 행위다. 그래서 기본 문턱이 낮다 — 잘못 만든 초안을
+치우는 데 대역외 열쇠를 요구하면 일상 작업이 막힌다. **다만 문턱은 행위의 이름이 아니라 결과의
+위험을 따른다.** 두 경우는 폐기가 곧 게이트 열기다:
+
+- **봉인된 문서.** 코드 게이트는 "대상 A-SPEC을 `depends_on`에 담은 approved T-SPEC"을 요구한다.
+  그 T-SPEC을 폐기하면 요구가 사라진다. 그래서 `approved_digest`를 가진 문서의 폐기는
+  `spec_approve`와 **같은** `HOLMES_APPROVAL`을 요구하며 fail-closed다.
+- **활성 문서가 의존하는 문서.** `approved` 자식이 하나라도 있으면 거부하고, 문면이 그 자식을
+  id로 지목한다. 그 사슬은 지금 무언가를 지탱하고 있다.
+
+사유는 `retired_reason`에 남는다 — 비어 있으면 적지 않고, `superseded_by`가 이미 답이면 묻지
+않는다. 멱등이다: 이미 `outdated`인 문서를 다시 폐기하면 아무것도 쓰지 않는다. 두 번째 호출이
+첫 번째의 사유를 덮어쓰면 기록이 아니라 낙서다.
+
+> `outdated`는 `SPEC_STATUSES`에 처음부터 있었지만 이를 쓰는 코드가 0곳, 그 상태인 문서도
+> 0건이었다(실측 2026-08-21). 도달할 수 없는 상태는 선언이 아니라 장식이다.
+
 ## 흔한 오해
 
 | 오해 | 사실 |
@@ -116,6 +135,7 @@ depends_on:
 | "A-SPEC을 승인했으니 코드를 쓸 수 있다" | 테스트는 그렇다. 코드는 T-SPEC이 남았다 |
 | "T-SPEC 승인했는데 막힌다 = 게이트 버그" | `depends_on` 누락. 메시지가 동일해서 구별되지 않는다 |
 | "일단 승인하고 검증은 나중에" | 통과한 채 깨진 그래프가 남는다. 4단계 참조 |
+| "폐기는 `status: outdated`로 손편집한다" | `spec_retire(id, reason)`이 유일한 경로다. 봉인된 문서는 승인 열쇠를 요구하고, approved 의존자가 있으면 거부한다 |
 | "`missing`이 'approved A-SPEC'이니 A-SPEC을 승인하면 된다" | `AUTHOR_TSPEC`이면 아무거나 하나, `WRITE_TEST`면 대상 그것. 같은 문자열이 두 가지를 뜻한다 |
 
 ## 검증