@spec-engine/spec-engine 0.6.0 → 0.7.0

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.0",
+    version: "0.7.0",
     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,57 +224,193 @@ 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
@@ -373,10 +512,10 @@ var init_flags = __esm(() => {
   FEATURE_KEYS = Object.keys(FEATURES);
 });
 // ../shared/src/net.ts
-function isLoopbackHostname(hostname) {
-  return LOOPBACK_HOSTNAMES.has(hostname);
+function isServedHostname(hostname, bindHost = DEFAULT_BIND_HOST) {
+  return LOOPBACK_HOSTNAMES.has(hostname) || hostname === bindHost;
 }
-var LOOPBACK_HOSTNAMES;
+var DEFAULT_BIND_HOST = "127.0.0.1", LOOPBACK_HOSTNAMES;
 var init_net = __esm(() => {
   LOOPBACK_HOSTNAMES = new Set(["127.0.0.1", "localhost", "::1", "[::1]"]);
 });
@@ -677,6 +816,7 @@ var init_storage = __esm(() => {
 
 // ../shared/src/index.ts
 var init_src = __esm(() => {
+  init_checkConfig();
   init_config();
   init_diagnostics();
   init_domain();
@@ -949,8 +1089,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 +1118,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 +1160,11 @@ var init_fs = __esm(() => {
     "lua",
     "luau",
     "go",
-    "rs"
+    "rs",
+    "tf",
+    "toml",
+    "sql",
+    "css"
   ];
 });
 
@@ -1120,6 +1267,9 @@ function readPlatformMap(dir) {
     return null;
   return { mapped: map(abs), located };
 }
+function platformName(platformDir) {
+  return readPlatformMap(platformDir)?.mapped.name ?? basename(resolve2(platformDir));
+}
 function platformMode(platformDir) {
   return readPlatformMap(platformDir)?.mapped.mode ?? "single-repo";
 }
@@ -1545,9 +1695,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'
@@ -1577,11 +1731,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'
   )
@@ -1595,11 +1748,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')
@@ -2442,7 +2594,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,
@@ -2450,7 +2602,6 @@ async function runIndex(opts) {
     members,
     specs,
     tagHits,
-    structuralDiagnostics,
     unpinned,
     platformDiagnostics
   });
@@ -2472,29 +2623,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}/`);
@@ -2546,16 +2690,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,
@@ -2579,8 +2714,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,
@@ -3014,6 +3147,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";
@@ -3112,6 +3288,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)
@@ -3140,7 +3336,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)
@@ -3149,6 +3345,7 @@ async function withReadStorage(opts, fn) {
     });
   } catch (e) {
     handleStorageUnavailable(e, dbPath);
+    handleInvalidDomainFiles(e, json);
     handleNotAPlatform(e);
   }
 }
@@ -3355,7 +3552,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 = {
@@ -3380,6 +3577,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
@@ -3454,6 +3655,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 {
@@ -3463,49 +3665,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 = [];
@@ -3688,6 +3847,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) {
@@ -4060,6 +4227,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();
@@ -4498,7 +4719,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("-"));
 }
@@ -4507,7 +4728,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);
@@ -4523,32 +4744,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();
 });
@@ -4603,7 +4850,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) {
@@ -4618,7 +4865,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, [
@@ -4646,7 +4893,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: [],
@@ -4805,8 +5052,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;
@@ -4858,15 +5105,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);
@@ -4877,10 +5124,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",
@@ -4917,10 +5164,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 {
@@ -4936,7 +5183,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
@@ -4949,38 +5196,232 @@ 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);
 }
-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 parsed = domainReqsFromText(text, platformRel);
-    for (const r of parsed.reqs) {
-      reqs.push(r);
-      relPathById.set(r.id, platformRel);
-    }
-  }
-  return { reqs, relPathById };
+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, diagnostics2) {
+function collectBaseReqs(platformDir, ref, specPaths2) {
   const reqs = [];
-  const relPathById = new Map;
+  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(join11(canonicalDir, rel)).text();
+    const parsed = domainReqsFromText(text, platformRel);
+    for (const r of parsed.reqs) {
+      reqs.push(r);
+      relPathById.set(r.id, platformRel);
+    }
+  }
+  return { reqs, relPathById };
+}
+function collectBaseReqs2(platformDir, ref, diagnostics2) {
+  const reqs = [];
+  const relPathById = new Map;
   for (const path of gitLsTree(platformDir, ref, CANONICAL_SPECS_DIR)) {
     if (!path.endsWith(`/${SPEC_FILENAME}`))
       continue;
@@ -5010,8 +5451,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);
@@ -5020,12 +5461,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" });
@@ -5040,20 +5502,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();
@@ -5061,6 +5527,7 @@ var init_check = __esm(() => {
   init_propagation_teeth();
   init_proven();
   init_removed();
+  init_severity();
   init_sqlDiagnostics();
   init_statusflip();
   init_supersedes();
@@ -5071,6 +5538,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
@@ -5120,17 +5593,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",
@@ -5181,6 +5654,7 @@ var init_check2 = __esm(() => {
           return result;
         });
       } catch (e) {
+        handleInvalidDomainFiles(e, jsonMode);
         exitAfterCrash(e);
       }
       if (outcome === undefined) {
@@ -5204,8 +5678,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)
@@ -5225,9 +5699,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 });
@@ -5525,7 +5999,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));
@@ -5638,7 +6112,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)`);
@@ -5712,7 +6186,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}`);
@@ -5789,7 +6263,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));
@@ -5912,7 +6386,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}`);
@@ -6034,7 +6508,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));
@@ -6159,7 +6633,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))
@@ -6173,7 +6647,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 {
@@ -6440,7 +6914,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));
@@ -6504,6 +6978,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)
@@ -6582,6 +7057,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)"
@@ -6614,9 +7090,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;
       }
@@ -6752,6 +7228,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) {
@@ -7024,14 +7503,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";
@@ -7067,18 +7550,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();
@@ -7187,6 +7671,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")
@@ -7200,7 +7687,6 @@ var supersedeArgs, supersedeCommand;
 var init_supersede2 = __esm(() => {
   init_constants();
   init_discover();
-  init__index();
   init_supersede();
   init_grammar3();
   init__args();
@@ -7225,6 +7711,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)"
@@ -7265,7 +7755,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);
@@ -7332,7 +7822,6 @@ var deprecateCommand;
 var init_deprecate2 = __esm(() => {
   init_constants();
   init_discover();
-  init__index();
   init_deprecate();
   init_grammar3();
   init__args();
@@ -7375,7 +7864,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;
@@ -7394,30 +7883,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) {
@@ -7466,7 +7953,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);
@@ -7527,7 +8014,6 @@ var init_move2 = __esm(() => {
   init_domains();
   init_constants();
   init_discover();
-  init__index();
   init_move();
   init_grammar3();
   init__args();
@@ -7589,7 +8075,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);
@@ -7623,18 +8109,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;
-  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.");
+  const tag = releaseHolding(platformDir, relFile, id);
+  if (tag === null)
+    return null;
+  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 = [];
@@ -7654,6 +8152,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");
@@ -7669,18 +8171,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") {
@@ -7702,12 +8203,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
@@ -7718,9 +8221,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() === "") {
@@ -7747,6 +8250,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() !== "")
@@ -7759,7 +8265,6 @@ var amendArgs, amendCommand;
 var init_amend2 = __esm(() => {
   init_constants();
   init_discover();
-  init__index();
   init_amend();
   init_grammar3();
   init__args();
@@ -7774,6 +8279,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)"
@@ -7788,7 +8294,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 }) {
@@ -7805,7 +8311,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);
@@ -7927,7 +8433,7 @@ 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) }] };
 }
@@ -7935,14 +8441,14 @@ function errorResult(message) {
   return { content: [{ type: "text", text: message }], isError: true };
 }
 function buildMcpServer(platformDir) {
-  const server = new McpServer({ name: "spec", version: "0.0.6" });
+  const server = new McpServer({ name: "spec", version: package_default.version });
   const fresh = (fn) => withIndex({ platformDir, build: "fresh" }, (h) => fn(h.storage));
   server.registerTool("spec_query", {
     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);
@@ -7952,13 +8458,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}`);
@@ -7981,7 +8487,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}`);
@@ -7991,7 +8497,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);
@@ -7999,7 +8505,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}`);
@@ -8013,8 +8519,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 = {};
@@ -8033,17 +8539,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)
@@ -8060,8 +8567,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)) {
@@ -8077,7 +8584,7 @@ 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)) {
@@ -8090,8 +8597,8 @@ function buildMcpServer(platformDir) {
     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;
@@ -8118,6 +8625,7 @@ function buildMcpServer(platformDir) {
 }
 var init_mcp = __esm(() => {
   init_src();
+  init_package();
   init_domains();
   init__index();
   init_accept();
@@ -8159,7 +8667,7 @@ var init_mcp2 = __esm(() => {
         handleNotAPlatform(e);
       }
       const server = buildMcpServer(platformDir);
-      console.error(`spec mcp: serving ${platformDir} over stdio`);
+      console.error(`spec mcp: serving ${platformName(platformDir)} over stdio`);
       await server.connect(new StdioServerTransport);
     }
   });
@@ -8171,7 +8679,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("--")) {
@@ -8210,7 +8718,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;
@@ -8250,7 +8758,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) {
@@ -8339,7 +8847,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",
@@ -8361,7 +8869,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 }) {
@@ -8394,7 +8902,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));
@@ -8521,8 +9029,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))
@@ -8546,7 +9054,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);
   }
@@ -8619,6 +9127,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);
@@ -8704,205 +9213,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, {
@@ -8941,7 +9251,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));
@@ -9248,6 +9558,18 @@ code {
   display: block;
 }
 
+.sidebar-platform {
+  margin-left: auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-family: var(--font-mono);
+  font-weight: 500;
+  font-size: 0.75rem;
+  color: var(--fg-dim);
+}
+
 .sidebar-scroll {
   flex: 1;
   overflow-y: auto;
@@ -10854,9 +11176,9 @@ var init_coverage = __esm(() => {
 // ../webapp/src/pages/editor.ts
 import { bodyLimit } from "hono/body-limit";
 import { html as html5, raw as raw4 } from "hono/html";
-function crossOriginRejected(c) {
+function crossOriginRejected(c, bindHost) {
   const selfUrl = new URL(c.req.url);
-  if (!isLoopbackHostname(selfUrl.hostname))
+  if (!isServedHostname(selfUrl.hostname, bindHost))
     return true;
   const origin = c.req.header("origin");
   if (origin === undefined)
@@ -10914,7 +11236,7 @@ async function renderResult(res) {
       <p><a href="/editor">Back to editor</a></p>
     `);
 }
-function mountEditor(app) {
+function mountEditor(app, bindHost = DEFAULT_BIND_HOST) {
   app.get("/editor", (c) => {
     if (!featureEnabled("editor"))
       return c.html(comingSoonDoc("editor", "Editor"));
@@ -10946,6 +11268,10 @@ function mountEditor(app) {
             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>
@@ -10974,12 +11300,13 @@ function mountEditor(app) {
   app.post("/editor/create", editorBodyLimit, async (c) => {
     if (!featureEnabled("editor"))
       return c.html(rejectPage(featureDisabledMessage("editor")), 404);
-    if (crossOriginRejected(c))
+    if (crossOriginRejected(c, bindHost))
       return c.html(rejectPage("cross-origin request rejected"), 403);
     const form = await c.req.parseBody();
     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
@@ -10988,6 +11315,8 @@ function mountEditor(app) {
       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" },
@@ -10998,7 +11327,7 @@ function mountEditor(app) {
   app.post("/editor/amend", editorBodyLimit, async (c) => {
     if (!featureEnabled("editor"))
       return c.html(rejectPage(featureDisabledMessage("editor")), 404);
-    if (crossOriginRejected(c))
+    if (crossOriginRejected(c, bindHost))
       return c.html(rejectPage("cross-origin request rejected"), 403);
     const form = await c.req.parseBody();
     const id = field(form, "id");
@@ -11752,12 +12081,27 @@ var init_setup = __esm(() => {
 
 // ../webapp/src/server.ts
 import { Hono } from "hono";
+import { html as htmlTemplate } from "hono/html";
 function createApp() {
   const app = new Hono;
   app.get("/", (c) => c.html(index_html_default));
   return app;
 }
-function mountWebapp(app) {
+function labelPlatform(app, platformName2) {
+  const name = htmlTemplate`${platformName2}`.toString();
+  app.use("*", async (c, next) => {
+    await next();
+    if (!c.res.headers.get("content-type")?.startsWith("text/html"))
+      return;
+    const body = (await c.res.text()).replace("<title>Spec Engine", `<title>${name} \xB7 Spec Engine`).replace("<span>Spec Engine</span></a>", `<span>Spec Engine</span><span class="sidebar-platform">${name}</span></a>`);
+    const headers = new Headers(c.res.headers);
+    headers.delete("content-length");
+    c.res = new Response(body, { status: c.res.status, headers });
+  });
+}
+function mountWebapp(app, bindHost = DEFAULT_BIND_HOST, platformName2) {
+  if (platformName2 !== undefined)
+    labelPlatform(app, platformName2);
   registerErrorBoundary(app);
   mountCoverage(app);
   mountRequirements(app);
@@ -11765,13 +12109,14 @@ function mountWebapp(app) {
   mountQuery(app);
   mountRelations(app);
   mountProvenance(app);
-  mountEditor(app);
+  mountEditor(app, bindHost);
   mountSetup(app);
   mountGlossary(app);
   mountLogs(app);
   return app;
 }
 var init_server = __esm(() => {
+  init_src();
   init_index_html();
   init_coverage();
   init_data();
@@ -11821,9 +12166,9 @@ function withWriteLock(fn) {
   writeChain = run.catch(() => {});
   return run;
 }
-function rejectCrossOrigin(c) {
+function rejectCrossOrigin(c, bindHost) {
   const selfUrl = new URL(c.req.url);
-  if (!isLoopbackHostname(selfUrl.hostname)) {
+  if (!isServedHostname(selfUrl.hostname, bindHost)) {
     return c.json({ error: "cross-origin request rejected" }, 403);
   }
   const origin = c.req.header("origin");
@@ -11872,7 +12217,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)
@@ -11883,11 +12228,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")
@@ -11895,7 +12249,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) {
@@ -11926,7 +12282,7 @@ function parseQueryLimit2(c, rawLimit) {
   }
   return { ok: true, limit };
 }
-function mountApi(app, storage2, platformDir = process.cwd()) {
+function mountApi(app, storage2, platformDir = process.cwd(), bindHost = DEFAULT_BIND_HOST) {
   app.use("/api/*", async (c, next) => {
     c.header("Cache-Control", "no-store");
     await next();
@@ -11935,7 +12291,12 @@ function mountApi(app, storage2, platformDir = process.cwd()) {
   app.get("/api/repos", guarded((c) => c.json(storage2.listRepos())));
   app.get("/api/platform", async (c) => {
     const version = await derivePlatformVersion(platformDir);
-    const info = { version, source: "derived", mode: platformMode(platformDir) };
+    const info = {
+      version,
+      name: platformName(platformDir),
+      source: "derived",
+      mode: platformMode(platformDir)
+    };
     return c.json(info);
   });
   app.get("/api/report", guarded((c) => c.json(coverageReport(storage2).rows)));
@@ -11957,7 +12318,7 @@ function mountApi(app, storage2, platformDir = process.cwd()) {
     if (!featureEnabled("editor")) {
       return c.json({ error: featureDisabledMessage("editor") }, 404);
     }
-    const originReject = rejectCrossOrigin(c);
+    const originReject = rejectCrossOrigin(c, bindHost);
     if (originReject)
       return originReject;
     const headerReject = rejectBadWriteHeaders(c);
@@ -11983,7 +12344,7 @@ function mountApi(app, storage2, platformDir = process.cwd()) {
     if (!featureEnabled("editor")) {
       return c.json({ error: featureDisabledMessage("editor") }, 404);
     }
-    const originReject = rejectCrossOrigin(c);
+    const originReject = rejectCrossOrigin(c, bindHost);
     if (originReject)
       return originReject;
     const headerReject = rejectBadWriteHeaders(c);
@@ -11997,12 +12358,9 @@ function mountApi(app, storage2, platformDir = process.cwd()) {
     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 });
@@ -12013,7 +12371,7 @@ function mountApi(app, storage2, platformDir = process.cwd()) {
     if (!featureEnabled("editor")) {
       return c.json({ error: featureDisabledMessage("editor") }, 404);
     }
-    const originReject = rejectCrossOrigin(c);
+    const originReject = rejectCrossOrigin(c, bindHost);
     if (originReject)
       return originReject;
     const headerReject = rejectBadWriteHeaders(c);
@@ -12030,14 +12388,7 @@ function mountApi(app, storage2, platformDir = process.cwd()) {
     if (statement === "")
       return c.json({ error: "statement is required (non-empty)" }, 400);
     return withWriteLock(async () => {
-      const r = await supersede({
-        platformDir,
-        id,
-        statement,
-        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
-      }, async (reqId) => {
+      const r = await supersede({ platformDir, id, statement, ...successorFieldsFromBody(body) }, async (reqId) => {
         await runIndex({ platformDir, storage: storage2 });
         return storage2.listTags({ req_id: reqId });
       });
@@ -12057,7 +12408,7 @@ function mountApi(app, storage2, platformDir = process.cwd()) {
     if (!featureEnabled("editor")) {
       return c.json({ error: featureDisabledMessage("editor") }, 404);
     }
-    const originReject = rejectCrossOrigin(c);
+    const originReject = rejectCrossOrigin(c, bindHost);
     if (originReject)
       return originReject;
     const headerReject = rejectBadWriteHeaders(c);
@@ -12087,7 +12438,7 @@ function mountApi(app, storage2, platformDir = process.cwd()) {
     if (!featureEnabled("editor")) {
       return c.json({ error: featureDisabledMessage("editor") }, 404);
     }
-    const originReject = rejectCrossOrigin(c);
+    const originReject = rejectCrossOrigin(c, bindHost);
     if (originReject)
       return originReject;
     const headerReject = rejectBadWriteHeaders(c);
@@ -12201,22 +12552,162 @@ var init_api = __esm(() => {
   writeChain = Promise.resolve();
 });
 
+// src/server/lan.ts
+import { createHash as createHash2, randomBytes, timingSafeEqual } from "crypto";
+import { isIP } from "net";
+function ipv4Prefix(ip) {
+  const parts = ip.split(".");
+  if (parts.length !== 4 || parts.some((p) => String(Number(p)) !== p))
+    return null;
+  return [Number(parts[0]), Number(parts[1])];
+}
+function isLoopbackAddress(ip) {
+  if (ip === "::1")
+    return true;
+  return ipv4Prefix(ip)?.[0] === 127;
+}
+function isPrivateIPv4([a, b]) {
+  if (a === 127 || a === 10)
+    return true;
+  if (a === 172 && b >= 16 && b <= 31)
+    return true;
+  if (a === 192 && b === 168)
+    return true;
+  return a === 100 && b >= 64 && b <= 127;
+}
+function bindHostRefusal(raw11) {
+  const kind = isIP(raw11);
+  if (kind === 0)
+    return `--host must be a literal IP address, not "${raw11}"`;
+  if (kind === 6) {
+    return raw11 === "::1" ? null : `--host ${raw11}: the only IPv6 address accepted is ::1`;
+  }
+  const prefix = ipv4Prefix(raw11);
+  if (prefix === null || !isPrivateIPv4(prefix)) {
+    return `--host ${raw11} is not a loopback, RFC 1918, or 100.64.0.0/10 address`;
+  }
+  return null;
+}
+function urlHost(ip, port) {
+  return `${isIP(ip) === 6 ? `[${ip}]` : ip}:${port}`;
+}
+function generateToken() {
+  return randomBytes(32).toString("hex");
+}
+function pinnedTokenRefusal(token) {
+  if (!/^[A-Za-z0-9_-]+$/.test(token))
+    return "the access token may only contain A-Z a-z 0-9 _ -";
+  if (token.length < MIN_PINNED_TOKEN_LENGTH) {
+    return `the access token must be at least ${MIN_PINNED_TOKEN_LENGTH} characters`;
+  }
+  return null;
+}
+function digest(value) {
+  return createHash2("sha256").update(value).digest();
+}
+function tokenMatches(candidate, token) {
+  if (!candidate)
+    return false;
+  return timingSafeEqual(digest(candidate), digest(token));
+}
+function cookieValue(header, name) {
+  for (const pair of (header ?? "").split(";")) {
+    const eq = pair.indexOf("=");
+    if (eq !== -1 && pair.slice(0, eq).trim() === name)
+      return pair.slice(eq + 1).trim();
+  }
+  return null;
+}
+function isWrite(req, url) {
+  if (req.method !== "GET" && req.method !== "HEAD")
+    return true;
+  if (url.pathname === "/provenance")
+    return true;
+  return url.pathname === "/api/provenance" && url.searchParams.has("resolve");
+}
+function plain(status, body, headers = {}) {
+  return new Response(`${body}
+`, {
+    status,
+    headers: {
+      "content-type": "text/plain; charset=utf-8",
+      "cache-control": "no-store",
+      ...headers
+    }
+  });
+}
+function lanGate(fetch2, { bindHost, token, allowWrites }) {
+  return (req) => {
+    const url = new URL(req.url);
+    if (!isServedHostname(url.hostname, bindHost))
+      return plain(403, "host rejected");
+    const queryToken = url.searchParams.get("token");
+    if (queryToken !== null) {
+      if (!tokenMatches(queryToken, token))
+        return plain(401, "invalid access token");
+      url.searchParams.delete("token");
+      return plain(302, "authenticated", {
+        location: `${url.pathname}${url.search}`,
+        "set-cookie": `${TOKEN_COOKIE}=${token}; Path=/; HttpOnly; SameSite=Strict`
+      });
+    }
+    if (!tokenMatches(cookieValue(req.headers.get("cookie"), TOKEN_COOKIE), token)) {
+      return plain(401, "access token required: open the tokenized URL spec serve printed");
+    }
+    if (!allowWrites && isWrite(req, url)) {
+      return plain(403, "read-only: restart spec serve with --allow-writes to permit changes");
+    }
+    return fetch2(req);
+  };
+}
+var TOKEN_COOKIE = "spec_token", MIN_PINNED_TOKEN_LENGTH = 16;
+var init_lan = __esm(() => {
+  init_src();
+});
+
 // src/commands/serve.ts
 var exports_serve = {};
 __export(exports_serve, {
   serveCommand: () => serveCommand,
+  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";
-function composeServeApp(storage2, platformDir = process.cwd()) {
+function composeServeApp(storage2, platformDir = process.cwd(), bindHost = DEFAULT_BIND_HOST) {
   const app = new Hono2;
-  mountApi(app, storage2, platformDir);
-  mountWebapp(app);
+  mountApi(app, storage2, platformDir, bindHost);
+  mountWebapp(app, bindHost, platformName(platformDir));
   return app;
 }
+function usageError(message) {
+  console.error(`spec serve: ${message}`);
+  process.exit(EXIT.USAGE);
+}
+function resolveBind(args) {
+  const host = args.host ?? DEFAULT_BIND_HOST;
+  const hostRefusal = bindHostRefusal(host);
+  if (hostRefusal !== null)
+    usageError(hostRefusal);
+  if (isLoopbackAddress(host))
+    return { host, lan: null };
+  const pinned = args.token ?? process.env.SPEC_SERVE_TOKEN;
+  if (pinned !== undefined) {
+    const tokenRefusal = pinnedTokenRefusal(pinned);
+    if (tokenRefusal !== null)
+      usageError(tokenRefusal);
+  }
+  return {
+    host,
+    lan: {
+      bindHost: host,
+      token: pinned ?? generateToken(),
+      allowWrites: args.allowWrites === true
+    }
+  };
+}
 async function runProbe() {
   const app = createApp();
   const server = Bun.serve({
@@ -12234,7 +12725,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);
     }
@@ -12249,26 +12740,41 @@ async function runProbe() {
 }
 var serveCommand;
 var init_serve = __esm(() => {
+  init_src();
   init_server();
   init_constants();
   init_discover();
   init_pipeline();
   init_prompt();
   init_api();
+  init_lan();
   init_sqlite();
   init__args();
   init__shared();
   serveCommand = defineCommand24({
     meta: {
       name: "serve",
-      description: "Run the local webapp. Binds 127.0.0.1 on --port (loopback only \u2014 no --host). --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,
       port: {
         type: "string",
         default: "4000",
-        description: "Port (default 4000; 0 = ephemeral). Hostname is hardcoded 127.0.0.1 (T-1-01); no --host accepted."
+        description: "Port (default 4000; 0 = ephemeral)."
+      },
+      host: {
+        type: "string",
+        default: DEFAULT_BIND_HOST,
+        description: "Address to bind (default 127.0.0.1). Only a literal loopback, RFC 1918, or 100.64.0.0/10 IP; a non-loopback address requires the printed access token and is read-only."
+      },
+      token: {
+        type: "string",
+        description: "Pin the access token for a non-loopback --host (else SPEC_SERVE_TOKEN, else random). At least 16 of A-Z a-z 0-9 _ -."
+      },
+      allowWrites: {
+        type: "boolean",
+        description: "On a non-loopback --host, permit editor writes and tracker resolution."
       },
       out: {
         type: "string",
@@ -12276,7 +12782,7 @@ var init_serve = __esm(() => {
       },
       probe: {
         type: "boolean",
-        description: "Smoke test: bind ephemeral port on 127.0.0.1, GET /, assert body contains placeholder, exit."
+        description: "Smoke test: bind ephemeral port on 127.0.0.1 (ignores --host), GET /, assert body contains placeholder, exit."
       },
       noPrompt: {
         type: "boolean",
@@ -12300,6 +12806,7 @@ var init_serve = __esm(() => {
         process.exit(EXIT.USAGE);
         return;
       }
+      const { host, lan } = resolveBind(args);
       const platformDir = resolvePlatformDir(args);
       const outArg2 = args.out;
       const dbPath = resolveDbPath(platformDir, outArg2);
@@ -12317,7 +12824,7 @@ var init_serve = __esm(() => {
         }
       });
       mkdirSync6(dirname8(dbPath), { recursive: true });
-      const needsIndex = !existsSync13(dbPath);
+      const needsIndex = !existsSync14(dbPath);
       let storage2;
       try {
         storage2 = openStorage(dbPath);
@@ -12330,20 +12837,27 @@ var init_serve = __esm(() => {
         if (needsIndex || storage2.listRepos().length === 0) {
           await runIndex({ platformDir, storage: storage2 });
         }
-        const app = composeServeApp(storage2, platformDir);
+        const app = composeServeApp(storage2, platformDir, host);
         server = Bun.serve({
           port,
-          hostname: "127.0.0.1",
-          fetch: app.fetch
+          hostname: host,
+          fetch: lan === null ? app.fetch : lanGate(app.fetch, lan)
         });
       } catch (err) {
         storage2.close();
+        handleInvalidDomainFiles(err, false);
         handleStorageUnavailable(err, dbPath);
-        console.error(`spec serve: failed to start on 127.0.0.1:${port}:`, err);
+        console.error(`spec serve: failed to start on ${urlHost(host, port)}:`, err);
         process.exit(EXIT.FAILURE);
         return;
       }
-      console.log(`spec: serving on http://127.0.0.1:${server.port}`);
+      const serving = `spec: serving ${platformName(platformDir)} on ${server.url.origin}`;
+      if (lan === null) {
+        console.log(serving);
+        return;
+      }
+      console.log(`${serving}/?token=${lan.token}`);
+      console.log(lan.allowWrites ? "spec: writes ALLOWED (--allow-writes)" : "spec: read-only");
     }
   });
 });
@@ -12358,13 +12872,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;
@@ -12388,17 +12902,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 });
@@ -12448,7 +12962,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",