@spec-engine/spec-engine 0.6.1 → 0.7.1

package/dist/impl.js

@@ -20,7 +20,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@spec-engine/spec-engine",
-    version: "0.6.1",
+    version: "0.7.1",
     description: "Cross-repo spec engine \u2014 durable requirements with permanent IDs, bound to code via @spec tags, checked in CI. Ships the spec CLI, the local coverage webapp (spec serve), and offline docs (spec docs).",
     license: "MIT",
     type: "module",
@@ -73,18 +73,8 @@ var init_package = __esm(() => {
   };
 });
 
-// ../shared/src/config.ts
-import { z } from "zod";
-var SpecConfigSchema;
-var init_config = __esm(() => {
-  SpecConfigSchema = z.object({
-    specs: z.string().regex(/^spec-engine@\d+$/, "must be of the form spec-engine@N where N is an integer"),
-    ignore: z.array(z.string().min(1, "ignore entries must be non-empty strings")).optional()
-  });
-});
-
 // ../shared/src/diagnostics.ts
-var DiagnosticCode, NotASpecPlatformError;
+var DiagnosticCode, NotASpecPlatformError, InvalidDomainFilesError;
 var init_diagnostics = __esm(() => {
   DiagnosticCode = {
     DUP_ID: "DUP_ID",
@@ -111,6 +101,9 @@ var init_diagnostics = __esm(() => {
     UNPROVEN_REQ: "UNPROVEN_REQ",
     PROOFS_UNCONFIRMED: "PROOFS_UNCONFIRMED",
     REQUIREMENT_REMOVED: "REQUIREMENT_REMOVED",
+    IMPL_LOST: "IMPL_LOST",
+    VERIFY_LOST: "VERIFY_LOST",
+    SPEC_FILE_DELETED: "SPEC_FILE_DELETED",
     UNAPPROVED_STATUS_FLIP: "UNAPPROVED_STATUS_FLIP",
     PARTIAL_PROPAGATION: "PARTIAL_PROPAGATION",
     MALFORMED_FILE: "MALFORMED_FILE",
@@ -135,10 +128,20 @@ var init_diagnostics = __esm(() => {
       Object.setPrototypeOf(this, NotASpecPlatformError.prototype);
     }
   };
+  InvalidDomainFilesError = class InvalidDomainFilesError extends Error {
+    diagnostics;
+    constructor(diagnostics) {
+      super(diagnostics.map((d) => `${d.source_file ?? ""}: ${d.detail}`).join(`
+`));
+      this.name = "InvalidDomainFilesError";
+      this.diagnostics = diagnostics;
+      Object.setPrototypeOf(this, InvalidDomainFilesError.prototype);
+    }
+  };
 });
 
 // ../shared/src/domain.ts
-import { z as z2 } from "zod";
+import { z } from "zod";
 function reqIdForIssuePath(input, path) {
   if (path.length < 2 || path[0] !== "requirements" || typeof path[1] !== "number") {
     return null;
@@ -221,62 +224,215 @@ function orderDomain(d) {
     }))
   };
 }
+function isDefaultValue(v) {
+  return v === undefined || v === null || Array.isArray(v) && v.length === 0;
+}
+function patchFields(raw, before, next) {
+  for (const key of new Set([...Object.keys(before), ...Object.keys(next)])) {
+    if (key === "requirements")
+      continue;
+    const v = next[key];
+    if (sameValue(before[key], v))
+      continue;
+    if (v === undefined)
+      delete raw[key];
+    else if (!isDefaultValue(v) || key in raw)
+      raw[key] = v;
+  }
+}
+function shapeLike(template, next) {
+  if (template === undefined)
+    return next;
+  const out = {};
+  for (const key of Object.keys(template)) {
+    if (next[key] !== undefined)
+      out[key] = next[key];
+  }
+  for (const [key, v] of Object.entries(next)) {
+    if (!(key in out) && !isDefaultValue(v))
+      out[key] = v;
+  }
+  return out;
+}
+function preserveShape(raw, rawDomain, domain) {
+  const before = orderDomain(rawDomain);
+  const next = orderDomain(domain);
+  patchFields(raw, before, next);
+  const rawEntries = raw.requirements;
+  const byId = new Map;
+  rawDomain.requirements.forEach((r, i) => {
+    byId.set(r.id, [...byId.get(r.id) ?? [], i]);
+  });
+  const template = rawEntries[rawEntries.length - 1];
+  raw.requirements = next.requirements.map((entry, i) => {
+    const idx = byId.get(domain.requirements[i]?.id ?? "")?.shift();
+    if (idx === undefined)
+      return shapeLike(template, entry);
+    const rawEntry = rawEntries[idx];
+    patchFields(rawEntry, before.requirements[idx], entry);
+    return rawEntry;
+  });
+  return raw;
+}
+function verifyRoundTrip(serialized, domain, sourceFile) {
+  const reparsed = parseDomainText(serialized, sourceFile);
+  if (!reparsed.ok)
+    return { ok: false, diagnostics: reparsed.diagnostics };
+  if (sameValue(orderDomain(reparsed.data), orderDomain(domain)))
+    return { ok: true };
+  return {
+    ok: false,
+    diagnostics: [
+      {
+        code: DiagnosticCode.INVALID_DOMAIN_FILE,
+        source_file: sourceFile,
+        line: 0,
+        repo: null,
+        req_id: null,
+        detail: "the shape-preserving rewrite does not re-parse to the validated domain",
+        severity: "error"
+      }
+    ]
+  };
+}
+async function readExisting(path, sourceFile) {
+  const file = Bun.file(path);
+  if (!await file.exists())
+    return null;
+  let raw;
+  try {
+    raw = JSON.parse(await file.text());
+  } catch {
+    return null;
+  }
+  const validated = validateDomainFile(raw, sourceFile);
+  return validated.ok ? { raw, data: validated.data } : null;
+}
 async function validateAndWrite(path, domain, sourceFile) {
-  const validated = validateDomainFile(domain, sourceFile ?? path);
+  const src = sourceFile ?? path;
+  const validated = validateDomainFile(domain, src);
   if (!validated.ok) {
     return { ok: false, diagnostics: validated.diagnostics };
   }
-  const serialized = `${JSON.stringify(orderDomain(validated.data), null, 2)}
+  const existing = await readExisting(path, src);
+  if (existing === null) {
+    await Bun.write(path, `${JSON.stringify(orderDomain(validated.data), null, 2)}
+`);
+    return { ok: true };
+  }
+  const shaped = preserveShape(existing.raw, existing.data, validated.data);
+  const serialized = `${JSON.stringify(shaped, null, 2)}
 `;
+  const verdict = verifyRoundTrip(serialized, validated.data, src);
+  if (!verdict.ok)
+    return verdict;
   await Bun.write(path, serialized);
   return { ok: true };
 }
-var ID_RE, KEY_RE, SpecIssueSchema, SpecCiteSchema, SpecRequirementSchema, SpecDomainSchema;
+var ID_RE, KEY_RE, SpecIssueSchema, SpecCiteSchema, SpecRequirementSchema, SpecDomainSchema, sameValue = (a, b) => JSON.stringify(a) === JSON.stringify(b);
 var init_domain = __esm(() => {
   init_diagnostics();
   ID_RE = /^[A-Z][A-Z0-9]*-\d+$/;
   KEY_RE = /^[A-Z][A-Z0-9]*$/;
-  SpecIssueSchema = z2.object({
-    role: z2.string().min(1),
-    id: z2.string().min(1)
+  SpecIssueSchema = z.object({
+    role: z.string().min(1),
+    id: z.string().min(1)
+  }).strict();
+  SpecCiteSchema = z.object({
+    term: z.string(),
+    pinned: z.number().int()
   }).strict();
-  SpecCiteSchema = z2.object({
-    term: z2.string(),
-    pinned: z2.number().int()
+  SpecRequirementSchema = z.object({
+    id: z.string().regex(ID_RE),
+    status: z.string().min(1),
+    statement: z.string().min(1),
+    why: z.string().nullable().optional(),
+    supersedes: z.string().nullable().optional(),
+    supersededBy: z.string().nullable().optional(),
+    relates: z.array(z.string()).optional().default([]),
+    livesIn: z.array(z.string()).optional().default([]),
+    issues: z.array(SpecIssueSchema).optional().default([]),
+    changedAtVersion: z.number().int().optional(),
+    supersededAtVersion: z.number().int().optional(),
+    deprecatedReason: z.string().optional(),
+    term: z.string().optional(),
+    aliases: z.array(z.string()).optional().default([]),
+    cites: z.array(SpecCiteSchema).optional().default([]),
+    section: z.string().nullable().optional()
   }).strict();
-  SpecRequirementSchema = z2.object({
-    id: z2.string().regex(ID_RE),
-    status: z2.string().min(1),
-    statement: z2.string().min(1),
-    why: z2.string().nullable().optional(),
-    supersedes: z2.string().nullable().optional(),
-    supersededBy: z2.string().nullable().optional(),
-    relates: z2.array(z2.string()).optional().default([]),
-    livesIn: z2.array(z2.string()).optional().default([]),
-    issues: z2.array(SpecIssueSchema).optional().default([]),
-    changedAtVersion: z2.number().int().optional(),
-    supersededAtVersion: z2.number().int().optional(),
-    deprecatedReason: z2.string().optional(),
-    term: z2.string().optional(),
-    aliases: z2.array(z2.string()).optional().default([]),
-    cites: z2.array(SpecCiteSchema).optional().default([]),
-    section: z2.string().nullable().optional()
+  SpecDomainSchema = z.object({
+    key: z.string().regex(KEY_RE),
+    owner: z.string().nullable().optional(),
+    specVersion: z.number().int().positive().optional(),
+    updated: z.string(),
+    scope: z.string().nullable().optional(),
+    grammar: z.enum(["ears", "freeform"]).optional(),
+    grammarSeverity: z.enum(["warning", "error"]).optional(),
+    requirements: z.array(SpecRequirementSchema)
   }).strict();
-  SpecDomainSchema = z2.object({
-    key: z2.string().regex(KEY_RE),
-    owner: z2.string().nullable().optional(),
-    specVersion: z2.number().int().positive().optional(),
-    updated: z2.string(),
-    scope: z2.string().nullable().optional(),
-    grammar: z2.enum(["ears", "freeform"]).optional(),
-    grammarSeverity: z2.enum(["warning", "error"]).optional(),
-    requirements: z2.array(SpecRequirementSchema)
+});
+
+// ../shared/src/checkConfig.ts
+import { z as z2 } from "zod";
+function parseCheckConfigText(text, sourceFile) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, detail: `${sourceFile}: not valid JSON: ${msg}` };
+  }
+  const result = CheckConfigSchema.safeParse(parsed);
+  if (result.success)
+    return { ok: true, config: result.data };
+  const issue = result.error.issues[0];
+  const path = issue && issue.path.length > 0 ? issue.path.join(".") : "(root)";
+  return { ok: false, detail: `${sourceFile}: ${path}: ${issue?.message ?? "invalid"}` };
+}
+var CODES, matchEntry, SeverityRuleSchema, CheckConfigSchema;
+var init_checkConfig = __esm(() => {
+  init_diagnostics();
+  init_domain();
+  CODES = Object.values(DiagnosticCode);
+  matchEntry = z2.string().refine((s) => KEY_RE.test(s) || ID_RE.test(s), "must be a domain key or a requirement id");
+  SeverityRuleSchema = z2.object({
+    code: z2.enum(CODES),
+    severity: z2.enum(["error", "warning", "off"]),
+    match: z2.array(matchEntry).optional()
   }).strict();
+  CheckConfigSchema = z2.object({ severity: z2.array(SeverityRuleSchema) }).strict();
+});
+
+// ../shared/src/config.ts
+import { z as z3 } from "zod";
+var SpecConfigSchema;
+var init_config = __esm(() => {
+  SpecConfigSchema = z3.object({
+    specs: z3.string().regex(/^spec-engine@\d+$/, "must be of the form spec-engine@N where N is an integer"),
+    ignore: z3.array(z3.string().min(1, "ignore entries must be non-empty strings")).optional()
+  });
 });
 
 // ../shared/src/ears.ts
-function reject(problem) {
-  return { ok: false, problem, expected: EARS_EXPECTED };
+function reject(problem, expected = SHAPE_EXPECTED) {
+  return { ok: false, problem, expected };
+}
+function onePromiseProblem(statement, response) {
+  if (/;\s/.test(response)) {
+    return 'joins a second clause with "; " after "shall" \u2014 split it into its own requirement';
+  }
+  if (/,\s+and\s+(?!shall\b)\S[^,;]*?\s+shall\b/i.test(response)) {
+    return 'joins a second clause with its own subject (", and <subject> shall") \u2014 split it into its own requirement';
+  }
+  const rationale = statement.match(RATIONALE_RE);
+  if (rationale) {
+    return `carries a rationale ("${rationale[1]}") \u2014 the reason belongs in the why field`;
+  }
+  return null;
+}
+function lint(clauses, statement) {
+  const problem = onePromiseProblem(statement, clauses.response);
+  return problem === null ? { ok: true, clauses } : reject(problem, ONE_PROMISE_EXPECTED);
 }
 function parseEarsStatement(raw) {
   const statement = raw.trim();
@@ -291,15 +447,12 @@ function parseEarsStatement(raw) {
     const m2 = statement.match(re);
     if (m2) {
       const [, condition = "", system = "", response = ""] = m2;
-      return {
-        ok: true,
-        clauses: {
-          pattern,
-          condition: condition.trim(),
-          system: system.trim().replace(/^the\s+/i, ""),
-          response: response.trim()
-        }
-      };
+      return lint({
+        pattern,
+        condition: condition.trim(),
+        system: system.trim().replace(/^the\s+/i, ""),
+        response: response.trim()
+      }, statement);
     }
     if (keyword === "If" && !/,\s*then\s/.test(statement)) {
       return reject('starts with "If" but has no ", then" \u2014 the failure clause never hands over to the system');
@@ -312,19 +465,16 @@ function parseEarsStatement(raw) {
     if (/,/.test(system)) {
       return reject('the clause before "shall" contains a comma but starts with no condition keyword (When/While/If/Where) \u2014 either drop the comma or lead with the condition');
     }
-    return {
-      ok: true,
-      clauses: {
-        pattern: "always",
-        condition: null,
-        system: system.trim().replace(/^the\s+/i, ""),
-        response: response.trim()
-      }
-    };
+    return lint({
+      pattern: "always",
+      condition: null,
+      system: system.trim().replace(/^the\s+/i, ""),
+      response: response.trim()
+    }, statement);
   }
   return reject('nothing follows "shall" \u2014 the observable result is missing');
 }
-var EARS_EXPECTED, CONDITIONAL, ALWAYS_RE;
+var EARS_EXPECTED, CONDITIONAL, ALWAYS_RE, SHAPE_EXPECTED, ONE_PROMISE_EXPECTED = "Expected one promise per statement: a second behavior is its own requirement, and the reason goes in the why.", RATIONALE_RE;
 var init_ears = __esm(() => {
   EARS_EXPECTED = [
     'When <trigger>, the <system> shall <result> \u2014 e.g. "When an unknown id is passed, spec resolve shall print [] and exit 0."',
@@ -341,6 +491,9 @@ var init_ears = __esm(() => {
     { keyword: "Where", pattern: "where", re: /^Where\s+(.+?),\s*(.+?)\s+shall\s+(.+)$/s }
   ];
   ALWAYS_RE = /^(.+?)\s+shall\s+(.+)$/s;
+  SHAPE_EXPECTED = `Expected one of:
+  ${EARS_EXPECTED}`;
+  RATIONALE_RE = /\b(because|so that|in order to)\b/i;
 });
 
 // ../shared/src/flags.ts
@@ -531,7 +684,8 @@ CREATE INDEX IF NOT EXISTS idx_term_citations_term ON term_citations(term_id);
 -- supersedes-via | amends-via), validated at parse time, never as a DB
 -- constraint. Exactly one index, on req_id; never on issue_id, which would
 -- treat the opaque payload as a lookup key.
--- @spec PROV-004
+-- @spec PROV-005
+-- @spec PROV-006
 CREATE TABLE IF NOT EXISTS provenance (
   id            INTEGER PRIMARY KEY AUTOINCREMENT,
   req_id        TEXT NOT NULL,
@@ -677,6 +831,7 @@ var init_storage = __esm(() => {
 
 // ../shared/src/index.ts
 var init_src = __esm(() => {
+  init_checkConfig();
   init_config();
   init_diagnostics();
   init_domain();
@@ -949,8 +1104,7 @@ import { readdir } from "fs/promises";
 import { join as join2 } from "path";
 function isPathIgnored(path, extra = []) {
   const anchored = `/${path}`;
-  const tokens = extra.length === 0 ? IGNORE_SUBSTR : [...IGNORE_SUBSTR, ...extra];
-  return tokens.some((t) => anchored.includes(`/${t.endsWith("/") ? t : `${t}/`}`));
+  return IGNORE_SUBSTR.some((t) => anchored.includes(`/${t}`)) || extra.some((t) => path.startsWith(t.endsWith("/") ? t : `${t}/`));
 }
 async function walkInto(rootDir, relDir, keep, extraIgnore, out) {
   const absDir = relDir ? join2(rootDir, relDir) : rootDir;
@@ -979,15 +1133,19 @@ async function walkFiles(rootDir, keep, extraIgnore) {
   out.sort();
   return out;
 }
+function isDockerfile(name) {
+  return name === "Dockerfile" || name.startsWith("Dockerfile.") && name.length > 11;
+}
+function isTagSource(rel, exts = DEFAULT_EXTS) {
+  const name = rel.slice(rel.lastIndexOf("/") + 1);
+  const dot = name.lastIndexOf(".");
+  return isDockerfile(name) || dot > 0 && exts.includes(name.slice(dot + 1));
+}
 async function findDomainJsonFiles(canonicalDir) {
   return walkFiles(canonicalDir, (rel) => rel === "SPEC.json" || rel.endsWith("/SPEC.json"), []);
 }
 async function findCodeFiles(repoDir, exts = DEFAULT_EXTS, extraIgnore = []) {
-  const extSet = new Set(exts);
-  return walkFiles(repoDir, (rel) => {
-    const dot = rel.lastIndexOf(".");
-    return dot > 0 && extSet.has(rel.slice(dot + 1));
-  }, extraIgnore);
+  return walkFiles(repoDir, (rel) => isTagSource(rel, exts), extraIgnore);
 }
 async function findDocFiles(repoDir, extraIgnore = []) {
   return walkFiles(repoDir, (rel) => rel.endsWith(".md") && rel !== "SPEC.md" && !rel.endsWith("/SPEC.md"), extraIgnore);
@@ -1017,7 +1175,11 @@ var init_fs = __esm(() => {
     "lua",
     "luau",
     "go",
-    "rs"
+    "rs",
+    "tf",
+    "toml",
+    "sql",
+    "css"
   ];
 });
 
@@ -1548,9 +1710,13 @@ SELECT
   t.file                                                      AS source_file,
   t.line                                                      AS line,
   t.req_id                                                    AS req_id,
-  ('Tag references Draft requirement ' || t.req_id ||
-    ' \u2014 code is bound to a promise nobody approved yet')      AS detail,
-  'warning'                                                   AS severity
+  CASE WHEN t.kind = 'verifies'
+    THEN ('Test verifies Draft requirement ' || t.req_id ||
+      ' \u2014 it asserts a promise nobody accepted yet')
+    ELSE ('Tag references Draft requirement ' || t.req_id ||
+      ' \u2014 code is bound to a promise nobody accepted yet')
+  END                                                         AS detail,
+  CASE WHEN t.kind = 'verifies' THEN 'error' ELSE 'warning' END AS severity
 FROM tags t
 JOIN requirements r ON r.id = t.req_id
 WHERE r.status = 'Draft'
@@ -1580,11 +1746,10 @@ SELECT
   'error'                                                     AS severity
 FROM requirements r
 WHERE r.status = 'Active'
-  -- code-coverage obligation \u2014 exclude the reserved TERM domain so a migrated
-  -- term never fires ORPHAN_REQ. Literal 'TERM' only, never a real domain key;
-  -- mirrors the coverage VIEW exclusion (WHERE r.key != 'TERM') in schema.ts.
+  -- Must stay in step with the coverage view's TERM exclusion in schema.ts.
   -- @spec SCHM-017
   AND r.key != 'TERM'
+  -- A doc paragraph citing a requirement is not an implementation.
   AND NOT EXISTS (
     SELECT 1 FROM tags t WHERE t.req_id = r.id AND t.kind != 'documents'
   )
@@ -1598,11 +1763,10 @@ SELECT
   r.id                                                        AS req_id,
   ('Requirement ' || r.id ||
     ' is implemented but has no verifies-kind tag')           AS detail,
-  'error'                                                     AS severity
+  'warning'                                                   AS severity
 FROM requirements r
 WHERE r.status = 'Active'
-  -- never implemented/verified by code, so it must never fire UNVERIFIED_REQ.
-  -- Literal 'TERM' only; mirrors Q4 + the coverage VIEW exclusion.
+  -- Must stay in step with Q4 and the coverage view's TERM exclusion.
   AND r.key != 'TERM'
   AND EXISTS (SELECT 1 FROM tags t WHERE t.req_id = r.id AND t.kind = 'implements')
   AND NOT EXISTS (SELECT 1 FROM tags t WHERE t.req_id = r.id AND t.kind = 'verifies')
@@ -2445,7 +2609,7 @@ async function runIndex(opts) {
     unpinned,
     diagnostics: platformDiagnostics
   } = await discoverRepos(platformDir);
-  const { specs, structuralDiagnostics } = await readSpecs(canonical);
+  const specs = await readSpecs(canonical);
   const { tagHits, docMentionCandidates } = await scanMembers(members);
   const rows = buildRows({
     canonical,
@@ -2453,7 +2617,6 @@ async function runIndex(opts) {
     members,
     specs,
     tagHits,
-    structuralDiagnostics,
     unpinned,
     platformDiagnostics
   });
@@ -2475,29 +2638,22 @@ async function runIndex(opts) {
 async function readSpecs(canonical) {
   const jsonPaths = await findDomainJsonFiles(canonical.path);
   const specs = [];
-  const structuralDiagnostics = [];
+  const invalid = [];
   for (const rel of jsonPaths) {
     const absPath = join4(canonical.path, rel);
     const text = await Bun.file(absPath).text();
     const platformRelative = `${canonical.name}/${rel}`;
     const fallbackKey = basename2(dirname3(rel));
     const result = parseDomainJsonFile({ text, sourceFile: platformRelative, fallbackKey });
-    if (!result.ok) {
-      for (const d of result.diagnostics) {
-        structuralDiagnostics.push({
-          code: d.code,
-          source_file: d.source_file ?? platformRelative,
-          line: d.line ?? 0,
-          req_id: d.req_id,
-          detail: d.detail,
-          severity: d.severity
-        });
-      }
-      continue;
-    }
-    specs.push(result.spec);
+    if (result.ok)
+      specs.push(result.spec);
+    else
+      for (const d of result.diagnostics)
+        invalid.push({ ...d, source_file: d.source_file ?? platformRelative });
   }
-  return { specs, structuralDiagnostics };
+  if (invalid.length > 0)
+    throw new InvalidDomainFilesError(invalid);
+  return specs;
 }
 function repoExtraIgnore(member) {
   const repoIgnore = (member.ignore ?? []).map((e) => e.endsWith("/") ? e : `${e}/`);
@@ -2549,16 +2705,7 @@ async function scanMembers(members) {
   return { tagHits, docMentionCandidates };
 }
 function buildRows(input) {
-  const {
-    canonical,
-    platformVersion,
-    members,
-    specs,
-    tagHits,
-    structuralDiagnostics,
-    unpinned,
-    platformDiagnostics
-  } = input;
+  const { canonical, platformVersion, members, specs, tagHits, unpinned, platformDiagnostics } = input;
   const sortedRepos = sortBy([
     {
       name: canonical.name,
@@ -2582,8 +2729,6 @@ function buildRows(input) {
   const { sortedTermAliases, sortedTermCitations } = buildTermRows(specs, flatRequirements);
   const sortedProvenance = sortBy(specs.flatMap((s) => s.provenance), (p) => `${p.req_id}\x00${p.role}\x00${p.issue_id}\x00${p.source_file}\x00${pad(p.line)}`);
   const diagnostics2 = validateStructure(specs);
-  for (const d of structuralDiagnostics)
-    diagnostics2.push(d);
   for (const s of unpinned) {
     diagnostics2.push({
       code: DiagnosticCode.NO_SPEC_CONFIG,
@@ -3017,6 +3162,49 @@ var init_init = __esm(() => {
   KNOWN_KEYS = new Set(SpecConfigSchema.keyof().options);
 });
 
+// src/check/format.ts
+function compareRepoNullsLast(a, b) {
+  if (a === b)
+    return 0;
+  if (a === null)
+    return 1;
+  if (b === null)
+    return -1;
+  return a.localeCompare(b);
+}
+function compareDiagnostics(a, b) {
+  const codeCmp = a.code.localeCompare(b.code);
+  if (codeCmp !== 0)
+    return codeCmp;
+  const repoCmp = compareRepoNullsLast(a.repo, b.repo);
+  if (repoCmp !== 0)
+    return repoCmp;
+  const fileCmp = (a.source_file ?? "").localeCompare(b.source_file ?? "");
+  if (fileCmp !== 0)
+    return fileCmp;
+  const lineCmp = (a.line ?? 0) - (b.line ?? 0);
+  if (lineCmp !== 0)
+    return lineCmp;
+  return (a.req_id ?? "").localeCompare(b.req_id ?? "");
+}
+function sortDiagnostics(rows) {
+  return [...rows].sort(compareDiagnostics);
+}
+function renderDiagnostics(rows, mode) {
+  const sorted = sortDiagnostics(rows);
+  if (mode === "json") {
+    return JSON.stringify(sorted);
+  }
+  return sorted.map((d) => {
+    const repo = d.repo ?? "";
+    const file = d.source_file ?? "";
+    const line = d.line ?? "";
+    const reqId = d.req_id ?? "";
+    return `${d.code}	${repo}	${file}:${line}	${reqId}	${d.detail}`;
+  }).join(`
+`);
+}
+
 // src/operations/_index.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync, statSync as statSync3 } from "fs";
 import { dirname as dirname4, join as join6 } from "path";
@@ -3115,6 +3303,26 @@ function handleNotAPlatform(e) {
   }
   throw e;
 }
+function handleInvalidDomainFiles(e, json, code = EXIT.FAILURE) {
+  if (!(e instanceof InvalidDomainFilesError))
+    return;
+  if (json)
+    console.log(renderDiagnostics(e.diagnostics, "json"));
+  else
+    console.error(renderDiagnostics(e.diagnostics, "text"));
+  process.exit(code);
+}
+function cliFreshTags(platformDir) {
+  const fresh = coldFreshTags(platformDir);
+  return async (reqId) => {
+    try {
+      return await fresh(reqId);
+    } catch (e) {
+      handleInvalidDomainFiles(e, false, EXIT.USAGE);
+      throw e;
+    }
+  };
+}
 function handleStorageUnavailable(e, dbPath) {
   const info = describeStorageError(e);
   if (info === null)
@@ -3143,7 +3351,7 @@ function exitOnFailure(cmdName, failure) {
   process.exit(EXIT.USAGE);
 }
 async function withReadStorage(opts, fn) {
-  const { platformDir, dbPath, fresh } = opts;
+  const { platformDir, dbPath, fresh, json = false } = opts;
   try {
     await withIndex({ platformDir, dbPath, build: fresh ? "fresh" : "missing" }, async (h) => {
       for (const w of h.warnings)
@@ -3152,6 +3360,7 @@ async function withReadStorage(opts, fn) {
     });
   } catch (e) {
     handleStorageUnavailable(e, dbPath);
+    handleInvalidDomainFiles(e, json);
     handleNotAPlatform(e);
   }
 }
@@ -3358,7 +3567,7 @@ function listFlag(rawArgs, name, parsed) {
   }
   return raw.flatMap((v) => v.split(",")).map((v) => v.trim()).filter((v) => v !== "");
 }
-var platformDirArg, outArg, jsonArg, freshArg, noPromptArg, livesArg;
+var platformDirArg, outArg, jsonArg, freshArg, noPromptArg, livesArg, relatesArg;
 var init__args = __esm(() => {
   init_constants();
   platformDirArg = {
@@ -3383,6 +3592,10 @@ var init__args = __esm(() => {
     type: "string",
     description: "Lives in (livesIn) paths: repeat the flag or comma-separate; an empty value clears the list"
   };
+  relatesArg = {
+    type: "string",
+    description: "Related requirement ids (relates): repeat the flag or comma-separate; an empty value clears the list"
+  };
 });
 
 // src/commands/index.ts
@@ -3457,6 +3670,7 @@ var init_commands = __esm(() => {
           console.error(formatNotASpecPlatform(err.platformDir));
           process.exit(EXIT.USAGE);
         }
+        handleInvalidDomainFiles(err, !!args.json);
         console.error("spec index FAILED:", err);
         process.exit(EXIT.FAILURE);
       } finally {
@@ -3466,49 +3680,6 @@ var init_commands = __esm(() => {
   });
 });
 
-// src/check/format.ts
-function compareRepoNullsLast(a, b) {
-  if (a === b)
-    return 0;
-  if (a === null)
-    return 1;
-  if (b === null)
-    return -1;
-  return a.localeCompare(b);
-}
-function compareDiagnostics(a, b) {
-  const codeCmp = a.code.localeCompare(b.code);
-  if (codeCmp !== 0)
-    return codeCmp;
-  const repoCmp = compareRepoNullsLast(a.repo, b.repo);
-  if (repoCmp !== 0)
-    return repoCmp;
-  const fileCmp = (a.source_file ?? "").localeCompare(b.source_file ?? "");
-  if (fileCmp !== 0)
-    return fileCmp;
-  const lineCmp = (a.line ?? 0) - (b.line ?? 0);
-  if (lineCmp !== 0)
-    return lineCmp;
-  return (a.req_id ?? "").localeCompare(b.req_id ?? "");
-}
-function sortDiagnostics(rows) {
-  return [...rows].sort(compareDiagnostics);
-}
-function renderDiagnostics(rows, mode) {
-  const sorted = sortDiagnostics(rows);
-  if (mode === "json") {
-    return JSON.stringify(sorted);
-  }
-  return sorted.map((d) => {
-    const repo = d.repo ?? "";
-    const file = d.source_file ?? "";
-    const line = d.line ?? "";
-    const reqId = d.req_id ?? "";
-    return `${d.code}	${repo}	${file}:${line}	${reqId}	${d.detail}`;
-  }).join(`
-`);
-}
-
 // src/check/proven.ts
 function normalizeToSegments(path) {
   const out = [];
@@ -3634,7 +3805,7 @@ var init_proven = __esm(() => {
 
 // src/base/gitBase.ts
 function isSafeRef(ref) {
-  return /^[A-Za-z0-9._/-]+$/.test(ref);
+  return /^[A-Za-z0-9._/][A-Za-z0-9._/-]*$/.test(ref);
 }
 function gitRepoPrefix(platformDir) {
   const proc = Bun.spawnSync(["git", "rev-parse", "--show-prefix"], { cwd: platformDir });
@@ -3672,7 +3843,7 @@ function gitLsTree(platformDir, ref, dir) {
 function gitDiffNameStatus(platformDir, ref) {
   if (!isSafeRef(ref))
     return [];
-  const proc = Bun.spawnSync(["git", "diff", "--name-status", "--no-renames", "--relative", ref], {
+  const proc = Bun.spawnSync(["git", "diff", "--name-status", "--no-renames", "--relative", ref, "--"], {
     cwd: platformDir
   });
   if (proc.exitCode !== 0)
@@ -3691,6 +3862,14 @@ function gitDiffNameStatus(platformDir, ref) {
   }
   return rows;
 }
+function newestReleaseTag(platformDir) {
+  const proc = Bun.spawnSync(["git", "tag", "--list", "v*", "--merged", "HEAD", "--sort=-v:refname"], { cwd: platformDir });
+  if (proc.exitCode !== 0)
+    return null;
+  const tag = proc.stdout.toString().split(`
+`)[0]?.trim() ?? "";
+  return tag !== "" && isSafeRef(tag) ? tag : null;
+}
 
 // src/check/codeowners.ts
 function parseCodeowners(text) {
@@ -3972,8 +4151,7 @@ function rowsForDomain2(key, domain2) {
       source_file: specPaths("", key).rel,
       line: found >= 0 ? found + 1 : 0,
       req_id: req.id,
-      detail: `${result.problem}. Expected one of:
-  ${result.expected}`
+      detail: `${result.problem}. ${result.expected}`
     });
   }
   return rows;
@@ -4063,6 +4241,60 @@ var init_removed = __esm(() => {
   init_src();
 });
 
+// src/check/severity.ts
+import { existsSync as existsSync7, readFileSync } from "fs";
+import { join as join8 } from "path";
+function readCheckConfig(platformDir) {
+  const path = join8(platformDir, CHECK_CONFIG_REL);
+  if (!existsSync7(path))
+    return { ok: true, config: { severity: [] } };
+  return parseCheckConfigText(readFileSync(path, "utf-8"), CHECK_CONFIG_REL);
+}
+function specificity(rule, row) {
+  if (rule.code !== row.code)
+    return Specificity.none;
+  if (rule.match === undefined)
+    return Specificity.code;
+  const id = row.req_id;
+  if (id === null)
+    return Specificity.none;
+  if (rule.match.includes(id))
+    return Specificity.id;
+  const key = id.slice(0, id.lastIndexOf("-"));
+  return rule.match.includes(key) ? Specificity.domain : Specificity.none;
+}
+function applySeverity(rows, rules) {
+  const out = [];
+  for (const row of rows) {
+    let best;
+    let bestScore = Specificity.none;
+    for (const rule of rules) {
+      const score = specificity(rule, row);
+      if (score !== Specificity.none && score >= bestScore) {
+        best = rule;
+        bestScore = score;
+      }
+    }
+    if (best === undefined)
+      out.push(row);
+    else if (best.severity !== "off")
+      out.push({ ...row, severity: best.severity });
+  }
+  return out;
+}
+var CHECK_CONFIG_REL, Specificity;
+var init_severity = __esm(() => {
+  init_src();
+  init_constants();
+  CHECK_CONFIG_REL = `${CANONICAL_SPECS_DIR}/check.json`;
+  Specificity = {
+    none: -1,
+    code: 0,
+    domain: 1,
+    id: 2
+  };
+});
+
 // src/check/sqlDiagnostics.ts
 function collectDiagnostics(storage2) {
   const semantic = storage2.listSemanticDiagnostics();
@@ -4501,7 +4733,7 @@ function localToday() {
 }
 
 // src/operations/_envelope.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 function domainKeyOf(id) {
   return id.slice(0, id.indexOf("-"));
 }
@@ -4510,7 +4742,7 @@ function displayStatus(raw) {
 }
 async function readEnvelope(platformDir, key, missingDetail) {
   const { abs: specPath, rel: relFile } = specPaths(platformDir, key);
-  if (!existsSync7(specPath)) {
+  if (!existsSync8(specPath)) {
     return fail("not_found", missingDetail ?? `no domain ${key} (expected ${relFile} under ${platformDir})`);
   }
   const parsed = parseDomainText(await Bun.file(specPath).text(), relFile);
@@ -4526,32 +4758,58 @@ async function readEnvelope(platformDir, key, missingDetail) {
   const domain2 = parsed.data;
   return { ok: true, key, specPath, relFile, domain: domain2, requirements: domain2.requirements };
 }
+async function scanForEntry(platformDir, id, skipKey) {
+  for (const key of listDomainKeys(platformDir)) {
+    if (key === skipKey)
+      continue;
+    const file = await readEnvelope(platformDir, key);
+    if (!file.ok)
+      continue;
+    const req = file.requirements.find((r) => r.id === id);
+    if (req !== undefined)
+      return { ...file, req };
+  }
+  return null;
+}
 async function locateEntry(platformDir, id, missingDomainDetail) {
-  const file = await readEnvelope(platformDir, domainKeyOf(id), missingDomainDetail);
-  if (!file.ok)
+  const prefixKey = domainKeyOf(id);
+  const file = await readEnvelope(platformDir, prefixKey, missingDomainDetail);
+  if (!file.ok && file.reason !== "not_found")
     return file;
-  const req = file.requirements.find((r) => r.id === id);
-  if (req === undefined)
-    return fail("not_found", `no entry ${id} in ${file.relFile}`);
-  return { ...file, req };
-}
-function successorEntry(id, fields) {
-  return {
+  const req = file.ok ? file.requirements.find((r) => r.id === id) : undefined;
+  if (file.ok && req !== undefined)
+    return { ...file, req };
+  const scanned = await scanForEntry(platformDir, id, prefixKey);
+  if (scanned !== null)
+    return scanned;
+  return file.ok ? fail("not_found", `no entry ${id} in ${file.relFile}`) : file;
+}
+function splitList(values) {
+  return values.flatMap((v) => v.split(",")).map((v) => v.trim()).filter((v) => v !== "");
+}
+function successorEntry(id, pred, fields) {
+  const entry = {
     id,
     status: "active",
     statement: fields.statement,
     why: fields.why === "" ? null : fields.why,
     supersedes: null,
     supersededBy: null,
-    relates: [],
+    relates: fields.relates,
     livesIn: fields.livesIn,
     issues: fields.issue ? [{ role: "created", id: fields.issue }] : [],
-    aliases: [],
-    cites: []
+    aliases: [...pred.aliases],
+    cites: pred.cites.map((c) => ({ ...c }))
   };
+  if (pred.term !== undefined)
+    entry.term = pred.term;
+  if (pred.section !== undefined)
+    entry.section = pred.section;
+  return entry;
 }
 var init__envelope = __esm(() => {
   init_src();
+  init_domains();
   init_constants();
   init__result();
 });
@@ -4588,8 +4846,7 @@ async function judgeStatementGrammar(platformDir, key, statement) {
     severity: cfg.severity,
     key,
     message: `the statement does not match the domain's EARS shape \u2014 ${result.problem}.
-` + `Expected one of:
-  ${result.expected}`
+${result.expected}`
   };
 }
 function grammarWarningText(cmdName, v) {
@@ -4606,7 +4863,7 @@ var init_grammar2 = __esm(() => {
 });
 
 // src/operations/mint.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 function unresolvableRefWarnings(platformDir, fieldValues) {
   const out = [];
   for (const value of fieldValues) {
@@ -4621,7 +4878,7 @@ function unresolvableRefWarnings(platformDir, fieldValues) {
 async function mint(input) {
   const { platformDir, key } = input;
   const { abs: specPath, rel: relFile } = specPaths(platformDir, key);
-  if (!existsSync8(specPath)) {
+  if (!existsSync9(specPath)) {
     return fail("not_found", `no domain ${key} (expected ${relFile} under ${platformDir})`);
   }
   const warnings = unresolvableRefWarnings(platformDir, [
@@ -4649,7 +4906,7 @@ async function mint(input) {
     why: input.why || null,
     supersedes: null,
     supersededBy: null,
-    relates: input.relates ?? [],
+    relates: splitList(input.relates ?? []),
     livesIn: input.livesIn,
     issues: input.issue ? [{ role: "created", id: input.issue }] : [],
     aliases: [],
@@ -4808,8 +5065,8 @@ var init_term = __esm(() => {
 });
 
 // src/operations/glossary.ts
-import { existsSync as existsSync9, readFileSync } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync2 } from "fs";
+import { join as join9 } from "path";
 function parseGlossary(md) {
   const terms = [];
   let section = null;
@@ -4861,15 +5118,15 @@ function generateGlossary(terms) {
 }
 function readStoreTerms(platformDir) {
   const { abs: specPath, rel: relFile } = specPaths(platformDir, TERM_KEY);
-  if (!existsSync9(specPath))
+  if (!existsSync10(specPath))
     return [];
-  const parsed = parseDomainText(readFileSync(specPath, "utf8"), relFile);
+  const parsed = parseDomainText(readFileSync2(specPath, "utf8"), relFile);
   if (!parsed.ok)
     return [];
   return parsed.data.requirements.filter((r) => r.status.toLowerCase() === "active").sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0).map((r) => ({ term: r.term ?? "", statement: r.statement, section: r.section ?? null }));
 }
 function glossaryPath(platformDir) {
-  return join8(platformDir, "GLOSSARY.md");
+  return join9(platformDir, "GLOSSARY.md");
 }
 async function migrateGlossary(platformDir) {
   const store = await termStore(platformDir);
@@ -4880,10 +5137,10 @@ async function migrateGlossary(platformDir) {
     return { ok: true, skipped: true, existing: domain2.requirements.length };
   }
   const gPath = glossaryPath(platformDir);
-  if (!existsSync9(gPath)) {
+  if (!existsSync10(gPath)) {
     return fail("not_found", `no GLOSSARY.md to migrate (expected ${gPath})`);
   }
-  const parsed = parseGlossary(readFileSync(gPath, "utf8"));
+  const parsed = parseGlossary(readFileSync2(gPath, "utf8"));
   domain2.requirements = parsed.map((t, i) => ({
     id: `${TERM_KEY}-${String(i + 1).padStart(3, "0")}`,
     status: "active",
@@ -4920,10 +5177,10 @@ function glossaryDriftDiagnostic(platformDir) {
   if (terms.length === 0)
     return null;
   const gPath = glossaryPath(platformDir);
-  if (!existsSync9(gPath))
+  if (!existsSync10(gPath))
     return null;
   const generated = generateGlossary(terms);
-  const committed = readFileSync(gPath, "utf8");
+  const committed = readFileSync2(gPath, "utf8");
   if (generated === committed)
     return null;
   return {
@@ -4939,7 +5196,7 @@ function glossaryDriftDiagnostic(platformDir) {
 function checkGlossary(platformDir) {
   const generated = generateGlossary(readStoreTerms(platformDir));
   const gPath = glossaryPath(platformDir);
-  const committed = existsSync9(gPath) ? readFileSync(gPath, "utf8") : "";
+  const committed = existsSync10(gPath) ? readFileSync2(gPath, "utf8") : "";
   return { ok: true, clean: generated === committed };
 }
 var GLOSSARY_INTRO = `Canonical names for Spec Engine concepts. When prose, code comments, diagnostics, or
@@ -4952,27 +5209,221 @@ var init_glossary = __esm(() => {
   init_term();
 });
 
-// src/operations/check.ts
-import { existsSync as existsSync10, readFileSync as readFileSync2 } from "fs";
-import { join as join9 } from "path";
-function readCodeownersText(platformDir) {
-  const path = join9(platformDir, ".github", "CODEOWNERS");
-  if (!existsSync10(path))
-    return null;
-  return readFileSync2(path, "utf-8");
+// src/guard/collect.ts
+import { join as join10 } from "path";
+function isIgnored(path) {
+  return isPathIgnored(path);
 }
-function domainReqsFromText(text, platformRel) {
-  const validated = parseDomainText(text, platformRel);
-  if (!validated.ok)
-    return { reqs: [], diagnostics: validated.diagnostics };
-  return { reqs: validated.data.requirements, diagnostics: [] };
+function isSpecFile(path) {
+  return path.startsWith(`${CANONICAL_SPECS_DIR}/`) && path.endsWith("/SPEC.json") && !isIgnored(path);
+}
+function isCodeFile(path) {
+  return !isSpecFile(path) && !isIgnored(path) && isTagSource(path);
+}
+function parseReqs(text) {
+  const v = parseDomainText(text, "");
+  return v.ok ? v.data.requirements : [];
+}
+function collectBaseReqs(platformDir, ref, specPaths2) {
+  const reqs = [];
+  const path = new Map;
+  for (const p of specPaths2) {
+    const bytes = gitShow(platformDir, ref, p);
+    if (bytes === null)
+      continue;
+    for (const r of parseReqs(bytes)) {
+      reqs.push(r);
+      path.set(r.id, p);
+    }
+  }
+  return { reqs, path };
+}
+function collectBaseTags(platformDir, ref, codePaths) {
+  const implSite = new Map;
+  const verifySite = new Map;
+  for (const p of codePaths) {
+    const bytes = gitShow(platformDir, ref, p);
+    if (bytes === null)
+      continue;
+    for (const tag of scanTagsInFile("", p, bytes)) {
+      const target = tag.kind === "verifies" ? verifySite : implSite;
+      if (!target.has(tag.req_id))
+        target.set(tag.req_id, { file: tag.file, line: tag.line });
+    }
+  }
+  return { implSite, verifySite };
+}
+async function collectWorktreeReqs(canonicalDir) {
+  const ids = new Set;
+  const activeIds = new Set;
+  const supersedesTargets = new Set;
+  for (const rel of await findDomainJsonFiles(canonicalDir)) {
+    const text = await Bun.file(join10(canonicalDir, rel)).text();
+    for (const r of parseReqs(text)) {
+      ids.add(r.id);
+      if (r.status.toLowerCase() === "active")
+        activeIds.add(r.id);
+      if (r.supersedes != null)
+        supersedesTargets.add(r.supersedes);
+    }
+  }
+  return { ids, activeIds, supersedesTargets };
+}
+function tallyWorktreeTags(storage2) {
+  const implCount = new Map;
+  const verifyCount = new Map;
+  for (const t of storage2.listTags()) {
+    const bucket = t.kind === "implements" ? implCount : t.kind === "verifies" ? verifyCount : null;
+    if (bucket !== null)
+      bucket.set(t.req_id, (bucket.get(t.req_id) ?? 0) + 1);
+  }
+  return { implCount, verifyCount };
+}
+async function collectFacts(platformDir, ref, storage2) {
+  const changed = gitDiffNameStatus(platformDir, ref);
+  const specPaths2 = changed.filter((e) => isSpecFile(e.path)).map((e) => e.path);
+  const codePaths = changed.filter((e) => isCodeFile(e.path)).map((e) => e.path);
+  const deletedSpecFiles = changed.filter((e) => e.status === "D" && isSpecFile(e.path)).map((e) => e.path);
+  const base = collectBaseReqs(platformDir, ref, specPaths2);
+  const baseTags = collectBaseTags(platformDir, ref, codePaths);
+  const worktree = await collectWorktreeReqs(join10(platformDir, CANONICAL_SPECS_DIR));
+  const counts = tallyWorktreeTags(storage2);
+  return {
+    baseReqs: base.reqs,
+    baseReqPath: base.path,
+    baseImplSite: baseTags.implSite,
+    baseVerifySite: baseTags.verifySite,
+    worktreeReqIds: worktree.ids,
+    worktreeActiveIds: worktree.activeIds,
+    worktreeSupersedesTargets: worktree.supersedesTargets,
+    worktreeImplCount: counts.implCount,
+    worktreeVerifyCount: counts.verifyCount,
+    deletedSpecFiles
+  };
+}
+var init_collect = __esm(() => {
+  init_src();
+  init_constants();
+  init_fs();
+  init_tags();
+});
+
+// src/guard/losses.ts
+function isActive(status) {
+  return status.toLowerCase() === "active";
+}
+function isSuperseded(base, f) {
+  const forward = base.supersededBy != null && f.worktreeReqIds.has(base.supersededBy);
+  return forward || f.worktreeSupersedesTargets.has(base.id);
+}
+function reqDeletedLoss(base, f) {
+  return {
+    kind: "REQUIREMENT_REMOVED",
+    req_id: base.id,
+    file: f.baseReqPath.get(base.id) ?? "",
+    line: 0,
+    detail: `${base.id} was Active at the ref but is absent from the working-tree spec and was not superseded \u2014 a requirement is never deleted`
+  };
+}
+function historyRemovedLoss(base, f) {
+  const display = base.status.charAt(0).toUpperCase() + base.status.slice(1).toLowerCase();
+  return {
+    kind: "REQUIREMENT_REMOVED",
+    req_id: base.id,
+    file: f.baseReqPath.get(base.id) ?? "",
+    line: 0,
+    detail: `${base.id} was ${display} at the ref but is absent from the working-tree spec \u2014 a requirement is never deleted, and its history is the record`
+  };
+}
+function implLostLoss(id, site) {
+  return {
+    kind: "IMPL_LOST",
+    req_id: id,
+    file: site.file,
+    line: site.line,
+    detail: `${id} lost its last implementing @spec tag (was ${site.file}:${site.line})`
+  };
+}
+function verifyLostLoss(id, site) {
+  return {
+    kind: "VERIFY_LOST",
+    req_id: id,
+    file: site.file,
+    line: site.line,
+    detail: `${id} lost its last verifying @spec tag (was ${site.file}:${site.line})`
+  };
+}
+function specFileDeletedLoss(path) {
+  return {
+    kind: "SPEC_FILE_DELETED",
+    req_id: null,
+    file: path,
+    line: 0,
+    detail: `canonical spec file ${path} present at the ref is absent from the working tree`
+  };
+}
+function reqDeletedFor(base, f) {
+  if (f.worktreeReqIds.has(base.id))
+    return null;
+  if (!isActive(base.status))
+    return historyRemovedLoss(base, f);
+  if (isSuperseded(base, f))
+    return null;
+  return reqDeletedLoss(base, f);
+}
+function lastTagGone(id, count, f) {
+  return f.worktreeActiveIds.has(id) && count === 0;
+}
+function classifyLosses(f) {
+  const out = [];
+  for (const base of f.baseReqs) {
+    const loss = reqDeletedFor(base, f);
+    if (loss !== null)
+      out.push(loss);
+  }
+  for (const [id, site] of f.baseImplSite) {
+    if (lastTagGone(id, f.worktreeImplCount.get(id) ?? 0, f))
+      out.push(implLostLoss(id, site));
+  }
+  for (const [id, site] of f.baseVerifySite) {
+    if (lastTagGone(id, f.worktreeVerifyCount.get(id) ?? 0, f))
+      out.push(verifyLostLoss(id, site));
+  }
+  for (const path of f.deletedSpecFiles)
+    out.push(specFileDeletedLoss(path));
+  return out;
+}
+
+// src/operations/guard.ts
+async function guard(storage2, platformDir, ref) {
+  const losses = classifyLosses(await collectFacts(platformDir, ref, storage2));
+  return { ok: true, ref, losses };
+}
+var init_guard = __esm(() => {
+  init_collect();
+});
+
+// src/operations/check.ts
+import { existsSync as existsSync11, readFileSync as readFileSync3 } from "fs";
+import { join as join11 } from "path";
+function readCodeownersText(platformDir) {
+  const path = join11(platformDir, ".github", "CODEOWNERS");
+  if (!existsSync11(path))
+    return null;
+  return readFileSync3(path, "utf-8");
+}
+function domainReqsFromText(text, platformRel) {
+  const validated = parseDomainText(text, platformRel);
+  if (!validated.ok)
+    return { reqs: [], diagnostics: validated.diagnostics };
+  return { reqs: validated.data.requirements, diagnostics: [] };
 }
 async function collectChangeReqs(canonicalDir) {
   const reqs = [];
   const relPathById = new Map;
   for (const rel of await findDomainJsonFiles(canonicalDir)) {
     const platformRel = `${CANONICAL_SPECS_DIR}/${rel}`;
-    const text = await Bun.file(join9(canonicalDir, rel)).text();
+    const text = await Bun.file(join11(canonicalDir, rel)).text();
     const parsed = domainReqsFromText(text, platformRel);
     for (const r of parsed.reqs) {
       reqs.push(r);
@@ -4981,7 +5432,7 @@ async function collectChangeReqs(canonicalDir) {
   }
   return { reqs, relPathById };
 }
-function collectBaseReqs(platformDir, ref, diagnostics2) {
+function collectBaseReqs2(platformDir, ref, diagnostics2) {
   const reqs = [];
   const relPathById = new Map;
   for (const path of gitLsTree(platformDir, ref, CANONICAL_SPECS_DIR)) {
@@ -5013,8 +5464,8 @@ async function ingestResults(storage2, resultsPath, diagnostics2) {
 }
 async function governanceGate(input, ref, diagnostics2, results) {
   const { platformDir } = input;
-  const change = await collectChangeReqs(join9(platformDir, CANONICAL_SPECS_DIR));
-  const base = collectBaseReqs(platformDir, ref, diagnostics2);
+  const change = await collectChangeReqs(join11(platformDir, CANONICAL_SPECS_DIR));
+  const base = collectBaseReqs2(platformDir, ref, diagnostics2);
   diagnostics2.push(...requirementRemoved(base.reqs, change.reqs, (id) => base.relPathById.get(id) ?? null));
   const codeowners = parseCodeowners(readCodeownersText(platformDir) ?? "");
   const approvedBy = (input.approvedBy ?? "").split(",").map((s) => s.trim()).filter(Boolean);
@@ -5023,12 +5474,33 @@ async function governanceGate(input, ref, diagnostics2, results) {
     diagnostics2.push(...partialPropagation(changedRules(base.reqs, change.reqs), results.verifyingTags, results.resultsParsed, (id) => change.relPathById.get(id) ?? null));
   }
 }
+async function lossDiagnostics(storage2, platformDir, ref) {
+  const { losses } = await guard(storage2, platformDir, ref);
+  const rows = [];
+  for (const loss of losses) {
+    if (loss.kind === "REQUIREMENT_REMOVED")
+      continue;
+    rows.push({
+      code: loss.kind,
+      severity: LOSS_SEVERITY[loss.kind],
+      repo: null,
+      source_file: loss.file === "" ? null : loss.file,
+      line: loss.line,
+      req_id: loss.req_id,
+      detail: loss.detail
+    });
+  }
+  return rows;
+}
 async function check(input, storage2) {
   const { platformDir } = input;
   if (input.base && !gitRefResolves(platformDir, input.base)) {
     return fail("usage", `--base ref '${input.base}' does not resolve in ${platformDir} ` + "(not a git repo, or the ref is unfetched/misspelled) \u2014 refusing to run the governance gate fail-open");
   }
   const result = await runIndex({ platformDir, storage: storage2 });
+  const checkConfig2 = readCheckConfig(platformDir);
+  if (!checkConfig2.ok)
+    return fail("usage", checkConfig2.detail);
   const diagnostics2 = collectDiagnostics(storage2);
   if (input.unsourcedChange) {
     const superseded = storage2.listRequirements({ status: "Superseded" });
@@ -5043,20 +5515,24 @@ async function check(input, storage2) {
   const results = await ingestResults(storage2, input.resultsPath, diagnostics2);
   if (input.base) {
     await governanceGate(input, input.base, diagnostics2, results);
+    diagnostics2.push(...await lossDiagnostics(storage2, platformDir, input.base));
   } else if (gitRefResolves(platformDir, "HEAD")) {
-    const change = await collectChangeReqs(join9(platformDir, CANONICAL_SPECS_DIR));
+    const change = await collectChangeReqs(join11(platformDir, CANONICAL_SPECS_DIR));
     const baseParseSink = [];
-    const base = collectBaseReqs(platformDir, "HEAD", baseParseSink);
+    const base = collectBaseReqs2(platformDir, "HEAD", baseParseSink);
     diagnostics2.push(...requirementRemoved(base.reqs, change.reqs, (id) => base.relPathById.get(id) ?? null));
+    diagnostics2.push(...await lossDiagnostics(storage2, platformDir, "HEAD"));
   }
+  const graded = applySeverity(diagnostics2, checkConfig2.config.severity);
   return {
     ok: true,
-    diagnostics: diagnostics2,
+    diagnostics: graded,
     buildId: result.build_id,
-    failing: diagnostics2.some((d) => d.severity === "error"),
+    failing: graded.some((d) => d.severity === "error"),
     proofsUnconfirmed: !input.resultsPath
   };
 }
+var LOSS_SEVERITY;
 var init_check = __esm(() => {
   init_src();
   init_filerefs2();
@@ -5064,6 +5540,7 @@ var init_check = __esm(() => {
   init_propagation_teeth();
   init_proven();
   init_removed();
+  init_severity();
   init_sqlDiagnostics();
   init_statusflip();
   init_supersedes();
@@ -5074,6 +5551,12 @@ var init_check = __esm(() => {
   init_fs();
   init__result();
   init_glossary();
+  init_guard();
+  LOSS_SEVERITY = {
+    IMPL_LOST: "error",
+    SPEC_FILE_DELETED: "error",
+    VERIFY_LOST: "warning"
+  };
 });
 
 // src/commands/check.ts
@@ -5123,17 +5606,17 @@ var init_check2 = __esm(() => {
       out: outArg,
       ci: {
         type: "boolean",
-        description: "Force cold rebuild: rm db+wal+shm BEFORE indexing (CHCK-01)"
+        description: "Force cold rebuild: rm db+wal+shm BEFORE indexing"
       },
       json: jsonArg,
       noPrompt: noPromptArg,
       unsourcedChange: {
         type: "boolean",
-        description: "Opt-in: emit warning-severity UNSOURCED_CHANGE for Superseded requirements lacking a supersedes-via issue (OFF by default; USRC-02)"
+        description: "Opt-in: emit warning-severity UNSOURCED_CHANGE for Superseded requirements lacking a supersedes-via issue (OFF by default)"
       },
       results: {
         type: "string",
-        description: "Ingest a JUnit XML results file; enforce the trusted-red PROVEN gate (GATE-01)"
+        description: "Ingest a JUnit XML results file; enforce the trusted-red PROVEN gate"
       },
       base: {
         type: "string",
@@ -5184,6 +5667,7 @@ var init_check2 = __esm(() => {
           return result;
         });
       } catch (e) {
+        handleInvalidDomainFiles(e, jsonMode);
         exitAfterCrash(e);
       }
       if (outcome === undefined) {
@@ -5207,8 +5691,8 @@ var init_check2 = __esm(() => {
 });
 
 // src/operations/domain.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync4 } from "fs";
-import { dirname as dirname6, join as join10, resolve as resolve9 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname6, join as join12, resolve as resolve9 } from "path";
 function definedFields(options) {
   const out = {};
   if (options.scope !== undefined)
@@ -5228,9 +5712,9 @@ async function newDomain(platformDir, key, options = {}) {
   if (!(resolvedDest === resolvedRoot || resolvedDest.startsWith(`${resolvedRoot}/`))) {
     return fail("usage", `refusing to write outside platformDir (${resolvedDest})`);
   }
-  if (existsSync11(dest))
+  if (existsSync12(dest))
     return fail("conflict", `refusing to overwrite ${dest}`);
-  if (existsSync11(join10(dirname6(dest), "SPEC.md"))) {
+  if (existsSync12(join12(dirname6(dest), "SPEC.md"))) {
     return fail("conflict", `refusing to create ${dest}: domain ${key} already exists as spec-engine/${key}/SPEC.md ` + "\u2014 migrate the SPEC.md first (a fresh empty SPEC.json would shadow it on the next index)");
   }
   mkdirSync4(dirname6(dest), { recursive: true });
@@ -5247,10 +5731,34 @@ async function newDomain(platformDir, key, options = {}) {
 async function listDomains(platformDir) {
   return { ok: true, domains: await domainsWithScope(platformDir) };
 }
+async function setDomainGrammar(platformDir, key, options) {
+  if (options.grammar === undefined && options.grammarSeverity === undefined) {
+    return fail("usage", "pass --grammar, --severity, or both");
+  }
+  const file = await readEnvelope(platformDir, key);
+  if (!file.ok)
+    return file;
+  const domain2 = { ...file.domain, ...definedFields(options) };
+  const res = await validateAndWrite(file.specPath, domain2, file.relFile);
+  if (!res.ok) {
+    return fail("invalid_domain_file", res.diagnostics.map((d) => d.detail).join(`
+`), {
+      diagnostics: res.diagnostics
+    });
+  }
+  return {
+    ok: true,
+    key,
+    grammar: domain2.grammar,
+    grammarSeverity: domain2.grammarSeverity,
+    file: file.relFile
+  };
+}
 var init_domain2 = __esm(() => {
   init_src();
   init_domains();
   init_constants();
+  init__envelope();
   init__result();
 });
 
@@ -5259,6 +5767,7 @@ var exports_domain = {};
 __export(exports_domain, {
   domainNewCommand: () => domainNewCommand,
   domainListCommand: () => domainListCommand,
+  domainGrammarCommand: () => domainGrammarCommand,
   domainCommand: () => domainCommand
 });
 import { defineCommand as defineCommand4 } from "citty";
@@ -5269,7 +5778,15 @@ function exitOnNewFailure(failure) {
   }
   exitOnFailure("spec domain new", failure);
 }
-var domainNewCommand, domainListCommand, domainCommand;
+function enumFlag(flag, value, allowed) {
+  if (value === undefined)
+    return;
+  if (allowed.includes(value))
+    return value;
+  console.error(`spec domain grammar: --${flag} must be one of ${allowed.join(", ")}`);
+  process.exit(EXIT.USAGE);
+}
+var domainNewCommand, domainListCommand, GRAMMARS, SEVERITIES, domainGrammarCommand, domainCommand;
 var init_domain3 = __esm(() => {
   init_domains();
   init_constants();
@@ -5337,6 +5854,55 @@ var init_domain3 = __esm(() => {
       }
     }
   });
+  GRAMMARS = ["ears", "freeform"];
+  SEVERITIES = ["warning", "error"];
+  domainGrammarCommand = defineCommand4({
+    meta: {
+      name: "grammar",
+      description: "Set a domain's statement grammar and its severity"
+    },
+    args: {
+      name: {
+        type: "positional",
+        required: true,
+        description: "Domain key (case-insensitive)"
+      },
+      platformDir: platformDirArg,
+      grammar: {
+        type: "string",
+        description: "ears | freeform"
+      },
+      severity: {
+        type: "string",
+        description: "warning | error \u2014 how STATEMENT_GRAMMAR and write-time judging treat a miss"
+      },
+      json: {
+        type: "boolean",
+        description: "Print { key, grammar, grammar_severity, file }"
+      }
+    },
+    async run({ args }) {
+      const platformDir = resolvePlatformDir(args);
+      const grammar = enumFlag("grammar", args.grammar, GRAMMARS);
+      const grammarSeverity = enumFlag("severity", args.severity, SEVERITIES);
+      const result = await setDomainGrammar(platformDir, normalizeDomainKey(args.name), {
+        grammar,
+        grammarSeverity
+      });
+      if (!result.ok)
+        exitOnFailure("spec domain grammar", result);
+      if (args.json) {
+        console.log(JSON.stringify({
+          key: result.key,
+          grammar: result.grammar ?? null,
+          grammar_severity: result.grammarSeverity ?? null,
+          file: result.file
+        }));
+        return;
+      }
+      console.log(`${result.file}: grammar ${result.grammar ?? "freeform"}, severity ${result.grammarSeverity ?? "warning"}`);
+    }
+  });
   domainCommand = defineCommand4({
     meta: {
       name: "domain",
@@ -5344,7 +5910,8 @@ var init_domain3 = __esm(() => {
     },
     subCommands: {
       new: domainNewCommand,
-      list: domainListCommand
+      list: domainListCommand,
+      grammar: domainGrammarCommand
     }
   });
 });
@@ -5528,7 +6095,7 @@ var init_map = __esm(() => {
           noPrompt: args.noPrompt
         }
       });
-      await withReadStorage({ platformDir, dbPath, fresh: !!args.fresh }, (storage2) => {
+      await withReadStorage({ platformDir, dbPath, fresh: !!args.fresh, json: !!args.json }, (storage2) => {
         const { rows } = coverageMatrix(storage2);
         if (!args.json && rows.length === 0) {
           console.error(formatNoRequirementsIndexed(platformDir));
@@ -5641,7 +6208,7 @@ var init_get = __esm(() => {
         platformDir,
         args: { noPrompt: args.noPrompt }
       });
-      await withReadStorage({ platformDir, dbPath, fresh: !!args.fresh }, (storage2) => {
+      await withReadStorage({ platformDir, dbPath, fresh: !!args.fresh, json: !!args.json }, (storage2) => {
         const result = getRecord(storage2, reqId);
         if (result.row === null) {
           console.error(result.platformEmpty ? formatNoRequirementsIndexed(platformDir) : `spec get: no requirement ${reqId} in the index under ${platformDir} (check the id, or re-run with --fresh after editing specs)`);
@@ -5715,7 +6282,7 @@ var init_list = __esm(() => {
         platformDir,
         args: { noPrompt: args.noPrompt }
       });
-      await withReadStorage({ platformDir, dbPath, fresh: !!args.fresh }, (storage2) => {
+      await withReadStorage({ platformDir, dbPath, fresh: !!args.fresh, json: !!args.json }, (storage2) => {
         const result = listRecords(storage2, filter);
         if (!args.json && result.rows.length === 0) {
           console.error(result.platformEmpty ? formatNoRequirementsIndexed(platformDir) : `spec list: no requirements match under ${platformDir}`);
@@ -5792,7 +6359,7 @@ var init_propagation2 = __esm(() => {
         platformDir,
         args: { noPrompt: args.noPrompt }
       });
-      await withReadStorage({ platformDir, dbPath, fresh: !!args.fresh }, (storage2) => {
+      await withReadStorage({ platformDir, dbPath, fresh: !!args.fresh, json: !!args.json }, (storage2) => {
         const result = propagation2(storage2, reqId);
         if (!args.json && result.platformEmpty) {
           console.error(formatNoRequirementsIndexed(platformDir));
@@ -5915,7 +6482,7 @@ var init_query = __esm(() => {
         platformDir,
         args: { noPrompt: args.noPrompt }
       });
-      await withReadStorage({ platformDir, dbPath, fresh: !!args.fresh }, (storage2) => {
+      await withReadStorage({ platformDir, dbPath, fresh: !!args.fresh, json: !!args.json }, (storage2) => {
         const result = query(storage2, text, limit);
         if (!result.ok) {
           console.error(`spec query: ${result.detail}`);
@@ -6037,7 +6604,7 @@ var init_relations = __esm(() => {
           noPrompt: args.noPrompt
         }
       });
-      await withReadStorage({ platformDir, dbPath, fresh: !!args.fresh }, (storage2) => {
+      await withReadStorage({ platformDir, dbPath, fresh: !!args.fresh, json: !!args.json }, (storage2) => {
         const { rows } = relations(storage2);
         if (!args.json && rows.length === 0) {
           console.error(formatNoRelations(platformDir));
@@ -6162,7 +6729,7 @@ var init_adapter = () => {};
 
 // ../tracker/src/cache.ts
 import { mkdirSync as mkdirSync5 } from "fs";
-import { dirname as dirname7, join as join11 } from "path";
+import { dirname as dirname7, join as join13 } from "path";
 function isFresh(entry, now, ttlMs = CACHE_TTL_MS) {
   const t = Date.parse(entry.fetched_at);
   if (Number.isNaN(t))
@@ -6176,7 +6743,7 @@ function isValidEntry(e) {
   return typeof r.title === "string" && typeof r.status === "string" && typeof r.url === "string" && typeof r.fetched_at === "string";
 }
 function sidecarPath(platformDir) {
-  return join11(platformDir, ".spec-engine", SIDECAR_FILE);
+  return join13(platformDir, ".spec-engine", SIDECAR_FILE);
 }
 async function readCache(platformDir) {
   try {
@@ -6443,7 +7010,7 @@ var init_provenance = __esm(() => {
           noPrompt: args.noPrompt
         }
       });
-      await withReadStorage({ platformDir, dbPath, fresh: !!args.fresh }, async (storage2) => {
+      await withReadStorage({ platformDir, dbPath, fresh: !!args.fresh, json: !!args.json }, async (storage2) => {
         const { rows } = provenance(storage2, issueId || undefined);
         if (!args.json && rows.length === 0) {
           console.error(issueId ? formatNoProvenanceForIssue(issueId, platformDir) : formatNoProvenance(platformDir));
@@ -6507,6 +7074,7 @@ async function mintFromFlags(platformDir, key, textFlag, args, rawArgs) {
     statement,
     why: (args.why ?? "").trim(),
     livesIn: listFlag(rawArgs, "lives", args.lives) ?? [],
+    relates: listFlag(rawArgs, "relates", args.relates) ?? [],
     issue: (args.issue ?? "").trim() || undefined,
     status: statusOf(args),
     json: Boolean(args.json)
@@ -6585,6 +7153,7 @@ var init_req = __esm(() => {
     },
     why: { type: "string", description: "Why it matters field (only with --text)" },
     lives: livesArg,
+    relates: relatesArg,
     issue: {
       type: "string",
       description: "Originating ticket id, recorded as created-provenance on the entry (only with --text; opaque \u2014 never a requirement id)"
@@ -6617,9 +7186,9 @@ var init_req = __esm(() => {
         await mintFromFlags(platformDir, key, textFlag, args, rawArgs);
         return;
       }
-      const hasFieldFlags = typeof args.why === "string" || typeof args.lives === "string" || typeof args.issue === "string";
+      const hasFieldFlags = typeof args.why === "string" || typeof args.lives === "string" || typeof args.relates === "string" || typeof args.issue === "string";
       if (hasFieldFlags) {
-        console.error("spec req: --why/--lives/--issue require --text (the Requirement field is mandatory)");
+        console.error("spec req: --why/--lives/--relates/--issue require --text (the Requirement field is mandatory)");
         process.exit(EXIT.USAGE);
         return;
       }
@@ -6755,6 +7324,9 @@ async function confirmTermCommand(opts) {
     exitOnFailure("spec term confirm", result);
   await withIndex({ platformDir, build: "fresh" }, () => {
     return;
+  }).catch((e) => {
+    handleInvalidDomainFiles(e, false, EXIT.USAGE);
+    throw e;
   });
   const { pinned, file } = result;
   if (opts.json) {
@@ -7027,14 +7599,18 @@ async function supersedeTarget(platformDir, id) {
   return located;
 }
 function successorFields(input, req) {
-  const predLives = (req.livesIn[0] ?? "").trim();
-  const why = (input.why ?? req.why ?? "").trim();
-  const livesIn = input.livesIn ?? (predLives === "" ? [] : [predLives]);
-  return { why, livesIn };
+  return {
+    why: (input.why ?? req.why ?? "").trim(),
+    livesIn: input.livesIn ?? [...req.livesIn],
+    relates: input.relates === undefined ? [...req.relates] : splitList(input.relates)
+  };
 }
-function successorTermFields(input, req) {
-  const term = (input.term ?? req.term)?.trim() || req.term;
-  return { term, aliases: input.aliases ?? req.aliases };
+function applyTermOverrides(successor, input) {
+  const term = input.term?.trim();
+  if (term)
+    successor.term = term;
+  if (input.aliases !== undefined)
+    successor.aliases = input.aliases;
 }
 function flipPredecessor(req, newId, issue) {
   req.status = "superseded";
@@ -7070,18 +7646,19 @@ async function supersede(input, freshTags) {
     }
     warnings.push({ kind: "grammar", text: grammarWarningText("", verdict).slice(2) });
   }
-  const { why, livesIn } = successorFields(input, req);
+  const { why, livesIn, relates } = successorFields(input, req);
   warnings.push(...unresolvableRefWarnings(platformDir, [input.statement, why, ...livesIn]));
   const newId = await nextRequirementId(platformDir, key);
   const issue = input.issue?.trim() || undefined;
+  const successor = successorEntry(newId, req, {
+    statement: input.statement,
+    why,
+    livesIn,
+    relates,
+    issue
+  });
+  applyTermOverrides(successor, input);
   flipPredecessor(req, newId, issue);
-  const successor = successorEntry(newId, { statement: input.statement, why, livesIn, issue });
-  if (key === "TERM") {
-    const termFields = successorTermFields(input, req);
-    if (termFields.term !== undefined)
-      successor.term = termFields.term;
-    successor.aliases = termFields.aliases;
-  }
   requirements.push(successor);
   const specVersion = applyVersionStage(domain2, req, successor, Boolean(input.noBump));
   domain2.updated = localToday();
@@ -7190,6 +7767,9 @@ function inputFromArgs(args, rawArgs, platformDir, id, statement) {
   const livesIn = listFlag(rawArgs, "lives", args.lives);
   if (livesIn !== undefined)
     input.livesIn = livesIn;
+  const relates = listFlag(rawArgs, "relates", args.relates);
+  if (relates !== undefined)
+    input.relates = relates;
   if (typeof args.term === "string")
     input.term = args.term;
   if (typeof args.aliases === "string")
@@ -7203,7 +7783,6 @@ var supersedeArgs, supersedeCommand;
 var init_supersede2 = __esm(() => {
   init_constants();
   init_discover();
-  init__index();
   init_supersede();
   init_grammar3();
   init__args();
@@ -7228,6 +7807,10 @@ var init_supersede2 = __esm(() => {
       type: "string",
       description: "Successor's Lives in: repeat or comma-separate; empty clears (default: copied from the old entry)"
     },
+    relates: {
+      type: "string",
+      description: "Successor's related ids: repeat or comma-separate; empty clears (default: copied from the old entry)"
+    },
     term: {
       type: "string",
       description: "TERM successor's headword (default: copied from the old entry; TERM ids only)"
@@ -7268,7 +7851,7 @@ var init_supersede2 = __esm(() => {
         handleNotAPlatform(e);
       }
       const statement = await resolveSuccessorText(args, platformDir, id);
-      const result = await supersede(inputFromArgs(args, rawArgs, platformDir, id, statement), coldFreshTags(platformDir));
+      const result = await supersede(inputFromArgs(args, rawArgs, platformDir, id, statement), cliFreshTags(platformDir));
       if (!result.ok)
         exitOnFailure("spec supersede", result);
       printWarnings("spec supersede", result.warnings);
@@ -7335,7 +7918,6 @@ var deprecateCommand;
 var init_deprecate2 = __esm(() => {
   init_constants();
   init_discover();
-  init__index();
   init_deprecate();
   init_grammar3();
   init__args();
@@ -7378,7 +7960,7 @@ var init_deprecate2 = __esm(() => {
       } catch (e) {
         handleNotAPlatform(e);
       }
-      const result = await deprecate({ platformDir, id, reason }, coldFreshTags(platformDir));
+      const result = await deprecate({ platformDir, id, reason }, cliFreshTags(platformDir));
       if (!result.ok)
         exitOnFailure("spec deprecate", result);
       const { file, sites } = result;
@@ -7397,30 +7979,28 @@ var init_deprecate2 = __esm(() => {
 
 // src/operations/move.ts
 async function locateMove(platformDir, id, targetKey) {
-  const sourceKey = domainKeyOf(id);
-  if (sourceKey === targetKey) {
+  const prefixKey = domainKeyOf(id);
+  const located = await locateEntry(platformDir, id, `no domain ${prefixKey} (expected spec-engine/${prefixKey}/SPEC.json)`);
+  if (!located.ok)
+    return located;
+  const { req, ...source } = located;
+  if (source.key === targetKey) {
     return fail("usage", `${id} is already in ${targetKey} \u2014 use spec supersede for an in-domain revision`);
   }
-  const source = await readEnvelope(platformDir, sourceKey, `no domain ${sourceKey} (expected spec-engine/${sourceKey}/SPEC.json)`);
-  if (!source.ok)
-    return source;
   const target = await readEnvelope(platformDir, targetKey, `no target domain ${targetKey} \u2014 run \`spec domain new ${targetKey}\` first`);
   if (!target.ok)
     return target;
-  const req = source.requirements.find((r) => r.id === id);
-  if (req === undefined)
-    return fail("not_found", `no entry ${id} in ${source.relFile}`);
   if (req.status.toLowerCase() !== "active") {
     return fail("conflict", `${id} is ${req.status} \u2014 only Active requirements move (superseded/retired entries stay as history)`);
   }
   return { ok: true, source, target, req };
 }
 function successorFields2(input, req) {
-  const srcLives = (req.livesIn[0] ?? "").trim();
   return {
     statement: (input.statement ?? req.statement).trim(),
     why: (input.why ?? req.why ?? "").trim(),
-    livesIn: input.livesIn ?? (srcLives === "" ? [] : [srcLives])
+    livesIn: input.livesIn ?? [...req.livesIn],
+    relates: [...req.relates]
   };
 }
 function versionSide(domain2, key, noBump) {
@@ -7469,7 +8049,7 @@ async function move(input, freshTags) {
   const sourceCurrent = source.domain.specVersion ?? 1;
   req.status = "superseded";
   req.supersededBy = newId;
-  target.requirements.push(successorEntry(newId, fields));
+  target.requirements.push(successorEntry(newId, req, fields));
   const noBump = Boolean(input.noBump);
   const sourceSpecVersion = versionSide(source.domain, source.key, noBump);
   const targetSpecVersion = versionSide(target.domain, target.key, noBump);
@@ -7530,7 +8110,6 @@ var init_move2 = __esm(() => {
   init_domains();
   init_constants();
   init_discover();
-  init__index();
   init_move();
   init_grammar3();
   init__args();
@@ -7592,7 +8171,7 @@ var init_move2 = __esm(() => {
       } catch (e) {
         handleNotAPlatform(e);
       }
-      const result = await move(inputFromArgs2(args, rawArgs, platformDir, id, targetKey), coldFreshTags(platformDir));
+      const result = await move(inputFromArgs2(args, rawArgs, platformDir, id, targetKey), cliFreshTags(platformDir));
       if (!result.ok)
         exitOnFailure("spec move", result);
       printWarnings("spec move", result.warnings);
@@ -7626,18 +8205,30 @@ var init_move2 = __esm(() => {
 });
 
 // src/operations/amend.ts
-async function gateRejection(id, req, freshTags) {
+function releaseHolding(platformDir, relFile, id) {
+  const tag = newestReleaseTag(platformDir);
+  if (tag === null)
+    return null;
+  const text = gitShow(platformDir, tag, relFile);
+  if (text === null)
+    return null;
+  const parsed = parseDomainText(text, relFile);
+  return parsed.ok && parsed.data.requirements.some((r) => r.id === id) ? tag : null;
+}
+function gateRejection(platformDir, relFile, req, fields) {
+  const { id } = req;
   const statusLc = req.status.toLowerCase();
   if (statusLc !== "active" && statusLc !== "draft") {
     return fail("conflict", `${id} is ${displayStatus(req.status)} \u2014 only Active/Draft entries amend (a superseded entry is history; supersede its successor instead)`);
   }
   if (statusLc !== "active")
     return null;
-  const bound = (await freshTags(id)).filter((t) => t.kind === "implements" || t.kind === "verifies");
-  const site = bound[0];
-  if (site === undefined)
+  if (!PROMISE_FIELDS.some((f) => fields[f] !== undefined))
+    return null;
+  const tag = releaseHolding(platformDir, relFile, id);
+  if (tag === null)
     return null;
-  return fail("conflict", `${id} is shipped \u2014 ${bound.length} code tag(s) bind it (e.g. ${site.file}:${site.line}). ` + "A bound requirement is immutable; supersede it with a successor instead of amending in place.");
+  return fail("conflict", `${id} is released in ${tag} \u2014 its promise is immutable. ` + `Run \`spec supersede ${id}\` to change the statement or why; ` + "pass only --lives or --relates to amend its metadata in place.");
 }
 function applyFields(req, fields) {
   const fieldsChanged = [];
@@ -7657,6 +8248,10 @@ function applyFields(req, fields) {
     fieldsChanged.push("lives");
     refValues.push(...fields.livesIn);
   }
+  if (fields.relates !== undefined) {
+    req.relates = splitList(fields.relates);
+    fieldsChanged.push("relates");
+  }
   if (fields.term !== undefined) {
     req.term = fields.term;
     fieldsChanged.push("term");
@@ -7672,18 +8267,17 @@ function applyFields(req, fields) {
   }
   return { fieldsChanged, refValues };
 }
-async function amend(input, freshTags) {
+async function amend(input) {
   const { platformDir, id, fields } = input;
   const located = await locateEntry(platformDir, id);
   if (!located.ok)
     return located;
-  const { specPath, relFile, domain: domain2, req } = located;
-  const rejection = await gateRejection(id, req, freshTags);
+  const { key, specPath, relFile, domain: domain2, req } = located;
+  const rejection = gateRejection(platformDir, relFile, req, fields);
   if (rejection !== null)
     return rejection;
   const warnings = [];
   if (fields.statement !== undefined) {
-    const key = domainKeyOf(id);
     const verdict = await judgeStatementGrammar(platformDir, key, fields.statement);
     if (!verdict.ok) {
       if (verdict.severity === "error") {
@@ -7705,12 +8299,14 @@ async function amend(input, freshTags) {
   }
   return { ok: true, id, file: relFile, fieldsChanged: [...fieldsChanged].sort(), warnings };
 }
+var PROMISE_FIELDS;
 var init_amend = __esm(() => {
   init_src();
   init_grammar2();
   init__envelope();
   init__result();
   init_mint();
+  PROMISE_FIELDS = ["statement", "why", "term", "aliases"];
 });
 
 // src/commands/amend.ts
@@ -7721,9 +8317,9 @@ __export(exports_amend, {
 import { defineCommand as defineCommand18 } from "citty";
 function assertAmendFlags(args) {
   const hasIssue = args.issue !== undefined && args.issue.trim() !== "";
-  const hasField = args.text !== undefined || args.why !== undefined || args.lives !== undefined || args.term !== undefined || args.aliases !== undefined;
+  const hasField = args.text !== undefined || args.why !== undefined || args.lives !== undefined || args.relates !== undefined || args.term !== undefined || args.aliases !== undefined;
   if (!hasField && !hasIssue) {
-    console.error("spec amend: nothing to amend \u2014 pass at least one of --text / --why / --lives / --term / --aliases");
+    console.error("spec amend: nothing to amend \u2014 pass at least one of --text / --why / --lives / --relates / --term / --aliases");
     process.exit(EXIT.USAGE);
   }
   if (args.text !== undefined && args.text.trim() === "") {
@@ -7750,6 +8346,9 @@ function fieldsFromArgs(args, rawArgs) {
   const livesIn = listFlag(rawArgs, "lives", args.lives);
   if (livesIn !== undefined)
     fields.livesIn = livesIn;
+  const relates = listFlag(rawArgs, "relates", args.relates);
+  if (relates !== undefined)
+    fields.relates = relates;
   if (args.term !== undefined)
     fields.term = args.term.trim();
   if (args.issue !== undefined && args.issue.trim() !== "")
@@ -7762,7 +8361,6 @@ var amendArgs, amendCommand;
 var init_amend2 = __esm(() => {
   init_constants();
   init_discover();
-  init__index();
   init_amend();
   init_grammar3();
   init__args();
@@ -7777,6 +8375,7 @@ var init_amend2 = __esm(() => {
     text: { type: "string", description: "New Requirement (statement) field value" },
     why: { type: "string", description: "New Why it matters field value" },
     lives: livesArg,
+    relates: relatesArg,
     issue: {
       type: "string",
       description: "Ticket that motivated this amendment \u2014 recorded as amends-via provenance (opaque, never a requirement id)"
@@ -7791,7 +8390,7 @@ var init_amend2 = __esm(() => {
   amendCommand = defineCommand18({
     meta: {
       name: "amend",
-      description: "Revise an unshipped requirement's fields in place (same id, no specVersion bump). Supersede shipped truth instead."
+      description: "Revise a requirement's fields in place (same id, no version bump). A released requirement's statement and why are superseded instead; --lives and --relates still amend."
     },
     args: amendArgs,
     async run({ args, rawArgs }) {
@@ -7808,7 +8407,7 @@ var init_amend2 = __esm(() => {
         handleNotAPlatform(e);
       }
       const fields = fieldsFromArgs(args, rawArgs);
-      const result = await amend({ platformDir, id, fields }, coldFreshTags(platformDir));
+      const result = await amend({ platformDir, id, fields });
       if (!result.ok)
         exitOnFailure("spec amend", result);
       printWarnings("spec amend", result.warnings);
@@ -7930,13 +8529,27 @@ Target domain: ${opts.domain} (no charter/scope recorded \u2014 check placement
 
 // src/server/mcp.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 function jsonResult(value) {
   return { content: [{ type: "text", text: JSON.stringify(value) }] };
 }
 function errorResult(message) {
   return { content: [{ type: "text", text: message }], isError: true };
 }
+function amendFieldsOf(args) {
+  const fields = {};
+  if (args.text !== undefined)
+    fields.statement = args.text;
+  if (args.why !== undefined)
+    fields.why = args.why || null;
+  if (args.lives !== undefined)
+    fields.livesIn = args.lives;
+  if (args.relates !== undefined)
+    fields.relates = args.relates;
+  if (args.issue)
+    fields.issue = args.issue;
+  return fields;
+}
 function buildMcpServer(platformDir) {
   const server = new McpServer({ name: "spec", version: package_default.version });
   const fresh = (fn) => withIndex({ platformDir, build: "fresh" }, (h) => fn(h.storage));
@@ -7944,8 +8557,8 @@ function buildMcpServer(platformDir) {
     title: "Full-text requirement retrieval",
     description: "Search requirements by full text (SQLite FTS5 MATCH syntax; wrap phrases in double quotes). Returns ranked hits \u2014 use this to load the requirements a task touches instead of re-asking the user.",
     inputSchema: {
-      text: z3.string().min(1).describe("FTS5 query text"),
-      limit: z3.number().int().min(1).max(LIMIT_MAX).optional().describe(`Max hits (default ${DEFAULT_QUERY_LIMIT})`)
+      text: z4.string().min(1).describe("FTS5 query text"),
+      limit: z4.number().int().min(1).max(LIMIT_MAX).optional().describe(`Max hits (default ${DEFAULT_QUERY_LIMIT})`)
     }
   }, async ({ text, limit }) => fresh((s) => {
     const r = query(s, text, limit ?? DEFAULT_QUERY_LIMIT);
@@ -7955,13 +8568,13 @@ function buildMcpServer(platformDir) {
     title: "Files \u2192 requirements",
     description: "The requirements tagged in the given files (platform-relative paths, e.g. api/src/renew.ts). Load these before changing the files.",
     inputSchema: {
-      files: z3.array(z3.string().min(1)).min(1).max(100).describe("Platform-relative file paths")
+      files: z4.array(z4.string().min(1)).min(1).max(100).describe("Platform-relative file paths")
     }
   }, async ({ files }) => fresh((s) => jsonResult(resolveFiles(s, files).rows)));
   server.registerTool("spec_req_tags", {
     title: "Requirement \u2192 tag sites (reverse query)",
     description: "Every code/test/doc site tagging the given requirement, across all repos \u2014 impact analysis and retag worklists.",
-    inputSchema: { req_id: z3.string().describe("Requirement id (KEY-NNN)") }
+    inputSchema: { req_id: z4.string().describe("Requirement id (KEY-NNN)") }
   }, async ({ req_id }) => {
     if (!ID_RE.test(req_id)) {
       return errorResult(`req_id must be a requirement id (KEY-NNN); got ${req_id}`);
@@ -7984,7 +8597,7 @@ function buildMcpServer(platformDir) {
   server.registerTool("spec_propagation", {
     title: "Cross-repo propagation for a superseded requirement",
     description: "Per member repo: migrated to the successor (verified or not), still on the predecessor, or unrelated \u2014 plus the drift flag.",
-    inputSchema: { req_id: z3.string().describe("Requirement id (KEY-NNN)") }
+    inputSchema: { req_id: z4.string().describe("Requirement id (KEY-NNN)") }
   }, async ({ req_id }) => {
     if (!ID_RE.test(req_id)) {
       return errorResult(`req_id must be a requirement id (KEY-NNN); got ${req_id}`);
@@ -7994,7 +8607,7 @@ function buildMcpServer(platformDir) {
   server.registerTool("spec_next_id", {
     title: "Next unused requirement id",
     description: "Allocate-preview the next unused id in a domain (filesystem-derived; nothing is written). Use before authoring a new requirement.",
-    inputSchema: { domain: z3.string().min(1).describe("Domain key (e.g. BILLING)") }
+    inputSchema: { domain: z4.string().min(1).describe("Domain key (e.g. BILLING)") }
   }, async ({ domain: domain2 }) => {
     const r = await nextId(platformDir, domain2);
     return r.ok ? jsonResult({ domain: r.key, next_id: r.nextId }) : errorResult(r.detail);
@@ -8002,7 +8615,7 @@ function buildMcpServer(platformDir) {
   server.registerTool("spec_get", {
     title: "One requirement's full record",
     description: "The full record for one requirement id: status, key, seq, statement, why, versions, and source location. An unknown id returns [] (the `spec get --json` shape).",
-    inputSchema: { req_id: z3.string().describe("Requirement id (KEY-NNN)") }
+    inputSchema: { req_id: z4.string().describe("Requirement id (KEY-NNN)") }
   }, async ({ req_id }) => {
     if (!ID_RE.test(req_id)) {
       return errorResult(`req_id must be a requirement id (KEY-NNN); got ${req_id}`);
@@ -8016,8 +8629,8 @@ function buildMcpServer(platformDir) {
     title: "Every requirement record",
     description: "Every requirement record in (key, seq) order, superseded and deprecated history included. Optional domain and status filters. The `spec list --json` shape.",
     inputSchema: {
-      domain: z3.string().optional().describe("Only this domain key (e.g. BILLING)"),
-      status: z3.string().optional().describe(`Only this status: ${STATUS_WORDS.join(" | ")}`)
+      domain: z4.string().optional().describe("Only this domain key (e.g. BILLING)"),
+      status: z4.string().optional().describe(`Only this status: ${STATUS_WORDS.join(" | ")}`)
     }
   }, async ({ domain: domain2, status }) => {
     const filter = {};
@@ -8036,17 +8649,18 @@ function buildMcpServer(platformDir) {
     title: "Supersede a shipped requirement",
     description: "Flip an Active requirement to superseded, mint its successor in the same domain, and return the retag worklist (the tag sites spec check reports as SUPERSEDED_REFERENCED until retagged). The same JSON as `spec supersede --json`.",
     inputSchema: {
-      req_id: z3.string().describe("The Active requirement id to supersede (KEY-NNN)"),
-      statement: z3.string().min(1).describe("The successor's statement"),
-      why: z3.string().optional().describe("Successor's why (default: copied from the predecessor)"),
-      lives_in: z3.array(z3.string()).optional().describe("Successor's livesIn paths (default: copied from the predecessor)"),
-      issue: z3.string().optional().describe("Ticket recorded as supersedes-via on the predecessor and created on the successor")
-    }
-  }, async ({ req_id, statement, why, lives_in, issue }) => {
+      req_id: z4.string().describe("The Active requirement id to supersede (KEY-NNN)"),
+      statement: z4.string().min(1).describe("The successor's statement"),
+      why: z4.string().optional().describe("Successor's why (default: copied from the predecessor)"),
+      lives_in: z4.array(z4.string()).optional().describe("Successor's livesIn paths (default: copied from the predecessor)"),
+      relates: z4.array(z4.string()).optional().describe("Successor's related ids, each comma-split; an empty list clears (default: copied from the predecessor)"),
+      issue: z4.string().optional().describe("Ticket recorded as supersedes-via on the predecessor and created on the successor")
+    }
+  }, async ({ req_id, statement, why, lives_in, relates, issue }) => {
     if (!ID_RE.test(req_id)) {
       return errorResult(`req_id must be a requirement id (KEY-NNN); got ${req_id}`);
     }
-    const r = await supersede({ platformDir, id: req_id, statement, why, livesIn: lives_in, issue }, coldFreshTags(platformDir));
+    const r = await supersede({ platformDir, id: req_id, statement, why, livesIn: lives_in, relates, issue }, coldFreshTags(platformDir));
     if (!r.ok)
       return errorResult(r.detail);
     for (const w of r.warnings)
@@ -8063,8 +8677,8 @@ function buildMcpServer(platformDir) {
     title: "Deprecate a requirement",
     description: "Mark an Active or Draft requirement deprecated with a recorded reason and return the code tags still bound to it (each a DEPRECATED_REFERENCED error in spec check until removed). The same JSON as `spec deprecate --json`.",
     inputSchema: {
-      req_id: z3.string().describe("The requirement id to deprecate (KEY-NNN)"),
-      reason: z3.string().min(1).describe("Why the requirement ended; the durable record")
+      req_id: z4.string().describe("The requirement id to deprecate (KEY-NNN)"),
+      reason: z4.string().min(1).describe("Why the requirement ended; the durable record")
     }
   }, async ({ req_id, reason }) => {
     if (!ID_RE.test(req_id)) {
@@ -8080,21 +8694,109 @@ function buildMcpServer(platformDir) {
     title: "Accept a draft requirement",
     description: "Promote a Draft requirement to Active, leaving every other field untouched. The same JSON as `spec accept --json`.",
     inputSchema: {
-      req_id: z3.string().describe("The Draft requirement id to accept (KEY-NNN)")
+      req_id: z4.string().describe("The Draft requirement id to accept (KEY-NNN)")
+    }
+  }, async ({ req_id }) => {
+    if (!ID_RE.test(req_id)) {
+      return errorResult(`req_id must be a requirement id (KEY-NNN); got ${req_id}`);
+    }
+    const r = await accept({ platformDir, id: req_id });
+    return r.ok ? jsonResult({ id: r.id, file: r.file }) : errorResult(r.detail);
+  });
+  server.registerTool("spec_req", {
+    title: "Author a requirement",
+    description: "Append a new requirement to a domain (Active, or Draft with draft: true). The same JSON as `spec req --text \u2026 --json`: { id, file }, plus clauses when the statement parses as EARS.",
+    inputSchema: {
+      domain: z4.string().min(1).describe("Domain key or unique case-insensitive prefix"),
+      text: z4.string().trim().min(1).describe("The requirement statement"),
+      why: z4.string().trim().default("").describe("What breaks without it"),
+      lives: z4.array(z4.string()).default([]).describe("livesIn paths"),
+      relates: z4.array(z4.string()).default([]).describe("Related requirement ids, each comma-split"),
+      issue: z4.string().trim().optional().describe("Originating ticket, recorded as created"),
+      draft: z4.boolean().default(false).describe("Author as Draft instead of Active")
+    }
+  }, async ({ domain: domain2, text, why, lives, relates, issue, draft }) => {
+    const allocated = await nextId(platformDir, domain2);
+    if (!allocated.ok)
+      return errorResult(allocated.detail);
+    const r = await mint({
+      platformDir,
+      key: allocated.key,
+      statement: text,
+      why,
+      livesIn: lives,
+      relates,
+      issue: issue || undefined,
+      status: draft ? "draft" : "active"
+    });
+    if (!r.ok)
+      return errorResult(r.detail);
+    for (const w of r.warnings)
+      console.error(`spec_req: ${w.text}`);
+    return jsonResult(r.clauses ? { id: r.id, file: r.file, clauses: r.clauses } : { id: r.id, file: r.file });
+  });
+  server.registerTool("spec_amend", {
+    title: "Amend a requirement in place",
+    description: "Revise an Active or Draft requirement's fields in place (same id, no version change); a shipped requirement's statement and why are superseded instead. The same JSON as `spec amend --json`.",
+    inputSchema: {
+      id: z4.string().describe("The requirement id to amend (KEY-NNN)"),
+      text: z4.string().trim().min(1).optional().describe("New statement"),
+      why: z4.string().trim().optional().describe("New why; empty clears it"),
+      lives: z4.array(z4.string()).optional().describe("Replacement livesIn list; empty clears"),
+      relates: z4.array(z4.string()).optional().describe("Replacement related ids, each comma-split; empty clears"),
+      issue: z4.string().trim().optional().describe("Ticket recorded as amends-via")
+    }
+  }, async ({ id, text, why, lives, relates, issue }) => {
+    if (!ID_RE.test(id))
+      return errorResult(`id must be a requirement id (KEY-NNN); got ${id}`);
+    const fields = amendFieldsOf({ text, why, lives, relates, issue });
+    if (Object.keys(fields).length === 0) {
+      return errorResult("nothing to amend \u2014 pass at least one of text, why, lives, relates");
     }
-  }, async ({ req_id }) => {
-    if (!ID_RE.test(req_id)) {
-      return errorResult(`req_id must be a requirement id (KEY-NNN); got ${req_id}`);
+    const r = await amend({ platformDir, id, fields });
+    if (!r.ok)
+      return errorResult(r.detail);
+    for (const w of r.warnings)
+      console.error(`spec_amend: ${w.text}`);
+    return jsonResult({ id, file: r.file, fields_changed: r.fieldsChanged });
+  });
+  server.registerTool("spec_move", {
+    title: "Move a requirement to another domain",
+    description: "Mint the successor in newDomain carrying the source's fields, mark the source superseded, and return the retag worklist. The same JSON as `spec move --json`.",
+    inputSchema: {
+      id: z4.string().describe("The Active requirement id to move (KEY-NNN)"),
+      newDomain: z4.string().min(1).describe("The existing target domain key"),
+      text: z4.string().optional().describe("Successor statement (default: copied)"),
+      why: z4.string().optional().describe("Successor why (default: copied)"),
+      lives: z4.array(z4.string()).optional().describe("Successor livesIn list; empty clears (default: copied)")
     }
-    const r = await accept({ platformDir, id: req_id });
-    return r.ok ? jsonResult({ id: r.id, file: r.file }) : errorResult(r.detail);
+  }, async ({ id, newDomain: newDomain2, text, why, lives }) => {
+    if (!ID_RE.test(id))
+      return errorResult(`id must be a requirement id (KEY-NNN); got ${id}`);
+    const targetKey = normalizeDomainKey(newDomain2);
+    if (targetKey === "")
+      return errorResult(`newDomain must be a domain key; got ${newDomain2}`);
+    const r = await move({ platformDir, id, targetKey, statement: text, why, livesIn: lives }, coldFreshTags(platformDir));
+    if (!r.ok)
+      return errorResult(r.detail);
+    for (const w of r.warnings)
+      console.error(`spec_move: ${w.text}`);
+    return jsonResult({
+      old_id: r.oldId,
+      new_id: r.newId,
+      from_file: r.fromFile,
+      to_file: r.toFile,
+      source_spec_version: r.sourceSpecVersion,
+      target_spec_version: r.targetSpecVersion,
+      retag: r.retag
+    });
   });
   server.registerPrompt("author_requirements", {
     title: "Author requirements from a brief",
     description: "Turn a vague brief/ticket into well-formed Spec Engine requirements: one requirement per testable promise, placed by domain charter, deduped via spec query, drafted to the GUARD template + cold-read rubric, minted with spec req. The engine returns a static playbook template \u2014 your model runs it.",
     argsSchema: {
-      brief: z3.string().min(1).describe("The vague brief / ticket text to author from"),
-      domain: z3.string().optional().describe("Optional target domain KEY \u2014 its charter/scope is injected when given")
+      brief: z4.string().min(1).describe("The vague brief / ticket text to author from"),
+      domain: z4.string().optional().describe("Optional target domain KEY \u2014 its charter/scope is injected when given")
     }
   }, async ({ brief, domain: domain2 }) => {
     let resolvedDomain;
@@ -8125,8 +8827,11 @@ var init_mcp = __esm(() => {
   init_domains();
   init__index();
   init_accept();
+  init_amend();
   init_check();
   init_deprecate();
+  init_mint();
+  init_move();
   init_nextId();
   init_reads2();
   init_records();
@@ -8175,7 +8880,7 @@ __export(exports_resolve, {
   resolveCommand: () => resolveCommand
 });
 import { statSync as statSync5 } from "fs";
-import { join as join12, relative as relative2, resolve as resolve13, sep as sep3 } from "path";
+import { join as join14, relative as relative2, resolve as resolve13, sep as sep3 } from "path";
 import { defineCommand as defineCommand21 } from "citty";
 function classifyArg(a) {
   if (a.startsWith("--")) {
@@ -8214,7 +8919,7 @@ function splitFilesAndPlatformDir(positionals, fallbackPlatformDir) {
     const resolved = resolve13(last);
     if (statSync5(resolved).isDirectory()) {
       try {
-        if (statSync5(join12(resolved, "spec-engine")).isDirectory()) {
+        if (statSync5(join14(resolved, "spec-engine")).isDirectory()) {
           lastIsPlatformDir = true;
         } else {
           lastIsDirWithoutSpecEngine = true;
@@ -8254,7 +8959,7 @@ async function runReverseQuery(opts) {
   if (outArg2)
     assertContainedPath(dbPath, platformDir, "spec resolve: --out");
   await maybePromptForOnboarding({ platformDir, args: { noPrompt } });
-  await withReadStorage({ platformDir, dbPath, fresh }, (storage2) => {
+  await withReadStorage({ platformDir, dbPath, fresh, json }, (storage2) => {
     const { rows, known } = reqTags(storage2, reqId);
     if (rows.length === 0) {
       if (!known) {
@@ -8343,7 +9048,7 @@ var init_resolve2 = __esm(() => {
     },
     req: {
       type: "string",
-      description: "Reverse query (T8): list every tag site (repo, file, line, kind, level) for the given requirement id instead of resolving files. Takes no file positionals."
+      description: "Reverse query: list every tag site (repo, file, line, kind, level) for the given requirement id instead of resolving files. Takes no file positionals."
     },
     out: {
       type: "string",
@@ -8365,7 +9070,7 @@ var init_resolve2 = __esm(() => {
   resolveCommand = defineCommand21({
     meta: {
       name: "resolve",
-      description: "Return the requirements tagged in the given files (RSLV-01). Accepts multiple positional file paths (e.g. `spec resolve api/src/renew.ts api/src/charge.ts`) and a comma-split fallback inside a single positional (`spec resolve a.ts,b.ts`). Paths may be platform-relative or absolute under the platform tree."
+      description: "Return the requirements tagged in the given files. Accepts multiple positional file paths (e.g. `spec resolve api/src/renew.ts api/src/charge.ts`) and a comma-split fallback inside a single positional (`spec resolve a.ts,b.ts`). Paths may be platform-relative or absolute under the platform tree."
     },
     args: resolveArgs,
     async run({ args, rawArgs }) {
@@ -8398,7 +9103,7 @@ var init_resolve2 = __esm(() => {
           noPrompt: args.noPrompt
         }
       });
-      await withReadStorage({ platformDir, dbPath, fresh: !!args.fresh }, (storage2) => {
+      await withReadStorage({ platformDir, dbPath, fresh: !!args.fresh, json: !!args.json }, (storage2) => {
         const rows = storage2.resolveByFiles(normalized);
         if (!args.json && rows.length === 0 && storage2.listRequirements().length === 0) {
           console.error(formatNoRequirementsIndexed(platformDir));
@@ -8525,8 +9230,8 @@ var exports_gate = {};
 __export(exports_gate, {
   gateCommand: () => gateCommand
 });
-import { existsSync as existsSync12 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join15 } from "path";
 import { defineCommand as defineCommand22 } from "citty";
 function isEpipe(e) {
   if (e === null || typeof e !== "object" || !("code" in e))
@@ -8550,7 +9255,7 @@ function resolveGateArgs(args) {
     process.exit(EXIT.USAGE);
   }
   const platformDir = resolvePlatformDir(args);
-  if (!existsSync12(join13(platformDir, "spec-engine"))) {
+  if (!existsSync13(join15(platformDir, "spec-engine"))) {
     console.error(formatNotASpecPlatform(platformDir));
     process.exit(EXIT.USAGE);
   }
@@ -8623,6 +9328,7 @@ var init_gate2 = __esm(() => {
             writeStdoutTolerant(`build_id: ${gated.buildId}`);
         }
       } catch (e) {
+        handleInvalidDomainFiles(e, Boolean(args.json));
         const msg = e instanceof Error ? e.message : String(e);
         console.error(`spec gate: crashed: ${msg}`);
         process.exit(EXIT.USAGE);
@@ -8708,205 +9414,6 @@ function renderGuard(losses, mode, ref) {
 }
 var STOP = "\uD83D\uDED1";
 
-// src/guard/collect.ts
-import { join as join14 } from "path";
-function isIgnored(path) {
-  return isPathIgnored(path);
-}
-function isSpecFile(path) {
-  return path.startsWith(`${CANONICAL_SPECS_DIR}/`) && path.endsWith("/SPEC.json") && !isIgnored(path);
-}
-function isCodeFile(path) {
-  if (isSpecFile(path) || isIgnored(path))
-    return false;
-  const ext = path.includes(".") ? path.split(".").pop() ?? "" : "";
-  return CODE_EXTS.has(ext);
-}
-function parseReqs(text) {
-  const v = parseDomainText(text, "");
-  return v.ok ? v.data.requirements : [];
-}
-function collectBaseReqs2(platformDir, ref, specPaths2) {
-  const reqs = [];
-  const path = new Map;
-  for (const p of specPaths2) {
-    const bytes = gitShow(platformDir, ref, p);
-    if (bytes === null)
-      continue;
-    for (const r of parseReqs(bytes)) {
-      reqs.push(r);
-      path.set(r.id, p);
-    }
-  }
-  return { reqs, path };
-}
-function collectBaseTags(platformDir, ref, codePaths) {
-  const implSite = new Map;
-  const verifySite = new Map;
-  for (const p of codePaths) {
-    const bytes = gitShow(platformDir, ref, p);
-    if (bytes === null)
-      continue;
-    for (const tag of scanTagsInFile("", p, bytes)) {
-      const target = tag.kind === "verifies" ? verifySite : implSite;
-      if (!target.has(tag.req_id))
-        target.set(tag.req_id, { file: tag.file, line: tag.line });
-    }
-  }
-  return { implSite, verifySite };
-}
-async function collectWorktreeReqs(canonicalDir) {
-  const ids = new Set;
-  const activeIds = new Set;
-  const supersedesTargets = new Set;
-  for (const rel of await findDomainJsonFiles(canonicalDir)) {
-    const text = await Bun.file(join14(canonicalDir, rel)).text();
-    for (const r of parseReqs(text)) {
-      ids.add(r.id);
-      if (r.status.toLowerCase() === "active")
-        activeIds.add(r.id);
-      if (r.supersedes != null)
-        supersedesTargets.add(r.supersedes);
-    }
-  }
-  return { ids, activeIds, supersedesTargets };
-}
-function tallyWorktreeTags(storage2) {
-  const implCount = new Map;
-  const verifyCount = new Map;
-  for (const t of storage2.listTags()) {
-    const bucket = t.kind === "implements" ? implCount : t.kind === "verifies" ? verifyCount : null;
-    if (bucket !== null)
-      bucket.set(t.req_id, (bucket.get(t.req_id) ?? 0) + 1);
-  }
-  return { implCount, verifyCount };
-}
-async function collectFacts(platformDir, ref, storage2) {
-  const changed = gitDiffNameStatus(platformDir, ref);
-  const specPaths2 = changed.filter((e) => isSpecFile(e.path)).map((e) => e.path);
-  const codePaths = changed.filter((e) => isCodeFile(e.path)).map((e) => e.path);
-  const deletedSpecFiles = changed.filter((e) => e.status === "D" && isSpecFile(e.path)).map((e) => e.path);
-  const base = collectBaseReqs2(platformDir, ref, specPaths2);
-  const baseTags = collectBaseTags(platformDir, ref, codePaths);
-  const worktree = await collectWorktreeReqs(join14(platformDir, CANONICAL_SPECS_DIR));
-  const counts = tallyWorktreeTags(storage2);
-  return {
-    baseReqs: base.reqs,
-    baseReqPath: base.path,
-    baseImplSite: baseTags.implSite,
-    baseVerifySite: baseTags.verifySite,
-    worktreeReqIds: worktree.ids,
-    worktreeActiveIds: worktree.activeIds,
-    worktreeSupersedesTargets: worktree.supersedesTargets,
-    worktreeImplCount: counts.implCount,
-    worktreeVerifyCount: counts.verifyCount,
-    deletedSpecFiles
-  };
-}
-var CODE_EXTS;
-var init_collect = __esm(() => {
-  init_src();
-  init_constants();
-  init_fs();
-  init_tags();
-  CODE_EXTS = new Set(DEFAULT_EXTS);
-});
-
-// src/guard/losses.ts
-function isActive(status) {
-  return status.toLowerCase() === "active";
-}
-function isSuperseded(base, f) {
-  const forward = base.supersededBy != null && f.worktreeReqIds.has(base.supersededBy);
-  return forward || f.worktreeSupersedesTargets.has(base.id);
-}
-function reqDeletedLoss(base, f) {
-  return {
-    kind: "REQUIREMENT_REMOVED",
-    req_id: base.id,
-    file: f.baseReqPath.get(base.id) ?? "",
-    line: 0,
-    detail: `${base.id} was Active at the ref but is absent from the working-tree spec and was not superseded \u2014 a requirement is never deleted`
-  };
-}
-function historyRemovedLoss(base, f) {
-  const display = base.status.charAt(0).toUpperCase() + base.status.slice(1).toLowerCase();
-  return {
-    kind: "REQUIREMENT_REMOVED",
-    req_id: base.id,
-    file: f.baseReqPath.get(base.id) ?? "",
-    line: 0,
-    detail: `${base.id} was ${display} at the ref but is absent from the working-tree spec \u2014 a requirement is never deleted, and its history is the record`
-  };
-}
-function implLostLoss(id, site) {
-  return {
-    kind: "IMPL_LOST",
-    req_id: id,
-    file: site.file,
-    line: site.line,
-    detail: `${id} lost its last implementing @spec tag (was ${site.file}:${site.line})`
-  };
-}
-function verifyLostLoss(id, site) {
-  return {
-    kind: "VERIFY_LOST",
-    req_id: id,
-    file: site.file,
-    line: site.line,
-    detail: `${id} lost its last verifying @spec tag (was ${site.file}:${site.line})`
-  };
-}
-function specFileDeletedLoss(path) {
-  return {
-    kind: "SPEC_FILE_DELETED",
-    req_id: null,
-    file: path,
-    line: 0,
-    detail: `canonical spec file ${path} present at the ref is absent from the working tree`
-  };
-}
-function reqDeletedFor(base, f) {
-  if (f.worktreeReqIds.has(base.id))
-    return null;
-  if (!isActive(base.status))
-    return historyRemovedLoss(base, f);
-  if (isSuperseded(base, f))
-    return null;
-  return reqDeletedLoss(base, f);
-}
-function lastTagGone(id, count, f) {
-  return f.worktreeActiveIds.has(id) && count === 0;
-}
-function classifyLosses(f) {
-  const out = [];
-  for (const base of f.baseReqs) {
-    const loss = reqDeletedFor(base, f);
-    if (loss !== null)
-      out.push(loss);
-  }
-  for (const [id, site] of f.baseImplSite) {
-    if (lastTagGone(id, f.worktreeImplCount.get(id) ?? 0, f))
-      out.push(implLostLoss(id, site));
-  }
-  for (const [id, site] of f.baseVerifySite) {
-    if (lastTagGone(id, f.worktreeVerifyCount.get(id) ?? 0, f))
-      out.push(verifyLostLoss(id, site));
-  }
-  for (const path of f.deletedSpecFiles)
-    out.push(specFileDeletedLoss(path));
-  return out;
-}
-
-// src/operations/guard.ts
-async function guard(storage2, platformDir, ref) {
-  const losses = classifyLosses(await collectFacts(platformDir, ref, storage2));
-  return { ok: true, ref, losses };
-}
-var init_guard = __esm(() => {
-  init_collect();
-});
-
 // src/commands/guard.ts
 var exports_guard = {};
 __export(exports_guard, {
@@ -8945,7 +9452,7 @@ var init_guard2 = __esm(() => {
         process.exit(EXIT.OK);
       }
       let losses = [];
-      await withReadStorage({ platformDir, dbPath: defaultIndexPath(platformDir), fresh: true }, async (storage2) => {
+      await withReadStorage({ platformDir, dbPath: defaultIndexPath(platformDir), fresh: true, json: jsonMode }, async (storage2) => {
         losses = (await guard(storage2, platformDir, ref)).losses;
       });
       console.log(renderGuard(losses, jsonMode ? "json" : "text", ref));
@@ -10962,6 +11469,10 @@ function mountEditor(app, bindHost = DEFAULT_BIND_HOST) {
             Lives in (optional, single path)
             <input type="text" name="livesIn" placeholder="path/to/impl.ts" />
           </label>
+          <label>
+            Relates to (optional, comma-separated ids)
+            <input type="text" name="relates" placeholder="BILLING-001, BILLING-002" />
+          </label>
           <button type="submit">Create</button>
         </form>
       </section>
@@ -10996,6 +11507,7 @@ function mountEditor(app, bindHost = DEFAULT_BIND_HOST) {
     const statement = field(form, "statement");
     const why = field(form, "why");
     const livesIn = field(form, "livesIn");
+    const relates = field(form, "relates");
     const payload = {
       key: field(form, "key"),
       statement
@@ -11004,6 +11516,8 @@ function mountEditor(app, bindHost = DEFAULT_BIND_HOST) {
       payload.why = why;
     if (livesIn.length > 0)
       payload.livesIn = livesIn;
+    if (relates.length > 0)
+      payload.relates = relates;
     const res = await app.request("/api/requirements", {
       method: "POST",
       headers: { "content-type": "application/json" },
@@ -11840,6 +12354,9 @@ function guarded(handler) {
     try {
       return await handler(c);
     } catch (err) {
+      if (err instanceof InvalidDomainFilesError) {
+        return c.json({ error: "invalid_domain_file", diagnostics: sortDiagnostics(err.diagnostics) }, 422);
+      }
       const info = describeStorageError(err);
       if (info === null)
         throw err;
@@ -11904,7 +12421,7 @@ async function readJsonBody(c) {
   }
   return { ok: true, body: parsed };
 }
-function toLivesIn(v) {
+function toStringList(v) {
   if (Array.isArray(v))
     return v.filter((x) => typeof x === "string");
   if (typeof v === "string" && v.length > 0)
@@ -11915,11 +12432,20 @@ function mintFieldsFromBody(body) {
   return {
     statement: typeof body.statement === "string" ? body.statement : "",
     why: typeof body.why === "string" ? body.why : "",
-    livesIn: toLivesIn(body.livesIn),
+    livesIn: toStringList(body.livesIn),
+    relates: toStringList(body.relates),
     issue: typeof body.issue === "string" && body.issue.trim() !== "" ? body.issue.trim() : undefined,
     status: body.status === "draft" ? "draft" : "active"
   };
 }
+function successorFieldsFromBody(body) {
+  return {
+    why: typeof body.why === "string" ? body.why : undefined,
+    livesIn: "livesIn" in body ? toStringList(body.livesIn) : undefined,
+    relates: "relates" in body ? toStringList(body.relates) : undefined,
+    issue: typeof body.issue === "string" && body.issue.trim() !== "" ? body.issue.trim() : undefined
+  };
+}
 function amendFieldsFromBody(body) {
   const fields = {};
   if (typeof body.statement === "string")
@@ -11927,7 +12453,9 @@ function amendFieldsFromBody(body) {
   if ("why" in body)
     fields.why = typeof body.why === "string" ? body.why : null;
   if ("livesIn" in body)
-    fields.livesIn = toLivesIn(body.livesIn);
+    fields.livesIn = toStringList(body.livesIn);
+  if ("relates" in body)
+    fields.relates = toStringList(body.relates);
   return Object.keys(fields).length === 0 ? null : fields;
 }
 function failureResponse(c, failure) {
@@ -12034,12 +12562,9 @@ function mountApi(app, storage2, platformDir = process.cwd(), bindHost = DEFAULT
     return withWriteLock(async () => {
       const fields = amendFieldsFromBody(body);
       if (fields === null) {
-        return c.json({ error: "nothing to amend \u2014 provide statement, why, or livesIn" }, 400);
+        return c.json({ error: "nothing to amend \u2014 provide statement, why, livesIn, or relates" }, 400);
       }
-      const r = await amend({ platformDir, id, fields }, async (reqId) => {
-        await runIndex({ platformDir, storage: storage2 });
-        return storage2.listTags({ req_id: reqId });
-      });
+      const r = await amend({ platformDir, id, fields });
       if (!r.ok)
         return failureResponse(c, r);
       await runIndex({ platformDir, storage: storage2 });
@@ -12067,13 +12592,50 @@ function mountApi(app, storage2, platformDir = process.cwd(), bindHost = DEFAULT
     if (statement === "")
       return c.json({ error: "statement is required (non-empty)" }, 400);
     return withWriteLock(async () => {
-      const r = await supersede({
+      const r = await supersede({ platformDir, id, statement, ...successorFieldsFromBody(body) }, async (reqId) => {
+        await runIndex({ platformDir, storage: storage2 });
+        return storage2.listTags({ req_id: reqId });
+      });
+      if (!r.ok)
+        return failureResponse(c, r);
+      return c.json({
+        ok: true,
+        old_id: r.oldId,
+        new_id: r.newId,
+        file: r.file,
+        spec_version: r.specVersion,
+        retag: r.retag
+      }, 201);
+    });
+  }));
+  app.post("/api/requirements/:id/move", guarded(async function moveRequirement(c) {
+    if (!featureEnabled("editor")) {
+      return c.json({ error: featureDisabledMessage("editor") }, 404);
+    }
+    const originReject = rejectCrossOrigin(c, bindHost);
+    if (originReject)
+      return originReject;
+    const headerReject = rejectBadWriteHeaders(c);
+    if (headerReject)
+      return headerReject;
+    const parsed = await readJsonBody(c);
+    if (!parsed.ok)
+      return parsed.res;
+    const body = parsed.body;
+    const id = c.req.param("id") ?? "";
+    if (!ID_RE.test(id))
+      return c.json({ error: "id must be a requirement id (KEY-NNN)" }, 400);
+    const targetKey = normalizeDomainKey(typeof body.newDomain === "string" ? body.newDomain : "");
+    if (targetKey === "")
+      return c.json({ error: "newDomain is required (a domain key)" }, 400);
+    return withWriteLock(async () => {
+      const r = await move({
         platformDir,
         id,
-        statement,
+        targetKey,
+        statement: typeof body.text === "string" ? body.text : undefined,
         why: typeof body.why === "string" ? body.why : undefined,
-        livesIn: "livesIn" in body ? toLivesIn(body.livesIn) : undefined,
-        issue: typeof body.issue === "string" && body.issue.trim() !== "" ? body.issue.trim() : undefined
+        livesIn: "lives" in body ? toStringList(body.lives) : undefined
       }, async (reqId) => {
         await runIndex({ platformDir, storage: storage2 });
         return storage2.listTags({ req_id: reqId });
@@ -12084,8 +12646,10 @@ function mountApi(app, storage2, platformDir = process.cwd(), bindHost = DEFAULT
         ok: true,
         old_id: r.oldId,
         new_id: r.newId,
-        file: r.file,
-        spec_version: r.specVersion,
+        from_file: r.fromFile,
+        to_file: r.toFile,
+        source_spec_version: r.sourceSpecVersion,
+        target_spec_version: r.targetSpecVersion,
         retag: r.retag
       }, 201);
     });
@@ -12228,6 +12792,7 @@ var init_api = __esm(() => {
   init_amend();
   init_deprecate();
   init_mint();
+  init_move();
   init_reads2();
   init_records();
   init_supersede();
@@ -12358,7 +12923,7 @@ __export(exports_serve, {
   resolveBind: () => resolveBind,
   composeServeApp: () => composeServeApp
 });
-import { existsSync as existsSync13, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync6 } from "fs";
 import { dirname as dirname8 } from "path";
 import { defineCommand as defineCommand24 } from "citty";
 import { Hono as Hono2 } from "hono";
@@ -12411,7 +12976,7 @@ async function runProbe() {
     }
     const body = await res.text();
     if (!body.includes("Spec Engine \u2014 coming online")) {
-      console.error(`serve --probe FAILED: body did not contain the placeholder string (D-14)`);
+      console.error(`serve --probe FAILED: body did not contain the placeholder string`);
       server.stop();
       process.exit(EXIT.FAILURE);
     }
@@ -12440,7 +13005,7 @@ var init_serve = __esm(() => {
   serveCommand = defineCommand24({
     meta: {
       name: "serve",
-      description: "Run the local webapp. Binds 127.0.0.1 on --port, or one private --host address behind an access token. --probe is the SERV-04 asset-embedding smoke."
+      description: "Run the local webapp. Binds 127.0.0.1 on --port, or one private --host address behind an access token. --probe is the asset-embedding smoke."
     },
     args: {
       platformDir: platformDirArg,
@@ -12510,7 +13075,7 @@ var init_serve = __esm(() => {
         }
       });
       mkdirSync6(dirname8(dbPath), { recursive: true });
-      const needsIndex = !existsSync13(dbPath);
+      const needsIndex = !existsSync14(dbPath);
       let storage2;
       try {
         storage2 = openStorage(dbPath);
@@ -12531,6 +13096,7 @@ var init_serve = __esm(() => {
         });
       } catch (err) {
         storage2.close();
+        handleInvalidDomainFiles(err, false);
         handleStorageUnavailable(err, dbPath);
         console.error(`spec serve: failed to start on ${urlHost(host, port)}:`, err);
         process.exit(EXIT.FAILURE);
@@ -12557,13 +13123,13 @@ __export(exports_docs, {
   docsCommand: () => docsCommand,
   createDocsFetchHandler: () => createDocsFetchHandler
 });
-import { existsSync as existsSync14, statSync as statSync6 } from "fs";
-import { join as join15, normalize, sep as sep4 } from "path";
+import { existsSync as existsSync15, statSync as statSync6 } from "fs";
+import { join as join16, normalize, sep as sep4 } from "path";
 import { fileURLToPath } from "url";
 import { defineCommand as defineCommand25 } from "citty";
 function resolveDocsRootFrom(candidates) {
   for (const candidate of candidates) {
-    if (existsSync14(join15(candidate, "index.html")))
+    if (existsSync15(join16(candidate, "index.html")))
       return candidate;
   }
   return null;
@@ -12587,17 +13153,17 @@ function createDocsFetchHandler(root) {
     if (pathname.includes("\x00")) {
       return new Response("Bad request", { status: 400 });
     }
-    const target = normalize(join15(normalRoot, pathname));
+    const target = normalize(join16(normalRoot, pathname));
     if (target !== normalRoot && !target.startsWith(rootPrefix)) {
       return new Response("Not found", { status: 404 });
     }
-    for (const candidate of [target, join15(target, "index.html"), `${target}.html`]) {
-      if (existsSync14(candidate) && statSync6(candidate).isFile()) {
+    for (const candidate of [target, join16(target, "index.html"), `${target}.html`]) {
+      if (existsSync15(candidate) && statSync6(candidate).isFile()) {
         return new Response(Bun.file(candidate));
       }
     }
-    const notFoundPage = join15(normalRoot, "404.html");
-    if (existsSync14(notFoundPage)) {
+    const notFoundPage = join16(normalRoot, "404.html");
+    if (existsSync15(notFoundPage)) {
       return new Response(Bun.file(notFoundPage), { status: 404 });
     }
     return new Response("Not found", { status: 404 });
@@ -12647,7 +13213,7 @@ var init_docs2 = __esm(() => {
       port: {
         type: "string",
         default: "4100",
-        description: "Port (default 4100; 0 = ephemeral). Hostname is hardcoded 127.0.0.1 (T-1-01); no --host accepted."
+        description: "Port (default 4100; 0 = ephemeral). Hostname is hardcoded 127.0.0.1; no --host accepted."
       },
       probe: {
         type: "boolean",