@wairon/cli 5.1.1-dev.75 → 5.1.1-dev.77

package/dist/index.js

@@ -1672,15 +1672,15 @@ var require_node = __commonJS({
     var slzh = function(d, b) {
       return b + 30 + b2(d, b + 26) + b2(d, b + 28);
     };
-    var zh = function(d, b, z11) {
+    var zh = function(d, b, z12) {
       var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl;
-      var _a2 = z64hs(d, es, efl, z11, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
+      var _a2 = z64hs(d, es, efl, z12, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
       return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off];
     };
-    var z64hs = function(d, b, l, z11, sc, su, off) {
+    var z64hs = function(d, b, l, z12, sc, su, off) {
       var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
       var nf = nsc + nsu + noff;
-      if (z11 && nf) {
+      if (z12 && nf) {
         for (; b + 4 < e; b += 4 + b2(d, b + 2)) {
           if (b2(d, b) == 1) {
             return [
@@ -1691,7 +1691,7 @@ var require_node = __commonJS({
             ];
           }
         }
-        if (z11 < 2)
+        if (z12 < 2)
           err(13);
       }
       return [sc, su, off, 0];
@@ -2300,18 +2300,18 @@ var require_node = __commonJS({
       if (lft) {
         var c = lft;
         var o = b4(data, e + 16);
-        var z11 = b4(data, e - 20) == 117853008;
-        if (z11) {
+        var z12 = b4(data, e - 20) == 117853008;
+        if (z12) {
           var ze = b4(data, e - 12);
-          z11 = b4(data, ze) == 101075792;
-          if (z11) {
+          z12 = b4(data, ze) == 101075792;
+          if (z12) {
             c = lft = b4(data, ze + 32);
             o = b4(data, ze + 48);
           }
         }
         var fltr = opts && opts.filter;
         var _loop_3 = function(i3) {
-          var _a2 = zh(data, o, z11), c_1 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+          var _a2 = zh(data, o, z12), c_1 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
           o = no;
           var cbl = function(e2, d) {
             if (e2) {
@@ -2366,18 +2366,18 @@ var require_node = __commonJS({
       if (!c)
         return {};
       var o = b4(data, e + 16);
-      var z11 = b4(data, e - 20) == 117853008;
-      if (z11) {
+      var z12 = b4(data, e - 20) == 117853008;
+      if (z12) {
         var ze = b4(data, e - 12);
-        z11 = b4(data, ze) == 101075792;
-        if (z11) {
+        z12 = b4(data, ze) == 101075792;
+        if (z12) {
           c = b4(data, ze + 32);
           o = b4(data, ze + 48);
         }
       }
       var fltr = opts && opts.filter;
       for (var i2 = 0; i2 < c; ++i2) {
-        var _a2 = zh(data, o, z11), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+        var _a2 = zh(data, o, z12), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
         o = no;
         if (!fltr || fltr({
           name: fn,
@@ -2497,7 +2497,7 @@ var require_dist = __commonJS({
       scaffoldPack: () => scaffoldPack2
     });
     module2.exports = __toCommonJS2(src_exports2);
-    var path29 = __toESM2(require("path"));
+    var path210 = __toESM2(require("path"));
     var import_js_yaml3 = require("js-yaml");
     var import_js_yaml = require("js-yaml");
     var import_crypto = require("crypto");
@@ -2510,8 +2510,8 @@ var require_dist = __commonJS({
       maxCompressionRatio: 100,
       maxDepth: 16
     };
-    function parseManifest(text) {
-      const raw = (0, import_js_yaml.load)(text);
+    function parseManifest(text2) {
+      const raw = (0, import_js_yaml.load)(text2);
       const manifest = validateEnvelope(raw);
       if (Math.trunc(manifest.formatVersion) > SUPPORTED_FORMAT_VERSION) {
         throw new Error("unsupported pack-archive formatVersion (newer than this wairon understands)");
@@ -2689,8 +2689,8 @@ var require_dist = __commonJS({
     var DERIVED_ROOTS = ["generated", "docs"];
     var EXECUTABLE_EXT_RE = /\.(c|m)?js$/i;
     var WAI_SEGMENT = ".wai";
-    function parseTreeManifest(text) {
-      const raw = (0, import_js_yaml2.load)(text);
+    function parseTreeManifest(text2) {
+      const raw = (0, import_js_yaml2.load)(text2);
       const manifest = validateEnvelope2(raw);
       if (Math.trunc(manifest.formatVersion) > SUPPORTED_FORMAT_VERSION2) {
         throw new Error("unsupported tree-archive formatVersion (newer than this wairon understands)");
@@ -3060,8 +3060,8 @@ var require_dist = __commonJS({
     function slug(name) {
       return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
     }
-    var fs18 = __toESM2(require("fs"));
-    var path30 = __toESM2(require("path"));
+    var fs20 = __toESM2(require("fs"));
+    var path31 = __toESM2(require("path"));
     var import_fflate = require_node();
     var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".hg", ".svn"]);
     function listEntries(archive) {
@@ -3099,9 +3099,9 @@ var require_dist = __commonJS({
     }
     function writeTree(destDir, files) {
       for (const file of files) {
-        const absolute = path30.join(destDir, file.path);
-        fs18.mkdirSync(path30.dirname(absolute), { recursive: true });
-        fs18.writeFileSync(absolute, file.contents);
+        const absolute = path31.join(destDir, file.path);
+        fs20.mkdirSync(path31.dirname(absolute), { recursive: true });
+        fs20.writeFileSync(absolute, file.contents);
       }
     }
     function classifyKind(name, symlinks) {
@@ -3110,14 +3110,14 @@ var require_dist = __commonJS({
       return "file";
     }
     function walkPackDir(root, current2, out) {
-      for (const entry of fs18.readdirSync(current2, { withFileTypes: true })) {
+      for (const entry of fs20.readdirSync(current2, { withFileTypes: true })) {
         if (entry.isDirectory()) {
           if (SKIP_DIRS.has(entry.name)) continue;
-          walkPackDir(root, path30.join(current2, entry.name), out);
+          walkPackDir(root, path31.join(current2, entry.name), out);
         } else if (entry.isFile()) {
-          const absolute = path30.join(current2, entry.name);
-          const relative22 = path30.relative(root, absolute).split(path30.sep).join("/");
-          out.push({ path: relative22, contents: fs18.readFileSync(absolute) });
+          const absolute = path31.join(current2, entry.name);
+          const relative22 = path31.relative(root, absolute).split(path31.sep).join("/");
+          out.push({ path: relative22, contents: fs20.readFileSync(absolute) });
         }
       }
     }
@@ -3167,7 +3167,7 @@ var require_dist = __commonJS({
     function scaffoldPack(request) {
       const files = render(request);
       writeTree(request.targetDir, files);
-      return files.map((file) => path29.join(request.targetDir, file.path));
+      return files.map((file) => path210.join(request.targetDir, file.path));
     }
     function buildPack(sourceDir) {
       const files = readPackDir(sourceDir);
@@ -3224,7 +3224,7 @@ var require_dist = __commonJS({
       }
       const manifest = parseManifest(decode(envelope.contents));
       verifyIntegrity2(manifest, files);
-      const directory = path29.resolve(destDir);
+      const directory = path210.resolve(destDir);
       writeTree(directory, files);
       const result = {
         directory,
@@ -3302,7 +3302,7 @@ var require_dist = __commonJS({
       }
       const manifest = parseTreeManifest(decode(envelope.contents));
       verifyTreeIntegrity(manifest, files);
-      const directory = path29.resolve(destDir);
+      const directory = path210.resolve(destDir);
       writeTree(directory, files);
       const result = {
         destDir: directory,
@@ -3317,7 +3317,7 @@ var require_dist = __commonJS({
       return normalized === "." ? ".wai/" : `${normalized}/.wai/`;
     }
     function normalizeRootPath(relativePath) {
-      const posix2 = relativePath.split(path29.sep).join("/").replace(/^\.\//, "").replace(/\/+$/, "");
+      const posix2 = relativePath.split(path210.sep).join("/").replace(/^\.\//, "").replace(/\/+$/, "");
       return posix2 === "" || posix2 === "." ? "." : posix2;
     }
     function slugify(projectName) {
@@ -3616,7 +3616,7 @@ __export(src_exports, {
   loadImplementationSpecs: () => loadImplementationSpecs,
   loadInterfaceSpec: () => loadInterfaceSpec,
   loadInterfaceSpecs: () => loadInterfaceSpecs,
-  loadProjectConfig: () => loadProjectConfig2,
+  loadProjectConfig: () => loadProjectConfig3,
   loadProjectExtensions: () => loadProjectExtensions,
   loadProjectVariants: () => loadProjectVariants,
   loadRegistry: () => loadRegistry,
@@ -3687,6 +3687,7 @@ __export(src_exports, {
   saveSpec: () => saveSpec,
   saveTopologyConfig: () => saveTopologyConfig,
   scanAllSpecs: () => scanAllSpecs,
+  schemaFingerprint: () => schemaFingerprint,
   serializeYaml: () => serializeYaml,
   setExecutionTier: () => setExecutionTier,
   setLogLevel: () => setLogLevel,
@@ -3918,6 +3919,40 @@ var BundleNotFoundError = class extends WaironError {
   }
 };
 
+// src/models/identity-rename.ts
+var EDGE = " -> ";
+var QUALIFIED_UNIT = /^(\d+:)?([^.\s]+)\.([^.\s]+)$/;
+function movedComponent(rename, id) {
+  return rename.components?.find((c) => c.from === id)?.to ?? id;
+}
+function rekeyUnit(rename, unit) {
+  if (unit.includes(EDGE)) return unit.split(EDGE).map((side) => movedComponent(rename, side)).join(EDGE);
+  const qualified = QUALIFIED_UNIT.exec(unit);
+  if (!qualified) return unit;
+  const [, step = "", component, method] = qualified;
+  const moved = rename.methods?.find((m) => m.component === component && m.method === method);
+  if (moved) return `${step}${moved.toComponent}.${moved.toMethod}`;
+  return `${step}${movedComponent(rename, component)}.${method}`;
+}
+function rekeyAnchor(rename, anchor) {
+  const { spec, at, covers } = anchor;
+  const movedSpec = rename.specs?.find((s) => s.from === spec && (!s.sites || at !== void 0 && s.sites.includes(at)));
+  let site = at;
+  if (at !== void 0) {
+    if (at.includes(EDGE)) {
+      site = rekeyUnit(rename, at);
+    } else {
+      const moved = rename.methods?.find((m) => m.method === at && m.specs?.includes(spec));
+      if (moved) site = moved.toMethod;
+    }
+  }
+  return {
+    spec: movedSpec?.to ?? spec,
+    ...site !== void 0 ? { at: site } : {},
+    ...covers !== void 0 ? { covers: covers.map((unit) => rekeyUnit(rename, unit)) } : {}
+  };
+}
+
 // src/models/project.ts
 var path2 = __toESM(require("path"));
 var import_zod3 = require("zod");
@@ -3975,6 +4010,21 @@ var ExecutionBudgetSchema = import_zod.z.object({
   allowNestedDelegation: import_zod.z.boolean(),
   mcp: McpAccessSchema
 });
+function summarize(budget, profile) {
+  const lines = [
+    `- **Work shape**: ${profile.breadth} breadth, ${profile.reasoningDepth} reasoning${profile.writes ? "" : ", read-only"}${profile.delegates ? ", delegating" : ""}`,
+    `- **Why**: ${profile.rationale}`
+  ];
+  if (budget.modelTier) lines.push(`- **Capability tier**: ${budget.modelTier}`);
+  if (budget.effort) lines.push(`- **Effort**: ${budget.effort}`);
+  if (budget.maxTurns !== void 0) {
+    lines.push(`- **Turn ceiling**: ${budget.maxTurns} (a circuit breaker \u2014 hitting it should read as a scoping error, not a limit to work up to)`);
+  }
+  lines.push(`- **Tool grant**: ${budget.toolClass}`);
+  lines.push(`- **May delegate further**: ${budget.allowNestedDelegation ? "yes" : "no"}`);
+  lines.push(`- **MCP access**: ${budget.mcp}`);
+  return lines;
+}
 var BudgetTierSchema = import_zod.z.enum(["off", "free", "default", "trade", "aggressive"]);
 var ExecutionConfigSchema = import_zod.z.object({
   /**
@@ -4538,6 +4588,12 @@ function projectConfigFsAdapterAt(rootDir) {
     },
     documentExists() {
       return fs2.existsSync(file());
+    },
+    readText() {
+      return readFileOrNull(file());
+    },
+    writeText(text2) {
+      writeFile(file(), text2);
     }
   };
 }
@@ -4563,8 +4619,158 @@ function storeOver(adapter, root) {
     },
     readField(field) {
       return valueAt(currentDocument(), field);
+    },
+    rewriteScalars(edits, dryRun = false) {
+      if (edits.length === 0) return;
+      const text2 = adapter.readText();
+      if (text2 === null) throw new ProjectNotInitializedError();
+      const next = rewriteScalarsInText(text2, edits, root);
+      if (!dryRun) adapter.writeText(next);
+    }
+  };
+}
+var KEY_RE = /^('(?:[^']|'')*'|"(?:[^"\\]|\\.)*"|[^\s'"#{}[\],&*!|>%@`][^:#]*?)\s*:(?=\s|$)/;
+function tokenize(lines) {
+  const tokens = [];
+  let blockAbove = null;
+  lines.forEach((raw, line) => {
+    const content = raw.replace(/\r?\n$/, "");
+    const indent = content.length - content.trimStart().length;
+    const trimmed = content.trim();
+    if (blockAbove !== null) {
+      if (trimmed === "" || indent > blockAbove) return;
+      blockAbove = null;
+    }
+    if (trimmed === "" || trimmed.startsWith("#")) return;
+    let col = indent;
+    let rest = content.slice(indent);
+    while (rest === "-" || rest.startsWith("- ")) {
+      tokens.push({ kind: "item", col, line });
+      const after = rest.slice(1);
+      const pad = after.length - after.trimStart().length;
+      col += 1 + pad;
+      rest = after.trimStart();
+    }
+    if (rest === "") return;
+    const key = KEY_RE.exec(rest);
+    if (key) {
+      const name = key[1].startsWith("'") ? key[1].slice(1, -1).replace(/''/g, "'") : key[1].startsWith('"') ? JSON.parse(key[1]) : key[1].trim();
+      const afterKey = rest.slice(key[0].length);
+      const value = afterKey.trimStart();
+      const token = { kind: "key", col, line, name };
+      if (value !== "" && !value.startsWith("#")) token.valueStart = col + key[0].length + (afterKey.length - value.length);
+      tokens.push(token);
+      if (/^[|>][-+0-9]*\s*(#.*)?$/.test(value)) blockAbove = col;
+      return;
+    }
+    tokens.push({ kind: "scalar", col, line, valueStart: col });
+    if (/^[|>][-+0-9]*\s*(#.*)?$/.test(rest)) blockAbove = col - 2;
+  });
+  return tokens;
+}
+function childrenOf(tokens, index) {
+  const parent = tokens[index];
+  const out = [];
+  for (let i = index + 1; i < tokens.length; i += 1) {
+    const t = tokens[i];
+    const nested = t.col > parent.col || parent.kind === "key" && t.kind === "item" && t.col === parent.col;
+    if (!nested) break;
+    out.push(t);
+  }
+  return out;
+}
+function locateScalar(tokens, path31) {
+  let region = tokens;
+  for (let k = 0; k < path31.length; k += 1) {
+    const segment = path31[k];
+    if (region.length === 0) return `nothing is nested at ${path31.slice(0, k).join(".")}`;
+    const base = Math.min(...region.map((t) => t.col));
+    const last = k === path31.length - 1;
+    let at;
+    if (typeof segment === "string") {
+      at = region.findIndex((t) => t.kind === "key" && t.col === base && t.name === segment);
+      if (at < 0) return `no block key "${segment}" at ${path31.slice(0, k).join(".") || "the document root"}`;
+      if (last) return region[at].valueStart !== void 0 ? region[at] : `"${segment}" holds no inline scalar`;
+    } else {
+      const items = region.map((t, i) => ({ t, i })).filter(({ t }) => t.kind === "item" && t.col === base);
+      if (segment >= items.length) return `no block sequence item ${segment} at ${path31.slice(0, k).join(".")}`;
+      at = items[segment].i;
+      if (last) {
+        const value = region[at + 1];
+        return value && value.kind === "scalar" && value.line === region[at].line ? value : `item ${segment} holds no inline scalar`;
+      }
+    }
+    const regionStart = tokens.indexOf(region[at]);
+    region = childrenOf(tokens, regionStart);
+  }
+  return "an empty path addresses no scalar";
+}
+function readScalar(text2) {
+  if (text2.startsWith("'")) {
+    let i = 1;
+    let value = "";
+    while (i < text2.length) {
+      if (text2[i] === "'") {
+        if (text2[i + 1] === "'") {
+          value += "'";
+          i += 2;
+          continue;
+        }
+        return { value, style: "single", end: i + 1 };
+      }
+      value += text2[i];
+      i += 1;
+    }
+    return null;
+  }
+  if (text2.startsWith('"')) {
+    const closing = /^"(?:[^"\\]|\\.)*"/.exec(text2);
+    if (!closing) return null;
+    try {
+      return { value: JSON.parse(closing[0]), style: "double", end: closing[0].length };
+    } catch {
+      return null;
     }
+  }
+  const comment = text2.search(/\s#/);
+  const body = (comment < 0 ? text2 : text2.slice(0, comment)).trimEnd();
+  return { value: body, style: "plain", end: body.length };
+}
+function writeScalar(value, style) {
+  if (style === "double") return JSON.stringify(value);
+  if (style === "plain" && /^[A-Za-z0-9_][A-Za-z0-9_./-]*$/.test(value)) return value;
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function setAt(document, path31, value) {
+  let node = document;
+  for (const segment of path31.slice(0, -1)) node = node[segment];
+  node[path31[path31.length - 1]] = value;
+}
+function rewriteScalarsInText(text2, edits, root) {
+  const refuse = (why) => {
+    throw new WaironError(`Cannot rewrite .wai/project.yaml at ${root} without disturbing its formatting: ${why}. Nothing was written.`);
   };
+  const lines = text2.split(/(?<=\n)/);
+  const tokens = tokenize(lines);
+  const expected = parseYaml(text2);
+  for (const edit of edits) {
+    const where = edit.path.join(".");
+    const token = locateScalar(tokens, edit.path);
+    if (typeof token === "string") refuse(`${where}: ${token}`);
+    const { line, valueStart } = token;
+    const content = lines[line].replace(/\r?\n$/, "");
+    const ending = lines[line].slice(content.length);
+    const scalar = readScalar(content.slice(valueStart));
+    if (!scalar) refuse(`${where}: the scalar there is not written on one line`);
+    if (scalar.value !== edit.from) refuse(`${where} holds "${scalar.value}", not "${edit.from}"`);
+    lines[line] = content.slice(0, valueStart) + writeScalar(edit.to, scalar.style) + content.slice(valueStart + scalar.end) + ending;
+    setAt(expected, edit.path, edit.to);
+  }
+  const next = lines.join("");
+  if (JSON.stringify(parseYaml(next)) !== JSON.stringify(expected)) {
+    refuse("the edited text does not read back as exactly the intended change");
+  }
+  return next;
 }
 function parseConfig(document, root) {
   try {
@@ -4707,6 +4913,35 @@ function registryOver(store, root) {
         ...config,
         extensions: { ...config.extensions, packs: [...packsOf(config), ...selections], useGlobalPacks: false }
       });
+    },
+    rekeyCarried(rename, dryRun = false) {
+      const groups = store.readField("rules.conformance.carried");
+      if (!Array.isArray(groups)) return [];
+      const edits = [];
+      const rekeys = [];
+      groups.forEach((group, g) => {
+        const findings = group?.findings;
+        if (!Array.isArray(findings)) return;
+        findings.forEach((finding, f) => {
+          const entry = finding;
+          if (!entry || typeof entry.spec !== "string") return;
+          const at = typeof entry.at === "string" ? entry.at : void 0;
+          const covers = Array.isArray(entry.covers) ? entry.covers.filter((u) => typeof u === "string") : void 0;
+          const next = rekeyAnchor(rename, { spec: entry.spec, at, covers });
+          const base = ["rules", "conformance", "carried", g, "findings", f];
+          const named = { code: String(entry.code), spec: entry.spec, at: at ?? "" };
+          const change = (path31, field, from, to) => {
+            if (from === to) return;
+            edits.push({ path: [...base, ...path31], from, to });
+            rekeys.push({ ...named, field, from, to });
+          };
+          change(["spec"], "spec", entry.spec, next.spec);
+          if (at !== void 0) change(["at"], "at", at, next.at);
+          (covers ?? []).forEach((unit, u) => change(["covers", u], "covers", unit, next.covers[u]));
+        });
+      });
+      store.rewriteScalars(edits, dryRun);
+      return rekeys;
     }
   };
 }
@@ -4791,6 +5026,9 @@ function projectConfigRepositoryOver(adapter, rootDir) {
     },
     pinGlobalPacksAsSelections(selections) {
       registry.pinGlobalPacksAsSelections(selections);
+    },
+    rekeyCarried(rename, dryRun) {
+      return registry.rekeyCarried(rename, dryRun);
     }
   };
 }
@@ -4840,6 +5078,9 @@ var projectConfigRepository = {
   },
   pinGlobalPacksAsSelections(selections) {
     bound().pinGlobalPacksAsSelections(selections);
+  },
+  rekeyCarried(rename, dryRun) {
+    return bound().rekeyCarried(rename, dryRun);
   }
 };
 
@@ -5609,9 +5850,9 @@ var MethodSignatureSchema = import_zod8.z.object({
   ext: ExtDataSchema.optional()
 });
 var INTENT_FLOOR_MIN_CHARS = 40;
-function passesIntentFloor(text, methodName) {
-  if (!text) return false;
-  const t = text.trim();
+function passesIntentFloor(text2, methodName) {
+  if (!text2) return false;
+  const t = text2.trim();
   if (t.length < INTENT_FLOOR_MIN_CHARS) return false;
   const norm = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
   if (norm(t) === norm(methodName)) return false;
@@ -6357,10 +6598,10 @@ function stepGraph(method) {
     const s = byNum.get(n);
     if (s.type !== "parallel" || s.endStep === void 0 || !s.branches?.length) continue;
     const entries = s.branches.map((b) => b.step).sort((a, b) => a - b);
-    const join17 = fallNext(s.endStep);
+    const join19 = fallNext(s.endStep);
     for (let i = 0; i < entries.length; i++) {
       const armEnd = i + 1 < entries.length ? prevOf(entries[i + 1]) : s.endStep;
-      if (armEnd !== void 0 && armEnd >= entries[i]) armEndJoin.set(armEnd, join17);
+      if (armEnd !== void 0 && armEnd >= entries[i]) armEndJoin.set(armEnd, join19);
     }
   }
   const successorsOf = (n) => {
@@ -7060,12 +7301,12 @@ function buildExcalidrawScene(model, L) {
       locked: false
     };
   }
-  function boundLabel(rect, text, fontSize, verticalAlign) {
+  function boundLabel(rect, text2, fontSize, verticalAlign) {
     const id = rect.id + "-label";
     const label = base(id, "text", { x: rect.x + 8, y: rect.y + 6, w: rect.width - 16, h: 20 });
     label.roundness = null;
-    label.text = text;
-    label.originalText = text;
+    label.text = text2;
+    label.originalText = text2;
     label.fontSize = fontSize;
     label.fontFamily = 1;
     label.textAlign = "center";
@@ -11573,6 +11814,161 @@ var SURFACES_DIRNAME = "surfaces";
 function surfacesDir(rootDir) {
   return path9.join(rootDir, ".wai", SURFACES_DIRNAME);
 }
+function audienceRank(audience) {
+  const idx = SURFACE_AUDIENCES.indexOf(audience ?? "instance");
+  return idx === -1 ? SURFACE_AUDIENCES.indexOf("instance") : idx;
+}
+function stateIdString() {
+  const s = computeStateId();
+  return `${s.algorithm}:${s.digest}`;
+}
+function computeTypeClosure(entries, types) {
+  const included = /* @__PURE__ */ new Map();
+  const queue = [];
+  const enqueueRef = (ref) => {
+    if (BUILTIN_TYPES.has(ref.toLowerCase())) return;
+    for (const spec of types) {
+      const qualifiedId = spec.subsystem && !spec.id.startsWith(`${spec.subsystem}::`) ? `${spec.subsystem}::${spec.id}` : spec.id;
+      if (matchTypeRef(ref, qualifiedId) && !included.has(spec.id)) {
+        included.set(spec.id, spec);
+        queue.push(spec.id);
+      }
+    }
+  };
+  for (const entry of entries) {
+    for (const m of entry.methods) {
+      for (const ref of methodTypeRefs(m)) enqueueRef(ref);
+    }
+  }
+  while (queue.length) {
+    const spec = included.get(queue.shift());
+    for (const field of spec.fields) {
+      for (const ref of extractTypeIdentifiers(field.type)) enqueueRef(ref);
+    }
+  }
+  return [...included.values()].map((t) => ({
+    id: t.id,
+    name: t.name,
+    kind: t.kind,
+    fields: t.fields.map((f) => ({
+      name: f.name,
+      type: f.type,
+      ...f.description ? { description: f.description } : {},
+      ...f.optional ? { optional: true } : {}
+    }))
+  }));
+}
+function projectOwnSurface(maxAudience) {
+  const system = loadSystemSpec();
+  if (!system) {
+    throw new Error("Cannot project a surface: the L0 system spec is missing.");
+  }
+  const subsystems = loadSubsystemSpecs();
+  const components = loadComponentSpecs();
+  const interfaces = loadInterfaceSpecs();
+  const types = loadTypeSpecs();
+  const floor = audienceRank(maxAudience);
+  const rawEntries = system.publicInterfaces ?? [];
+  const entries = [];
+  for (const raw of rawEntries) {
+    const audience = raw.audience ?? "instance";
+    if (audienceRank(audience) < floor) continue;
+    if (!raw.component) continue;
+    const comp = components.find((c) => c.id === raw.component);
+    if (!comp) continue;
+    const compInterfaces = interfaces.filter((i) => i.component === comp.id && (!raw.interface || i.id === raw.interface));
+    const methods = compInterfaces.flatMap((i) => i.methods);
+    const subsystemType = subsystems.find((s) => s.id === comp.subsystem)?.publicInterfaces.find((pi) => pi.component === comp.id)?.type;
+    entries.push({
+      id: raw.id ?? raw.interface ?? comp.id,
+      name: raw.name ?? comp.name,
+      audience,
+      type: raw.type ?? subsystemType ?? "Custom",
+      component: comp.id,
+      methods,
+      ...comp.dispatch && comp.dispatch.length ? { dispatch: comp.dispatch } : {},
+      // Project the backing Portal's auth + basePath so the codec can emit
+      // OpenAPI security + per-portal servers self-contained from the snapshot.
+      ...comp.auth && comp.auth.scheme !== "none" ? { auth: comp.auth } : {},
+      ...comp.basePath ? { basePath: comp.basePath } : {},
+      details: raw.details ?? "",
+      ...raw.version ? { version: raw.version } : {},
+      ...raw.stability ? { stability: raw.stability } : {}
+    });
+  }
+  return SurfaceSnapshotSchema.parse({
+    projectName: system.name,
+    origin: "generated",
+    stateId: stateIdString(),
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    interfaces: entries,
+    types: computeTypeClosure(entries, types)
+  });
+}
+function projectChildSurface() {
+  return projectOwnSurface("project");
+}
+function localName(id) {
+  return id.split("::").pop();
+}
+var CROSS_BOUNDARY_TARGETS = /* @__PURE__ */ new Set(["Portal", "Observer"]);
+function projectSubsystemSurface(subsystemId) {
+  const system = loadSystemSpec();
+  if (!system) {
+    throw new Error("Cannot project a subsystem surface: the L0 system spec is missing.");
+  }
+  const subsystems = loadSubsystemSpecs();
+  const target = subsystems.find((s) => s.id === subsystemId);
+  if (!target) {
+    throw new Error(`Cannot project a subsystem surface: subsystem "${subsystemId}" does not exist.`);
+  }
+  const components = loadComponentSpecs();
+  const interfaces = loadInterfaceSpecs();
+  const types = loadTypeSpecs();
+  const entries = [];
+  const unprojectable = [];
+  for (const pub of target.publicInterfaces ?? []) {
+    if (!pub.component) continue;
+    const comp = components.find((c) => c.id === pub.component || c.id === `${subsystemId}::${pub.component}`);
+    if (!comp) continue;
+    if (!CROSS_BOUNDARY_TARGETS.has(comp.componentType)) {
+      unprojectable.push({ component: pub.component, componentType: comp.componentType });
+      continue;
+    }
+    const compInterfaces = interfaces.filter((i) => i.component === comp.id && (!pub.interface || i.id === pub.interface || i.id === `${subsystemId}::${pub.interface}`));
+    const methods = compInterfaces.flatMap((i) => i.methods);
+    entries.push({
+      id: localName(pub.interface ?? comp.id),
+      name: comp.name,
+      // Family ceiling: a sibling surface is consumable by the system family only.
+      audience: "project",
+      type: pub.type ?? "Custom",
+      // The snapshot carries the LOCAL portal name — consumers resolve cross-tree
+      // refs by their final segment.
+      component: localName(comp.id),
+      methods,
+      ...comp.dispatch && comp.dispatch.length ? { dispatch: comp.dispatch } : {},
+      // Project the backing component's auth + basePath so the codec can emit
+      // OpenAPI security + per-portal servers self-contained from the snapshot.
+      ...comp.auth && comp.auth.scheme !== "none" ? { auth: comp.auth } : {},
+      ...comp.basePath ? { basePath: comp.basePath } : {},
+      details: pub.details ?? ""
+    });
+  }
+  for (const skipped of unprojectable) {
+    console.error(
+      `[surfaces] skipped "${subsystemId}::${skipped.component}": a published ${skipped.componentType} can never serve a cross-boundary caller, so it stays out of every chained child's sibling surface \u2014 publish this surface through a Portal, or an Observer (for events).`
+    );
+  }
+  return SurfaceSnapshotSchema.parse({
+    projectName: `${system.name}::${subsystemId}`,
+    origin: "generated",
+    stateId: stateIdString(),
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    interfaces: entries,
+    types: computeTypeClosure(entries, types)
+  });
+}
 function listSnapshots(rootDir = getProjectRoot()) {
   const dir = surfacesDir(rootDir);
   if (!fs7.existsSync(dir)) return [];
@@ -11597,6 +11993,43 @@ function listMountSnapshots(mounts) {
   }
   return out;
 }
+function projectFamilySurfaces(parent) {
+  return runWithProjectRoot(parent.parentRoot, () => {
+    const siblings = loadSubsystemSpecs().filter((s) => !s.id.includes("::") && s.id !== parent.subsystemId);
+    return [projectChildSurface(), ...siblings.map((s) => projectSubsystemSurface(s.id))];
+  });
+}
+function projectedFamilyContent(parent) {
+  try {
+    return new Map(projectFamilySurfaces(parent).map((s) => [s.projectName, surfaceContentKey(s)]));
+  } catch {
+    return null;
+  }
+}
+function listExternalInterfaces() {
+  const snapshots = listSnapshots();
+  const chainingParent = resolveChainingParent();
+  const projected = chainingParent ? projectedFamilyContent(chainingParent) : null;
+  return snapshots.map((snapshot) => {
+    const generated = snapshot.origin === "generated";
+    const sourceKind = !generated ? "foreign" : snapshot.projectName.includes("::") ? "sibling" : "parent";
+    const freshness = generated && projected ? projected.get(snapshot.projectName) === surfaceContentKey(snapshot) ? "fresh" : "stale" : "unverifiable";
+    return {
+      projectName: snapshot.projectName,
+      origin: snapshot.origin,
+      sourceKind,
+      generatedAt: snapshot.generatedAt,
+      ...snapshot.stateId ? { stateId: snapshot.stateId } : {},
+      ...snapshot.version ? { version: snapshot.version } : {},
+      freshness,
+      interfaceIds: snapshot.interfaces.map((e) => e.id)
+    };
+  });
+}
+function surfaceContentKey(snapshot) {
+  const { stateId, generatedAt, origin, ...content } = snapshot;
+  return JSON.stringify(content);
+}
 
 // src/core/extensions.ts
 var fs9 = __toESM(require("fs"));
@@ -11650,7 +12083,7 @@ function defaultTargetConfig(type) {
     enabled: true
   };
 }
-var WAIRON_VERSION = "5.1.1-dev.75";
+var WAIRON_VERSION = "5.1.1-dev.77";
 var GITHUB_REPO = "SYW-Apps/Waffle-AIron";
 var ARCHITECT_AGENT_ID = "agent-architect";
 var ARCHITECT_TEMPLATE_ID = "architect";
@@ -11901,7 +12334,7 @@ var PackSkillSchema = import_zod9.z.object({
 });
 var PackInstructionBlockSchema = import_zod9.z.union([
   // Scalar shorthand: `instructions: >- …` — the common case, unscoped.
-  import_zod9.z.string().min(1).transform((text) => ({ text })),
+  import_zod9.z.string().min(1).transform((text2) => ({ text: text2 })),
   import_zod9.z.object({
     text: import_zod9.z.string().min(1),
     profile: import_zod9.z.array(import_zod9.z.string().min(1)).min(1).optional()
@@ -12361,21 +12794,21 @@ function buildCodeIndex(model) {
   const declarations = /* @__PURE__ */ new Map();
   const anchors = /* @__PURE__ */ new Map();
   const findingAnchors = /* @__PURE__ */ new Map();
-  const namesAt = (cache, path29, make) => {
-    const cached = cache.get(path29);
+  const namesAt = (cache, path31, make) => {
+    const cached = cache.get(path31);
     if (cached) return cached;
-    const f = facts.get(path29);
+    const f = facts.get(path31);
     if (!f) return NO_NAMES;
     const built = make(f);
-    cache.set(path29, built);
+    cache.set(path31, built);
     return built;
   };
   const republished = /* @__PURE__ */ new Map();
-  const republishedFrom = (path29) => {
-    const cached = republished.get(path29);
+  const republishedFrom = (path31) => {
+    const cached = republished.get(path31);
     if (cached) return cached;
-    const out = /* @__PURE__ */ new Set([path29]);
-    const queue = [path29];
+    const out = /* @__PURE__ */ new Set([path31]);
+    const queue = [path31];
     while (queue.length) {
       const from = queue.pop();
       const f = facts.get(from);
@@ -12388,7 +12821,7 @@ function buildCodeIndex(model) {
         }
       }
     }
-    republished.set(path29, out);
+    republished.set(path31, out);
     return out;
   };
   const NO_ORIGIN = /* @__PURE__ */ new Set();
@@ -12397,9 +12830,9 @@ function buildCodeIndex(model) {
     return to ? republishedFrom(to) : NO_ORIGIN;
   };
   const scopeOf = (site, from) => {
-    const path29 = pathKey(site.from ?? from);
-    const f = facts.get(path29);
-    return f?.status === "analyzed" && f.analysisGrade === "exact" ? { path: path29, facts: f } : void 0;
+    const path31 = pathKey(site.from ?? from);
+    const f = facts.get(path31);
+    return f?.status === "analyzed" && f.analysisGrade === "exact" ? { path: path31, facts: f } : void 0;
   };
   const originOf2 = (site, from) => {
     const resolved = scopeOf(site, from);
@@ -12438,16 +12871,39 @@ function buildCodeIndex(model) {
     if (site.via) for (const typeName of localTypesOf(f, site.via)) widenThroughType(typeName);
     return out;
   };
-  const declarationsAt = (path29) => namesAt(declarations, pathKey(path29), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames]));
+  const declarationsAt = (path31) => namesAt(declarations, pathKey(path31), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames]));
+  const forwardsOf = (start, name) => {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    const queue = [{ file: pathKey(start), name }];
+    while (queue.length) {
+      const at = queue.shift();
+      const key = `${at.file}#${at.name}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(at);
+      for (const binding of facts.get(at.file)?.reexportBindings ?? []) {
+        const star = binding.exported === "*";
+        if (!star && binding.exported !== at.name) continue;
+        if (star && at.name === "default") continue;
+        const to = resolveImport(at.file, binding.from, paths);
+        if (!to) continue;
+        if (star && !facts.get(to)?.exportedNames.includes(at.name)) continue;
+        queue.push({ file: to, name: star ? at.name : binding.local });
+      }
+    }
+    return out;
+  };
   return {
     paths,
     exactPaths,
-    factsAt: (path29) => facts.get(pathKey(path29)),
+    factsAt: (path31) => facts.get(pathKey(path31)),
     declarationsAt,
-    anchorsAt: (path29) => namesAt(anchors, pathKey(path29), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames, ...f.anchoredNames])),
-    findingAnchorsAt: (path29) => namesAt(findingAnchors, pathKey(path29), (f) => new Set(f.anchoredNames)),
+    anchorsAt: (path31) => namesAt(anchors, pathKey(path31), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames, ...f.anchoredNames])),
+    findingAnchorsAt: (path31) => namesAt(findingAnchors, pathKey(path31), (f) => new Set(f.anchoredNames)),
     originOf: originOf2,
-    possibleOriginsOf
+    possibleOriginsOf,
+    forwardsOf
   };
 }
 function buildRealizationIndex(ctx) {
@@ -12483,10 +12939,10 @@ function buildRealizationIndex(ctx) {
   return {
     paths,
     implementationsOf: (compId) => implsByComponent.get(compId) ?? NONE_IMPL,
-    implementationsAt: (path29) => implsByPath.get(pathKey(path29)) ?? NONE_IMPL,
+    implementationsAt: (path31) => implsByPath.get(pathKey(path31)) ?? NONE_IMPL,
     filesOf: (compId) => filesByComponent.get(compId) ?? NONE_PATH,
     filesIn: (subsystemId) => filesBySubsystem.get(subsystemId) ?? NONE_PATH,
-    componentsAt: (path29) => componentsByPath.get(pathKey(path29)) ?? NONE_COMP
+    componentsAt: (path31) => componentsByPath.get(pathKey(path31)) ?? NONE_COMP
   };
 }
 function buildImportGraph(index, universe) {
@@ -12498,22 +12954,22 @@ function buildImportGraph(index, universe) {
       if (to && to !== from) into.add(to);
     }
   };
-  const importsOf = (path29) => {
-    const cached = imports.get(path29);
+  const importsOf = (path31) => {
+    const cached = imports.get(path31);
     if (cached) return cached;
-    const facts = index.factsAt(path29);
+    const facts = index.factsAt(path31);
     const out = /* @__PURE__ */ new Set();
-    if (facts?.status === "analyzed") resolveAll(path29, facts.imports, out);
-    imports.set(path29, out);
+    if (facts?.status === "analyzed") resolveAll(path31, facts.imports, out);
+    imports.set(path31, out);
     return out;
   };
-  const tracesOf = (path29) => {
-    const cached = traces.get(path29);
+  const tracesOf = (path31) => {
+    const cached = traces.get(path31);
     if (cached) return cached;
-    const facts = index.factsAt(path29);
-    const out = new Set(importsOf(path29));
-    if (facts?.status === "analyzed") resolveAll(path29, facts.reexports, out);
-    traces.set(path29, out);
+    const facts = index.factsAt(path31);
+    const out = new Set(importsOf(path31));
+    if (facts?.status === "analyzed") resolveAll(path31, facts.reexports, out);
+    traces.set(path31, out);
     return out;
   };
   return {
@@ -13850,11 +14306,11 @@ var unconditionalCallCyclesRule = {
       const memberEdges = keys.flatMap((k) => (adjacency.get(k) ?? []).filter((e) => inScc.has(e.toKey)));
       if (memberEdges.length === 0) continue;
       const anchor = [...memberEdges].sort((a, b) => byCodeUnit(a.fromKey, b.fromKey) || byCodeUnit(a.impl.id, b.impl.id) || a.stepNumber - b.stepNumber)[0];
-      const path29 = [...keys].sort(byCodeUnit).join(" \u2192 ");
+      const path31 = [...keys].sort(byCodeUnit).join(" \u2192 ");
       ctx.addIssue(
         "warning",
         "UNCONDITIONAL_CALL_CYCLE",
-        `Call cycle with no guard: ${path29} \u2014 every call edge in this cycle is unavoidable on all paths of its narrative (e.g. step ${anchor.stepNumber} of "${anchor.methodName}" in "${anchor.impl.id}" always calls ${anchor.toLabel}). This recurses without a base case, by construction. Guard at least one edge with a branch/return before the call, or lint.allow with the termination argument.`,
+        `Call cycle with no guard: ${path31} \u2014 every call edge in this cycle is unavoidable on all paths of its narrative (e.g. step ${anchor.stepNumber} of "${anchor.methodName}" in "${anchor.impl.id}" always calls ${anchor.toLabel}). This recurses without a base case, by construction. Guard at least one edge with a branch/return before the call, or lint.allow with the termination argument.`,
         anchor.impl.id,
         memberEdges.some((e) => ctx.isImplementationDraft(e.impl))
       );
@@ -15521,8 +15977,8 @@ var lifecycleRule = {
 };
 
 // src/core/rules/wiring/portal-mounts.ts
-function liesUnder(path29, prefix) {
-  return path29 === prefix || path29.startsWith(prefix + "/");
+function liesUnder(path31, prefix) {
+  return path31 === prefix || path31.startsWith(prefix + "/");
 }
 var portalMountsRule = {
   name: "portal-mounts",
@@ -15975,8 +16431,8 @@ function componentOfImpl(ctx, implContract) {
 }
 var CLAIM_PHRASES = /\b(persist(s|ed|ent|ing|ence)?|survives?\s+(a\s+)?restart|writ(es?|ten)\s+to\s+disk|registered\s+into|durabl[ey])\b/i;
 var QUOTED_SPAN = /"[^"]*"|“[^”]*”|`[^`]*`|(?<![\p{L}\p{N}])['‘](?:[^'‘’]|(?<=[\p{L}\p{N}])['’](?=[\p{L}\p{N}]))*['’](?![\p{L}\p{N}])/gu;
-function withoutQuotedText(text) {
-  return text.replace(QUOTED_SPAN, " ");
+function withoutQuotedText(text2) {
+  return text2.replace(QUOTED_SPAN, " ");
 }
 var proseClaimRule = {
   name: "prose-claims",
@@ -16510,6 +16966,25 @@ function resolveCallTarget(ctx, componentId, methodName) {
   }
   return { accepted, files };
 }
+function isTarget(pairs, target) {
+  return pairs.some((p) => target.files.has(p.file) && target.accepted.has(p.name));
+}
+function invokedAs(code, site, file) {
+  const scope = pathKey(site.from ?? file);
+  const facts = code.factsAt(scope);
+  if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") return [];
+  if (!site.member) {
+    const binding = importBindingOf(facts, site.name);
+    if (!binding || binding.namespace) return [];
+    const module3 = resolveImport(scope, binding.from, code.paths);
+    return module3 ? code.forwardsOf(module3, binding.imported ?? site.name) : [];
+  }
+  if (!site.via) return [];
+  const receiver = importBindingOf(facts, site.via);
+  if (!receiver?.namespace) return [];
+  const module2 = resolveImport(scope, receiver.from, code.paths);
+  return module2 ? code.forwardsOf(module2, site.name) : [];
+}
 function claimsOf(implMethod) {
   const claims = [];
   for (const step of implMethod.narrative) {
@@ -16575,6 +17050,7 @@ var callConformanceRule = {
         if (!ctx.componentMap.has(claim.component)) continue;
         const target = resolveCallTarget(ctx, claim.component, claim.method);
         if (target.accepted.has(fnSymbol)) continue;
+        if (isTarget(code.forwardsOf(file, fnSymbol), target)) continue;
         const matching = sites.filter((s) => target.accepted.has(s.name));
         const ref = `${claim.component}.${claim.method}`;
         if (target.files.size === 0) {
@@ -16583,6 +17059,7 @@ var callConformanceRule = {
           }
           continue;
         }
+        if (sites.some((s) => !target.accepted.has(s.name) && isTarget(invokedAs(code, s, file), target))) continue;
         const landed = /* @__PURE__ */ new Set();
         let realized = false;
         for (const site of matching) {
@@ -16690,11 +17167,11 @@ var hiddenStateRule = {
         byPath.set(key, list);
       }
     }
-    for (const path29 of code.exactPaths) {
-      const facts = code.factsAt(path29);
+    for (const path31 of code.exactPaths) {
+      const facts = code.factsAt(path31);
       const bindings = facts.topLevelMutableBindings ?? [];
       if (bindings.length === 0) continue;
-      const mapped = byPath.get(path29) ?? [];
+      const mapped = byPath.get(path31) ?? [];
       if (mapped.length === 0) continue;
       if (!mapped.every((m) => isStatelessLogic(m.component))) continue;
       const anchor = [...mapped].sort((a, b) => a.impl.id.localeCompare(b.impl.id))[0];
@@ -16760,7 +17237,7 @@ var dependencyConformanceRule = {
       }
       return false;
     };
-    const draftAt = (path29) => realization.implementationsAt(path29).some((impl) => ctx.isImplementationDraft(impl));
+    const draftAt = (path31) => realization.implementationsAt(path31).some((impl) => ctx.isImplementationDraft(impl));
     for (const fromPath of mappedPaths) {
       const fromComponents = realization.componentsAt(fromPath);
       for (const toPath of graph.importsOf(fromPath)) {
@@ -16845,7 +17322,7 @@ var portalImportsRule = {
       }
       return files;
     };
-    const draftAt = (path29) => realization.implementationsAt(path29).some((impl) => ctx.isImplementationDraft(impl));
+    const draftAt = (path31) => realization.implementationsAt(path31).some((impl) => ctx.isImplementationDraft(impl));
     for (const fromPath of mappedPaths) {
       const fromSubsystems = new Set(realization.componentsAt(fromPath).map((c) => c.subsystem));
       for (const toPath of graph.importsOf(fromPath)) {
@@ -17306,7 +17783,7 @@ var paramConformanceRule = {
       codeNameOf.set(type.id, named);
       if (type.subsystem) codeNameOf.set(`${type.subsystem}.${type.id}`, named);
     }
-    const normalize3 = (text) => text.replace(/\s+/g, " ").trim();
+    const normalize3 = (text2) => text2.replace(/\s+/g, " ").trim();
     const typeAgrees = (declared, realized) => {
       if (!realized.type) return false;
       const stated = normalize3(declared.type);
@@ -17381,8 +17858,8 @@ var paramConformanceRule = {
 };
 
 // src/core/rules/conformance/route-coverage.ts
-function liesUnder2(path29, prefix) {
-  return path29 === prefix || path29.startsWith(prefix + "/");
+function liesUnder2(path31, prefix) {
+  return path31 === prefix || path31.startsWith(prefix + "/");
 }
 function normalizeSegment(segment) {
   return /^\{.+\}$/.test(segment) || segment.startsWith(":") ? "*" : segment;
@@ -18137,9 +18614,9 @@ function makeMatcher(tech) {
   const joined = parts.join("");
   if (joined.length < 3) return null;
   const n = parts.length;
-  return (text) => {
-    if (!text) return false;
-    const words2 = text.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+  return (text2) => {
+    if (!text2) return false;
+    const words2 = text2.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
     if (words2.some((w) => w.includes(joined))) return true;
     if (n < 2) return false;
     for (let i = 0; i + n <= words2.length; i++) {
@@ -19077,6 +19554,9 @@ function ruleSequence() {
   const audits = [carriedDebtRule, lintAllowsRule].filter((r) => ruleSet.includes(r));
   return [...ruleSet.filter((r) => !audits.includes(r)), ...audits];
 }
+function specScopedRules() {
+  return ruleSequence().filter((r) => r.scope === "spec");
+}
 function knownIssueCodes() {
   return listRules().flatMap((r) => r.codes);
 }
@@ -19211,8 +19691,8 @@ LANGUAGE_PATTERNS.cpp = LANGUAGE_PATTERNS.c;
 var PATTERN_ANALYSIS_MAX_BYTES = 1e6;
 var IDENTIFIER_RE = /[A-Za-z_$][\w$]*/g;
 var STRING_RE = /'([^'\\\n]*(?:\\.[^'\\\n]*)*)'|"([^"\\\n]*(?:\\.[^"\\\n]*)*)"|`([^`\\]*(?:\\.[^`\\]*)*)`/g;
-function stripComments(text, patterns) {
-  let out = text;
+function stripComments(text2, patterns) {
+  let out = text2;
   for (const [open, close] of patterns.blockComments) {
     const re = new RegExp(`${escapeRe(open)}[\\s\\S]*?${escapeRe(close)}`, "g");
     out = out.replace(re, " ");
@@ -19238,16 +19718,16 @@ function boundNames(captured, localOnly) {
   }
   return names;
 }
-function collectStrings(text) {
+function collectStrings(text2) {
   const anchors = /* @__PURE__ */ new Set();
-  for (const m of text.matchAll(STRING_RE)) {
+  for (const m of text2.matchAll(STRING_RE)) {
     const value = m[1] ?? m[2] ?? m[3];
     if (value) anchors.add(value);
   }
   return anchors;
 }
-function analyzeWithPatterns(text, patterns) {
-  const stripped = stripComments(text, patterns);
+function analyzeWithPatterns(text2, patterns) {
+  const stripped = stripComments(text2, patterns);
   const declared = /* @__PURE__ */ new Set();
   const exported = /* @__PURE__ */ new Set();
   const imports = /* @__PURE__ */ new Set();
@@ -19275,7 +19755,7 @@ function analyzeWithPatterns(text, patterns) {
       }
     }
   }
-  const anchors = collectStrings(text);
+  const anchors = collectStrings(text2);
   for (const m of stripped.matchAll(IDENTIFIER_RE)) anchors.add(m[0]);
   return {
     analysisGrade: "pattern",
@@ -19286,11 +19766,11 @@ function analyzeWithPatterns(text, patterns) {
     reexports: []
   };
 }
-function analyzeGeneric(text) {
+function analyzeGeneric(text2) {
   const words2 = /* @__PURE__ */ new Set();
-  for (const m of text.matchAll(IDENTIFIER_RE)) words2.add(m[0]);
+  for (const m of text2.matchAll(IDENTIFIER_RE)) words2.add(m[0]);
   const anchors = new Set(words2);
-  for (const s of collectStrings(text)) anchors.add(s);
+  for (const s of collectStrings(text2)) anchors.add(s);
   return {
     analysisGrade: "generic",
     declaredNames: [...words2],
@@ -19860,14 +20340,14 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
       files.push({ path: sourcePath, status: "unreadable", ...empty });
       continue;
     }
-    const text = buffer.toString("utf8");
+    const text2 = buffer.toString("utf8");
     const language = EXTENSION_LANGUAGE[path13.extname(sourcePath).toLowerCase()];
     let analyzed;
     if (language === "typescript" || language === "javascript") {
       const ts = resolveTypeScript(projectRoot);
       if (ts) {
         try {
-          const facts = walkExact(ts, text, absolute);
+          const facts = walkExact(ts, text2, absolute);
           chaseReexports(ts, facts, absolute, projectRoot, /* @__PURE__ */ new Set([absolute]), exactCache);
           analyzed = {
             analysisGrade: "exact",
@@ -19876,6 +20356,10 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
             exportedNames: [...facts.exported],
             imports: [...facts.imports],
             reexports: [...facts.reexports],
+            reexportBindings: [
+              ...facts.namedReexports.map(({ exported, local, from }) => ({ exported, local, from })),
+              ...facts.starExports.map((from) => ({ exported: "*", local: "*", from }))
+            ],
             functionComplexity: Object.fromEntries(facts.complexity),
             functionCallSites: Object.fromEntries([...facts.calls].map(([k, v]) => [k, [...v.values()]])),
             importBindings: Object.fromEntries(facts.importBindings),
@@ -19889,20 +20373,159 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
             reexportOnly: facts.reexportOnly
           };
         } catch {
-          analyzed = analyzeGeneric(text);
+          analyzed = analyzeGeneric(text2);
         }
       } else {
-        analyzed = analyzeWithPatterns(text, LANGUAGE_PATTERNS[language]);
+        analyzed = analyzeWithPatterns(text2, LANGUAGE_PATTERNS[language]);
       }
-    } else if (language && LANGUAGE_PATTERNS[language] && text.length <= PATTERN_ANALYSIS_MAX_BYTES) {
-      analyzed = analyzeWithPatterns(text, LANGUAGE_PATTERNS[language]);
+    } else if (language && LANGUAGE_PATTERNS[language] && text2.length <= PATTERN_ANALYSIS_MAX_BYTES) {
+      analyzed = analyzeWithPatterns(text2, LANGUAGE_PATTERNS[language]);
     } else {
-      analyzed = analyzeGeneric(text);
+      analyzed = analyzeGeneric(text2);
     }
     files.push({ path: sourcePath, status: "analyzed", language, ...analyzed });
   }
   return { files, projectRoot, rootFiles };
 }
+var IMPORT_FROM_RE = /(?:^|;)[ \t]*import\s+(?!\()([^'";]*?)\s*from\s*['"]([^'"]+)['"]/gm;
+var DYNAMIC_IMPORT_RE = /\{([^{}]*)\}\s*=\s*await\s+import\(\s*['"]([^'"]+)['"]\s*\)/g;
+var IDENTIFIER_ONLY_RE = /^[A-Za-z_$][\w$]*$/;
+function clauseBindings(clause, specifier) {
+  const out = [];
+  const body = clause.replace(/^\s*type\s+/, "");
+  const named = /\{([^}]*)\}/.exec(body);
+  if (named) {
+    for (const piece of named[1].split(",")) {
+      const sides = piece.replace(/^\s*type\s+/, "").split(/\s+as\s+/).map((s) => s.trim());
+      const exported = sides[0];
+      const local = sides[1] ?? exported;
+      if (IDENTIFIER_ONLY_RE.test(exported) && IDENTIFIER_ONLY_RE.test(local)) out.push({ exported, local, specifier });
+    }
+  }
+  const namespace = /\*\s*as\s+([A-Za-z_$][\w$]*)/.exec(body);
+  if (namespace) out.push({ exported: "*", local: namespace[1], specifier });
+  const head = body.replace(/\{[^}]*\}/, "").replace(/\*\s*as\s+[A-Za-z_$][\w$]*/, "");
+  const defaulted = /^\s*([A-Za-z_$][\w$]*)/.exec(head);
+  if (defaulted) out.push({ exported: "default", local: defaulted[1], specifier });
+  return out;
+}
+function readTestFiles(testRoots, projectRoot) {
+  const scanned = [];
+  for (const key of walkDeclaredRoots(testRoots, [], projectRoot)) {
+    let text2;
+    try {
+      const buffer = fs10.readFileSync(path13.resolve(projectRoot, key));
+      if (looksBinary(buffer)) continue;
+      text2 = buffer.toString("utf8");
+    } catch {
+      continue;
+    }
+    const imports = /* @__PURE__ */ new Set();
+    for (const m of text2.matchAll(NAMED_IMPORT_BINDINGS_RE)) {
+      for (const name of boundNames(m[1] ?? "", false)) imports.add(name);
+    }
+    const code = stripComments(text2, JS_PATTERNS);
+    const bindings = [];
+    for (const m of code.matchAll(IMPORT_FROM_RE)) bindings.push(...clauseBindings(m[1], m[2]));
+    for (const m of code.matchAll(DYNAMIC_IMPORT_RE)) bindings.push(...clauseBindings(`{${m[1].replace(/:/g, " as ")}}`, m[2]));
+    const words2 = /* @__PURE__ */ new Set();
+    for (const m of text2.matchAll(IDENTIFIER_RE)) words2.add(m[0]);
+    scanned.push({ path: key, imports, bindings, words: words2 });
+  }
+  return scanned;
+}
+var NAMED_REEXPORT_RE = /\bexport\s+(?:type\s+)?\{([^}]*)\}\s*from\s*['"]([^'"]+)['"]/g;
+var STAR_REEXPORT_RE = /\bexport\s+\*\s+from\s*['"]([^'"]+)['"]/g;
+function reexportReader() {
+  const cache = /* @__PURE__ */ new Map();
+  return (file) => {
+    const cached = cache.get(file);
+    if (cached) return cached;
+    const found = { named: [], stars: [] };
+    try {
+      const code = stripComments(fs10.readFileSync(file, "utf8"), JS_PATTERNS);
+      for (const m of code.matchAll(NAMED_REEXPORT_RE)) {
+        for (const piece of m[1].split(",")) {
+          const sides = piece.replace(/^\s*type\s+/, "").split(/\s+as\s+/).map((s) => s.trim());
+          if (!IDENTIFIER_ONLY_RE.test(sides[0] ?? "")) continue;
+          found.named.push({ local: sides[0], exported: sides[1] ?? sides[0], specifier: m[2] });
+        }
+      }
+      for (const m of code.matchAll(STAR_REEXPORT_RE)) found.stars.push(m[1]);
+    } catch {
+    }
+    cache.set(file, found);
+    return found;
+  };
+}
+function publishesFrom(module2, name, target, symbol, readReexports, visited = /* @__PURE__ */ new Set()) {
+  if (path13.resolve(module2) === target && name === symbol) return true;
+  const key = `${module2}#${name}`;
+  if (visited.has(key)) return false;
+  visited.add(key);
+  const reexports = readReexports(module2);
+  for (const re of reexports.named) {
+    if (re.exported !== name) continue;
+    const next = resolveRelativeModule(module2, re.specifier);
+    if (next && publishesFrom(next, re.local, target, symbol, readReexports, visited)) return true;
+  }
+  if (name === "default") return false;
+  for (const specifier of reexports.stars) {
+    const next = resolveRelativeModule(module2, specifier);
+    if (next && publishesFrom(next, name, target, symbol, readReexports, visited)) return true;
+  }
+  return false;
+}
+function findTestsReferencing(methods, projectRoot, testRoots = []) {
+  const scanned = readTestFiles(testRoots, projectRoot);
+  if (scanned.length === 0) return [];
+  const indiscriminateAbove = scanned.length / 10;
+  const searches = [];
+  for (const method of methods) {
+    const symbol = method.symbol ?? method.name;
+    let search = searches.find((s) => s.method === method.name && s.symbol === symbol);
+    if (!search) {
+      search = { method: method.name, symbol, files: [] };
+      searches.push(search);
+    }
+    const file = method.sourcePath ? path13.resolve(projectRoot, method.sourcePath) : void 0;
+    if (file && !search.files.includes(file)) search.files.push(file);
+  }
+  const readReexports = reexportReader();
+  const found = [];
+  for (const { method, symbol, files } of searches) {
+    const imported = [];
+    const mentioned = [];
+    for (const test of scanned) {
+      if (files.length === 0) {
+        if (test.imports.has(symbol)) imported.push(test.path);
+        else if (test.words.has(symbol)) mentioned.push(test.path);
+        continue;
+      }
+      const testFile = path13.resolve(projectRoot, test.path);
+      const fromMethod = (binding, name) => {
+        const module2 = resolveRelativeModule(testFile, binding.specifier);
+        return module2 !== null && files.some((target) => publishesFrom(module2, name, target, symbol, readReexports));
+      };
+      const naming = test.bindings.filter((b) => b.exported === symbol || b.local === symbol);
+      if (test.bindings.some((b) => b.exported !== "*" && fromMethod(b, b.exported)) || test.words.has(symbol) && test.bindings.some((b) => b.exported === "*" && fromMethod(b, symbol))) {
+        imported.push(test.path);
+      } else if (naming.length === 0 && test.words.has(symbol)) {
+        mentioned.push(test.path);
+      }
+    }
+    const indiscriminate = mentioned.length > indiscriminateAbove;
+    if (imported.length === 0 && mentioned.length === 0) continue;
+    found.push({
+      method,
+      symbol,
+      imported,
+      mentioned: indiscriminate ? [] : mentioned,
+      indiscriminate
+    });
+  }
+  return found;
+}
 
 // src/core/rules/index.ts
 function composeRuleSequence(extraRules = []) {
@@ -20275,7 +20898,7 @@ function buildRuleContext(opts) {
     }
     const severity = getRuleSeverity(code, defaultSeverity, isDraftContext, owner);
     if (severity === "off") return;
-    let text = message;
+    let text2 = message;
     if (specId) {
       const key = `${specId}\0${code}`;
       let seen = sitesSeen.get(key);
@@ -20293,7 +20916,7 @@ function buildRuleContext(opts) {
         if (grew.length === 0) {
           if (severity === "warning") return;
         } else {
-          text = `${text} A lint.allow covers this site, but not ${grew.length} part(s) of it \u2014 ${grew.map((u) => `"${u}"`).join("; ")} ${grew.length === 1 ? "is" : "are"} new. Decide on them: add them to the allow's \`covers\` with a reason that is actually true, or fix them.`;
+          text2 = `${text2} A lint.allow covers this site, but not ${grew.length} part(s) of it \u2014 ${grew.map((u) => `"${u}"`).join("; ")} ${grew.length === 1 ? "is" : "are"} new. Decide on them: add them to the allow's \`covers\` with a reason that is actually true, or fix them.`;
         }
       }
     }
@@ -20308,13 +20931,13 @@ function buildRuleContext(opts) {
           else grew.push(unit);
         }
         if (grew.length === 0) return;
-        text = `${text} The conformance debt register carries this finding, but not ${grew.length} part(s) of it \u2014 ${grew.map((u) => `"${u}"`).join("; ")} ${grew.length === 1 ? "is" : "are"} new. Fix them, or add them to the entry's \`covers\` with a reason that is actually true.`;
+        text2 = `${text2} The conformance debt register carries this finding, but not ${grew.length} part(s) of it \u2014 ${grew.map((u) => `"${u}"`).join("; ")} ${grew.length === 1 ? "is" : "are"} new. Fix them, or add them to the entry's \`covers\` with a reason that is actually true.`;
       }
     }
     issues.push({
       severity,
       code,
-      message: text,
+      message: text2,
       specId,
       ...isDraftContext ? { draftContext: true } : {},
       ...surfaceResolved ? { surfaceResolved: true } : {}
@@ -20399,6 +21022,54 @@ function buildRuleContext(opts) {
   return ctx;
 }
 
+// src/core/rules/candidate.ts
+function stubSystem() {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    schemaVersion: "1.0.0",
+    name: "candidate",
+    vision: "",
+    boundaries: [],
+    globalRequirements: [],
+    databases: [],
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function validateComponentCandidate(candidate, opts = {}) {
+  const issues = [];
+  registerBuiltinRules();
+  if (opts.extensions?.rules?.length) registerPackRules(opts.extensions.rules);
+  const knownCodes = /* @__PURE__ */ new Set([
+    ...knownIssueCodes().map((rc) => rc.code),
+    ...(opts.extensions?.assertions ?? []).map((a) => a.fullCode)
+  ]);
+  const ctx = buildRuleContext({
+    system: stubSystem(),
+    subsystems: [],
+    components: [candidate],
+    interfaces: [],
+    implementations: [],
+    types: [],
+    rules: opts.rules,
+    projectType: opts.projectType ?? "backend",
+    extensions: opts.extensions,
+    // Only a tree-scoped rule reads these (roundtrip-serialization); no
+    // spec-scoped rule does, so a candidate carries none.
+    roundTripIssues: [],
+    knownIssueCodes: knownCodes,
+    issues
+  });
+  for (const rule of specScopedRules()) {
+    rule.check(ctx);
+  }
+  const own = issues.filter((i) => !i.specId || i.specId === candidate.id);
+  return {
+    errors: own.filter((i) => i.severity === "error"),
+    warnings: own.filter((i) => i.severity === "warning")
+  };
+}
+
 // src/core/validation.ts
 var path14 = __toESM(require("path"));
 function projectPackSelections() {
@@ -20408,6 +21079,9 @@ function projectPackSelections() {
     return [];
   }
 }
+function findTestsReferencing2(methods, projectRoot, testRoots = []) {
+  return findTestsReferencing(methods, projectRoot, testRoots);
+}
 var RESOLUTION_FAILURE_CODES = /* @__PURE__ */ new Set([
   "UNDEFINED_TYPE_REFERENCE",
   "INVALID_DEPENDENCY_REFERENCE",
@@ -20446,6 +21120,67 @@ function stricterSeverities(parent, child) {
 function issue(severity, code, message, agentId, specId) {
   return { severity, code, message, agentId, specId };
 }
+function validateRegistry(registry, rules) {
+  const issues = [];
+  const idCounts = /* @__PURE__ */ new Map();
+  for (const agent of registry.agents) {
+    idCounts.set(agent.id, (idCounts.get(agent.id) ?? 0) + 1);
+  }
+  for (const [id, count] of idCounts) {
+    if (count > 1) {
+      issues.push(issue("error", "DUPLICATE_AGENT_ID", `Duplicate agent id: "${id}"`, id));
+    }
+  }
+  for (const agent of registry.agents) {
+    validateAgent(agent, rules, issues);
+  }
+  if (rules.noOverlappingOwnership) {
+    checkOverlappingOwnership(registry.agents, issues);
+  }
+  return {
+    valid: issues.every((i) => i.severity !== "error"),
+    issues
+  };
+}
+function validateAgent(agent, rules, issues) {
+  const isMeta = agent.tags.some((t) => rules.metaAgentTags.includes(t));
+  if (rules.requireOwnedPaths && !isMeta && agent.ownedPaths.length === 0) {
+    issues.push(
+      issue(
+        "warning",
+        "NO_OWNED_PATHS",
+        `Agent "${agent.id}" has no ownedPaths. Add paths or tag as meta/guardian.`,
+        agent.id
+      )
+    );
+  }
+  if (agent.targets.length === 0) {
+    issues.push(
+      issue("warning", "NO_TARGETS", `Agent "${agent.id}" has no output targets configured.`, agent.id)
+    );
+  }
+}
+function checkOverlappingOwnership(agents, issues) {
+  const pathToAgents = /* @__PURE__ */ new Map();
+  for (const agent of agents) {
+    for (const p of agent.ownedPaths) {
+      const owners = pathToAgents.get(p) ?? [];
+      owners.push(agent.id);
+      pathToAgents.set(p, owners);
+    }
+  }
+  for (const [p, owners] of pathToAgents) {
+    if (owners.length > 1) {
+      issues.push(
+        issue(
+          "error",
+          "OVERLAPPING_OWNERSHIP",
+          `Path "${p}" is claimed by multiple agents: ${owners.join(", ")}`
+        )
+      );
+    }
+  }
+}
 function validateSddTree(rulesOrOptions, projectType = "backend") {
   let rules = rulesOrOptions;
   let scopeSubsystem;
@@ -20631,16 +21366,16 @@ function resolveThroughParent(boundRoot, treatAllAsComplete, childRules) {
   }));
   return { root: top, scope, issues };
 }
-function stripNamespace(text, scope) {
+function stripNamespace(text2, scope) {
   const prefix = `${scope}::`;
   let out = "";
   let from = 0;
-  for (let at = text.indexOf(prefix); at !== -1; at = text.indexOf(prefix, from)) {
-    const atBoundary = at === 0 || !isIdChar(text[at - 1]);
-    out += text.slice(from, at) + (atBoundary ? "" : prefix);
+  for (let at = text2.indexOf(prefix); at !== -1; at = text2.indexOf(prefix, from)) {
+    const atBoundary = at === 0 || !isIdChar(text2[at - 1]);
+    out += text2.slice(from, at) + (atBoundary ? "" : prefix);
     from = at + prefix.length;
   }
-  return out + text.slice(from);
+  return out + text2.slice(from);
 }
 function isIdChar(ch) {
   return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_" || ch === "-" || ch === "." || ch === ":";
@@ -20833,11 +21568,11 @@ var IdPool = class {
     return candidate;
   }
 };
-function escapeLabel(text) {
-  return text.replace(/"/g, "#quot;");
+function escapeLabel(text2) {
+  return text2.replace(/"/g, "#quot;");
 }
-function truncate(text, max) {
-  const clean = text.replace(/\s+/g, " ").trim();
+function truncate(text2, max) {
+  const clean = text2.replace(/\s+/g, " ").trim();
   return clean.length <= max ? clean : `${clean.slice(0, max - 1)}\u2026`;
 }
 function nodeDecl(id, label, comp) {
@@ -21684,8 +22419,8 @@ function rewriteSpecRefs(raw, remap) {
 }
 function summarizeValue(value) {
   if (value === void 0) return "";
-  const text = typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
-  return text.length > 120 ? `${text.slice(0, 117)}...` : text;
+  const text2 = typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
+  return text2.length > 120 ? `${text2.slice(0, 117)}...` : text2;
 }
 function identityKeyOf(field, item) {
   if (item === null || typeof item !== "object") return null;
@@ -21760,6 +22495,9 @@ function specChanges(before, after, prefix = "") {
     if (after.length === 0 && before.length > 0) {
       return [{ path: prefix, change: "cleared", before: summarizeValue(before) }];
     }
+    if ((prefix.split(".").pop() ?? prefix) === "narrative" && [...before, ...after].every((i) => i !== null && typeof i === "object" && !Array.isArray(i))) {
+      return narrativeChanges(before, after, prefix);
+    }
     const identified = [...before, ...after].every((i) => reportIdentityOf(prefix.split(".").pop() ?? prefix, i) !== null);
     if (!identified) {
       return JSON.stringify(before) === JSON.stringify(after) ? [] : [{ path: prefix, change: "set", before: summarizeValue(before), after: summarizeValue(after) }];
@@ -21793,6 +22531,152 @@ function specChanges(before, after, prefix = "") {
   if (JSON.stringify(before) === JSON.stringify(after)) return [];
   return [{ path: prefix, change: "set", before: summarizeValue(before), after: summarizeValue(after) }];
 }
+var STEP_JUMP_FIELDS = ["onTrueStep", "onFalseStep", "defaultStep", "endStep", "finallyStep", "toStep"];
+var STEP_JUMP_LISTS = [["cases", "value"], ["catches", "error"], ["branches", "name"]];
+function jumpsOf(step) {
+  const jumps = /* @__PURE__ */ new Map();
+  for (const field of STEP_JUMP_FIELDS) {
+    if (typeof step[field] === "number") jumps.set(field, step[field]);
+  }
+  for (const [list, name] of STEP_JUMP_LISTS) {
+    const entries = step[list];
+    if (!Array.isArray(entries)) continue;
+    entries.forEach((entry, i) => {
+      if (entry && typeof entry.step === "number") jumps.set(`${list}.${String(entry[name] ?? i)}.step`, entry.step);
+    });
+  }
+  return jumps;
+}
+function withoutNumbers(step) {
+  const out = { ...step };
+  delete out.stepNumber;
+  for (const field of STEP_JUMP_FIELDS) delete out[field];
+  for (const [list] of STEP_JUMP_LISTS) {
+    if (Array.isArray(out[list])) {
+      out[list] = out[list].map((entry) => {
+        if (!entry || typeof entry !== "object") return entry;
+        const { step: _step, ...rest } = entry;
+        return rest;
+      });
+    }
+  }
+  return out;
+}
+function canonicalJson(value) {
+  return JSON.stringify(value, (_key, v) => v && typeof v === "object" && !Array.isArray(v) ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, v[k]])) : v);
+}
+function commonRun(a, b, same) {
+  const rows = a.length + 1;
+  const cols = b.length + 1;
+  const table = new Uint32Array(rows * cols);
+  for (let i2 = a.length - 1; i2 >= 0; i2--) {
+    for (let j2 = b.length - 1; j2 >= 0; j2--) {
+      table[i2 * cols + j2] = same(a[i2], b[j2]) ? table[(i2 + 1) * cols + j2 + 1] + 1 : Math.max(table[(i2 + 1) * cols + j2], table[i2 * cols + j2 + 1]);
+    }
+  }
+  const pairs = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    if (same(a[i], b[j])) {
+      pairs.push([i, j]);
+      i++;
+      j++;
+    } else if (table[(i + 1) * cols + j] >= table[i * cols + j + 1]) i++;
+    else j++;
+  }
+  return pairs;
+}
+function recognisablySame(a, b) {
+  if (typeof a.description === "string" && a.description === b.description) return true;
+  if (typeof a.label === "string" && a.label === b.label) return true;
+  return typeof a.targetComponent === "string" && a.type === b.type && a.targetComponent === b.targetComponent && a.targetMethod === b.targetMethod;
+}
+function pairSteps(before, after) {
+  const keysBefore = before.map((s) => canonicalJson(withoutNumbers(s)));
+  const keysAfter = after.map((s) => canonicalJson(withoutNumbers(s)));
+  const anchors = commonRun(keysBefore, keysAfter, (x, y) => x === y);
+  const pairs = [];
+  const bounds = [[-1, -1], ...anchors, [before.length, after.length]];
+  for (let g = 0; g < bounds.length - 1; g++) {
+    const [oi, ni] = bounds[g];
+    const [oj, nj] = bounds[g + 1];
+    const gapBefore = before.slice(oi + 1, oj).map((step, k) => ({ step, at: oi + 1 + k }));
+    const gapAfter = after.slice(ni + 1, nj).map((step, k) => ({ step, at: ni + 1 + k }));
+    const similar = commonRun(gapBefore, gapAfter, (x, y) => recognisablySame(x.step, y.step)).map(([x, y]) => [gapBefore[x].at, gapAfter[y].at]);
+    const inner = [[oi, ni], ...similar, [oj, nj]];
+    for (let k = 0; k < inner.length - 1; k++) {
+      const [a0, b0] = inner[k];
+      const [a1, b1] = inner[k + 1];
+      if (a1 - a0 === b1 - b0) for (let d = 1; d < a1 - a0; d++) pairs.push([a0 + d, b0 + d]);
+      if (k < inner.length - 2) pairs.push(inner[k + 1]);
+    }
+    if (g < bounds.length - 2) pairs.push(bounds[g + 1]);
+  }
+  return pairs.sort((x, y) => x[0] - y[0]);
+}
+function numberOf(step, index) {
+  return typeof step.stepNumber === "number" ? step.stepNumber : index + 1;
+}
+function renumberedRuns(moves) {
+  const runs = [];
+  const range = (a, b) => a === b ? `step ${a}` : `steps ${a}-${b}`;
+  let start = 0;
+  for (let k = 1; k <= moves.length; k++) {
+    const continues = k < moves.length && moves[k][0] === moves[k - 1][0] + 1 && moves[k][1] - moves[k][0] === moves[start][1] - moves[start][0];
+    if (continues) continue;
+    const [firstOld, firstNew] = moves[start];
+    const [lastOld, lastNew] = moves[k - 1];
+    runs.push({ from: range(firstOld, lastOld), to: range(firstNew, lastNew) });
+    start = k;
+  }
+  return runs;
+}
+function narrativeChanges(before, after, prefix) {
+  const pairs = pairSteps(before, after);
+  const oldToNew = /* @__PURE__ */ new Map();
+  for (const [o, n] of pairs) oldToNew.set(numberOf(before[o], o), numberOf(after[n], n));
+  const pairedOld = new Set(pairs.map(([o]) => o));
+  const pairedNew = new Set(pairs.map(([, n]) => n));
+  const removed = before.flatMap((step, o) => pairedOld.has(o) ? [] : [{
+    path: `${prefix}.step ${numberOf(step, o)}`,
+    change: "removed",
+    before: summarizeValue(step)
+  }]);
+  const added = after.flatMap((step, n) => pairedNew.has(n) ? [] : [{
+    path: `${prefix}.step ${numberOf(step, n)}`,
+    change: "added",
+    after: summarizeValue(step)
+  }]);
+  const edited = [];
+  const relocated = [];
+  const moves = [];
+  for (const [o, n] of pairs) {
+    const oldNumber = numberOf(before[o], o);
+    const newNumber = numberOf(after[n], n);
+    const at = oldNumber === newNumber ? `${prefix}.step ${newNumber}` : `${prefix}.step ${newNumber} (was ${oldNumber})`;
+    edited.push(...specChanges(withoutNumbers(before[o]), withoutNumbers(after[n]), at));
+    const oldJumps = jumpsOf(before[o]);
+    const newJumps = jumpsOf(after[n]);
+    for (const field of /* @__PURE__ */ new Set([...oldJumps.keys(), ...newJumps.keys()])) {
+      const was = oldJumps.get(field);
+      const now = newJumps.get(field);
+      if (was === now) continue;
+      if (was === void 0) edited.push({ path: `${at}.${field}`, change: "added", after: String(now) });
+      else if (now === void 0) edited.push({ path: `${at}.${field}`, change: "removed", before: String(was) });
+      else if (oldToNew.get(was) === now) relocated.push({ path: `${at}.${field}`, change: "relocated", before: String(was), after: String(now) });
+      else edited.push({ path: `${at}.${field}`, change: "set", before: String(was), after: String(now) });
+    }
+    if (oldNumber !== newNumber && !edited.some((c) => c.path.startsWith(`${at}.`))) moves.push([oldNumber, newNumber]);
+  }
+  const renumbered = renumberedRuns(moves).map(({ from, to }) => ({
+    path: prefix,
+    change: "renumbered",
+    before: from,
+    after: to
+  }));
+  return [...removed, ...added, ...edited, ...renumbered, ...relocated];
+}
 var DELTA_VERBS = /* @__PURE__ */ new Set(["action", "remove", "captureJumps"]);
 var JUMP_LABEL_TWINS = /* @__PURE__ */ new Set([
   "onTrueLabel",
@@ -21850,13 +22734,13 @@ function ineffectiveDeltaPaths(delta, merged, stored) {
   const isPlain = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
   const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
   const at = (prefix, key) => prefix ? `${prefix}.${key}` : key;
-  const say = (path29, why) => {
-    out.push(`${path29} \u2014 ${why}`);
+  const say = (path31, why) => {
+    out.push(`${path31} \u2014 ${why}`);
   };
-  const walkValue = (d, m, s, path29, field) => {
+  const walkValue = (d, m, s, path31, field) => {
     if (Array.isArray(d)) {
       if (!Array.isArray(m)) {
-        say(path29, "the level does not have this field, so the write dropped it");
+        say(path31, "the level does not have this field, so the write dropped it");
         return;
       }
       if (field === "narrative" && d.some(carriesEditMarker)) return;
@@ -21864,32 +22748,32 @@ function ineffectiveDeltaPaths(delta, merged, stored) {
         if (carriesEditMarker(element)) continue;
         const key = reportIdentityOf(field, element);
         if (key === null) {
-          if (!same(m, d)) say(path29, "the level does not keep this value, so the write dropped it");
-          else if (same(s, d)) say(path29, "the stored spec already held this value");
+          if (!same(m, d)) say(path31, "the level does not keep this value, so the write dropped it");
+          else if (same(s, d)) say(path31, "the stored spec already held this value");
           return;
         }
         const mMatch = m.find((i) => reportIdentityOf(field, i) === key);
         const sMatch = Array.isArray(s) ? s.find((i) => reportIdentityOf(field, i) === key) : void 0;
         if (mMatch === void 0) {
-          say(at(path29, key), "the write did not store this element");
+          say(at(path31, key), "the write did not store this element");
           continue;
         }
-        walk2(element, mMatch, sMatch, at(path29, key), field);
+        walk2(element, mMatch, sMatch, at(path31, key), field);
       }
       return;
     }
     if (isPlain(d)) {
       if (!isPlain(m)) {
-        say(path29, "the level does not have this field, so the write dropped it");
+        say(path31, "the level does not have this field, so the write dropped it");
         return;
       }
-      walk2(d, m, s, path29, field);
+      walk2(d, m, s, path31, field);
       return;
     }
-    if (!same(m, d)) say(path29, "the write did not store it \u2014 the level's schema does not keep this value");
-    else if (same(s, d)) say(path29, "the stored spec already held this value");
+    if (!same(m, d)) say(path31, "the write did not store it \u2014 the level's schema does not keep this value");
+    else if (same(s, d)) say(path31, "the stored spec already held this value");
   };
-  function walk2(d, m, s, path29, container) {
+  function walk2(d, m, s, path31, container) {
     for (const [key, value] of Object.entries(d)) {
       if (DELTA_VERBS.has(key) || JUMP_LABEL_TWINS.has(key)) continue;
       if (key === "label" && LABEL_TWIN_CONTAINERS.has(container)) continue;
@@ -21899,13 +22783,13 @@ function ineffectiveDeltaPaths(delta, merged, stored) {
           if (typeof name !== "string") continue;
           const had = isPlain(s) && s[name] !== void 0;
           const still = isPlain(m) && m[name] !== void 0;
-          if (!had) say(at(path29, name), "unset named a field the stored spec did not have");
-          else if (still) say(at(path29, name), "unset did not remove it");
+          if (!had) say(at(path31, name), "unset named a field the stored spec did not have");
+          else if (still) say(at(path31, name), "unset did not remove it");
         }
         continue;
       }
       if (value === void 0 || value === null) continue;
-      const here = at(path29, key);
+      const here = at(path31, key);
       const mValue = isPlain(m) ? m[key] : void 0;
       const sValue = isPlain(s) ? s[key] : void 0;
       if (mValue === void 0) {
@@ -23756,14 +24640,14 @@ var SpecWorkspace = class {
 - ${labelErrors.join("\n- ")}`);
       }
     }
-    const canonical = (spec) => {
+    const canonical2 = (spec) => {
       const parsed = deltaSchema.safeParse(spec);
       const value = { ...parsed.success ? parsed.data : spec };
       delete value.updatedAt;
       return value;
     };
-    const canonicalStored = canonical(storedBefore);
-    const canonicalMerged = canonical(mergedResult);
+    const canonicalStored = canonical2(storedBefore);
+    const canonicalMerged = canonical2(mergedResult);
     const changes = specChanges(canonicalStored, canonicalMerged);
     const ineffective = ineffectiveDeltaPaths(
       { ...qualifiedDelta, ...unsetFields.length ? { unset: unsetFields } : {} },
@@ -23859,6 +24743,8 @@ var SpecWorkspace = class {
     const plan = this.planMethodMove(source, to, methods, contracts);
     const repointed = this.repointToNewHome(from, to, methods, plan);
     const mentions = this.moveMentions(from, plan);
+    const rename = moveRename(from, to, methods, plan);
+    this.rekeyMoveAllows(plan, rename);
     if (hooks) {
       const verdict = judgeMoveResult(hooks, plan);
       plan.notices.push(...verdict.notices);
@@ -23876,10 +24762,13 @@ var SpecWorkspace = class {
           notices: plan.notices,
           summary: refusedMoveSummary(from, to, methods, verdict.refusals, alternatives),
           dryRun,
-          mentions
+          mentions,
+          created: [],
+          carried: []
         };
       }
     }
+    const carried = projectConfigRepository.rekeyCarried(rename, true);
     if (dryRun) {
       const edits2 = moveChangeReports([...plan.edits.values()], true);
       return {
@@ -23892,12 +24781,16 @@ var SpecWorkspace = class {
         refusals: [],
         alternatives: [],
         notices: plan.notices,
-        summary: `Dry run: moving ${namedMethods(methods)} from "${from}" to "${to}" would touch ${edits2.length} spec${edits2.length === 1 ? "" : "s"} and re-point ${repointed} reference${repointed === 1 ? "" : "s"}. Nothing was written.`,
+        summary: `Dry run: moving ${namedMethods(methods)} from "${from}" to "${to}" would touch ${edits2.length} spec${edits2.length === 1 ? "" : "s"}${createdClause(plan.created, "would create")} and re-point ${repointed} reference${repointed === 1 ? "" : "s"}${registerClause(carried, "would rekey")}. Nothing was written.`,
         dryRun: true,
-        mentions
+        mentions,
+        created: plan.created,
+        carried
       };
     }
-    const edits = this.writeMoveEdits([...plan.edits.values()]);
+    const edits = this.writeMoveEdits([...plan.edits.values()], () => {
+      projectConfigRepository.rekeyCarried(rename);
+    });
     return {
       moved: true,
       from,
@@ -23908,11 +24801,49 @@ var SpecWorkspace = class {
       refusals: [],
       alternatives: [],
       notices: plan.notices,
-      summary: `Moved ${namedMethods(methods)} from "${from}" to "${to}": ${edits.length} spec${edits.length === 1 ? "" : "s"} written, ${repointed} reference${repointed === 1 ? "" : "s"} re-pointed${mentions.length ? `, ${mentions.length} still naming the old home in prose or on the wire` : ""}.`,
+      summary: `Moved ${namedMethods(methods)} from "${from}" to "${to}": ${edits.length} spec${edits.length === 1 ? "" : "s"} written${createdClause(plan.created, "created")}, ${repointed} reference${repointed === 1 ? "" : "s"} re-pointed${registerClause(carried, "rekeyed")}${mentions.length ? `, ${mentions.length} still naming the old home in prose or on the wire` : ""}.`,
       dryRun: false,
-      mentions
+      mentions,
+      created: plan.created,
+      carried
     };
   }
+  /**
+   * Rekey every lint allow keyed on a moved method, staging each spec it
+   * changes like any other reference the move follows. An allow anchored at a
+   * moved method on a spec the method left moves to the spec it arrived in; a
+   * covered `<from>.<method>` unit anywhere names `<to>.<method>`. An allow
+   * whose new home the plan does not stage stays where it is.
+   */
+  rekeyMoveAllows(plan, rename) {
+    const subjects = [...this.everySpecInTree()];
+    for (const edit of plan.edits.values()) if (edit.before === null) subjects.push({ kind: edit.kind, id: edit.id, spec: edit.after });
+    const stagedAfter = (kind, id) => plan.edits.get(`${kind}:${id}`)?.after;
+    for (const { kind, id, spec } of subjects) {
+      if (id.includes("::")) continue;
+      const allows = spec?.lint?.allow ?? [];
+      if (allows.length === 0) continue;
+      const staged = plan.edits.get(`${kind}:${id}`);
+      const subject = staged ? staged.after : cloneSpec(spec);
+      const kept = [];
+      let changed = false;
+      for (const allow of subject.lint?.allow ?? []) {
+        const next = rekeyAnchor(rename, { spec: id, ...allow.at !== void 0 ? { at: allow.at } : {}, ...allow.covers ? { covers: allow.covers } : {} });
+        const rekeyed = { ...allow, ...next.at !== void 0 ? { at: next.at } : {}, ...next.covers ? { covers: next.covers } : {} };
+        if (JSON.stringify(rekeyed) !== JSON.stringify(allow)) changed = true;
+        const home = next.spec !== id ? stagedAfter(kind, next.spec) : void 0;
+        if (home) {
+          home.lint = { ...home.lint ?? {}, allow: [...home.lint?.allow ?? [], rekeyed] };
+          changed = true;
+          continue;
+        }
+        kept.push(rekeyed);
+      }
+      if (!changed) continue;
+      subject.lint = { ...subject.lint, allow: kept };
+      if (!staged) this.stageMoveEdit(plan, kind, id, spec, subject);
+    }
+  }
   /**
    * Why this move cannot be attempted at all, or null when the request is
    * answerable. Every check here is about what the CALLER named, so its answer
@@ -23943,15 +24874,26 @@ var SpecWorkspace = class {
     }
     const receiving = this.moveTargetContract(to, ofTarget);
     if (typeof receiving === "string") return receiving;
-    const travelling = this.loadImplementationSpecs().some((impl) => ofSource.some((i) => i.id === impl.contract) && impl.methods.some((m) => methods.includes(m.name)));
-    if (travelling && !this.loadImplementationSpecs().some((i) => i.contract === receiving.id)) {
-      return `no implementation realizes "${receiving.id}", so the moved methods' narratives would have nowhere to arrive.`;
+    const contractId = receiving?.id ?? `i${to}`;
+    const holder = contracts.find((i) => i.id === contractId);
+    if (!receiving && holder) {
+      return `"${to}" declares no contract, and the one the move would create for it, "${contractId}", is already the id of "${holder.component}"'s contract \u2014 rename that contract, or give "${to}" its own first.`;
+    }
+    const implementations = this.loadImplementationSpecs();
+    const travelling = implementations.some((impl) => ofSource.some((i) => i.id === impl.contract) && impl.methods.some((m) => methods.includes(m.name)));
+    const implId = `${to}_impl`;
+    const implHolder = implementations.find((i) => i.id === implId);
+    if (travelling && !implementations.some((i) => i.contract === contractId) && implHolder) {
+      return `no implementation realizes "${contractId}", and the one the move would create for it, "${implId}", is already the id of the implementation of "${implHolder.contract}" \u2014 rename it, or realize "${contractId}" first.`;
     }
     return null;
   }
-  /** The contract of `to` that receives the methods, or why that cannot be decided. */
+  /**
+   * The contract of `to` that receives the methods; null when it declares none
+   * yet, so the move creates `i<to>`; or why the choice cannot be decided.
+   */
   moveTargetContract(to, ofTarget) {
-    if (ofTarget.length === 0) return `"${to}" declares no contract, so the methods would have nowhere to arrive.`;
+    if (ofTarget.length === 0) return null;
     if (ofTarget.length === 1) return ofTarget[0];
     const named = ofTarget.find((i) => i.id === `i${to}` || i.id.endsWith(`::i${to}`));
     return named ?? `"${to}" declares ${ofTarget.length} contracts and none is named "i${to}", so which one receives the methods is not decidable.`;
@@ -23964,7 +24906,7 @@ var SpecWorkspace = class {
    */
   planMethodMove(source, to, methods, contracts) {
     const target = this.loadComponentSpec(to);
-    const receiving = this.moveTargetContract(to, contracts.filter((i) => i.component === to));
+    const stated = this.moveTargetContract(to, contracts.filter((i) => i.component === to));
     const implementations = this.loadImplementationSpecs();
     const plan = {
       edits: /* @__PURE__ */ new Map(),
@@ -23973,10 +24915,15 @@ var SpecWorkspace = class {
       reach: [],
       newDependencies: [],
       wireBound: [],
-      notices: []
+      notices: [],
+      created: [],
+      rehomed: []
     };
+    const leftImplementations = [];
+    const receiving = stated ?? createdContract(target, source.id, methods, contracts);
     const arriving = [];
     const travelling = [];
+    const realizedIn = /* @__PURE__ */ new Map();
     for (const contract of contracts.filter((i) => i.component === source.id)) {
       const leaving = contract.methods.filter((m) => methods.includes(m.name));
       if (leaving.length === 0) continue;
@@ -23984,6 +24931,7 @@ var SpecWorkspace = class {
       const remaining = cloneSpec(contract);
       remaining.methods = remaining.methods.filter((m) => !methods.includes(m.name));
       this.stageMoveEdit(plan, "interface", contract.id, contract, remaining);
+      plan.rehomed.push({ from: contract.id, to: receiving.id });
       if (contract.methods.length === leaving.length) {
         plan.notices.push(`"${contract.id}" is left with no methods \u2014 "${source.id}" no longer declares anything on it.`);
       }
@@ -23991,17 +24939,20 @@ var SpecWorkspace = class {
         const moving = impl.methods.filter((m) => methods.includes(m.name));
         if (moving.length === 0) continue;
         travelling.push(...cloneSpec(moving));
+        for (const entry of moving) if (impl.sourcePath) realizedIn.set(entry.name, impl.sourcePath);
         const kept = cloneSpec(impl);
         kept.methods = kept.methods.filter((m) => !methods.includes(m.name));
         this.stageMoveEdit(plan, "implementation", impl.id, impl, kept);
+        leftImplementations.push(impl.id);
       }
     }
-    this.stageMoveEdit(plan, "interface", receiving.id, receiving, {
+    this.stageMoveEdit(plan, "interface", receiving.id, stated, {
       ...cloneSpec(receiving),
       methods: [...cloneSpec(receiving.methods), ...arriving]
     });
+    if (!stated) plan.created.push(`interface "${receiving.id}"`);
     if (arriving.some((m) => m.endpoint)) plan.wireBound.push(receiving.id);
-    if (receiving.status !== void 0 && receiving.status !== statusOfContracts(contracts, source.id)) {
+    if (stated && receiving.status !== void 0 && receiving.status !== statusOfContracts(contracts, source.id)) {
       plan.notices.push(`"${receiving.id}" is ${receiving.status} where the methods came from a ${statusOfContracts(contracts, source.id)} contract \u2014 the status of a moved method is the status of its new home.`);
     }
     for (const entry of travelling) {
@@ -24011,10 +24962,23 @@ var SpecWorkspace = class {
     }
     const targetImpl = implementations.find((i) => i.contract === receiving.id);
     if (travelling.length > 0 && targetImpl) {
+      for (const entry of travelling) {
+        const file = realizedIn.get(entry.name);
+        if (entry.sourcePath || !file || file === targetImpl.sourcePath) continue;
+        entry.sourcePath = file;
+        plan.notices.push(`"${entry.name}" keeps ${file} as its own sourcePath: it was realized there by default, and "${targetImpl.id}" names ${targetImpl.sourcePath ? targetImpl.sourcePath : "no file"} \u2014 moving a method is not moving its code.`);
+      }
       this.stageMoveEdit(plan, "implementation", targetImpl.id, targetImpl, {
         ...cloneSpec(targetImpl),
         methods: [...cloneSpec(targetImpl.methods), ...travelling]
       });
+      for (const id of leftImplementations) plan.rehomed.push({ from: id, to: targetImpl.id });
+    } else if (travelling.length > 0) {
+      const created = createdImplementation(target, receiving.id, source.id, travelling, implementations, contracts);
+      this.stageMoveEdit(plan, "implementation", created.spec.id, null, created.spec);
+      for (const id of leftImplementations) plan.rehomed.push({ from: id, to: created.spec.id });
+      plan.created.push(created.named);
+      plan.notices.push(...created.notices);
     }
     plan.reach = reachOf(travelling, source.id, new Set(methods)).filter((id) => id !== to);
     const held = /* @__PURE__ */ new Set([...target.dependsOn ?? [], ...target.owns ?? []]);
@@ -24058,6 +25022,9 @@ var SpecWorkspace = class {
       }
       this.stageMoveEdit(plan, kind, id, spec, subject);
     }
+    for (const edit of plan.edits.values()) {
+      if (edit.before === null) rewriteSpecRefs(edit.after, remap);
+    }
     plan.notices.push(...this.callersOwingADependency(to, plan));
     return repointed;
   }
@@ -24139,7 +25106,7 @@ var SpecWorkspace = class {
    * here: every save does it already, and a second call would only be a hop
    * across a component boundary that no narrative claims.
    */
-  writeMoveEdits(edits) {
+  writeMoveEdits(edits, finish) {
     const reports = moveChangeReports(edits, false);
     const written = [];
     try {
@@ -24148,10 +25115,12 @@ var SpecWorkspace = class {
         report.notices.push(...this.saveMovedSpec(edit.kind, edit.after));
         written.push(edit);
       }
+      finish?.();
     } catch (e) {
       for (const edit of [...written].reverse()) {
         try {
-          this.saveMovedSpec(edit.kind, edit.before);
+          if (edit.before === null) this.delete(edit.kind, edit.id);
+          else this.saveMovedSpec(edit.kind, edit.before);
         } catch {
         }
       }
@@ -24241,7 +25210,7 @@ function weighMoveHome(hooks, candidate, reach, dependencyLimit) {
   };
 }
 function moveChangeReports(edits, dryRun) {
-  return edits.map((edit) => ({ edit, changes: specChanges(edit.before, edit.after) })).filter(({ changes }) => changes.length > 0).map(({ edit, changes }) => ({
+  return edits.map((edit) => ({ edit, changes: specChanges(edit.before ?? {}, edit.after) })).filter(({ changes }) => changes.length > 0).map(({ edit, changes }) => ({
     kind: edit.kind,
     id: edit.id,
     written: !dryRun,
@@ -24250,9 +25219,66 @@ function moveChangeReports(edits, dryRun) {
     ineffective: [],
     notices: [],
     testsToRevisit: [],
-    summary: `${dryRun ? "Would move" : "Moved"} into ${edit.kind} "${edit.id}": ${changes.length} change${changes.length === 1 ? "" : "s"}.`
+    summary: edit.before === null ? `${dryRun ? "Would create" : "Created"} ${edit.kind} "${edit.id}" to receive the moved methods.` : `${dryRun ? "Would move" : "Moved"} into ${edit.kind} "${edit.id}": ${changes.length} change${changes.length === 1 ? "" : "s"}.`
   }));
 }
+function moveRename(from, to, methods, plan) {
+  return {
+    specs: plan.rehomed.map(({ from: left, to: arrived }) => ({ from: left, to: arrived, sites: [...methods] })),
+    methods: methods.map((method) => ({ component: from, method, toComponent: to, toMethod: method }))
+  };
+}
+function registerClause(carried, verb) {
+  return carried.length ? `, ${verb} ${carried.length} debt-register key${carried.length === 1 ? "" : "s"}` : "";
+}
+function createdClause(created, verb) {
+  return created.length ? `, ${verb} ${created.join(" and ")}` : "";
+}
+function createdContract(target, from, methods, contracts) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const status = statusOfContracts(contracts, from);
+  return {
+    id: `i${target.id}`,
+    name: `${target.name} Interface`,
+    description: `The contract of ${target.name}, created by moving ${namedMethods(methods)} here from "${from}".`,
+    component: target.id,
+    methods: [],
+    ...status ? { status } : {},
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function createdImplementation(target, contractId, from, travelling, implementations, contracts) {
+  const ofSource = new Set(contracts.filter((i) => i.component === from).map((i) => i.id));
+  const leaving = implementations.filter((impl) => ofSource.has(impl.contract) && impl.methods.some((m) => travelling.some((t) => t.name === m.name)));
+  const paths = [...new Set(leaving.map((impl) => impl.sourcePath))];
+  const inherited = paths.length === 1 ? paths[0] : void 0;
+  const notices = [];
+  if (paths.length > 1) {
+    for (const entry of travelling) {
+      if (entry.sourcePath) continue;
+      const home = leaving.find((impl) => impl.methods.some((m) => m.name === entry.name));
+      if (home?.sourcePath) entry.sourcePath = home.sourcePath;
+    }
+    notices.push(`"${target.id}_impl" is created without a sourcePath: the moved entries come from implementations with different ones, so each keeps the file it was realized in as its own sourcePath.`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const status = leaving[0]?.status;
+  const spec = {
+    id: `${target.id}_impl`,
+    name: `${target.name} Implementation`,
+    description: `The implementation of ${target.name}, created by moving methods here from "${from}".`,
+    contract: contractId,
+    ...inherited ? { sourcePath: inherited } : {},
+    methods: travelling,
+    ...status ? { status } : {},
+    createdAt: now,
+    updatedAt: now
+  };
+  const origin = leaving.length === 1 ? ` from "${leaving[0].id}"` : "";
+  const named = inherited ? `implementation "${spec.id}" (sourcePath ${inherited}, inherited${origin})` : `implementation "${spec.id}" (no sourcePath)`;
+  return { spec, named, notices };
+}
 function refusedMoveSummary(from, to, methods, refusals, alternatives) {
   const cheapest = alternatives.find((c) => c.legal);
   return `Refused: moving ${namedMethods(methods)} from "${from}" to "${to}" is refused by ${refusals.join(", ")}. Nothing was written. ` + (cheapest ? `The cheapest legal home is "${cheapest.component}" (${cheapest.newDependencies.length} new dependenc${cheapest.newDependencies.length === 1 ? "y" : "ies"}, ${cheapest.dependencyCount} of ${cheapest.dependencyLimit}).` : `No component of this subsystem can take them as they stand \u2014 ${alternatives.length} were weighed.`);
@@ -24894,7 +25920,8 @@ function rewriteRefFields(specsDir, remap, excludeDir) {
   }
   return rewritten;
 }
-function rebaseImplementationPaths(specsDir, fromRoot, toRoot) {
+function rekeyLintAllows(specsDir, rename) {
+  const rewritten = [];
   for (const file of listFilesRecursive(specsDir, ".yaml")) {
     let raw;
     try {
@@ -24902,13 +25929,48 @@ function rebaseImplementationPaths(specsDir, fromRoot, toRoot) {
     } catch {
       continue;
     }
-    if (!raw || typeof raw !== "object" || !("contract" in raw)) continue;
+    const allows = raw?.lint?.allow;
+    const kind = raw && typeof raw === "object" ? specKind(raw) : null;
+    if (!kind || !Array.isArray(allows)) continue;
+    const specId = kind === "system" ? "system" : String(raw.id);
     let changed = false;
-    const rebase = (holder, key) => {
-      const p = holder[key];
-      if (typeof p !== "string" || p === "" || path17.isAbsolute(p)) return;
-      const next = toPosixPath(path17.relative(toRoot, path17.resolve(fromRoot, p)));
-      if (next !== p) {
+    for (const allow of allows) {
+      if (!allow || typeof allow !== "object") continue;
+      const next = rekeyAnchor(rename, {
+        spec: specId,
+        ...typeof allow.at === "string" ? { at: allow.at } : {},
+        ...Array.isArray(allow.covers) ? { covers: allow.covers } : {}
+      });
+      if (next.at !== void 0 && next.at !== allow.at) {
+        allow.at = next.at;
+        changed = true;
+      }
+      if (next.covers && JSON.stringify(next.covers) !== JSON.stringify(allow.covers)) {
+        allow.covers = next.covers;
+        changed = true;
+      }
+    }
+    if (!changed) continue;
+    writeYamlFile(file, raw);
+    rewritten.push({ kind, id: specId });
+  }
+  return rewritten;
+}
+function rebaseImplementationPaths(specsDir, fromRoot, toRoot) {
+  for (const file of listFilesRecursive(specsDir, ".yaml")) {
+    let raw;
+    try {
+      raw = readYamlFile(file);
+    } catch {
+      continue;
+    }
+    if (!raw || typeof raw !== "object" || !("contract" in raw)) continue;
+    let changed = false;
+    const rebase = (holder, key) => {
+      const p = holder[key];
+      if (typeof p !== "string" || p === "" || path17.isAbsolute(p)) return;
+      const next = toPosixPath(path17.relative(toRoot, path17.resolve(fromRoot, p)));
+      if (next !== p) {
         holder[key] = next;
         changed = true;
       }
@@ -24963,24 +26025,32 @@ function renameComponent(componentId, newId) {
     ...movingInterface ? [{ kind: "interface", from: movingInterface.id, to: interfaceId }] : [],
     ...movingImplementation ? [{ kind: "implementation", from: movingImplementation.id, to: implementationId }] : []
   ];
-  const rewritten = rewriteRefFields(aiPathsAt(getProjectRoot()).specsDir(), (ref, position) => {
+  const rename = {
+    specs: renamed.map(({ from, to }) => ({ from, to })),
+    components: [{ from: componentId, to: newId }]
+  };
+  projectConfigRepository.rekeyCarried(rename, true);
+  const rewrittenRefs = rewriteRefFields(aiPathsAt(getProjectRoot()).specsDir(), (ref, position) => {
     if (position === "component" || position === "entity-class" || position === "auth-source") {
       return ref === componentId ? newId : ref;
     }
     if (position === "interface" && ref === movingInterface?.id) return interfaceId;
     return ref;
-  }).filter((spec) => !renamed.some((moved) => moved.kind === spec.kind && moved.from === spec.id)).map((spec) => spec.id);
+  });
+  const allowsRekeyed = rekeyLintAllows(aiPathsAt(getProjectRoot()).specsDir(), rename);
+  const rewritten = [...new Set([...rewrittenRefs, ...allowsRekeyed].filter((spec) => !renamed.some((moved) => moved.kind === spec.kind && moved.from === spec.id)).map((spec) => spec.id))];
   invalidateSpecCache();
   moveRenamedSpecs(componentId, newId, component, movingInterface, movingImplementation);
-  return { renamed, rewritten };
+  const carried = projectConfigRepository.rekeyCarried(rename);
+  return { renamed, rewritten, carried };
 }
 function moveRenamedSpecs(componentId, newId, component, movingInterface, movingImplementation) {
   const interfaceId = `i${newId}`;
   const implementationId = `${newId}_impl`;
-  const movedComponent = loadComponentSpec(componentId) ?? component;
+  const movedComponent2 = loadComponentSpec(componentId) ?? component;
   const movedInterface = movingInterface ? loadInterfaceSpec(movingInterface.id) ?? movingInterface : null;
   const movedImplementation = movingImplementation ? loadImplementationSpec(movingImplementation.id) ?? movingImplementation : null;
-  saveComponentSpec({ ...movedComponent, id: newId });
+  saveComponentSpec({ ...movedComponent2, id: newId });
   if (movedInterface) saveInterfaceSpec({ ...movedInterface, id: interfaceId, component: newId });
   if (movedImplementation) {
     const oldFile = getImplementationPath(movedImplementation.id);
@@ -25045,6 +26115,19 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
   const implementations = loadImplementationSpecs();
   const movingContracts = new Set(moving.map((i) => i.id));
   const renamed = [];
+  const rename = {
+    methods: [{
+      component: componentId,
+      method: methodName,
+      toComponent: componentId,
+      toMethod: newName,
+      specs: [
+        ...moving.map((i) => i.id),
+        ...implementations.filter((impl) => movingContracts.has(impl.contract) && impl.methods.some((m) => m.name === methodName)).map((impl) => impl.id)
+      ]
+    }]
+  };
+  projectConfigRepository.rekeyCarried(rename, true);
   for (const contract of moving) {
     saveInterfaceSpec({
       ...contract,
@@ -25067,8 +26150,11 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
   }
   invalidateSpecCache();
   const specsDir = aiPathsAt(getProjectRoot()).specsDir();
-  const rewritten = rewriteRefFields(specsDir, (ref, position, owner) => position === "method" && owner === componentId && ref === methodName ? newName : ref).map((spec) => spec.id);
+  const retargeted = rewriteRefFields(specsDir, (ref, position, owner) => position === "method" && owner === componentId && ref === methodName ? newName : ref);
+  const allowsRekeyed = rekeyLintAllows(specsDir, rename);
+  const rewritten = [...new Set([...retargeted, ...allowsRekeyed].map((spec) => spec.id))];
   const mentions = collectMentions(specsDir, methodName, moving);
+  const carried = projectConfigRepository.rekeyCarried(rename);
   return {
     component: componentId,
     from: methodName,
@@ -25076,7 +26162,8 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
     renamed,
     rewritten,
     mentions,
-    ...pinnedSymbol ? { pinnedSymbol } : {}
+    ...pinnedSymbol ? { pinnedSymbol } : {},
+    carried
   };
 }
 function renameInSignature(signature, from, to) {
@@ -25727,8 +26814,8 @@ function inferSourcePathForComponent(comp, subsystems) {
     return null;
   }
 }
-function summarize(text, max = 140) {
-  const clean = text.replace(/\s+/g, " ").trim();
+function summarize2(text2, max = 140) {
+  const clean = text2.replace(/\s+/g, " ").trim();
   const period = clean.indexOf(". ");
   const firstSentence = period > 0 ? clean.slice(0, period + 1) : clean;
   if (firstSentence.length <= max) return firstSentence;
@@ -25754,7 +26841,7 @@ function resolveAgentTopology() {
   agents.push({
     id: "system-architect",
     name: `${system.name} Architect`,
-    description: `Global architect for ${system.name} \u2014 owns the spec tree and topology. ${summarize(system.vision)}`,
+    description: `Global architect for ${system.name} \u2014 owns the spec tree and topology. ${summarize2(system.vision)}`,
     template: "architect",
     creationReason: "Automatically inferred from L0 system spec",
     ownedPaths: [".wai/specs/**"],
@@ -25834,7 +26921,7 @@ function resolveAgentTopology() {
     agents.push({
       id: `${sub.id}-owner`,
       name: `${sub.name} Owner`,
-      description: `Owns the ${sub.id} subsystem. ${summarize(sub.description)}`,
+      description: `Owns the ${sub.id} subsystem. ${summarize2(sub.description)}`,
       template: "domain-owner",
       creationReason: `Automatically inferred from L1 subsystem spec: ${sub.id}`,
       domainRoot: sub.id,
@@ -25899,7 +26986,7 @@ function resolveAgentTopology() {
     agents.push({
       id: `${dom.id}-owner`,
       name: `${dom.name ?? dom.id} Owner`,
-      description: dom.description ? summarize(dom.description) : `Owner agent for the free-standing "${dom.id}" domain.`,
+      description: dom.description ? summarize2(dom.description) : `Owner agent for the free-standing "${dom.id}" domain.`,
       template: "domain-owner",
       creationReason: "Inferred from a free-standing domain in .wai/topology.yaml",
       domainRoot: dom.id,
@@ -26243,19 +27330,19 @@ function commitStagedTree(stagingDir, destDir, roots, backupExisting) {
   const backupDir = path26.join(root, BACKUP_DIR, timestampSlug());
   let backedUp = false;
   for (const rootRel of roots) {
-    const relative9 = rootRel === "." ? "" : rootRel;
-    const stagedSpecDir = path26.join(stagingDir, relative9, ".wai");
+    const relative10 = rootRel === "." ? "" : rootRel;
+    const stagedSpecDir = path26.join(stagingDir, relative10, ".wai");
     if (!fs16.existsSync(stagedSpecDir)) continue;
-    const liveSpecDir = liveSpecDirFor(path26.join(root, relative9));
+    const liveSpecDir = liveSpecDirFor(path26.join(root, relative10));
     if (backupExisting && liveSpecDir && fs16.existsSync(liveSpecDir)) {
-      const backupTarget = path26.join(backupDir, relative9, path26.basename(liveSpecDir));
+      const backupTarget = path26.join(backupDir, relative10, path26.basename(liveSpecDir));
       fs16.mkdirSync(path26.dirname(backupTarget), { recursive: true });
       fs16.renameSync(liveSpecDir, backupTarget);
       backedUp = true;
     } else if (liveSpecDir && fs16.existsSync(liveSpecDir)) {
       fs16.rmSync(liveSpecDir, { recursive: true, force: true });
     }
-    const target = path26.join(root, relative9, ".wai");
+    const target = path26.join(root, relative10, ".wai");
     fs16.mkdirSync(path26.dirname(target), { recursive: true });
     if (fs16.existsSync(target)) fs16.rmSync(target, { recursive: true, force: true });
     fs16.renameSync(stagedSpecDir, target);
@@ -26960,13 +28047,13 @@ function syncContextFiles() {
 }
 
 // src/core/status.ts
-var asWritten = (text) => text;
+var asWritten = (text2) => text2;
 function fillDecor(decor) {
   return {
     structure: decor?.structure ?? asWritten,
     emphasis: decor?.emphasis ?? asWritten,
-    layer: decor?.layer ?? ((_kind, text) => text),
-    score: decor?.score ?? ((_pct, text) => text),
+    layer: decor?.layer ?? ((_kind, text2) => text2),
+    score: decor?.score ?? ((_pct, text2) => text2),
     draft: decor?.draft ?? asWritten,
     present: decor?.present ?? asWritten,
     missing: decor?.missing ?? asWritten
@@ -26978,13 +28065,13 @@ function getStatusReport(options = {}, decor) {
   const system = loadSystemSpec();
   const loaderErrors = getLoaderIssues();
   if (loaderErrors.length > 0) {
-    let errText = "Failed to parse specification files:\n";
+    let errText2 = "Failed to parse specification files:\n";
     for (const issue2 of loaderErrors) {
       const prefix = issue2.specId ? mark.structure(`[${issue2.specId}] `) : "";
-      errText += `${prefix}[${issue2.code}] ${issue2.message}
+      errText2 += `${prefix}[${issue2.code}] ${issue2.message}
 `;
     }
-    return { text: errText, failed: true };
+    return { text: errText2, failed: true };
   }
   if (!system) {
     return { text: "L0 System specification (system.yaml) is missing.", failed: true };
@@ -27178,17 +28265,2326 @@ var logger = {
   }
 };
 
+// src/core/skills.ts
+var path29 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
+
+// src/core/instructions.ts
+function governingProfile() {
+  try {
+    return loadProjectConfig()?.projectType ?? null;
+  } catch {
+    return null;
+  }
+}
+function blockApplies(block, profile) {
+  if (!block.profile || block.profile.length === 0) return true;
+  return profile !== null && block.profile.includes(profile);
+}
+function skillPointers(skills) {
+  if (skills.length === 0) return "(none published by this server)";
+  return skills.map((s) => `- \`${s.resourceUri}\` \u2014 ${s.description || s.name}`).join("\n");
+}
+function waironInstructions(profile, packNames, skills, variants) {
+  return `# wairon \u2014 Spec-Driven Development (SDD)
+
+This server owns one system's **spec tree**: its architecture, specified top-down
+and machine-checked. Author it ONLY through this server's \`sdd_*\` tools \u2014 never by
+writing spec files directly, and never via the \`wairon\` CLI (that is the human
+developer's tool).
+
+## The tree: L0 \u2192 L5
+
+- **L0 System** \u2014 vision, boundaries, global requirements, target language.
+- **L1 Subsystem** \u2014 an isolated service, its \`publicInterfaces\`, its trusted links.
+- **L2 Component** \u2014 ONE building block (\`Portal\`, \`Orchestrator\`, \`Supervisor\`,
+  \`Actor\`, \`Store\`, \`Index\`, \`Query\`, \`Registry\`, \`Adapter\`, \`Observer\`, and
+  \`View\` for UIs) or pattern (\`Repository\`, and \`FeatureComponent\` or
+  \`RouterComponent\` for UIs), plus \`owns\` (a pattern's private members) and
+  \`dependsOn\` (collaborators). Logic is an \`Orchestrator\` whose \`dependencyClass\`
+  (\`pure\` or \`read\`; unset, a workflow) bounds what it may depend on; a gateway is
+  a \`Portal\` with the \`gateway\` variant. \`Specialist\` and \`Gateway\` are retired.
+- **L3 Interface** \u2014 the contract: method signatures with structured \`params\`,
+  plus wire \`endpoint\` bindings for a Portal's methods.
+- **L4 Implementation** \u2014 a concrete realization of one L3 contract: narrative
+  detail level, bound \`technologies\` (the vendor swap seam), optional \`sourcePath\`.
+- **L5 Narrative** \u2014 each method's logic as a FLAT numbered step list; \`call\` steps
+  resolve to real dependency methods, and flow steps jump by step number.
+
+These stereotypes are not labels \u2014 they carry enforced dependency rules (e.g. a
+Portal may not depend on a Store; state lives in a Store, never as fields inside
+an Orchestrator). \`sdd_validate_tree\` is the gate, and it is the authority on
+whether a design is legal.
+
+## Authoring order
+
+1. \`sdd_initialize_system\` (L0), then \`sdd_add_subsystem\` (L1).
+2. Then, **one subsystem at a time**: \`sdd_add_component\` (L2) \u2192 \`sdd_define_interface\`
+   (L3) \u2192 \`sdd_set_endpoints\` for Portals \u2192 \`sdd_write_narrative\` (L4+L5).
+3. Run \`sdd_validate_tree\` as you go \u2014 early and per subsystem, not once at the end.
+   \`sdd_get_status\` reports completeness; \`sdd_get_spec\` reads any spec back as JSON.
+4. Edit granularly with \`sdd_update_spec\` (it renumbers narrative steps and
+   relocates jump targets for you).
+
+## The tool schemas are the field reference
+
+Every \`sdd_*\` tool's input schema is self-describing and authoritative \u2014 read the
+schema rather than guessing field names, and prefer structured \`params\` over prose
+signatures. Specs are ${profile === null ? "validated against the project's configured profile" : `governed by the **\`${profile}\`** profile`}, which decides which stereotypes are legal
+here, which narrative flow constructs the target language supports, and which
+extra rules apply. A subsystem may override the profile for itself.
+
+## Loaded extension packs
+
+${packNames.length === 0 ? "None \u2014 only wairon's built-in doctrine applies." : `${packNames.map((n) => `\`${n}\``).join(", ")} \u2014 these inject profiles, language tables, patterns, and
+additional conformance rules. Their doctrine is enforced by the same gate.`}
+
+${variants.length === 0 ? "" : `## Component variants in play
+
+This project defines variants \u2014 named, base-anchored kinds carrying implementation
+guidance, so every component of the same kind is built alike: ${variants.map((v) => `\`${v.id}\` (a kind of ${v.base})`).join(", ")}.
+Tag a component with \`variant\` where it fits, and read a component's resolved
+guidance and its same-variant siblings from \`sdd_get_spec\` (kind: component).
+
+`}## Read the skills BEFORE authoring
+
+This server publishes its skills as MCP resources. **Read \`wairon-skill://sdd-architect\`
+before you design anything**, and the others when their turn comes \u2014 they carry the
+architecture standard, the narrative step reference, and the review checklist that
+this briefing only points at:
+
+${skillPointers(skills)}
+
+## Delegating implementation
+
+Delegate component work from a LIVE agent brief, never a generated file: discover
+agents via \`listAgents\` (or the \`wairon-agent://\` resources), fetch the target's
+brief with \`sdd_get_agent_brief\`, and spawn a scoped subagent from it \u2014 its
+\`instructions\` as prompt, its \`ownedPaths\` as write fence. Briefs are composed
+from the current spec tree on every call, so a re-lock never requires a session
+restart \u2014 fetch fresh per delegation. \`wairon-skill://sdd-delegate\` carries the
+full flow.`;
+}
+function buildServerInstructions() {
+  const profile = governingProfile();
+  let skills = [];
+  let blocks = [];
+  let packNames = [];
+  const variants = [];
+  try {
+    skills = listSkillResources();
+    const extensions = loadProjectExtensions();
+    blocks = extensions.instructions;
+    packNames = extensions.packNames;
+  } catch {
+  }
+  const sections = [waironInstructions(profile, packNames, skills, variants)];
+  for (const block of blocks) {
+    if (!blockApplies(block, profile)) continue;
+    sections.push(`## From pack "${block.pack}"
+
+${block.text.trim()}`);
+  }
+  return sections.join("\n\n");
+}
+
 // src/core/skills.ts
 var SKILL_NAMES = ["sdd-architect", "sdd-narrative", "sdd-auditor", "sdd-implement", "sdd-delegate"];
+function packSkillId(skill) {
+  return `${packNamespace(skill.pack)}-${skill.id}`;
+}
+function packNamespace(pack) {
+  return pack.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function extensionsFor(builtin, packSkills) {
+  return packSkills.filter((s) => s.extends === builtin && fs18.existsSync(s.sourcePath));
+}
+function composeBuiltinSkill(name, packSkills) {
+  const srcPath = skillTemplatePath(name);
+  const base = fs18.existsSync(srcPath) ? fs18.readFileSync(srcPath, "utf-8") : "";
+  const sections = extensionsFor(name, packSkills);
+  if (sections.length === 0) return base;
+  const parts = [base.trimEnd()];
+  for (const section of sections) {
+    const body = fs18.readFileSync(section.sourcePath, "utf-8").replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "");
+    parts.push(`## Platform: ${section.pack}`, body.trim());
+  }
+  return `${parts.join("\n\n")}
+`;
+}
+function readFrontmatter(raw, fallbackName) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(raw);
+  const block = match ? match[1] : "";
+  const field = (key) => {
+    const m = new RegExp(`^${key}:\\s*(.*)$`, "m").exec(block);
+    return m ? m[1].trim() : "";
+  };
+  return { name: field("name") || fallbackName, description: field("description") };
+}
+function builtinSkillsDir() {
+  return path29.resolve(__dirname, "..", "templates", "skills");
+}
+function skillTemplatePath(name) {
+  return path29.join(builtinSkillsDir(), `${name}.md`);
+}
 function activeTargetTypes2() {
   const config = loadProjectConfig();
   if (!config) return [];
   return activeTargetTypes(config);
 }
+var SKILL_RESOURCE_SCHEME = "wairon-skill";
 var RESOURCE_SKILL_IDS = [...SKILL_NAMES].sort();
+var SkillResourceNotFoundError = class extends Error {
+  constructor(resourceId) {
+    super(`Unknown SDD skill resource id: "${resourceId}".`);
+    this.name = "SkillResourceNotFoundError";
+  }
+};
+function readSkillFrontmatter(name) {
+  return readFrontmatter(fs18.readFileSync(skillTemplatePath(name), "utf-8"), name);
+}
+function listSkillResources() {
+  const builtin = RESOURCE_SKILL_IDS.map((id) => {
+    const fm = readSkillFrontmatter(id);
+    return {
+      id,
+      name: fm.name,
+      description: fm.description,
+      version: WAIRON_VERSION,
+      resourceUri: `${SKILL_RESOURCE_SCHEME}://${id}`,
+      defaultForHostedMcp: true
+    };
+  });
+  const pack = loadProjectExtensions().skills.filter((s) => s.extends === void 0 && fs18.existsSync(s.sourcePath)).map((skill) => {
+    const id = packSkillId(skill);
+    const fm = readFrontmatter(fs18.readFileSync(skill.sourcePath, "utf-8"), id);
+    return {
+      id,
+      name: fm.name,
+      description: fm.description,
+      version: skill.packVersion ?? WAIRON_VERSION,
+      resourceUri: `${SKILL_RESOURCE_SCHEME}://${id}`,
+      defaultForHostedMcp: true
+    };
+  });
+  return [...builtin, ...pack];
+}
+function readSkillResource(resourceId) {
+  const packSkills = loadProjectExtensions().skills;
+  if (SKILL_NAMES.includes(resourceId)) return composeBuiltinSkill(resourceId, packSkills);
+  const packSkill = packSkills.find((s) => s.extends === void 0 && packSkillId(s) === resourceId);
+  if (packSkill) return fs18.readFileSync(packSkill.sourcePath, "utf-8");
+  return fs18.readFileSync(skillTemplatePath(resourceId), "utf-8");
+}
+function listResources() {
+  return listSkillResources();
+}
+function buildServerInstructions2() {
+  return buildServerInstructions();
+}
+function readResource(resourceId) {
+  const known = listSkillResources().some((d) => d.id === resourceId);
+  if (!known) throw new SkillResourceNotFoundError(resourceId);
+  return readSkillResource(resourceId);
+}
 
-// src/index.ts
+// src/mcp/server.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_zod11 = require("zod");
+var import_types4 = require("@modelcontextprotocol/sdk/types.js");
+var crypto4 = __toESM(require("crypto"));
+
+// src/core/adapters/authoring-core.ts
 function loadProjectConfig2() {
+  try {
+    return loadProjectConfig();
+  } catch {
+    return null;
+  }
+}
+
+// src/models/candidate.ts
+function formatCandidateRefusal(verdict) {
+  const lines = verdict.errors.map((e) => `- ${e.code}: ${e.message}`);
+  return `Refused: this component's fields do not match its componentType.
+${lines.join("\n")}
+
+Nothing was written. Fix the fields and retry \u2014 on an EXISTING spec, remove a field with sdd_update_spec's "unset" (e.g. {"unset": ["basePath"]}); passing null leaves it in place.`;
+}
+
+// src/core/authoring.ts
+function candidateOptions() {
+  const config = loadProjectConfig2();
+  return config ? { rules: config.rules, projectType: config.projectType } : {};
+}
+function noticesFrom(verdict) {
+  return verdict.warnings.map((w) => `${w.code}: ${w.message}`);
+}
+function componentCandidateGate(options = candidateOptions()) {
+  return {
+    gate: (kind, merged) => {
+      if (kind !== "component") return;
+      const verdict = validateComponentCandidate(merged, options);
+      if (verdict.errors.length) throw new Error(formatCandidateRefusal(verdict));
+      return noticesFrom(verdict);
+    }
+  };
+}
+var STORE_MANAGED_FIELDS = /* @__PURE__ */ new Set(["status", "updatedAt"]);
+var ALWAYS_CARRIED_FIELDS = /* @__PURE__ */ new Set(["ext"]);
+var STATUS_ORDER = ["draft", "design", "complete"];
+var STATUSED_KINDS = /* @__PURE__ */ new Set(["subsystem", "component", "interface", "implementation"]);
+var MISSING_PARENT = {
+  subsystem: () => "System spec must be initialized (sdd_initialize_system) first.",
+  component: (id) => `Parent subsystem "${id}" does not exist.`,
+  interface: (id) => `Component "${id}" does not exist.`,
+  implementation: (id) => `Interface contract "${id}" does not exist.`,
+  type: (id) => `Owning subsystem "${id}" does not exist \u2014 name a subsystem the tree has, or omit subsystem for a system-level value object.`
+};
+var REWRITE_LABEL = {
+  system: "System spec",
+  subsystem: "Subsystem",
+  component: "Component",
+  interface: "Interface",
+  implementation: "Implementation",
+  type: "Type"
+};
+function restatementParent(restatement) {
+  const spec = restatement.spec;
+  switch (restatement.kind) {
+    case "subsystem":
+      return { kind: "system", id: "system" };
+    case "component":
+      return { kind: "subsystem", id: spec.subsystem };
+    case "interface":
+      return { kind: "component", id: spec.component };
+    case "implementation":
+      return { kind: "interface", id: spec.contract };
+    case "type":
+      return typeof spec.subsystem === "string" && spec.subsystem !== "" ? { kind: "subsystem", id: spec.subsystem } : null;
+    default:
+      return null;
+  }
+}
+function applyRestatement(restatement, existing, parent) {
+  const replacedExisting = existing !== null;
+  const parentRef = restatementParent(restatement);
+  if (parentRef && !parent) return refused(restatement, replacedExisting, MISSING_PARENT[restatement.kind](parentRef.id));
+  const status = statusForCreate(restatement, existing);
+  if ("refusal" in status) return refused(restatement, replacedExisting, status.refusal);
+  const candidate = JSON.parse(JSON.stringify(restatement.spec));
+  if (restatement.kind === "subsystem") candidate.parentSystem = parent.name;
+  const carried = carryInto(restatement, existing, candidate);
+  const cleared = clearedByOmission(existing, candidate, restatement.fields);
+  stampLifecycle(candidate, existing, status.status);
+  const labelErrors = resolveLabelsOf(restatement.kind, candidate);
+  if (labelErrors.length) {
+    return refused(restatement, replacedExisting, `Unresolved narrative label references \u2014 nothing was saved:
+- ${labelErrors.join("\n- ")}`);
+  }
+  const parsed = parseCandidate(restatement.kind, candidate);
+  if ("refusal" in parsed) return refused(restatement, replacedExisting, parsed.refusal);
+  return {
+    spec: parsed.spec,
+    ...status.status ? { status: status.status } : {},
+    replacedExisting,
+    notices: existing ? rewriteNotices(restatement.kind, existing, candidate, carried, cleared) : [],
+    changedMethods: changedMethodsOf(restatement.kind, existing, candidate)
+  };
+}
+var SPEC_SCHEMA = {
+  system: SystemSpecSchema,
+  subsystem: SubsystemSpecSchema,
+  component: ComponentSpecSchema,
+  interface: InterfaceSpecSchema,
+  implementation: ImplementationSpecSchema,
+  type: TypeSpecSchema
+};
+function parseCandidate(kind, candidate) {
+  const masked = /* @__PURE__ */ new Map();
+  const mask = (value) => {
+    if (typeof value === "string") {
+      if (!value.includes("::")) return value;
+      const token = `nsref_${masked.size}_masked`;
+      masked.set(token, value);
+      return token;
+    }
+    if (Array.isArray(value)) return value.map(mask);
+    if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, mask(v)]));
+    return value;
+  };
+  const restore = (value) => {
+    if (typeof value === "string") return masked.get(value) ?? value;
+    if (Array.isArray(value)) return value.map(restore);
+    if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, restore(v)]));
+    return value;
+  };
+  const result = SPEC_SCHEMA[kind].safeParse(mask(candidate));
+  if (result.success) return { spec: restore(result.data) };
+  const id = kind === "system" ? "system" : String(candidate.id);
+  const issues = result.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+  return {
+    refusal: `Refusing to write ${kind} "${id}": the spec it would become does not parse \u2014 ${issues}. Nothing was written. State the missing or malformed field and call again.`
+  };
+}
+function refused(restatement, replacedExisting, refusal2) {
+  return { spec: restatement.spec, refusal: refusal2, replacedExisting, notices: [], changedMethods: [] };
+}
+function statusForCreate(restatement, existing) {
+  if (!STATUSED_KINDS.has(restatement.kind)) return {};
+  const stated = restatement.status;
+  const stored = existing?.status;
+  const held = stored !== void 0 && STATUS_ORDER.includes(stored) ? stored : void 0;
+  if (stated === void 0) return { status: held ?? "draft" };
+  if (held === void 0 || STATUS_ORDER.indexOf(stated) >= STATUS_ORDER.indexOf(held)) return { status: stated };
+  const label = `${restatement.kind} "${restatement.spec.id}"`;
+  return {
+    refusal: `Refusing to re-author ${label} at status "${stated}": it is stored at "${held}", and a create tool never lowers a spec's status \u2014 a restatement that reopened a frozen spec would undo a lock without saying so. Nothing was written. To reopen it deliberately, use sdd_update_spec with {"status": "${stated}"}; to keep the level it has, leave status out.`
+  };
+}
+function carryInto(restatement, existing, candidate) {
+  if (!existing) return [];
+  const carried = ["createdAt"];
+  if (restatement.memberFields && Array.isArray(candidate.methods)) {
+    const stored = existing.methods ?? [];
+    for (const method of candidate.methods) {
+      const prev = stored.find((p) => p.name === method.name);
+      for (const field of carryUnexpressed(prev, method, restatement.memberFields)) carried.push(`${field} (${String(method.name)})`);
+    }
+  }
+  carried.push(...carryUnexpressed(existing, candidate, [...restatement.fields, "createdAt"]));
+  return carried;
+}
+function carryUnexpressed(existing, next, expressed) {
+  if (!existing) return [];
+  const carried = [];
+  for (const [field, value] of Object.entries(existing)) {
+    if (value === void 0) continue;
+    if (STORE_MANAGED_FIELDS.has(field)) continue;
+    if (expressed.includes(field) && !ALWAYS_CARRIED_FIELDS.has(field)) continue;
+    if (next[field] !== void 0) continue;
+    next[field] = value;
+    carried.push(field);
+  }
+  return carried;
+}
+function isEmptyValue(value) {
+  if (value === void 0 || value === null) return true;
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "string") return value.trim() === "";
+  if (typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+function clearedByOmission(existing, next, expressed) {
+  if (!existing) return [];
+  const stored = existing;
+  const cleared = [];
+  for (const field of expressed) {
+    const before = stored[field];
+    if (STORE_MANAGED_FIELDS.has(field) || ALWAYS_CARRIED_FIELDS.has(field)) continue;
+    if (isEmptyValue(before) || !isEmptyValue(next[field])) continue;
+    cleared.push(Array.isArray(before) ? `${field} (had ${before.length})` : field);
+  }
+  return cleared;
+}
+function stampLifecycle(candidate, existing, status) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  candidate.createdAt = existing?.createdAt ?? now;
+  candidate.updatedAt = now;
+  if (status) candidate.status = status;
+  else delete candidate.status;
+}
+function resolveLabelsOf(kind, candidate) {
+  if (kind !== "implementation") return [];
+  const methods = candidate.methods ?? [];
+  return methods.flatMap((m) => resolveNarrativeLabels(m.name, m.narrative ?? []));
+}
+function removedByName(before, after) {
+  if (!before?.length) return [];
+  const kept = new Set((after ?? []).map((m) => m.name));
+  return before.map((m) => m.name).filter((n) => !kept.has(n));
+}
+function rewriteNotices(kind, existing, candidate, carried, cleared) {
+  const named = kind === "system" ? existing.name : String(candidate.id);
+  const notices = [`${REWRITE_LABEL[kind]} "${named}" already existed \u2014 re-authored in place; this input REPLACES what it expresses.`];
+  if (carried.length) notices.push(`Carried forward (not expressible through this tool): ${carried.join(", ")}.`);
+  const removal = removalNotice(kind, existing, candidate);
+  if (removal) notices.push(removal);
+  if (cleared.length) {
+    notices.push(
+      `CLEARED by omission: ${cleared.join(", ")} \u2014 the argument was not repeated, so the previous value is gone. Use sdd_update_spec if you meant to leave it untouched.`
+    );
+  }
+  return notices;
+}
+function removalNotice(kind, existing, candidate) {
+  const before = existing;
+  let removed = [];
+  let noun = "method";
+  let suffix = "";
+  if (kind === "interface" || kind === "implementation") {
+    removed = removedByName(before.methods, candidate.methods);
+    suffix = kind === "interface" ? " (endpoint bindings included)" : " (L5 narratives included)";
+  } else if (kind === "type") {
+    removed = [
+      ...removedByName(before.fields, candidate.fields).map((n) => `field ${n}`),
+      ...removedByName(before.methods, candidate.methods).map((n) => `method ${n}`)
+    ];
+    noun = "member";
+  }
+  if (!removed.length) return void 0;
+  return `REMOVED by this restatement: ${removed.length === 1 ? noun : `${noun}s`} ${removed.map((n) => `"${n}"`).join(", ")}${suffix} \u2014 absent from the input, so no longer in the spec. Restate them to keep them, or use sdd_update_spec to edit one member at a time.`;
+}
+var METHOD_SCHEMA = {
+  interface: MethodSignatureSchema,
+  implementation: MethodImplementationSchema,
+  type: TypeMethodSchema
+};
+function changedMethodsOf(kind, existing, candidate) {
+  if (!existing || !(kind in METHOD_SCHEMA)) return [];
+  const schema = METHOD_SCHEMA[kind];
+  const stored = existing.methods ?? [];
+  const next = candidate.methods ?? [];
+  return stored.filter((method) => {
+    const restated = next.find((m) => m.name === method.name);
+    if (!restated) return true;
+    const parsed = schema.safeParse(restated);
+    return !parsed.success || canonical(parsed.data) !== canonical(method);
+  }).map((method) => method.name);
+}
+function canonical(value) {
+  return JSON.stringify(value, (_key, v) => v && typeof v === "object" && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).filter(([, x]) => x !== void 0).sort(([a], [b]) => a.localeCompare(b))) : v);
+}
+function writeSpec(restatement) {
+  const bound2 = candidateOptions();
+  const parentRef = restatementParent(restatement);
+  const parent = parentRef ? loadSpec(parentRef.kind, parentRef.id) : null;
+  const id = restatement.kind === "system" ? "system" : restatement.spec.id;
+  const existing = loadSpec(restatement.kind, id);
+  const application = applyRestatement(restatement, existing, parent);
+  if (application.refusal !== void 0) throw new Error(application.refusal);
+  const gateNotices = restatement.kind === "component" ? judgeComponent(application.spec, bound2) : [];
+  const persisted = persistCandidate(restatement.kind, application.spec);
+  const testsToRevisit = testsInvalidatedBy(restatement.kind, id, application.changedMethods, [existing, application.spec], bound2);
+  return {
+    kind: restatement.kind,
+    id,
+    name: application.spec.name,
+    replacedExisting: application.replacedExisting,
+    ...application.status ? { status: application.status } : {},
+    notices: [...gateNotices, ...persisted.notices, ...application.notices],
+    ...persisted.scaffoldedProjectPath ? { scaffoldedProjectPath: persisted.scaffoldedProjectPath } : {},
+    testsToRevisit
+  };
+}
+function judgeComponent(candidate, options) {
+  const verdict = validateComponentCandidate(candidate, options);
+  if (verdict.errors.length) throw new Error(formatCandidateRefusal(verdict));
+  return noticesFrom(verdict);
+}
+function persistCandidate(kind, spec) {
+  const projectPath = kind === "subsystem" ? spec.projectPath : void 0;
+  if (projectPath && projectPath.trim() !== "") {
+    createChainedSubsystem(spec, spec.name);
+    return { notices: [], scaffoldedProjectPath: projectPath };
+  }
+  return { notices: saveSpec(kind, spec) };
+}
+function testsInvalidatedBy(kind, id, methods, specs, options, written = []) {
+  const testRoots = options.rules?.conformance?.testRoots ?? [];
+  if (methods.length === 0 || testRoots.length === 0) return [];
+  return findTestsReferencing2(searchedMethods(kind, id, methods, specs, written), getProjectRoot(), testRoots);
+}
+function searchedMethods(kind, id, names, specs, written) {
+  const stated = (name) => written.find((m) => m?.name === name)?.symbol;
+  if (kind === "interface") {
+    const realizations = loadImplementationSpecs().filter((impl) => impl.contract === id);
+    return names.flatMap((name) => {
+      const found = realizations.flatMap((impl) => impl.methods.filter((m) => m.name === name).map((m) => ({ name, symbol: stated(name) ?? m.symbol, sourcePath: m.sourcePath ?? impl.sourcePath })));
+      return found.length > 0 ? found : [{ name, symbol: stated(name) }];
+    });
+  }
+  return names.map((name) => {
+    const holders = specs.map((spec) => {
+      const holder = spec;
+      const method = holder?.methods?.find((m) => m.name === name);
+      return method ? { method, file: method.sourcePath ?? holder?.sourcePath } : null;
+    }).filter((h) => h !== null);
+    const symbol = stated(name) ?? holders.map((h) => h.method.symbol).find((s) => s !== void 0);
+    const sourcePath = holders.map((h) => h.file).find((f) => f !== void 0) ?? specs.map((spec) => spec?.sourcePath).find((f) => f !== void 0);
+    return { name, symbol, sourcePath };
+  });
+}
+function deleteSpec2(kind, id) {
+  const bound2 = candidateOptions();
+  const stored = loadSpec(kind, id);
+  const deleted = deleteSpec(kind, id);
+  const methods = deleted ? (stored?.methods ?? []).map((m) => m.name) : [];
+  const testsToRevisit = testsInvalidatedBy(kind, id, methods, [stored], bound2);
+  return { kind, id, deleted, testsToRevisit };
+}
+function updateSpecGated(kind, id, delta, dryRun) {
+  const bound2 = candidateOptions();
+  const gate = componentCandidateGate(bound2);
+  const testRoots = bound2.rules?.conformance?.testRoots ?? [];
+  const stored = testRoots.length > 0 ? loadSpec(kind, id) : null;
+  const report = updateSpec(kind, id, delta, gate, dryRun);
+  const changed = changedMethods(report);
+  if (changed.length > 0 && testRoots.length > 0) {
+    const written = Array.isArray(delta?.methods) ? delta.methods : [];
+    report.testsToRevisit = testsInvalidatedBy(kind, id, changed, [stored], bound2, written);
+  }
+  return report;
+}
+function changedMethods(report) {
+  const named = /* @__PURE__ */ new Set();
+  for (const change of report.changes) {
+    const [field, name] = change.path.split(".");
+    if (field === "methods" && name) named.add(name);
+  }
+  return [...named];
+}
+function methodMoveGate(source) {
+  const bound2 = candidateOptions();
+  return {
+    gate: (kind, merged) => {
+      if (kind !== "component") return;
+      const { codes, verdict, ceiling } = judgeMoveHome(merged, source, bound2);
+      if (codes.length === 0) return noticesFrom(verdict);
+      throw new Error(
+        `${codes.join(", ")} refuses "${merged.id}" as the home for these methods. ` + (verdict.errors.length ? formatCandidateRefusal(verdict) : `It would reach ${merged.dependsOn?.length ?? 0} dependencies against a ceiling of ${ceiling}.`)
+      );
+    },
+    assess: (kind, merged) => kind === "component" ? judgeMoveHome(merged, source, bound2).codes : []
+  };
+}
+function judgeMoveHome(component, source, options) {
+  const ceiling = options.rules?.complexity?.maxComponentDependencies;
+  const verdict = validateComponentCandidate(component, options);
+  const codes = verdict.errors.map((e) => e.code);
+  if (component.id !== source && ceiling !== void 0 && (component.dependsOn?.length ?? 0) > ceiling) {
+    codes.push("EXCESSIVE_DEPENDENCIES");
+  }
+  return { codes: [...new Set(codes)], verdict, ceiling };
+}
+function moveMethods2(from, to, methods, dryRun) {
+  return moveMethods(from, to, methods, methodMoveGate(from), dryRun);
+}
+
+// src/mcp/build.ts
+var fs19 = __toESM(require("fs"));
+var path30 = __toESM(require("path"));
+var import_child_process2 = require("child_process");
+function captureBuildStamp(entryPath) {
+  try {
+    const s = fs19.statSync(entryPath);
+    return { path: entryPath, mtimeMs: s.mtimeMs, size: s.size };
+  } catch {
+    return null;
+  }
+}
+function isBuildStale(stamp) {
+  if (!stamp) return false;
+  try {
+    const s = fs19.statSync(stamp.path);
+    return s.mtimeMs !== stamp.mtimeMs || s.size !== stamp.size;
+  } catch {
+    return false;
+  }
+}
+var fingerprintCache = /* @__PURE__ */ new Map();
+function readBuildFingerprint(stamp) {
+  const current2 = fs19.statSync(stamp.path);
+  const key = `${stamp.path}|${current2.mtimeMs}|${current2.size}`;
+  const cached = fingerprintCache.get(key);
+  if (cached !== void 0) return cached;
+  const modulePath = fingerprintModuleFor(stamp.path);
+  const loaderFlags = modulePath.endsWith(".ts") ? process.execArgv : [];
+  let printed;
+  try {
+    printed = (0, import_child_process2.execFileSync)(
+      process.execPath,
+      [...loaderFlags, "-e", "const m = require(process.argv[1]); process.stdout.write(String(m.schemaFingerprint()));", modulePath],
+      { encoding: "utf8", timeout: 6e4, stdio: ["ignore", "pipe", "pipe"], windowsHide: true }
+    ).trim();
+  } catch (e) {
+    const stderr = String(e.stderr ?? "").split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+    const cause = stderr.find((l) => /^[A-Za-z]*Error\b/.test(l)) ?? stderr[0] ?? e.message;
+    throw new Error(`the build at ${modulePath} could not be asked for its schema fingerprint (${cause})`);
+  }
+  if (!printed) throw new Error(`the build at ${modulePath} answered no schema fingerprint`);
+  fingerprintCache.set(key, printed);
+  return printed;
+}
+function fingerprintModuleFor(entryPath) {
+  let dir = path30.dirname(entryPath);
+  for (; ; ) {
+    const manifest = path30.join(dir, "package.json");
+    if (fs19.existsSync(manifest)) {
+      try {
+        const pkg = JSON.parse(fs19.readFileSync(manifest, "utf8"));
+        const inDist = path30.relative(path30.join(dir, "dist"), entryPath);
+        if (pkg.name === "@wairon/cli" && pkg.main && !inDist.startsWith("..") && !path30.isAbsolute(inDist)) {
+          return path30.resolve(dir, pkg.main);
+        }
+      } catch {
+      }
+      return entryPath;
+    }
+    const parent = path30.dirname(dir);
+    if (parent === dir) return entryPath;
+    dir = parent;
+  }
+}
+
+// src/mcp/server.ts
+function statusFamilyContext() {
+  const lines = [];
+  try {
+    const parent = resolveChainingParent();
+    if (parent) {
+      let parentName;
+      try {
+        const system = readYamlFile(aiPathsAt(parent.parentRoot).specsSystem());
+        if (typeof system?.name === "string") parentName = system.name;
+      } catch {
+      }
+      lines.push(
+        `Family: this project is a chained subproject, mounted as subsystem "${parent.subsystemId}" of ${parentName ? `the parent project "${parentName}"` : "its parent project"} \u2014 the surfaces it can consume are listed by sdd_list_external_interfaces.`
+      );
+    }
+    const mounts = loadSubsystemSpecs().filter((s) => s.projectPath && !s.id.includes("::"));
+    if (mounts.length > 0) {
+      lines.push(`Family: chained subprojects mounted here \u2014 ${mounts.map((s) => `${s.id} (${s.projectPath})`).join(", ")}.`);
+    }
+  } catch {
+  }
+  return lines.length > 0 ? `${lines.join("\n")}
+
+` : "";
+}
+function resolveComponentVariantGuidance(component) {
+  if (!component.variant) return null;
+  const byId = new Map(loadProjectVariants().map((v) => [v.id, v]));
+  return resolveVariantGuidance(component, loadComponentSpecs(), byId);
+}
+function qualifiedComponentId(id) {
+  const ids = loadComponentSpecs().map((c) => c.id);
+  if (ids.includes(id)) return id;
+  const bare = id.startsWith("::") ? id.slice(2) : id;
+  if (ids.includes(bare)) return bare;
+  const chained = ids.filter((known) => known.endsWith(`::${bare}`));
+  return chained.length === 1 ? chained[0] : id;
+}
+function publicInterfacesReplacement(subsystem, stored, list) {
+  const identity = (pi) => pi.component ? `${pi.component}${pi.interface ? `.${pi.interface}` : ""}` : `${pi.type} ${pi.details}`;
+  const restated = /* @__PURE__ */ new Map();
+  for (const pi of list) restated.set(identity(pi), (restated.get(identity(pi)) ?? 0) + 1);
+  const twice = [...restated].filter(([, n]) => n > 1).map(([key]) => `"${key}"`);
+  if (twice.length) {
+    return `Refusing to set the public interfaces of subsystem "${subsystem}": the list names ${twice.join(", ")} more than once. An entry is identified by the component and interface it is bound to \u2014 or, not yet bound, by its type and details \u2014 so two entries sharing one are the same entry stated twice. Drop the duplicate. Nothing was written.`;
+  }
+  const seen = /* @__PURE__ */ new Map();
+  const deletes = [];
+  for (const pi of stored) {
+    const key = identity(pi);
+    seen.set(key, (seen.get(key) ?? 0) + 1);
+    if (seen.get(key) > (restated.get(key) ?? 0)) {
+      deletes.push(pi.component ? { component: pi.component, interface: pi.interface, action: "delete" } : { type: pi.type, details: pi.details, action: "delete" });
+    }
+  }
+  const restatedEntries = list.map((pi) => {
+    const prev = stored.find((s) => identity(s) === identity(pi));
+    const dropped = prev ? Object.keys(prev).filter((f) => prev[f] !== void 0 && pi[f] === void 0) : [];
+    return dropped.length ? { ...pi, unset: dropped } : pi;
+  });
+  return { publicInterfaces: [...deletes, ...restatedEntries] };
+}
+function text(content) {
+  return { content: [{ type: "text", text: content }] };
+}
+function json(value) {
+  return text(JSON.stringify(value, null, 2));
+}
+function errText(message) {
+  return { content: [{ type: "text", text: `Error: ${message.replace(/^(?:\s*Error:\s*)+/, "")}` }], isError: true };
+}
+function errMessage(e) {
+  return errText(e instanceof Error ? e.message : String(e));
+}
+var TYPE_REF_GRAMMAR = (what) => `${what}: a primitive/builtin or a defined type id (qualified across subsystems, e.g. "billing.Invoice" or "billing::Invoice"). Generics, arrays and UNIONS are all read, at any depth: "Invoice | null" (the commonest shape there is), "Invoice | undefined", "Invoice | Receipt", "Promise<Invoice | null>", "Map<string, Invoice | null>", "Invoice[] | null", "(Invoice | null)[]". Every identifier the string names must resolve \u2014 a union of two defined types means BOTH must exist. A union of string literals ("read" | "write") names no type and resolves to nothing.`;
+function structured(content, data) {
+  return { content: [{ type: "text", text: content }], structuredContent: data };
+}
+function jsonStructured(value) {
+  return structured(JSON.stringify(value, null, 2), value);
+}
+var staleServerOutput = {
+  staleServer: import_zod11.z.boolean().optional().describe(
+    "True when the wairon build on disk changed after this server started \u2014 the structured twin of the text answer's STALE SERVER banner. When the rebuild left the spec and tool schemas alone, writes still go through; reconnect to run the new code."
+  ),
+  writesRefused: import_zod11.z.boolean().optional().describe(
+    "True when the rebuild changed a spec or tool schema (or its schemas could not be compared): every spec write through this server is refused and writes nothing, because it would silently drop the fields only the new build knows. The human has to reconnect the server (/mcp reconnect wairon)."
+  )
+};
+function renderChangeReport(report) {
+  const lines = [report.dryRun ? `DRY RUN \u2014 nothing was written. ${report.summary}` : report.summary];
+  for (const change of report.changes) {
+    const to = change.after === void 0 ? "" : `: ${JSON.stringify(change.after)}`;
+    const from = change.before === void 0 ? "" : ` (was ${JSON.stringify(change.before)})`;
+    lines.push(`- ${change.path} ${report.dryRun ? `would be ${change.change}` : change.change}${to}${from}`);
+  }
+  if (report.ineffective.length) {
+    lines.push("", "NO EFFECT:", ...report.ineffective.map((i) => `- ${i}`));
+  }
+  if (report.notices.length) lines.push("", "NOTICE:", ...report.notices.map((n) => `- ${n}`));
+  lines.push(...renderTestsToRevisit(report.testsToRevisit));
+  return lines.join("\n");
+}
+var SPEC_KINDS = ["system", "subsystem", "component", "interface", "implementation", "type"];
+var STATUS_VALUES = ["draft", "design", "complete"];
+var testsToRevisitOutput = import_zod11.z.array(import_zod11.z.object({
+  method: import_zod11.z.string().describe("The contract method this write changed or deleted."),
+  symbol: import_zod11.z.string().describe("The code-level name searched for: the method's `symbol` when it declares one, else its name."),
+  imported: import_zod11.z.array(import_zod11.z.string()).describe("Test files that IMPORT that symbol \u2014 the high-confidence list, because an import is a binding and not a coincidence."),
+  mentioned: import_zod11.z.array(import_zod11.z.string()).describe("Test files that name the symbol without importing it \u2014 usually a test driving it through a portal. Empty when `indiscriminate` is true."),
+  indiscriminate: import_zod11.z.boolean().describe("True when the bare name matched more than a tenth of the test suite, so the mention list was withheld as noise.")
+})).describe(
+  "The tests that encode a method this write changed or deleted, one entry per such method. Empty when the write touched no method, when the project declares no `rules.conformance.testRoots`, or when nothing references them. Read it before promising that existing tests still pass."
+);
+function renderTestsToRevisit(entries) {
+  if (!entries.length) return [];
+  const lines = ["", "TESTS TO REVISIT:"];
+  for (const entry of entries) {
+    lines.push(`- ${entry.method} (searched as "${entry.symbol}")`);
+    if (entry.imported.length) lines.push(`  imports it: ${entry.imported.join(", ")}`);
+    if (entry.mentioned.length) lines.push(`  names it: ${entry.mentioned.join(", ")}`);
+    if (entry.indiscriminate) {
+      lines.push("  names it: withheld \u2014 the bare name matches more than a tenth of the suite, so the list carries no signal.");
+    }
+  }
+  return lines;
+}
+var specWriteReceiptOutput = {
+  kind: import_zod11.z.enum(SPEC_KINDS).describe("The spec kind written."),
+  id: import_zod11.z.string().describe('The id the spec is stored under; "system" for the L0 singleton.'),
+  name: import_zod11.z.string().describe("The spec's display name as written."),
+  replacedExisting: import_zod11.z.boolean().describe(
+    "True when a spec already held this id and the call re-authored it in place rather than adding one. The notices then say what was carried forward, removed or cleared by the restatement."
+  ),
+  status: import_zod11.z.enum(STATUS_VALUES).optional().describe(
+    "The lifecycle status written. Absent for the L0 and a type, which carry none."
+  ),
+  notices: import_zod11.z.array(import_zod11.z.string()).describe(
+    "The notice lines the text answer lists, one per entry: what was carried forward, what a restatement removed, what an omission cleared, and every gate warning the write raised. Empty for a clean create."
+  ),
+  scaffoldedProjectPath: import_zod11.z.string().optional().describe(
+    "The child project directory a chained subsystem's create scaffolded; absent for every other write."
+  ),
+  testsToRevisit: testsToRevisitOutput,
+  ...staleServerOutput
+};
+function writeReceipt(sentence, receipt) {
+  const noticeBlock = receipt.notices.length ? `
+
+NOTICE:
+- ${receipt.notices.join("\n- ")}` : "";
+  const testsBlock = renderTestsToRevisit(receipt.testsToRevisit).join("\n");
+  return structured(`${sentence}${noticeBlock}${testsBlock ? `
+${testsBlock}` : ""}`, receipt);
+}
+var specDeletionOutput = {
+  kind: import_zod11.z.enum(SPEC_KINDS).describe("The spec kind deleted."),
+  id: import_zod11.z.string().describe("The id the spec was stored under."),
+  deleted: import_zod11.z.boolean().describe("True when a spec document was removed."),
+  testsToRevisit: testsToRevisitOutput,
+  ...staleServerOutput
+};
+var specChangeOutput = {
+  path: import_zod11.z.string().describe("The dotted path the change addresses, with names and indexes."),
+  change: import_zod11.z.enum(["set", "added", "removed", "cleared", "renumbered", "relocated"]).describe(
+    "What happened at that path. A narrative is compared by step identity: `renumbered` is a run of unchanged steps shifted by an insert or delete (before/after name the ranges), `relocated` a jump field that followed its target to the target's new number."
+  ),
+  before: import_zod11.z.string().optional().describe("The previous value, summarized; absent when there was none."),
+  after: import_zod11.z.string().optional().describe("The new value, summarized; absent when there is none.")
+};
+var specChangeReportOutput = {
+  kind: import_zod11.z.enum(SPEC_KINDS).describe("The spec kind written."),
+  id: import_zod11.z.string().describe("The stored spec's id."),
+  written: import_zod11.z.boolean().describe("False when the merged spec equals what is stored: nothing reached disk."),
+  dryRun: import_zod11.z.boolean().describe(
+    "True when the caller asked what the delta WOULD do. `written` is false for a dry run exactly as it is for a delta that changed nothing, and only this field tells the two apart."
+  ),
+  changes: import_zod11.z.array(import_zod11.z.object(specChangeOutput)).describe(
+    "Every change the write made; empty exactly when `written` is false."
+  ),
+  ineffective: import_zod11.z.array(import_zod11.z.string()).describe(
+    "Every path the delta named that the write did not act on, each with why. Read it: a nested typo the permissive delta cannot refuse shows up here and nowhere else."
+  ),
+  notices: import_zod11.z.array(import_zod11.z.string()).describe("Store placement notices, gate warnings and delta notices."),
+  summary: import_zod11.z.string().describe("One line for people."),
+  testsToRevisit: testsToRevisitOutput,
+  ...staleServerOutput
+};
+var validationIssueOutput = {
+  severity: import_zod11.z.enum(["error", "warning"]).describe("The finding's severity after project overrides."),
+  code: import_zod11.z.string().describe("The rule code, UPPER_SNAKE \u2014 the stable handle to filter and suppress by."),
+  message: import_zod11.z.string().describe("What is wrong, named."),
+  agentId: import_zod11.z.string().optional().describe("The agent the finding concerns, when it concerns one."),
+  specId: import_zod11.z.string().optional().describe("The spec the finding concerns, when it concerns one."),
+  draftContext: import_zod11.z.boolean().optional().describe(
+    "True when the finding was raised against a draft/design spec \u2014 what the --ci gate waives."
+  ),
+  surfaceResolved: import_zod11.z.boolean().optional().describe(
+    "True when the finding was verified against a vendored surface snapshot, so it is a contract verdict rather than a resolution failure."
+  )
+};
+var validateTreeOutput = {
+  valid: import_zod11.z.boolean().describe("False when the tree holds at least one error."),
+  errors: import_zod11.z.array(import_zod11.z.object(validationIssueOutput)).describe("Every finding of severity error."),
+  warnings: import_zod11.z.array(import_zod11.z.object(validationIssueOutput)).describe("Every finding of severity warning."),
+  resolvedThrough: import_zod11.z.object({
+    root: import_zod11.z.string().describe("The top root that was validated."),
+    scope: import_zod11.z.string().describe("The mount chain the verdict was scoped to.")
+  }).optional().describe(
+    "Present when a chained subproject's verdict was resolved through its parent; absent when the tree was validated on its own."
+  ),
+  ...staleServerOutput
+};
+var getSpecOutput = {
+  kind: import_zod11.z.enum(SPEC_KINDS).describe("The kind of spec read."),
+  id: import_zod11.z.string().describe("The id it was read by."),
+  spec: import_zod11.z.record(import_zod11.z.unknown()).describe(
+    "The stored spec, exactly as the text block renders it \u2014 minus the two derived markers below, which the text folds in and this answer keeps separate so nothing derived can be mistaken for stored."
+  ),
+  partialResult: import_zod11.z.object({
+    shown: import_zod11.z.array(import_zod11.z.string()).describe("The method names this answer carries."),
+    omitted: import_zod11.z.number().describe("How many of the spec's methods are NOT in it."),
+    warning: import_zod11.z.string().describe("Why it must never be re-authored from.")
+  }).optional().describe(
+    "Present only when `methods` filtered the read. A filtered spec is a partial one: sdd_define_interface and sdd_write_narrative REPLACE the method list, so re-authoring from it would delete every method left out."
+  ),
+  variantGuidance: import_zod11.z.object({
+    variant: import_zod11.z.string().describe("The variant id the component declares."),
+    base: import_zod11.z.string().describe("The core stereotype it specializes."),
+    guidance: import_zod11.z.string().describe("How to implement a component of this variant."),
+    siblings: import_zod11.z.array(import_zod11.z.string()).describe("Other components of the same variant, to implement alike."),
+    target: import_zod11.z.string().optional().describe("The target language the variant scopes itself to, if any."),
+    profile: import_zod11.z.string().optional().describe("The architectural profile it scopes itself to, if any.")
+  }).optional().describe(
+    "Derived, read-only guidance for a variant-tagged component \u2014 resolved from the variant registry, not part of the spec. Never write it back."
+  ),
+  ...staleServerOutput
+};
+var FINGERPRINT_VERSION = 1;
+function schemaShape(schema, seen = /* @__PURE__ */ new Map()) {
+  const def = schema?._def;
+  if (!def) return null;
+  const known = seen.get(schema);
+  if (known !== void 0) return { ref: known };
+  seen.set(schema, seen.size);
+  const inner = (s) => schemaShape(s, seen);
+  const kind = String(def.typeName);
+  switch (kind) {
+    case "ZodObject": {
+      const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+      return {
+        kind,
+        keys: Object.keys(shape).sort().map((key) => [key, inner(shape[key])]),
+        unknownKeys: def.unknownKeys,
+        catchall: inner(def.catchall)
+      };
+    }
+    case "ZodArray":
+      return { kind, of: inner(def.type), min: def.minLength?.value, max: def.maxLength?.value };
+    case "ZodOptional":
+    case "ZodNullable":
+    case "ZodReadonly":
+    case "ZodBranded":
+    case "ZodCatch":
+      return { kind, of: inner(def.innerType ?? def.type) };
+    case "ZodDefault":
+      return { kind, of: inner(def.innerType), default: JSON.stringify(def.defaultValue?.()) };
+    case "ZodEffects":
+      return { kind, effect: def.effect?.type, of: inner(def.schema) };
+    case "ZodLazy":
+      return { kind, of: inner(def.getter()) };
+    case "ZodUnion":
+    case "ZodDiscriminatedUnion": {
+      const options = def.options instanceof Map ? [...def.options.values()] : def.options;
+      return { kind, discriminator: def.discriminator, of: options.map(inner) };
+    }
+    case "ZodIntersection":
+      return { kind, left: inner(def.left), right: inner(def.right) };
+    case "ZodTuple":
+      return { kind, of: def.items.map(inner), rest: inner(def.rest) };
+    case "ZodRecord":
+    case "ZodMap":
+      return { kind, key: inner(def.keyType), value: inner(def.valueType) };
+    case "ZodSet":
+      return { kind, of: inner(def.valueType) };
+    case "ZodEnum":
+      return { kind, values: def.values };
+    case "ZodNativeEnum":
+      return { kind, values: def.values };
+    case "ZodLiteral":
+      return { kind, value: def.value };
+    case "ZodPipeline":
+      return { kind, in: inner(def.in), out: inner(def.out) };
+    default:
+      return { kind, checks: def.checks?.map((c) => [c.kind, c.value ?? null]) ?? [] };
+  }
+}
+var runningFingerprint;
+function schemaFingerprint() {
+  if (runningFingerprint !== void 0) return runningFingerprint;
+  const specs = {
+    system: schemaShape(SystemSpecSchema),
+    subsystem: schemaShape(SubsystemSpecSchema),
+    component: schemaShape(ComponentSpecSchema),
+    interface: schemaShape(InterfaceSpecSchema),
+    implementation: schemaShape(ImplementationSpecSchema),
+    type: schemaShape(TypeSpecSchema)
+  };
+  const registered = createMcpServer()._registeredTools;
+  const tools = [...SPEC_WRITE_TOOLS].sort().map((name) => [name, schemaShape(registered[name]?.inputSchema)]);
+  runningFingerprint = crypto4.createHash("sha256").update(JSON.stringify({ version: FINGERPRINT_VERSION, specs, tools })).digest("hex");
+  return runningFingerprint;
+}
+var RECONNECT = "The human has to reconnect this MCP server (in Claude Code: /mcp reconnect wairon) \u2014 an agent cannot.";
+function assessBuildFreshness(stamp) {
+  if (!isBuildStale(stamp)) return { state: "fresh", writesRefused: false, reason: "" };
+  const running = schemaFingerprint();
+  let onDisk;
+  try {
+    onDisk = readBuildFingerprint(stamp);
+  } catch (e) {
+    return {
+      state: "unreadable",
+      writesRefused: true,
+      reason: `the wairon build on disk changed after this MCP server started, and its schemas could not be compared (${e instanceof Error ? e.message : String(e)}), so a schema change cannot be ruled out. Every spec write through this server is REFUSED and writes nothing. ${RECONNECT}`
+    };
+  }
+  if (onDisk === running) {
+    return {
+      state: "build-changed",
+      writesRefused: false,
+      reason: "the wairon build on disk changed after this MCP server started. Its spec and tool schemas did not change, so spec writes still go through; reconnect the server (/mcp reconnect wairon) to run the new code."
+    };
+  }
+  return {
+    state: "schema-changed",
+    writesRefused: true,
+    reason: `the wairon build on disk changed after this MCP server started, and its spec or tool schemas changed with it. A write through this server would silently drop the fields only the new build knows, so every spec write is REFUSED and writes nothing. ${RECONNECT}`
+  };
+}
+function markStale(result, freshness = assessedAsChanged, placement = "trail") {
+  const marked = result.structuredContent ? {
+    ...result,
+    structuredContent: {
+      ...result.structuredContent,
+      staleServer: true,
+      ...freshness.writesRefused ? { writesRefused: true } : {}
+    }
+  } : result;
+  const banner = `\u26A0 STALE SERVER: ${freshness.reason}`;
+  const first = marked.content?.[0];
+  if (first && first.type === "text") {
+    const textWithBanner = placement === "lead" ? `${banner}
+
+${first.text}` : `${first.text}
+
+${banner}`;
+    return { ...marked, content: [{ ...first, text: textWithBanner }, ...marked.content.slice(1)] };
+  }
+  return marked;
+}
+var assessedAsChanged = {
+  state: "build-changed",
+  writesRefused: false,
+  reason: "the wairon build on disk changed after this MCP server started. Reconnect the server (/mcp reconnect wairon) before further spec edits \u2014 a write through a stale server can silently drop fields a newer schema introduced."
+};
+var serverBuildStamps = /* @__PURE__ */ new WeakMap();
+var SERVER_BUILD_STAMP = captureBuildStamp(__filename);
+var SPEC_WRITE_TOOLS = /* @__PURE__ */ new Set([
+  "sdd_initialize_system",
+  "sdd_add_subsystem",
+  "sdd_set_public_interfaces",
+  "sdd_set_subsystem_project_path",
+  "sdd_move_subsystem_project",
+  "sdd_externalize_subsystem",
+  "sdd_internalize_subsystem",
+  "sdd_rename_component",
+  "sdd_rename_method",
+  "sdd_add_component",
+  "sdd_define_interface",
+  "sdd_set_endpoints",
+  "sdd_write_narrative",
+  "sdd_add_type",
+  "sdd_delete_spec",
+  "sdd_update_spec",
+  "sdd_move_methods"
+]);
+var listChangedEmitters = /* @__PURE__ */ new WeakMap();
+function reg(server, name, config, cb) {
+  const guarded = (args) => {
+    const freshness = assessBuildFreshness(serverBuildStamps.get(server) ?? null);
+    if (freshness.writesRefused && SPEC_WRITE_TOOLS.has(name)) {
+      return errText(`${name} refused \u2014 ${freshness.reason}`);
+    }
+    const answered = cb(args);
+    const result = freshness.state === "fresh" ? answered : markStale(answered, freshness, name === "sdd_get_status" ? "lead" : "trail");
+    if (result.isError !== true && SPEC_WRITE_TOOLS.has(name)) listChangedEmitters.get(server)?.();
+    return result;
+  };
+  const strictConfig = config.inputSchema ? { ...config, inputSchema: import_zod11.z.object(config.inputSchema).strict() } : config;
+  server.registerTool(name, strictConfig, guarded);
+}
+var statusInput = import_zod11.z.enum(STATUS_VALUES).optional().describe(
+  "The spec's lifecycle status. Omitted means draft for a NEW spec and the status already stored for a re-authoring, so a restatement never reopens a frozen spec. State it to author straight at design or complete instead of promoting afterwards. A status that would LOWER the stored one is refused \u2014 reopening a spec for revision is sdd_update_spec's job, which sets the demotion deliberately."
+);
+var SKILL_RESOURCE_MIME = "text/markdown";
+function skillIdFromResourceUri(uri) {
+  try {
+    const u = new URL(uri);
+    return u.host || u.pathname.replace(/^\/+/, "") || uri;
+  } catch {
+    return uri;
+  }
+}
+var AGENT_BRIEF_SCHEME = "wairon-agent://";
+function listAgentBriefResources() {
+  try {
+    return resolveAgentTopology().map((a) => ({
+      uri: `${AGENT_BRIEF_SCHEME}${a.id}`,
+      name: a.name,
+      description: a.description,
+      mimeType: SKILL_RESOURCE_MIME
+    }));
+  } catch {
+    return [];
+  }
+}
+function renderAgentBriefMarkdown(brief) {
+  const lines = [
+    `# Agent brief: ${brief.agentId}`,
+    "",
+    `- **Name**: ${brief.name}`,
+    `- **Template**: ${brief.template}`,
+    ...brief.domainRoot ? [`- **Domain root**: ${brief.domainRoot}`] : [],
+    `- **Owned paths**: ${brief.ownedPaths.join(", ")}`,
+    ...brief.readPaths?.length ? [`- **Read paths**: ${brief.readPaths.join(", ")}`] : [],
+    "",
+    "## Instructions",
+    "",
+    brief.instructions
+  ];
+  if (brief.variantGuidance && !brief.instructions.includes(brief.variantGuidance)) {
+    lines.push("", "## Variant guidance", "", brief.variantGuidance);
+  }
+  if (brief.budget && brief.profile) {
+    lines.push(
+      "",
+      "## Execution budget",
+      "",
+      ...summarize(brief.budget, brief.profile),
+      "",
+      "Advisory \u2014 apply these when spawning. Map the capability tier onto your host tool's models; a tool that cannot express a field should ignore it rather than approximate it."
+    );
+  }
+  return `${lines.join("\n")}
+`;
+}
+function registerSkillResources(server, listChanged) {
+  server.server.registerCapabilities({ resources: listChanged ? { listChanged: true } : {} });
+  server.server.setRequestHandler(import_types4.ListResourcesRequestSchema, () => ({
+    resources: [
+      ...listResources().map((d) => ({
+        uri: d.resourceUri,
+        name: d.name,
+        description: d.description,
+        mimeType: SKILL_RESOURCE_MIME
+      })),
+      ...listAgentBriefResources()
+    ]
+  }));
+  server.server.setRequestHandler(import_types4.ReadResourceRequestSchema, (request) => {
+    const uri = request.params.uri;
+    if (uri.startsWith(AGENT_BRIEF_SCHEME)) {
+      try {
+        const brief = composeAgentBrief(uri.slice(AGENT_BRIEF_SCHEME.length));
+        return { contents: [{ uri, mimeType: SKILL_RESOURCE_MIME, text: renderAgentBriefMarkdown(brief) }] };
+      } catch (e) {
+        throw new import_types4.McpError(import_types4.ErrorCode.InvalidParams, e instanceof Error ? e.message : String(e));
+      }
+    }
+    try {
+      const content = readResource(skillIdFromResourceUri(uri));
+      return { contents: [{ uri, mimeType: SKILL_RESOURCE_MIME, text: content }] };
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      throw new import_types4.McpError(import_types4.ErrorCode.InvalidParams, message);
+    }
+  });
+}
+function registerSkillPrompts(server, listChanged) {
+  server.server.registerCapabilities({ prompts: listChanged ? { listChanged: true } : {} });
+  server.server.setRequestHandler(import_types4.ListPromptsRequestSchema, () => ({
+    prompts: listResources().map((d) => ({
+      name: d.id,
+      title: d.name,
+      description: d.description
+    }))
+  }));
+  server.server.setRequestHandler(import_types4.GetPromptRequestSchema, (request) => {
+    const name = request.params.name;
+    try {
+      const content = readResource(name);
+      return {
+        description: `The wairon "${name}" skill.`,
+        messages: [{ role: "user", content: { type: "text", text: content } }]
+      };
+    } catch (e) {
+      throw new import_types4.McpError(import_types4.ErrorCode.InvalidParams, e instanceof Error ? e.message : String(e));
+    }
+  });
+}
+function createMcpServer(options = {}) {
+  const server = new import_mcp.McpServer({
+    name: "wairon",
+    version: WAIRON_VERSION
+  }, {
+    instructions: buildServerInstructions2()
+  });
+  serverBuildStamps.set(server, options.buildStamp === void 0 ? SERVER_BUILD_STAMP : options.buildStamp);
+  if (!options.hostedTools) {
+    listChangedEmitters.set(server, () => {
+      try {
+        void server.server.sendResourceListChanged().catch(() => {
+        });
+        void server.server.sendPromptListChanged().catch(() => {
+        });
+      } catch {
+      }
+    });
+  }
+  reg(
+    server,
+    "listAgents",
+    {
+      description: "List all AI agents registered in this project. Returns id, name, description, domainRoot, template, tags, and status for each agent. Filter by domainId to scope to one domain.",
+      inputSchema: { domainId: import_zod11.z.string().optional() }
+    },
+    ({ domainId }) => {
+      try {
+        const registry = loadRegistry();
+        const agents = domainId ? registry.agents.filter((a) => a.domainRoot === domainId) : registry.agents;
+        return json(agents.map((a) => ({
+          id: a.id,
+          name: a.name,
+          description: a.description,
+          domainRoot: a.domainRoot,
+          template: a.template,
+          tags: a.tags,
+          status: a.status
+        })));
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  reg(
+    server,
+    "getAgent",
+    {
+      description: "Get full details of a specific agent by id, including ownership rules, context, and output targets.",
+      inputSchema: { id: import_zod11.z.string() }
+    },
+    ({ id }) => {
+      try {
+        const registry = loadRegistry();
+        const agent = registry.agents.find((a) => a.id === id);
+        if (!agent) return errText(`Agent "${id}" not found.`);
+        return json(agent);
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  reg(
+    server,
+    "listDomains",
+    {
+      description: "List all domains in this project: subsystem-derived (boundTo set) plus free-standing domains from .wai/topology.yaml."
+    },
+    () => {
+      try {
+        return json(resolveDomains2());
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  reg(
+    server,
+    "validateTopology",
+    {
+      description: "Validate the project's agent topology. Returns errors and warnings (duplicate ids, overlapping ownership, missing paths, etc.). Supports optional subsystem scoping.",
+      inputSchema: {
+        subsystem: import_zod11.z.string().optional().describe("Only validate topology for agents under the specified subsystem")
+      }
+    },
+    ({ subsystem }) => {
+      try {
+        let registry = loadRegistry();
+        if (subsystem) {
+          registry = {
+            ...registry,
+            agents: registry.agents.filter((a) => a.domainRoot === subsystem || a.domainRoot?.startsWith(`${subsystem}::`))
+          };
+        }
+        const config = loadProjectConfig();
+        if (!config) throw new ProjectNotInitializedError();
+        const result = validateRegistry(registry, config.rules);
+        return json({
+          valid: result.issues.filter((i) => i.severity === "error").length === 0,
+          errors: result.issues.filter((i) => i.severity === "error"),
+          warnings: result.issues.filter((i) => i.severity === "warning")
+        });
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  reg(
+    server,
+    "getProjectConfig",
+    {
+      description: "Get the current project configuration (name, targets, rules, paths)."
+    },
+    () => {
+      try {
+        const config = loadProjectConfig();
+        if (!config) throw new ProjectNotInitializedError();
+        return json(config);
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  const systemInput = {
+    name: import_zod11.z.string().describe("Overarching name of the project/system"),
+    vision: import_zod11.z.string().describe("Vision, mission, and core goals of the system"),
+    boundaries: import_zod11.z.array(import_zod11.z.union([import_zod11.z.string(), import_zod11.z.object({ name: import_zod11.z.string(), description: import_zod11.z.string().optional() }).strict()])).optional().describe("System boundary rules or scope statements (strings or name/description objects)"),
+    globalRequirements: import_zod11.z.array(import_zod11.z.union([import_zod11.z.string(), import_zod11.z.object({ description: import_zod11.z.string() }).strict()])).optional().describe("Global functional and non-functional requirements (strings or description objects)"),
+    targetLanguage: import_zod11.z.string().optional().describe('Default implementation language for the system (e.g. "typescript", "rust", "python"). Subsystems may override. Enables language-aware validation.')
+  };
+  const systemInputFields = Object.keys(systemInput);
+  reg(
+    server,
+    "sdd_initialize_system",
+    {
+      description: "Initialize the L0 System Specification (system.yaml). Re-running it on an existing system RE-AUTHORS it: the fields above are replaced, and everything this tool cannot express (databases, the project gateway publicInterfaces, diagram defaults) is carried forward. The answer carries a write receipt as structured content beside the sentence \u2014 what was written, and whether a system spec already existed \u2014 so a caller never has to read English to find out.",
+      inputSchema: systemInput,
+      outputSchema: specWriteReceiptOutput
+    },
+    ({ name, vision, boundaries, globalRequirements, targetLanguage }) => {
+      try {
+        const restatement = {
+          kind: "system",
+          spec: {
+            name,
+            vision,
+            boundaries: boundaries ?? [],
+            globalRequirements: globalRequirements ?? [],
+            ...targetLanguage ? { targetLanguage } : {}
+          },
+          fields: systemInputFields
+        };
+        const receipt = writeSpec(restatement);
+        return writeReceipt(
+          `Successfully ${receipt.replacedExisting ? "re-authored" : "initialized"} L0 System Spec for "${name}".`,
+          receipt
+        );
+      } catch (e) {
+        return errMessage(e);
+      }
+    }
+  );
+  const subsystemInput = {
+    id: import_zod11.z.string().describe("Lowercase identifier for the subsystem"),
+    name: import_zod11.z.string().describe("Human-readable display name"),
+    description: import_zod11.z.string().describe("Purpose and details of the subsystem"),
+    publicInterfaces: import_zod11.z.array(import_zod11.z.object({
+      type: import_zod11.z.enum(["REST", "GraphQL", "MessageBus", "RPC", "Custom"]),
+      details: import_zod11.z.string(),
+      component: import_zod11.z.string().optional().describe("The L2 component id that realizes this interface (this subsystem's published surface)"),
+      interface: import_zod11.z.string().optional().describe("Optional L3 interface id on that component backing this entry"),
+      consumers: import_zod11.z.array(import_zod11.z.string()).optional().describe("The subsystem ids this surface is published to. Absent, any subsystem may depend on the component; present, only these may \u2014 when every entry publishing the component names consumers, the union of the lists is the whole set, and a dependency from any other subsystem is CROSS_SUBSYSTEM_UNLISTED_CONSUMER. Every id must name a subsystem of the tree (PUBLIC_INTERFACE_UNKNOWN_CONSUMER).")
+    }).strict()).optional().describe("Public entrypoints exposed by this subsystem, each bound to a realizing component"),
+    projectPath: import_zod11.z.string().optional().describe("Relative path to external project root for subsystem chaining"),
+    targetLanguage: import_zod11.z.string().optional().describe("Override of the system-level targetLanguage for this subsystem"),
+    profile: import_zod11.z.string().optional().describe("Architectural profile override for this subsystem (built-ins: backend, frontend-reactive, frontend-controller, lowlevel-os, game-ecs, realtime-embedded, plc-cyclic; extension packs may add more \u2014 unknown names get UNKNOWN_PROFILE)"),
+    designDepth: import_zod11.z.enum(["components", "interfaces", "implementations", "narratives"]).optional().describe("How deep THIS subsystem commits to designing (overrides project rules.designDepth; default narratives = full depth). Expectation checks below the depth are gated \u2014 soundness of authored content always applies."),
+    trustedLinks: import_zod11.z.array(import_zod11.z.object({
+      subsystem: import_zod11.z.string().describe("Peer subsystem id"),
+      reason: import_zod11.z.string().describe('Why the coupling is sanctioned (e.g. "dispatch latency fast lane")')
+    }).strict()).optional().describe("Sanctioned tight couplings with peers \u2014 required to acknowledge a mutual subsystem dependency; the Adapter \u2192 published Portal shape still applies."),
+    lifecycle: import_zod11.z.array(import_zod11.z.object({
+      phase: import_zod11.z.enum(["init", "shutdown", "cyclic", "interrupt", "scheduled"]).describe("Which lifecycle/execution flow this roots (cyclic = every scan/tick, interrupt = hardware/OS interrupt, scheduled = timer/cron)"),
+      component: import_zod11.z.string().describe("Component id whose method the runtime invokes at this phase"),
+      method: import_zod11.z.string().describe("Method name on that component's interface"),
+      description: import_zod11.z.string().optional()
+    }).strict()).optional().describe("Declared execution-flow roots \u2014 reachability entrypoints alongside Portals/Observers. Only init flows feed the durable-Store hydration check (MISSING_HYDRATION); cyclic/interrupt/scheduled root non-request/response execution models (PLC scan, ISR, cron)."),
+    status: statusInput
+  };
+  const subsystemInputFields = [...Object.keys(subsystemInput), "parentSystem"];
+  reg(
+    server,
+    "sdd_add_subsystem",
+    {
+      description: "Add an L1 Subsystem / Service under the system boundary. publicInterfaces should bind each entry to the component that realizes it (the subsystem's published surface); if components do not exist yet, add them later with sdd_set_public_interfaces. Re-running it on an existing id RE-AUTHORS it: the fields above are replaced, lint/ext are carried forward, and the stored status is kept unless this input states a higher one. The answer carries a write receipt as structured content beside the sentence \u2014 the status written, whether a spec already held the id, and the child project directory a chained subsystem scaffolded.",
+      inputSchema: subsystemInput,
+      outputSchema: specWriteReceiptOutput
+    },
+    ({ id, name, description, publicInterfaces, projectPath, targetLanguage, profile, designDepth, trustedLinks, lifecycle, status }) => {
+      try {
+        const restatement = {
+          kind: "subsystem",
+          spec: {
+            id,
+            name,
+            description,
+            publicInterfaces: publicInterfaces ?? [],
+            projectPath,
+            ...targetLanguage ? { targetLanguage } : {},
+            ...profile ? { profile } : {},
+            ...designDepth ? { designDepth } : {},
+            ...lifecycle ? { lifecycle } : {},
+            trustedLinks: trustedLinks ?? []
+          },
+          fields: subsystemInputFields,
+          status
+        };
+        const receipt = writeSpec(restatement);
+        if (receipt.scaffoldedProjectPath) {
+          return writeReceipt(
+            `Successfully added external subsystem "${name}" (${id}) and scaffolded its child project at ${receipt.scaffoldedProjectPath}.`,
+            receipt
+          );
+        }
+        return writeReceipt(`Successfully added L1 Subsystem Spec "${name}" (${id}).`, receipt);
+      } catch (e) {
+        return errMessage(e);
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_set_public_interfaces",
+    {
+      description: "Set (replace) an existing subsystem's publicInterfaces, binding each to the component (and optional interface) that realizes it. Use this to backfill bindings once the subsystem's components exist \u2014 cross-subsystem dependencies may only target a published public component. A replacement, not a merge: an entry left out is removed. An entry's identity is its component and interface, so a list naming one identity twice is refused. Written through the authoring seam as one gated delta, and answered with the change report \u2014 every entry added, changed or removed, or that nothing changed \u2014 as structured content beside the sentence.",
+      inputSchema: {
+        subsystem: import_zod11.z.string().describe("The L1 subsystem id to update"),
+        publicInterfaces: import_zod11.z.array(import_zod11.z.object({
+          type: import_zod11.z.enum(["REST", "GraphQL", "MessageBus", "RPC", "Custom"]),
+          details: import_zod11.z.string(),
+          component: import_zod11.z.string().optional().describe("The L2 component id that realizes this interface"),
+          interface: import_zod11.z.string().optional().describe("Optional L3 interface id on that component"),
+          consumers: import_zod11.z.array(import_zod11.z.string()).optional().describe("The subsystem ids this surface is published to. Absent, any subsystem may depend on the component; present, only these may \u2014 when every entry publishing the component names consumers, the union of the lists is the whole set, and a dependency from any other subsystem is CROSS_SUBSYSTEM_UNLISTED_CONSUMER. Every id must name a subsystem of the tree (PUBLIC_INTERFACE_UNKNOWN_CONSUMER).")
+        }).strict()).describe("The full replacement list of public interfaces for this subsystem")
+      },
+      outputSchema: specChangeReportOutput
+    },
+    ({ subsystem, publicInterfaces }) => {
+      try {
+        const sub = loadSubsystemSpec(subsystem);
+        if (!sub) return errText(`Subsystem "${subsystem}" does not exist.`);
+        const delta = publicInterfacesReplacement(subsystem, sub.publicInterfaces ?? [], publicInterfaces);
+        if (typeof delta === "string") return errText(delta);
+        const report = updateSpecGated("subsystem", subsystem, delta);
+        return structured(
+          `Updated public interfaces for subsystem "${subsystem}" (${publicInterfaces.length} ${publicInterfaces.length === 1 ? "entry" : "entries"}).
+${renderChangeReport(report)}`,
+          report
+        );
+      } catch (e) {
+        return errMessage(e);
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_set_subsystem_project_path",
+    {
+      description: "Set (or clear) the projectPath of an L1 Subsystem for subsystem chaining. projectPath should be a relative path to the external project root directory. It rewrites the link only (sdd_move_subsystem_project relocates the directory with it). Written through the authoring seam as a gated delta, and answered with the change report as structured content beside the sentence.",
+      inputSchema: {
+        subsystem: import_zod11.z.string().describe("The L1 subsystem id to update"),
+        projectPath: import_zod11.z.string().optional().describe("Relative path to external project root (or omit to clear)")
+      },
+      outputSchema: specChangeReportOutput
+    },
+    ({ subsystem, projectPath }) => {
+      try {
+        const delta = projectPath ? { projectPath } : { unset: ["projectPath"] };
+        const report = updateSpecGated("subsystem", subsystem, delta);
+        return structured(
+          `Updated projectPath for subsystem "${subsystem}" to: ${projectPath || "none (cleared)"}
+${renderChangeReport(report)}`,
+          report
+        );
+      } catch (e) {
+        return errMessage(e);
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_move_subsystem_project",
+    {
+      description: "Relocate an external subsystem: move its subproject directory on disk to newProjectPath and update its projectPath link in one step. Errors if the subsystem has no projectPath (not an external subproject).",
+      inputSchema: {
+        subsystem: import_zod11.z.string().describe("The external L1 subsystem id to relocate"),
+        newProjectPath: import_zod11.z.string().describe("The new relative path for the subproject directory")
+      }
+    },
+    ({ subsystem, newProjectPath }) => {
+      try {
+        moveSubsystemProject(subsystem, newProjectPath);
+        return text(`Moved subsystem "${subsystem}" to: ${newProjectPath}`);
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_externalize_subsystem",
+    {
+      description: "Migrate an internal subsystem into a standalone subproject at projectPath: move its spec subtree out, mount it via projectPath, and rewrite cross-subsystem references to the new namespaced ids. Source code is not moved. Errors if the subsystem is missing or already external.",
+      inputSchema: {
+        subsystem: import_zod11.z.string().describe("The internal L1 subsystem id to externalize"),
+        projectPath: import_zod11.z.string().describe("Relative destination directory for the new subproject")
+      }
+    },
+    ({ subsystem, projectPath }) => {
+      try {
+        externalizeSubsystem(subsystem, projectPath);
+        return text(`Externalized subsystem "${subsystem}" into subproject: ${projectPath}. Move its source code there and re-validate.`);
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_internalize_subsystem",
+    {
+      description: "Migrate an external subsystem back into the parent tree: move its subproject spec subtree back under the parent, drop projectPath, delete the child .wai project, and rewrite references back to bare ids. Errors if the subsystem is not external or its subproject is not a single flat subsystem.",
+      inputSchema: {
+        subsystem: import_zod11.z.string().describe("The external L1 subsystem id to internalize")
+      }
+    },
+    ({ subsystem }) => {
+      try {
+        internalizeSubsystem(subsystem);
+        return text(`Internalized subsystem "${subsystem}" back into this project (child .wai removed).`);
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_rename_component",
+    {
+      description: "Rename a component and rewrite every reference to it in the bound tree: dependsOn, owns and dispatch entries, lifecycle entrypoints, published interfaces at L1 and L0, narrative call/dispatch/register targets, an interface's component, an implementation's contract and an entity's componentClass. The interface named i<id> and the implementation named <id>_impl move to the new ids and files; interfaces and implementations named otherwise keep their ids. Findings keyed on the component follow it too: every lint allow naming it on an edge site or in a covered unit, and every entry of the debt register (.wai/project.yaml rules.conformance.carried) anchored on a renamed spec or naming the component in its site or units \u2014 rewritten in place, every comment and all other formatting of the register kept, so unchanged debt never reads as paid and new at once. A register that cannot be rewritten that precisely is refused before the first write. Display names are left as they are. Refuses, writing nothing: a component that does not exist (component-missing), one inside a chained subproject (chained-component \u2014 rename it from that project's own root), a new id that is not a lowercase identifier without a namespace separator (invalid-id), and a new id \u2014 or i<newId> or <newId>_impl \u2014 already in use (id-taken). Returns the specs moved, each with its old and new id, the ids of the other specs rewritten (lint allows included), and `carried`: each register edit \u2014 the entry by code, spec and site as it stood, the key changed (spec, at or covers), from and to.",
+      inputSchema: {
+        id: import_zod11.z.string().describe("The component to rename (namespaced if needed)"),
+        newId: import_zod11.z.string().describe("Its new id: a lowercase identifier with no namespace separator")
+      }
+    },
+    ({ id, newId }) => {
+      try {
+        return json(renameComponent(qualifiedComponentId(id), newId));
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_rename_method",
+    {
+      description: "Rename a contract method and retarget every reference to it in the bound tree. The method moves on every interface of the component that declares it \u2014 its name, and the name inside its signature \u2014 and on the implementations of those contracts, carrying narrative, sourcePath, symbol, detail, intent and findings unchanged; an implementation that declared no symbol is pinned to the old name unless pinSymbol is false, so the function it already binds to keeps binding. Narrative call, register and dispatch steps naming this component and method, dispatch-table bindings and lifecycle entrypoints are retargeted, and so are the findings keyed on it: a lint allow at the method on a spec it moved in or covering `<component>.<method>`, and every debt-register entry (.wai/project.yaml rules.conformance.carried) keyed the same way \u2014 rewritten in place with every comment and all other formatting kept (a register that cannot be rewritten that precisely is refused before the first write). Prose is never rewritten and a gRPC endpoint binding keeps its wire method \u2014 renaming a contract method must not silently rename an RPC; both are reported as mentions. Refuses, writing nothing: a component that does not exist (component-missing), one inside a chained subproject (chained-component \u2014 rename its method from that project's own root), a new name that is not a camel-case identifier (invalid-name), a method the component does not declare (method-missing), and a name a moving contract already declares (name-taken). Returns the specs the method moved in, the specs retargeted (lint allows included), the specs whose prose still names it, the pinned symbol when one was set, and `carried`: each register edit.",
+      inputSchema: {
+        id: import_zod11.z.string().describe("The component whose method is renamed (namespaced if needed)"),
+        method: import_zod11.z.string().describe("The method name as it stands"),
+        newName: import_zod11.z.string().describe("Its new name: a camel-case identifier"),
+        pinSymbol: import_zod11.z.boolean().optional().describe("Whether an implementation that declares no symbol is pinned to the old name so its function still binds; true when omitted")
+      }
+    },
+    ({ id, method, newName, pinSymbol }) => {
+      try {
+        return json(renameMethod(qualifiedComponentId(id), method, newName, pinSymbol));
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_move_methods",
+    {
+      description: "Move contract methods from one component to another, carrying each method's narrative, calls and bindings, and re-pointing every reference that named the old home: narrative call/register/dispatch steps, dispatch-table bindings, lifecycle entrypoints and `calls` entries. The target gains the dependencies the moved narratives call. Findings keyed on a moved method follow it: a lint allow anchored at it moves to the receiving spec, one covering `<from>.<method>` names `<to>.<method>`, and the debt register (.wai/project.yaml rules.conformance.carried) is rekeyed the same way in place, every comment and all other formatting kept \u2014 the report's `carried` lists each register edit, and a register that cannot be rewritten that precisely is refused before the first write. ONE all-or-nothing gated write: if a rule refuses the move nothing is written and the report names the rule plus where these methods could live instead, cheapest legal home first, with the requested target among them so its shortfall reads beside the others. Prose is never rewritten and a wire endpoint keeps its address \u2014 moving a method between components must not silently re-address an RPC; both are reported as mentions. A target that declares no contract yet receives one, i<target>, and when implementation entries travel and no implementation realizes the receiving contract, <target>_impl is created for them, inheriting the source implementation's sourcePath; the report's `created` names every spec the move created. Refuses before the first write (unmovable request): a component or method that does not exist, a method name already declared on the target, a source and target that are the same component, a target with several contracts none named i<target>, a contract or implementation to create whose id another spec already holds, and a component inside a chained subproject (move it from that project's own root). A dry run runs the whole move, gate included, and reports what it would have done.",
+      inputSchema: {
+        from: import_zod11.z.string().describe("The component the methods belong to (namespaced if needed)"),
+        to: import_zod11.z.string().describe("The component that should receive them (namespaced if needed)"),
+        methods: import_zod11.z.array(import_zod11.z.string()).describe("The method names to move; every one must exist on the source contract"),
+        dryRun: import_zod11.z.boolean().optional().describe("Answer with what the move would do and write nothing")
+      }
+    },
+    ({ from, to, methods, dryRun }) => {
+      try {
+        const source = qualifiedComponentId(from);
+        const target = qualifiedComponentId(to);
+        if (!loadComponentSpec(source)) return errText(`no component has the id "${from}".`);
+        if (!loadComponentSpec(target)) return errText(`no component has the id "${to}".`);
+        return json(moveMethods2(source, target, methods, dryRun));
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  const componentInput = {
+    id: import_zod11.z.string().describe("Lowercase identifier for the component"),
+    name: import_zod11.z.string().describe("Human-readable display name"),
+    description: import_zod11.z.string().describe("Responsibility / internal architecture details"),
+    subsystem: import_zod11.z.string().describe("The L1 subsystem ID this component belongs to"),
+    componentType: import_zod11.z.enum(["Portal", "Orchestrator", "Supervisor", "Actor", "Store", "Index", "Query", "Registry", "Adapter", "Observer", "Repository"]).describe("The building block, or the pattern Repository. Specialist and Gateway are retired and cannot be authored: logic is an Orchestrator with a dependencyClass, a gateway is a Portal with the gateway variant"),
+    owns: import_zod11.z.array(import_zod11.z.string()).optional().describe("Member block ids privately owned by this component (patterns only)"),
+    dependsOn: import_zod11.z.array(import_zod11.z.string()).optional().describe("IDs of other components this collaborates with (facades or standalone blocks)"),
+    portalType: import_zod11.z.enum(["HTTP_API", "gRPC", "GraphQL", "MessageBus", "CLI", "NamedPipe", "IPC", "Custom"]).optional().describe("Portal-only, and expected on every Portal. OMIT IT on any other componentType \u2014 passing it there is refused at the write (UNEXPECTED_PORTAL_FIELD), nothing is saved."),
+    basePath: import_zod11.z.string().optional().describe("Portal-only: base path/prefix all the portal's endpoints mount under. OMIT IT on any other componentType \u2014 passing it there is refused at the write (UNEXPECTED_PORTAL_FIELD), nothing is saved."),
+    dispatch: import_zod11.z.array(import_zod11.z.object({
+      capability: import_zod11.z.string().describe('Capability name exactly as dispatched at runtime (e.g. "shadow_module.get")'),
+      component: import_zod11.z.string().describe("Component id serving this capability (must also appear under dependsOn/owns)"),
+      method: import_zod11.z.string().describe("Method name on the serving component's interface"),
+      description: import_zod11.z.string().optional()
+    }).strict()).optional().describe("Portal-only: capability \u2192 component.method dispatch table for generic-handle portals. Gives the reachability walker real edges and is validated against target interfaces (UNSERVED_CAPABILITY)."),
+    mounts: import_zod11.z.array(import_zod11.z.object({
+      portal: import_zod11.z.string().describe("The mounted Portal's component id"),
+      prefixes: import_zod11.z.array(import_zod11.z.string()).describe('The path prefixes this listener routes to the portal. A path lies under a prefix when it equals it or continues it past a slash, so "/" covers only the root itself'),
+      via: import_zod11.z.string().optional().describe("The router entry the listener calls to hand the portal its request, exported by the PORTAL's own file (held to it: UNREALIZED_EXPORT_HANDLE). Omit when the listener calls the portal's contract methods directly, route by route")
+    }).strict()).optional().describe("Portal-only: the portals this LISTENER serves, each under its path prefixes and through its router entry. Declaring the field \u2014 even as an empty array \u2014 marks this portal as a listener, the one kind of portal nothing else needs to mount. Checked by portal-mounts: a mount must name a Portal (MOUNT_TARGET_NOT_PORTAL), every HTTP endpoint of a mounted portal must lie under one of its prefixes (ENDPOINT_OUTSIDE_MOUNT), and a portal with HTTP endpoints that is neither a listener nor mounted by one is reported (UNMOUNTED_PORTAL)."),
+    durability: import_zod11.z.enum(["ram-projection", "durable", "read-through", "cache"]).optional().describe("Store-only \u2014 OMIT IT on any other componentType, where it is refused at the write (DURABILITY_ON_NON_STORE) and nothing is saved. Every Store should declare one (MISSING_DURABILITY): durable = persisted RAM projection (hydration read-back from a lifecycle init entrypoint required \u2014 MISSING_HYDRATION); read-through = persisted with no RAM copy (every read is the read-back, hydration exempt); ram-projection = rebuilt not restored; cache = evictable loss-safe memo state."),
+    dependencyClass: import_zod11.z.enum(["pure", "read"]).optional().describe("Orchestrator-only \u2014 OMIT IT on any other componentType, where it is refused at the write (DEPENDENCY_CLASS_ON_NON_ORCHESTRATOR) and nothing is saved. Declares what logic may depend on, enforced as a Store's durability is (DEPENDENCY_CLASS_VIOLATION): pure = depends only on pure Orchestrators (a computation over the values it is handed, e.g. an arbiter or codec); read = also on read Orchestrators, Repositories, Indexes and Adapters, never calling their write methods; unset = a workflow."),
+    emits: import_zod11.z.array(import_zod11.z.object({
+      topic: import_zod11.z.string().describe("Topic/channel name exactly as used on the bus"),
+      event: import_zod11.z.string().optional().describe("Optional event name within the topic (informational; pairing is by topic)"),
+      description: import_zod11.z.string().optional()
+    }).strict()).optional().describe("Topics this component publishes \u2014 every emitted topic needs a subscriber somewhere in the tree (UNCONSUMED_TOPIC)."),
+    subscribesTo: import_zod11.z.array(import_zod11.z.object({
+      topic: import_zod11.z.string().describe("Topic/channel name exactly as used on the bus"),
+      event: import_zod11.z.string().optional(),
+      description: import_zod11.z.string().optional()
+    }).strict()).optional().describe("Topics this component consumes (typical on Observers) \u2014 every subscription needs an emitter somewhere in the tree (UNSOURCED_SUBSCRIPTION)."),
+    ext: import_zod11.z.record(import_zod11.z.unknown()).optional().describe('Opaque pack/tool extension data (namespaced keys, e.g. "mypack:priority") \u2014 preserved verbatim, never validated or interpreted by the core'),
+    status: statusInput
+  };
+  const componentInputFields = Object.keys(componentInput);
+  reg(
+    server,
+    "sdd_add_component",
+    {
+      description: `Add an L2 Component under a subsystem. componentType is a building block (Portal, Orchestrator, Supervisor, Actor, Store, Index, Query, Registry, Adapter, Observer) or the pattern Repository. Specialist and Gateway are retired (STEREOTYPE_RETIRED) and cannot be authored: logic is an Orchestrator with a dependencyClass (pure | read; unset = a workflow), and a gateway is a Portal with the gateway variant (set variant with sdd_update_spec). Patterns set "owns" (their private member blocks); all components set "dependsOn" (collaborators \u2014 facades or standalone blocks). Held/persisted state (configs, permissions, sessions, caches): model the Repository recipe \u2014 a Store + Registry (write) + Index (read), plus a Query for computed reads over the Store, owned by a Repository facade consumers depend on; a deliberately standalone Store is the sanctioned lightweight form (workflow-layer consumers + lint.allow on UNOWNED_STORE). Never hold state as fields inside an Orchestrator because a Store link was refused. Re-running it on an existing id RE-AUTHORS it: the fields above are replaced (an omitted array is CLEARED), while lint.allow, a Portal's auth, variant, patterns and externalLinks are carried forward \u2014 edit those with sdd_update_spec. The stored status is kept unless this input states a higher one. The answer carries a write receipt as structured content beside the sentence \u2014 the status written, whether a spec already held the id, and every gate notice the write raised, each as its own entry.`,
+      inputSchema: componentInput,
+      outputSchema: specWriteReceiptOutput
+    },
+    ({ id, name, description, subsystem, componentType, owns, dependsOn, portalType, basePath, dispatch, mounts, durability, dependencyClass, emits, subscribesTo, ext, status }) => {
+      try {
+        const restatement = {
+          kind: "component",
+          spec: {
+            id,
+            name,
+            description,
+            subsystem,
+            componentType,
+            owns: owns ?? [],
+            dependsOn: dependsOn ?? [],
+            ...portalType ? { portalType } : {},
+            ...basePath ? { basePath } : {},
+            ...dispatch ? { dispatch } : {},
+            // An EMPTY list is kept: declaring the field is what marks a listener.
+            ...mounts ? { mounts } : {},
+            ...durability ? { durability } : {},
+            ...dependencyClass ? { dependencyClass } : {},
+            ...emits ? { emits } : {},
+            ...subscribesTo ? { subscribesTo } : {},
+            ...ext ? { ext } : {}
+          },
+          fields: componentInputFields,
+          status
+        };
+        const receipt = writeSpec(restatement);
+        return writeReceipt(
+          `Successfully ${receipt.replacedExisting ? "re-authored" : "added"} L2 Component Spec "${name}" (${id}, ${componentType}).`,
+          receipt
+        );
+      } catch (e) {
+        return errMessage(e);
+      }
+    }
+  );
+  const interfaceMethodShape = {
+    name: import_zod11.z.string(),
+    description: import_zod11.z.string(),
+    signature: import_zod11.z.string(),
+    returns: import_zod11.z.string().describe(TYPE_REF_GRAMMAR("The type the method answers with")),
+    params: import_zod11.z.array(import_zod11.z.object({
+      name: import_zod11.z.string(),
+      type: import_zod11.z.string().describe(TYPE_REF_GRAMMAR("The parameter's type")),
+      description: import_zod11.z.string().optional(),
+      optional: import_zod11.z.boolean().optional().describe(
+        'Whether the parameter may be OMITTED by a caller. It is not nullability: a parameter that must be passed but may be passed as nothing is a required parameter whose type is a union \u2014 "ProjectConfig | null". Say whichever is true; they are different contracts.'
+      )
+    }).strict()).optional().describe("Structured parameters \u2014 authoritative for type checking (the prose signature becomes display-only). Strongly preferred."),
+    guarantees: import_zod11.z.array(import_zod11.z.string().min(1)).optional().describe("Semantic guarantees the method promises (combinable); any guarantee a narrative step asserts must be declared here. Builtin tokens: idempotent | atomic | transactional | exactly-once; extension packs may declare more (any other token is UNKNOWN_GUARANTEE)"),
+    effect: import_zod11.z.enum(["read", "write"]).optional().describe("State-effect direction on the component's held state \u2014 required on a durable Store's contract methods so the durability round-trip rule can pair writes with hydration read-backs"),
+    invokedBy: import_zod11.z.object({
+      kind: import_zod11.z.enum(["runtime", "external", "sibling-subsystem"]).describe("Who owns the out-of-graph invocation: runtime (timer/signal/shutdown hook), external (a system outside this project), sibling-subsystem (a modeled sibling whose edge is not narrated here)"),
+      caller: import_zod11.z.string().optional().describe("WHO invokes it and when, as reviewable prose \u2014 missing or placeholder-thin prose is INVOKED_BY_UNDESCRIBED")
+    }).strict().optional().describe("Typed acknowledgment of a real caller OUTSIDE the modeled narrative graph. Unused-detection seeds the method as an entrypoint so reachability propagates through its narrative (unlike lint.allow); a method the internal walk already reaches is flagged stale (INVOKED_BY_REDUNDANT). Prefer a `register` narrative step when the wiring is internal."),
+    findings: import_zod11.z.array(import_zod11.z.object({
+      code: import_zod11.z.string().describe("UPPER_SNAKE finding code, unique within the method; a pack's codes carry the pack prefix (<PACK>_<CODE>)"),
+      severity: import_zod11.z.enum(["error", "warning"]).describe("Default severity, before project severity overrides and draft-context downgrades"),
+      summary: import_zod11.z.string().describe("One line saying what the finding means")
+    }).strict()).optional().describe("The finding codes this method can report, each with its default severity and summary. Each declared code must be anchored in the method's source file, as a string literal or a property-access name (UNREALIZED_FINDING). A code is declared once per method; sdd_update_spec upserts and deletes findings by code."),
+    ext: import_zod11.z.record(import_zod11.z.unknown()).optional().describe("Opaque pack/tool extension data for this method (namespaced keys) \u2014 preserved verbatim")
+  };
+  const interfaceMethodInputFields = Object.keys(interfaceMethodShape);
+  const interfaceInput = {
+    id: import_zod11.z.string().describe('Lowercase identifier prefixed with "i", e.g. "istorage"'),
+    name: import_zod11.z.string().describe("Human-readable contract name"),
+    description: import_zod11.z.string().describe("Contract description and obligations"),
+    component: import_zod11.z.string().describe("The L2 component ID this interface belongs to"),
+    methods: import_zod11.z.array(import_zod11.z.object(interfaceMethodShape).strict()).optional().describe("List of method signature contracts"),
+    status: statusInput
+  };
+  const interfaceInputFields = Object.keys(interfaceInput);
+  reg(
+    server,
+    "sdd_define_interface",
+    {
+      description: "Define an L3 Contract / Interface with method signatures for a component. Prefer supplying structured `params` per method \u2014 they are the authoritative source for type checking (the free-form signature string then becomes display-only and is never heuristically parsed). A method declares the finding codes it reports in `findings` ({code, severity, summary}); each code must be anchored in the method's source file, as a string literal or a property-access name (UNREALIZED_FINDING). Re-defining an existing id REPLACES the method list: a method left out of the input is REMOVED (and reported); spec-level lint/ext and each method's endpoint binding are carried forward, and the stored status is kept unless this input states a higher one. The answer carries a write receipt as structured content beside the sentence \u2014 the status written, whether a spec already held the id, and the notices a restatement raised, each as its own entry.",
+      inputSchema: interfaceInput,
+      outputSchema: specWriteReceiptOutput
+    },
+    ({ id, name, description, component, methods, status }) => {
+      try {
+        const restatement = {
+          kind: "interface",
+          spec: { id, name, description, component, methods: methods ?? [] },
+          fields: interfaceInputFields,
+          memberFields: interfaceMethodInputFields,
+          status
+        };
+        const receipt = writeSpec(restatement);
+        return writeReceipt(
+          `Successfully ${receipt.replacedExisting ? "re-authored" : "defined"} L3 Interface Contract "${name}" (${id}).`,
+          receipt
+        );
+      } catch (e) {
+        return errMessage(e);
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_set_endpoints",
+    {
+      description: "Bind concrete wire endpoints to existing L3 interface methods (required for every Portal). Pick `transport` and fill that transport's address fields. Run after sdd_define_interface. Written through the authoring seam as one gated delta, and answered with the change report \u2014 every binding set or changed, or that nothing changed \u2014 as structured content beside the sentence.",
+      inputSchema: {
+        interface: import_zod11.z.string().describe('The L3 interface ID (e.g. "ibilling-gateway")'),
+        endpoints: import_zod11.z.array(import_zod11.z.object({
+          method: import_zod11.z.string().describe("The NAME of the interface method to bind (not the HTTP verb)"),
+          transport: import_zod11.z.enum(["HTTP", "gRPC", "GraphQL", "MessageBus", "NamedPipe", "IPC", "CLI", "Custom"]).describe("Wire protocol; must match the Portal's portalType"),
+          httpMethod: import_zod11.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]).optional().describe("HTTP: verb"),
+          path: import_zod11.z.string().optional().describe('HTTP: route path, e.g. "/v1/checkout"'),
+          service: import_zod11.z.string().optional().describe("gRPC: service name"),
+          rpcMethod: import_zod11.z.string().optional().describe("gRPC: rpc method name"),
+          operation: import_zod11.z.enum(["query", "mutation", "subscription"]).optional().describe("GraphQL: operation kind"),
+          field: import_zod11.z.string().optional().describe("GraphQL: root field name"),
+          topic: import_zod11.z.string().optional().describe("MessageBus: topic"),
+          event: import_zod11.z.string().optional().describe("MessageBus: event name"),
+          queue: import_zod11.z.string().optional().describe("MessageBus: optional queue/consumer group"),
+          direction: import_zod11.z.enum(["subscribe", "publish"]).optional().describe("MessageBus: subscribe (default) or publish"),
+          pipe: import_zod11.z.string().optional().describe('NamedPipe: pipe name, e.g. "\\\\.\\pipe\\gk-events"'),
+          channel: import_zod11.z.string().optional().describe("IPC: channel name"),
+          command: import_zod11.z.string().optional().describe("CLI: command/subcommand"),
+          address: import_zod11.z.string().optional().describe("Custom: free-form address")
+        }).strict()).describe("One binding per method")
+      },
+      outputSchema: specChangeReportOutput
+    },
+    ({ interface: interfaceId, endpoints }) => {
+      try {
+        const intf = loadInterfaceSpec(interfaceId);
+        if (!intf) return errText(`Interface "${interfaceId}" does not exist.`);
+        const buildRaw = (e) => {
+          switch (e.transport) {
+            case "HTTP":
+              return { transport: "HTTP", method: e.httpMethod, path: e.path };
+            case "gRPC":
+              return { transport: "gRPC", service: e.service, method: e.rpcMethod };
+            case "GraphQL":
+              return { transport: "GraphQL", operation: e.operation, field: e.field };
+            case "MessageBus":
+              return { transport: "MessageBus", topic: e.topic, event: e.event, queue: e.queue, direction: e.direction ?? "subscribe" };
+            case "NamedPipe":
+              return { transport: "NamedPipe", pipe: e.pipe };
+            case "IPC":
+              return { transport: "IPC", channel: e.channel };
+            case "CLI":
+              return { transport: "CLI", command: e.command };
+            case "Custom":
+              return { transport: "Custom", address: e.address };
+          }
+        };
+        const bound2 = [];
+        const methods = [];
+        for (const e of endpoints) {
+          const m = intf.methods.find((x) => x.name === e.method);
+          if (!m) return errText(`Method "${e.method}" not found on interface "${interfaceId}". Define it via sdd_define_interface first.`);
+          const parsed = EndpointSchema.safeParse(buildRaw(e));
+          if (!parsed.success) {
+            const detail = parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+            return errText(`Invalid ${e.transport} endpoint for method "${e.method}": ${detail}`);
+          }
+          methods.push({ name: e.method, endpoint: parsed.data });
+          bound2.push(`${e.method}\u2192${e.transport}`);
+        }
+        const report = updateSpecGated("interface", interfaceId, { methods });
+        return structured(
+          `Bound ${bound2.length} endpoint(s) on "${interfaceId}": ${bound2.join(", ")}.
+${renderChangeReport(report)}`,
+          report
+        );
+      } catch (e) {
+        return errMessage(e);
+      }
+    }
+  );
+  const stepNo = () => import_zod11.z.number().int().positive();
+  const labelRef = () => import_zod11.z.string().min(1);
+  const narrativeStepInput = import_zod11.z.object({
+    stepNumber: stepNo().optional().describe("Defaults to the 1-based array position \u2014 jump fields reference these numbers"),
+    label: labelRef().optional().describe("Optional symbolic anchor for this step (unique per narrative). Every jump-by-number field has a *Label twin resolved against these anchors at write time \u2014 prefer labels over hand-counted step numbers"),
+    description: import_zod11.z.string(),
+    type: import_zod11.z.enum(["local", "call", "dispatch", "register", "branch", "switch", "loop", "try", "parallel", "jump", "return", "throw"]),
+    targetComponent: import_zod11.z.string().optional().describe("call/register/dispatch: L2 component id (for dispatch, the Portal routed through)"),
+    targetMethod: import_zod11.z.string().optional().describe("call/register: method name on the target. A register step hands the target method to the runtime as a callback (timer, event listener, shutdown hook): reachability follows the edge, but it is never an invocation \u2014 exempt from call-graph conformance, call-cycle detection, and the durability boot walk"),
+    auth: import_zod11.z.object({ from: import_zod11.z.string(), note: import_zod11.z.string().optional() }).strict().optional().describe("call/dispatch: the credential this step presents to an AUTHED callee Portal and WHERE it loads from (`from`). Opaque form (env:API_KEY, a config key, vault:path) = a design note wairon never resolves; modeled form `component:<id>` references the Adapter/Store that provides the secret and is validated (must resolve, be an Adapter/Store, and be wired to the presenter). Absence on a call into a Portal whose auth \u2260 none warns (PORTAL_AUTH_UNMET). The authenticated call itself should be made by an Adapter (AUTH_PRESENTER_NOT_ADAPTER)."),
+    detach: import_zod11.z.boolean().optional().describe("call/dispatch: fire-and-forget \u2014 issue the call and continue without awaiting the result (no later step consumes it)"),
+    capability: import_zod11.z.string().optional().describe("dispatch: the capability routed through the target Portal's dispatch table (validated against it \u2014 UNSERVED_CAPABILITY)"),
+    assertsGuarantees: import_zod11.z.array(import_zod11.z.string().min(1)).optional().describe("Semantic guarantees this step relies on \u2014 each must be declared in the called method's L3 guarantees (NARRATIVE_SEMANTIC_UNBACKED otherwise). Builtin tokens: idempotent | atomic | transactional | exactly-once; extension packs may declare more (any other token is UNKNOWN_GUARANTEE)"),
+    assertsInvariants: import_zod11.z.array(import_zod11.z.string()).optional().describe(`Declared entity invariants this step upholds, as "<type-id>.<invariant-id>" refs (UNKNOWN_INVARIANT_REF when unresolved); write-effect methods of the entity's componentClass must carry one per declared invariant (UNASSERTED_INVARIANT)`),
+    condition: import_zod11.z.string().optional().describe("branch / while / doWhile"),
+    onTrueStep: stepNo().optional().describe("branch: default = next step"),
+    onTrueLabel: labelRef().optional().describe("branch: symbolic alternative to onTrueStep"),
+    onFalseStep: stepNo().optional().describe("branch: required (or onFalseLabel)"),
+    onFalseLabel: labelRef().optional().describe("branch: symbolic alternative to onFalseStep"),
+    on: import_zod11.z.string().optional().describe("switch: the dispatched value"),
+    cases: import_zod11.z.array(import_zod11.z.object({ value: import_zod11.z.string(), step: stepNo().optional(), label: labelRef().optional() }).strict()).optional().describe("switch: required; each case targets its region by step number or label"),
+    defaultStep: stepNo().optional().describe("switch: default = next step"),
+    defaultLabel: labelRef().optional().describe("switch: symbolic alternative to defaultStep"),
+    loopKind: import_zod11.z.enum(["forEach", "for", "while", "doWhile"]).optional().describe('loop: default forEach when "over" is set, else while'),
+    over: import_zod11.z.string().optional().describe("loop forEach/for: iteration source"),
+    endStep: stepNo().optional().describe("loop/try: last step of the body region (required, or endLabel)"),
+    endLabel: labelRef().optional().describe("loop/try: symbolic alternative to endStep"),
+    catches: import_zod11.z.array(import_zod11.z.object({ error: import_zod11.z.string(), step: stepNo().optional(), label: labelRef().optional() }).strict()).optional().describe("try: handler regions, each targeted by step number or label"),
+    finallyStep: stepNo().optional().describe("try: first step of the always-runs region"),
+    finallyLabel: labelRef().optional().describe("try: symbolic alternative to finallyStep"),
+    branches: import_zod11.z.array(import_zod11.z.object({ step: stepNo().optional(), label: labelRef().optional(), name: import_zod11.z.string().optional() }).strict()).optional().describe("parallel: >= 2 arm entries (step number or label), ascending, first = the step after the header; arms are contiguous sub-regions of body next..endStep, joining after endStep once ALL complete"),
+    toStep: stepNo().optional().describe("jump: required (break/continue/rejoin), or toLabel"),
+    toLabel: labelRef().optional().describe("jump: symbolic alternative to toStep \u2014 resolves to the labeled step at write time"),
+    outcome: import_zod11.z.string().optional().describe('return: e.g. "success", "not found"'),
+    error: import_zod11.z.string().optional().describe("throw: the raised error")
+  }).strict();
+  const detailEnum = import_zod11.z.enum(["full", "calls-only", "intent"]);
+  const conformanceEnum = import_zod11.z.enum(["declared", "anchored", "off"]);
+  const implMethodShape = {
+    name: import_zod11.z.string(),
+    sourcePath: import_zod11.z.string().optional().describe("Optional: the source file realizing THIS method when it is not the implementation's sourcePath (e.g. a command whose body lives in its own file); the implementation's sourcePath is the default. Relative to project root \u2014 for a chained subproject's implementation (qualified id), relative to that subproject's root; a path given relative to this root that lands inside the subproject is re-expressed for you"),
+    detail: detailEnum.optional().describe("Detail level for this method (overrides the spec default)"),
+    intent: import_zod11.z.string().optional().describe("detail: intent \u2014 behavioral prose (what it does and how it fails); substitute for a narrative"),
+    conformance: conformanceEnum.optional().describe("Conformance tier for this method (overrides the spec default)"),
+    symbol: import_zod11.z.string().optional().describe("Code-level name realizing this contract method in the sourcePath file, when it legitimately differs from the intent-language contract name (e.g. put realized by saveSnapshot)"),
+    exportedVia: import_zod11.z.string().optional().describe("The exported binding a consumer imports to REACH this method, when the realization is published as a value that composes it rather than exported in its own right (a rule module publishes callConformanceRule, and the method is the check inside it). Not symbol, which names the function itself: this names the route to it, so the surface check reads that export as promised. A handle the method's own source file does not actually export is reported (UNREALIZED_EXPORT_HANDLE) and allows nothing"),
+    ext: import_zod11.z.record(import_zod11.z.unknown()).optional().describe("Opaque pack/tool extension data for this method (namespaced keys) \u2014 preserved verbatim"),
+    narrative: import_zod11.z.array(narrativeStepInput).optional(),
+    calls: import_zod11.z.array(import_zod11.z.string().min(1)).optional().describe('The calls this method makes, when its narrative does not show them (detail: intent, or calls-only with no steps authored) \u2014 each as "<component>.<method>", the spelling the debt register and lint allows name a unit with. The narrative walk takes exactly these edges and no others, so an undeclared collaborator is NOT reached: this is what keeps unused-detection honest at a lower detail dial. Each entry is validated like a call step (the component resolves, this component declares it, the method is on its contract). Refused beside a non-empty narrative \u2014 add the call step there instead')
+  };
+  const implMethodInputFields = Object.keys(implMethodShape);
+  const implInput = {
+    id: import_zod11.z.string().describe('Lowercase identifier, e.g. "vfs_storage"'),
+    name: import_zod11.z.string().describe("Human-readable implementation name"),
+    description: import_zod11.z.string().describe("Implementation details"),
+    contract: import_zod11.z.string().describe("The L3 Interface contract ID this implements"),
+    sourcePath: import_zod11.z.string().optional().describe("Optional: target source code file path relative to project root \u2014 for a chained subproject's implementation (qualified id), relative to that subproject's root; a path given relative to this root that lands inside the subproject is re-expressed for you"),
+    simPath: import_zod11.z.string().optional().describe("Optional: the committed integration-sim harness file (project-relative; N:1 sharing allowed). The validator proves it exists and its import graph wires the REAL modules (this component + each direct dependency; technology adapters may stay faked) \u2014 running it is CI's job. Declaring the first simPath in a subsystem activates MISSING_INTEGRATION_SIM for its other complete non-leaf implementations"),
+    technologies: import_zod11.z.array(import_zod11.z.string()).optional().describe(`External technologies this implementation binds to (e.g. ["mysql"]) \u2014 declares this component's ownership tree as the technology's home; references outside it are flagged (TECH_LEAKAGE) and contract identifiers must stay intent-language. Only for Adapter/Store/Registry/Index components.`),
+    injectedParams: import_zod11.z.array(import_zod11.z.string()).optional().describe("The parameter names this realization takes BEFORE the ones its contract declares \u2014 a config object, a data root, the transport handles a portal is handed. Supplied by whatever wires the component up, never by the caller the contract describes, which is why they belong here and not to the contract: another realization may hold them as fields instead. Declared rather than guessed, because a leading parameter the contract does not name cannot be told from one it named under a different name (`seed(config)` realized as `bootstrapInstance(cfg)`); a leading parameter this list does not name is reported (UNDECLARED_PARAM). Only a LEADING run is dropped \u2014 one of these names appearing after the contract's own parameters is an argument in the middle of the caller's list, not wiring"),
+    detail: detailEnum.optional().describe("Spec-level narrative detail default for all methods"),
+    conformance: conformanceEnum.optional().describe("Spec-level conformance tier default: declared | anchored | off (omitted = stereotype default: Portal \u2192 anchored, else declared)"),
+    methods: import_zod11.z.array(import_zod11.z.object(implMethodShape).strict()).optional().describe("Method implementations containing L5 narratives"),
+    status: statusInput
+  };
+  const implInputFields = Object.keys(implInput);
+  reg(
+    server,
+    "sdd_write_narrative",
+    {
+      description: "Write L4 Concrete Implementation spec containing L5 method narratives. Narratives are a FLAT ordered step list; flow steps (branch/switch/loop/try/parallel/jump/return/throw) jump by step number \u2014 blocks are just skipped regions. Steps may declare a `label` anchor, and every jump field has a *Label twin (toLabel, onTrueLabel, endLabel, \u2026) resolved to step numbers at write time \u2014 prefer labels over hand-counted numbers; an unresolvable label rejects the write. Detail dial per method: full (narrative required) | calls-only (call choreography suffices) | intent (prose instead of steps); omitted = stereotype default (Portal/Observer/Adapter: calls-only, Store/Index/Registry: intent, else full). A method whose narrative shows no steps declares the calls it makes in `calls` (one \"<component>.<method>\" each): the reachability walk takes exactly those edges and no others, so an intent-level method that reaches a collaborator must name it or that collaborator is reported unused. Conformance dial per method or spec: declared | anchored | off \u2014 how strictly structural conformance requires contract methods to be realized in their source file (omitted = Portal: anchored, else declared). A method whose body lives in its own file names it in the method's sourcePath; the implementation's sourcePath is the default for every method that names none. Parameters the realization takes BEFORE its contract's own \u2014 a config object, a data root, a portal's transport handles \u2014 are wiring, and are declared once for the spec in injectedParams; a leading parameter it does not name is reported against the contract (UNDECLARED_PARAM). Re-authoring an existing id REPLACES the method list: a method left out of the input is REMOVED together with its narrative (and reported); spec-level lint/ext are carried forward, and the stored status is kept unless this input states a higher one. The answer carries a write receipt as structured content beside the sentence \u2014 the status written, whether a spec already held the id, and the notices a restatement raised, each as its own entry.",
+      inputSchema: implInput,
+      outputSchema: specWriteReceiptOutput
+    },
+    ({ id, name, description, contract, sourcePath, simPath, technologies, injectedParams, detail, conformance, methods, status }) => {
+      try {
+        const restatement = {
+          kind: "implementation",
+          spec: {
+            id,
+            name,
+            description,
+            contract,
+            sourcePath,
+            simPath,
+            technologies,
+            injectedParams,
+            detail,
+            conformance,
+            methods: (methods ?? []).map((m) => ({
+              ...m,
+              narrative: (m.narrative ?? []).map((s, i) => ({ ...s, stepNumber: s.stepNumber ?? i + 1 }))
+            }))
+          },
+          fields: implInputFields,
+          memberFields: implMethodInputFields,
+          status
+        };
+        const receipt = writeSpec(restatement);
+        return writeReceipt(
+          `Successfully saved L4 Implementation Spec "${name}" (${id}) with method narratives.`,
+          receipt
+        );
+      } catch (e) {
+        return errMessage(e);
+      }
+    }
+  );
+  const typeInput = {
+    kind: import_zod11.z.enum(["entity", "value-object"]).describe("entity (owned by a subsystem) or value-object (often system-level shared)"),
+    id: import_zod11.z.string().describe("Lowercase identifier"),
+    name: import_zod11.z.string().describe("Human-readable name"),
+    description: import_zod11.z.string().optional(),
+    subsystem: import_zod11.z.string().optional().describe("Owning subsystem id; omit for a system-level shared value object. A subsystem the tree does not have is refused and nothing is written"),
+    group: import_zod11.z.string().optional().describe("Optional logical group ID to organize this type in subfolders"),
+    fields: import_zod11.z.array(import_zod11.z.object({
+      name: import_zod11.z.string(),
+      type: import_zod11.z.string().describe(TYPE_REF_GRAMMAR("The field's type")),
+      description: import_zod11.z.string().optional(),
+      optional: import_zod11.z.boolean().optional(),
+      key: import_zod11.z.enum(["primary", "unique", "foreign"]).optional().describe("Identity marker (PK/unique/FK) for ERD and database schema derivation"),
+      references: import_zod11.z.string().optional().describe('For foreign keys, the referenced type/table id and optional field, e.g. "invoice.id"')
+    }).strict()).optional().describe('Data fields (type is a primitive or a qualified type id, e.g. "billing.Invoice")'),
+    methods: import_zod11.z.array(import_zod11.z.object({
+      name: import_zod11.z.string(),
+      signature: import_zod11.z.string(),
+      returns: import_zod11.z.string().describe(TYPE_REF_GRAMMAR("The type the method answers with")),
+      description: import_zod11.z.string().optional(),
+      sourcePath: import_zod11.z.string().optional().describe("Source file realizing this method when the type's own sourcePath does not hold it \u2014 a pure type method often lives apart from the declaration"),
+      symbol: import_zod11.z.string().optional().describe("Code-level name realizing this method when it differs from the method name, e.g. narrative_step.foreignFields realized by narrativeStepForeignFields")
+    }).strict()).optional().describe("Pure intrinsic methods only"),
+    componentClass: import_zod11.z.string().optional().describe("Optional component id that implements or owns this logical entity"),
+    invariants: import_zod11.z.array(import_zod11.z.object({
+      id: import_zod11.z.string().describe("Stable invariant id, unique within the entity"),
+      description: import_zod11.z.string().describe("The property that must hold, stated precisely")
+    }).strict()).optional().describe("Declared domain invariants (entities): every write-effect method of the componentClass must carry a narrative step asserting each (assertsInvariants) \u2014 declarations checked, enforcement never proven"),
+    database: import_zod11.z.string().optional().describe("Optional database id for table-schema types"),
+    table: import_zod11.z.string().optional().describe("Optional database table name for table-schema types"),
+    linkedEntity: import_zod11.z.string().optional().describe("Optional logical entity id represented by this table-schema type"),
+    sourcePath: import_zod11.z.string().optional().describe("Source file holding the declaration of this type (project-relative). Naming one turns the type into a claim on code: the file must resolve and the declaration must be anchored in it (UNREALIZED_TYPE)"),
+    symbol: import_zod11.z.string().optional().describe('Code-level name realizing the declaration when it differs from name, e.g. a type named "Invoice Line" declared as InvoiceLine')
+  };
+  const typeInputFields = Object.keys(typeInput);
+  reg(
+    server,
+    "sdd_add_type",
+    {
+      description: "Define an entity or value-object type (the data components operate on). Entities are owned by a subsystem; shared value objects omit subsystem (system-level). Fields are data; methods are PURE intrinsic behaviour only \u2014 anything needing a collaborator belongs on a component, taking the entity as an argument. A type may also CLAIM code: sourcePath names the file holding its declaration (and each method may name its own), symbol binds the code-level name when it differs \u2014 the file must then resolve and the declaration must be anchored in it. An owning subsystem the tree does not have is refused, writing nothing, exactly as a component under an unknown subsystem is. Re-defining an existing id REPLACES fields/methods/invariants and restates sourcePath/symbol (an omitted list or path is CLEARED, and a dropped member is reported); lint/ext are carried forward. The answer carries a write receipt as structured content beside the sentence \u2014 whether a spec already held the id, and the notices a restatement raised, each as its own entry. A type carries no lifecycle status, so the receipt states none.",
+      inputSchema: typeInput,
+      outputSchema: specWriteReceiptOutput
+    },
+    ({ kind, id, name, description, subsystem, group, fields, methods, componentClass, invariants, database, table, linkedEntity, sourcePath, symbol }) => {
+      try {
+        const spec = {
+          kind,
+          id,
+          name,
+          ...description ? { description } : {},
+          ...subsystem ? { subsystem } : {},
+          ...group ? { group } : {},
+          fields: (fields ?? []).map((f) => ({
+            name: f.name,
+            type: f.type,
+            description: f.description,
+            optional: f.optional ?? false,
+            ...f.key ? { key: f.key } : {},
+            ...f.references ? { references: f.references } : {}
+          })),
+          methods: methods ?? [],
+          ...componentClass ? { componentClass } : {},
+          ...invariants?.length ? { invariants } : {},
+          ...database ? { database } : {},
+          ...table ? { table } : {},
+          ...linkedEntity ? { linkedEntity } : {},
+          ...sourcePath ? { sourcePath } : {},
+          ...symbol ? { symbol } : {}
+        };
+        const receipt = writeSpec({ kind: "type", spec, fields: typeInputFields });
+        return writeReceipt(
+          `Successfully ${receipt.replacedExisting ? "re-authored" : "defined"} ${kind} type "${name}" (${id}).`,
+          receipt
+        );
+      } catch (e) {
+        return errMessage(e);
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_validate_tree",
+    {
+      description: "Validate the SDD spec tree, checking parent references, contract compatibility, narratives, and component type boundaries. Supports scoping and recursion controls. Findings come back as structured content too, under the schema this tool declares \u2014 errors and warnings already split, each with its code, severity, message and the spec it concerns \u2014 so a caller filters them as objects instead of parsing the JSON text block and hoping its shape holds.",
+      inputSchema: {
+        subsystem: import_zod11.z.string().optional().describe("Only validate the specified subsystem (granular)"),
+        recursive: import_zod11.z.boolean().optional().describe("Whether to recursively validate subprojects (default: true)")
+      },
+      outputSchema: validateTreeOutput
+    },
+    ({ subsystem, recursive }) => {
+      try {
+        const config = loadProjectConfig();
+        if (!config) throw new ProjectNotInitializedError();
+        const result = validateSddTree({
+          rules: config.rules,
+          projectType: config.projectType,
+          scopeSubsystem: subsystem,
+          recursive: recursive ?? true
+        });
+        return jsonStructured({
+          valid: result.valid,
+          errors: result.issues.filter((i) => i.severity === "error"),
+          warnings: result.issues.filter((i) => i.severity === "warning"),
+          ...result.resolvedThrough ? { resolvedThrough: result.resolvedThrough } : {}
+        });
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_get_spec",
+    {
+      description: `Get/read the parsed JSON contents of a specific spec from the spec tree. Returns structural contents without file system path searching. Pass "methods" to read only the named methods of a contract, an implementation or a type \u2014 a 45-method spec fetched whole to look at one of them is the read side of the same waste a restatement is on the write side; the answer then carries a "partialResult" marker naming what was left out, and must never be re-authored from. For a variant-tagged COMPONENT the result also carries a derived, read-only "variantGuidance" (the variant's base, its implementation guidance, and the same-variant sibling components to implement alike) \u2014 it is resolved from the variant registry, not part of the spec, so never write it back. The structured content carries the same answer with the two derived markers KEPT SEPARATE from the stored spec ({kind, id, spec, partialResult?, variantGuidance?}), so nothing derived can be mistaken for something stored; the text block folds them in as it always has.`,
+      inputSchema: {
+        kind: import_zod11.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).describe("The kind of specification"),
+        id: import_zod11.z.string().describe('The identifier of the spec to fetch (the L0 system spec is a singleton \u2014 pass the system name or "system")'),
+        methods: import_zod11.z.array(import_zod11.z.string().min(1)).optional().describe("Return only these methods by name; every other field of the spec comes back unchanged. Only an interface, an implementation or a type declares methods \u2014 asking for one elsewhere is refused, as is a name the spec does not declare (the answer names the ones it does). Omit it for the whole spec.")
+      },
+      outputSchema: getSpecOutput
+    },
+    ({ kind, id, methods }) => {
+      try {
+        let result = null;
+        let partial = null;
+        switch (kind) {
+          case "system":
+            result = loadSystemSpec();
+            break;
+          case "subsystem":
+            result = loadSubsystemSpec(id);
+            break;
+          case "component":
+            result = loadComponentSpec(id);
+            break;
+          case "interface":
+            result = loadInterfaceSpec(id);
+            break;
+          case "implementation":
+            result = loadImplementationSpec(id);
+            break;
+          case "type":
+            result = loadTypeSpec(id);
+            break;
+        }
+        if (!result) return errText(`Spec of kind "${kind}" with ID "${id}" does not exist.`);
+        if (methods !== void 0) {
+          const declared = result.methods;
+          if (!Array.isArray(declared)) {
+            return errText(
+              `A ${kind} spec declares no methods, so "methods" cannot filter it. Drop the argument to read "${id}" whole; methods live on an interface, an implementation and a type.`
+            );
+          }
+          const names = declared.map((m) => String(m?.name));
+          const unknown = methods.filter((n) => !names.includes(n));
+          if (unknown.length > 0) {
+            return errText(
+              `${kind} "${id}" does not declare ${unknown.map((n) => `"${n}"`).join(", ")}. It declares: ${names.join(", ")}. Nothing was returned, so a misspelled name never reads as a method with no content.`
+            );
+          }
+          const kept = declared.filter((m) => methods.includes(String(m?.name)));
+          partial = {
+            shown: kept.map((m) => String(m?.name)),
+            omitted: names.length - kept.length,
+            warning: `PARTIAL: ${names.length - kept.length} of this spec's ${names.length} methods are not in this answer. Never re-author from it \u2014 sdd_define_interface and sdd_write_narrative REPLACE the method list, so every method missing here would be removed from the spec.`
+          };
+          result = { ...result, methods: kept };
+        }
+        const guidance = kind === "component" ? resolveComponentVariantGuidance(result) : null;
+        const folded = {
+          ...result,
+          ...partial ? { partialResult: partial } : {},
+          ...guidance ? { variantGuidance: guidance } : {}
+        };
+        return structured(JSON.stringify(folded, null, 2), {
+          kind,
+          id,
+          spec: result,
+          ...partial ? { partialResult: partial } : {},
+          ...guidance ? { variantGuidance: guidance } : {}
+        });
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_delete_spec",
+    {
+      description: "Delete a specification file from the spec tree and clean up any empty parent directories. Answers with a structured deletion beside the sentence: whether a spec was removed, and the tests that encode a method the deletion took away (when the project declares test roots).",
+      inputSchema: {
+        kind: import_zod11.z.enum(["subsystem", "component", "interface", "implementation", "type"]).describe("The kind of spec to delete"),
+        id: import_zod11.z.string().describe("The ID of the spec to delete")
+      },
+      outputSchema: specDeletionOutput
+    },
+    ({ kind, id }) => {
+      try {
+        const deletion = deleteSpec2(kind, id);
+        if (!deletion.deleted) return errText(`Spec of kind "${kind}" with ID "${id}" could not be deleted (file may not exist).`);
+        const testsBlock = renderTestsToRevisit(deletion.testsToRevisit).join("\n");
+        return structured(`Successfully deleted ${kind} spec "${id}".${testsBlock ? `
+${testsBlock}` : ""}`, deletion);
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_update_spec",
+    {
+      description: "Update/patch an existing SDD specification (subsystem, component, interface, implementation, or type) using a granular delta. Updates fields, appends/merges array elements, or inserts/deletes narrative steps. Answers with exactly what changed, and with every path the delta named that the write did not act on. Pass dryRun to be told what it would do without writing it.",
+      inputSchema: {
+        kind: import_zod11.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).describe("The spec kind to update (system = the singleton L0 \u2014 vision, boundaries, globalRequirements, databases, and publicInterfaces: the project gateway surface, each entry {id, name, subsystem, component, type, details, audience: project|department|instance|partner|external}; id is informational)"),
+        id: import_zod11.z.string().describe("The ID of the spec to update (namespaced if needed)"),
+        delta: import_zod11.z.record(import_zod11.z.any()).describe(`The partial fields to merge into the spec. ARRAYS UPSERT, they do not replace: an array whose elements carry an identity is merged element-by-element, so a delta naming ONE element leaves the others intact. Identity is "name" or "id" by default, and per field: dispatch by "capability", a listener's mounts by "portal", lifecycle by phase+component+method, emits/subscribesTo by topic+event, trustedLinks by "subsystem", a subsystem's publicInterfaces by component+interface (or type+details for an entry not yet bound to a component), invariants and patterns by "id", lint.allow by "code" AND "at" (an allow covers one occurrence, so several may share a code on one spec), an interface method's findings by "code", boundaries by "name", globalRequirements by "description", switch cases by "value", try catches by "error". Identity merging applies at EVERY depth, including an array INSIDE an element (a method's params, a step's catches). Add "action: 'delete'" (or "remove: true") alongside that identity to REMOVE an element \u2014 including a stale lint allow. Arrays of plain STRINGS (owns, dependsOn, guarantees) carry no per-element identity and are replaced wholesale; pass [] to clear any array outright. To REMOVE an optional field entirely, list it in "unset": e.g. {"unset": ["basePath", "variant"]} \u2014 passing null/undefined means "no change" (they are skipped), and writing "" would leave the field present but empty, which is a different and usually wrong spec. Unsetting a required field is refused by schema validation, which names it. For narrative steps, match by "stepNumber" and use "action: 'insert'" (shifts subsequent steps up) or "action: 'delete'" (shifts subsequent steps down and removes it). Step entries apply in ASCENDING stepNumber order, each against the numbering the earlier entries of the SAME delta left behind \u2014 delete step 3 and step 7 becomes step 6 \u2014 so prefer labels, and restate the step's "label" or "description" on a delete to have it checked against the step actually addressed. Renumbering RELOCATES every flow jump field (onTrueStep/onFalseStep/cases.step/defaultStep/endStep/catches.step/finallyStep/toStep) in the same narrative. A delete is REJECTED when the narrative has no such step, when a jump still targets it (retarget the referrers first), when a restated label/description does not match, or when it is a loop/try/parallel header whose body would be left standing (retype the header first to dissolve the region, then delete it). Changing a step's "type" REBUILDS it for the new type: its description and label are kept and every field the new type cannot carry is dropped (returned as a NOTICE); a delta that retypes AND sets such a field is refused. A step delta is also refused when it carries a marker the merge does not recognise: a non-boolean "remove", an "action" that is neither "insert" nor "delete", a "captureJumps" outside an insert, or no "stepNumber" to address. Inserting AT a jump target relocates those jumps past the inserted step by default (a NOTICE is returned) \u2014 add "captureJumps": true on the inserted step to retarget entry jumps onto it (loop/try endStep region tails always relocate with the body and are never captured). Every jump field has a "*Label" twin (toLabel, onFalseLabel, endLabel, \u2026, and "label" on a cases/catches entry) resolved against step labels AFTER the merge, so a delta may anchor on a label only pre-existing steps carry; a label the delta supplies REPLACES the stored number it twins, while setting the number and its label together in one delta is refused as a contradiction. Reference ids in deltas may use LOCAL names \u2014 they are qualified against the spec's namespace exactly as the loader would. Per-spec lint suppression: set "lint: { allow: [{ code, at, covers, reason }] }" to silence a WARNING code on this spec only (errors always surface; stale allows are flagged). An allow covers EXACTLY the occurrence it names: "at" is the site the finding names (a contract method, an import edge "from -> to", a declared edge "component -> target") and is REQUIRED for a code whose findings report one, while a finding that reports no site is covered only by an allow that names none; "covers" lists the units an aggregating finding reports, and the allow silences it only when every one is listed. This delta is deliberately OPEN below its top level \u2014 the shapes nest further than a schema here should restate \u2014 so a key that is not a field at its depth is not refused, it is NAMED BACK under NO EFFECT in the answer, together with any value the spec already held and any "unset" that removed nothing. Read that list: it is where a nested typo shows up.`),
+        dryRun: import_zod11.z.boolean().optional().describe("Ask what this delta WOULD do instead of doing it. The whole write runs, the candidate gate included, and the answer is the change report it would have produced \u2014 marked DRY RUN, with nothing stamped and not one byte of the stored file moved. Use it before a delta that renumbers a long narrative.")
+      },
+      outputSchema: specChangeReportOutput
+    },
+    ({ kind, id, delta, dryRun }) => {
+      try {
+        const report = updateSpecGated(kind, id, delta, dryRun);
+        return structured(renderChangeReport(report), report);
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_get_status",
+    {
+      description: "Get the completeness status dashboard of the SDD spec tree. Supports scoping and recursion controls.",
+      inputSchema: {
+        subsystem: import_zod11.z.string().optional().describe("Only show status for the specified subsystem"),
+        recursive: import_zod11.z.boolean().optional().describe("Whether to recursively load subprojects (default: true)")
+      }
+    },
+    ({ subsystem, recursive }) => {
+      try {
+        const report = getStatusReport({
+          subsystem,
+          recursive: recursive ?? true
+        });
+        const family = statusFamilyContext();
+        const verdict = approvalVerdict();
+        return text(`${family}${report.text}${verdict.text}`);
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_list_external_interfaces",
+    {
+      description: "List the bound project's consumable external surfaces (parent family, siblings, foreign imports) as discovery entries with origin, provenance, and freshness \u2014 the tool an agent inside a subproject uses to SEE its outward world instead of discovering it by failed reference resolution. Full contracts stay in the vendored snapshots (.wai/surfaces/); each entry summarizes the interface ids it exposes."
+    },
+    () => {
+      try {
+        return json(listExternalInterfaces());
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_get_agent_brief",
+    {
+      description: "Compose the LIVE delegation brief for one resolved agent: the fully rendered instruction body plus the ownedPaths/readPaths scope fence \u2014 the dynamic replacement for generated per-component agent files. Fetch a brief and spawn a generic subagent with it: always fresh after a re-lock, no session restart needed. List agent ids via listAgents or resources/list (the wairon-agent:// entries).",
+      inputSchema: {
+        agentId: import_zod11.z.string().describe("The resolved agent id (list via listAgents or resources/list)")
+      }
+    },
+    ({ agentId }) => {
+      try {
+        return json(composeAgentBrief(agentId));
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
+  registerSkillResources(server, !options.hostedTools);
+  registerSkillPrompts(server, !options.hostedTools);
+  try {
+    const chainingParent = resolveChainingParent();
+    if (chainingParent) {
+      let externalSurfaceCount = 0;
+      try {
+        externalSurfaceCount = listExternalInterfaces().length;
+      } catch {
+      }
+      process.stderr.write(
+        `[wairon mcp] chained subproject: this root is mounted as subsystem "${chainingParent.subsystemId}" of the parent project at ${chainingParent.parentRoot} \u2014 ${externalSurfaceCount} vendored external surface(s) discoverable via sdd_list_external_interfaces
+`
+      );
+    }
+  } catch {
+  }
+  advertiseHostedTools(server, options);
+  return server;
+}
+function advertiseHostedTools(server, options) {
+  if (options.hostedTools) {
+    const hostedStub = () => errText("This hosted tool is dispatched by the hosting data plane before reaching the MCP server; it is unavailable outside a hosted request.");
+    reg(server, "sdd_host_lock_project", {
+      description: "Hosted project lifecycle (execute-primary): LOCK the bound project (validate-as-complete gate + commit-scoped lock record). Executes directly when your resolved permission is yes and returns the completed outcome; when it is approval, a pending approval request is created instead (await it with sdd_host_await_approval).",
+      inputSchema: {}
+    }, hostedStub);
+    reg(server, "sdd_host_initialize_project", {
+      description: "Hosted project lifecycle (execute-primary): initialize a new hosted project into its REQUIRED owner organization unit (with an optional profile selection). Executes directly when your resolved permission is yes; when it is approval, a pending approval request is created instead.",
+      inputSchema: {
+        id: import_zod11.z.string().describe("Requested project id"),
+        displayName: import_zod11.z.string().optional(),
+        description: import_zod11.z.string().optional(),
+        ownerUnitId: import_zod11.z.string().describe("REQUIRED organization unit that owns the new project (every project is placed at creation)"),
+        environment: import_zod11.z.string().optional()
+      }
+    }, hostedStub);
+    reg(server, "sdd_host_get_approval_status", {
+      description: "Hosted project lifecycle: read the status of one of your approval requests.",
+      inputSchema: { requestId: import_zod11.z.string() }
+    }, hostedStub);
+    reg(server, "sdd_host_await_approval", {
+      description: "Hosted project lifecycle: long-poll one of YOUR approval requests until it is decided (approved requests auto-execute, so an approval resolves as completed) or the timeout elapses. Returns the request in its current state.",
+      inputSchema: {
+        requestId: import_zod11.z.string(),
+        timeoutSeconds: import_zod11.z.number().optional().describe("How long to wait server-side (clamped; 0 returns the current state immediately)")
+      }
+    }, hostedStub);
+    reg(server, "sdd_landscape_list_reachable_projects", {
+      description: "Hosted landscape: the projects reachable from the BOUND project through ACTIVE cross-project relations (directional, relations-only), each with the relation ids/kinds and target public interface ids.",
+      inputSchema: {}
+    }, hostedStub);
+    reg(server, "sdd_landscape_list_reachable_project_interfaces", {
+      description: "Hosted landscape: redacted, audience-filtered public interface summaries of one reachable target project (Forbidden outside the reachable set; private by default).",
+      inputSchema: { projectId: import_zod11.z.string().describe("The reachable target project id") }
+    }, hostedStub);
+    reg(server, "sdd_landscape_list_visible_surfaces", {
+      description: "Hosted landscape: the visibility-resolved discovery catalog for the BOUND project \u2014 every target the organization unit graph exposes to it (open-within-tenant, closed groups hidden, exposeTo grants honored), with audience distance and audience-filtered summaries. No relation required.",
+      inputSchema: {}
+    }, hostedStub);
+    reg(server, "sdd_landscape_get_project_surface", {
+      description: `Hosted landscape: fetch a visible target project's CONTRACT-GRADE surface snapshot (full method contracts, dispatch tables, type closure) at your audience-distance ceiling, origin "exchanged" \u2014 save it under .wai/surfaces/ (wairon surface import) so your adapters validate against the declared contract.`,
+      inputSchema: { projectId: import_zod11.z.string().describe("The visible target project id") }
+    }, hostedStub);
+    reg(server, "sdd_host_pack_list", {
+      description: "Hosted project ops: list the BOUND project's registered extension packs (requires project:read over it).",
+      inputSchema: {}
+    }, hostedStub);
+    reg(server, "sdd_host_pack_install", {
+      description: "Hosted project ops: install a DECLARATIVE extension pack (profiles + language/platform tables \u2014 never rule/code packs) into the BOUND project (requires project:admin over it).",
+      inputSchema: {
+        name: import_zod11.z.string().describe("Pack name (letters, digits, dot, underscore, hyphen)"),
+        content: import_zod11.z.string().describe("The declarative pack YAML content")
+      }
+    }, hostedStub);
+    reg(server, "sdd_host_policy_evaluate", {
+      description: "Hosted project ops: evaluate the BOUND project's packs and profile selection against the instance pack policy \u2014 compliance without side effects (requires project:write over it).",
+      inputSchema: {}
+    }, hostedStub);
+    reg(server, "sdd_host_policy_reconcile", {
+      description: "Hosted project ops: reconcile the BOUND project against the instance pack policy \u2014 under auto_reconcile enforcement the missing required/default declarative packs are applied (requires project:write over it).",
+      inputSchema: {}
+    }, hostedStub);
+    reg(server, "sdd_host_produce", {
+      description: "Hosted project ops: run a configured producer projection (Notion/Miro) of the BOUND project to the named target (requires project:admin over it).",
+      inputSchema: { target: import_zod11.z.string().describe("The configured producer target (e.g. notion, miro)") }
+    }, hostedStub);
+    reg(server, "sdd_host_commit_project", {
+      description: "Hosted project ops: publish a DELIBERATE, .wai/-scoped commit+push of the BOUND project's specs to its bound repository (commit = local save, push = the actual backup; a clean scope publishes nothing). The data plane binds ONE project, so there is no project argument. Requires project:write over it.",
+      inputSchema: {
+        subsystem: import_zod11.z.string().optional().describe("Narrow staging to .wai/specs/<subsystem>/ (a convenience \u2014 git history stays per-repo)"),
+        message: import_zod11.z.string().optional().describe("Commit message; defaults to a timestamped wairon message")
+      }
+    }, hostedStub);
+    reg(server, "sdd_host_export_tree", {
+      description: "Hosted spec-tree transfer: pack the BOUND project's WHOLE spec tree \u2014 its own .wai plus every chained subproject \u2014 into a .waitree archive, returned as base64 with its roots, file count and state id. The migration counterpart of an import: use it to take a hosted project local, or to move it to another instance. Requires project:read over the project. Bounded by the data-plane body cap; a very large tree exports through the web download route instead. Refuses when a chained mount cannot be packed (escaping, missing, cyclic, too deep, or holding no .wai), naming every one and why, unless allowPartial is set \u2014 then the archive is built anyway and the result lists what was skipped.",
+      inputSchema: {
+        allowPartial: import_zod11.z.boolean().optional().describe("Build the archive even when some chained mounts cannot be packed, listing them as skipped; default false (refuse and name them)")
+      }
+    }, hostedStub);
+    reg(server, "sdd_host_import_tree", {
+      description: "Hosted spec-tree transfer: REPLACE the BOUND project's spec tree from a base64 .waitree archive. Requires project:admin over the project (strictly above project:write \u2014 this replaces the whole design, not one spec). Refuses an occupied destination unless replaceExisting is set, always refuses executable entries (rule/code packs install only through the trusted filesystem), and moves the previous tree aside to a backup whose path is returned.",
+      inputSchema: {
+        archiveBase64: import_zod11.z.string().describe("The .waitree archive bytes, base64-encoded"),
+        replaceExisting: import_zod11.z.boolean().optional().describe("Replace a tree already present (backed up first); without it an occupied destination is refused")
+      }
+    }, hostedStub);
+  }
+}
+
+// src/index.ts
+function loadProjectConfig3() {
   const config = loadProjectConfig();
   if (!config) throw new ProjectNotInitializedError();
   return config;
@@ -27497,6 +30893,7 @@ function loadProjectConfig2() {
   saveSpec,
   saveTopologyConfig,
   scanAllSpecs,
+  schemaFingerprint,
   serializeYaml,
   setExecutionTier,
   setLogLevel,