@wairon/cli 5.1.1-dev.107 → 5.1.1-dev.108

package/dist/index.js

@@ -3059,8 +3059,8 @@ var require_dist = __commonJS({
     function slug(name) {
       return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
     }
-    var fs29 = __toESM2(require("fs"));
-    var path49 = __toESM2(require("path"));
+    var fs31 = __toESM2(require("fs"));
+    var path50 = __toESM2(require("path"));
     var import_fflate = require_node();
     var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".hg", ".svn"]);
     function listEntries(archive) {
@@ -3098,9 +3098,9 @@ var require_dist = __commonJS({
     }
     function writeTree(destDir, files) {
       for (const file of files) {
-        const absolute = path49.join(destDir, file.path);
-        fs29.mkdirSync(path49.dirname(absolute), { recursive: true });
-        fs29.writeFileSync(absolute, file.contents);
+        const absolute = path50.join(destDir, file.path);
+        fs31.mkdirSync(path50.dirname(absolute), { recursive: true });
+        fs31.writeFileSync(absolute, file.contents);
       }
     }
     function classifyKind(name, symlinks) {
@@ -3109,14 +3109,14 @@ var require_dist = __commonJS({
       return "file";
     }
     function walkPackDir(root, current2, out) {
-      for (const entry of fs29.readdirSync(current2, { withFileTypes: true })) {
+      for (const entry of fs31.readdirSync(current2, { withFileTypes: true })) {
         if (entry.isDirectory()) {
           if (SKIP_DIRS.has(entry.name)) continue;
-          walkPackDir(root, path49.join(current2, entry.name), out);
+          walkPackDir(root, path50.join(current2, entry.name), out);
         } else if (entry.isFile()) {
-          const absolute = path49.join(current2, entry.name);
-          const relative22 = path49.relative(root, absolute).split(path49.sep).join("/");
-          out.push({ path: relative22, contents: fs29.readFileSync(absolute) });
+          const absolute = path50.join(current2, entry.name);
+          const relative22 = path50.relative(root, absolute).split(path50.sep).join("/");
+          out.push({ path: relative22, contents: fs31.readFileSync(absolute) });
         }
       }
     }
@@ -3316,8 +3316,8 @@ var require_dist = __commonJS({
       return normalized === "." ? ".wai/" : `${normalized}/.wai/`;
     }
     function normalizeRootPath(relativePath) {
-      const posix7 = relativePath.split(path210.sep).join("/").replace(/^\.\//, "").replace(/\/+$/, "");
-      return posix7 === "" || posix7 === "." ? "." : posix7;
+      const posix8 = relativePath.split(path210.sep).join("/").replace(/^\.\//, "").replace(/\/+$/, "");
+      return posix8 === "" || posix8 === "." ? "." : posix8;
     }
     function slugify(projectName) {
       const slug2 = projectName.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -3551,6 +3551,7 @@ __export(src_exports, {
   SwitchCaseSchema: () => SwitchCaseSchema,
   SystemPublicInterfaceSchema: () => SystemPublicInterfaceSchema,
   SystemSpecSchema: () => SystemSpecSchema,
+  TECHNOLOGY_PACKAGES: () => TECHNOLOGY_PACKAGES,
   TargetConfigSchema: () => TargetConfigSchema,
   TechnologySchema: () => TechnologySchema,
   TemplateNotFoundError: () => TemplateNotFoundError,
@@ -3581,7 +3582,9 @@ __export(src_exports, {
   approvalKeyIn: () => approvalKeyIn,
   approvalRecord: () => approvalRecord,
   approvalVerdict: () => approvalVerdict,
+  approvedRevision: () => approvedRevision,
   approvedStatuses: () => approvedStatuses,
+  asSchemaReads: () => asSchemaReads,
   assertContainedProjectPath: () => assertContainedProjectPath,
   assertProjectInitialized: () => assertProjectInitialized,
   attachRetiredMounts: () => attachRetiredMounts,
@@ -3829,6 +3832,7 @@ __export(src_exports, {
   reexpress: () => reexpress,
   registerExporter: () => registerExporter,
   registerPackRef: () => registerPackRef,
+  registerProjectServer: () => registerProjectServer,
   reinjectLocalGuides: () => reinjectLocalGuides,
   relationHealth: () => relationHealth,
   removeDomain: () => removeDomain,
@@ -3841,6 +3845,7 @@ __export(src_exports, {
   renameField: () => renameField,
   renameId: () => renameProjectId,
   renameMethod: () => renameMethod,
+  renameParam: () => renameParam,
   renameType: () => renameType,
   renderDiagram: () => renderDiagram2,
   repairForeignStepFields: () => repairForeignStepFields,
@@ -3897,8 +3902,10 @@ __export(src_exports, {
   storedMethodSignature: () => storedMethodSignature,
   storedTypeMethod: () => storedTypeMethod,
   subsystemDesignView: () => subsystemDesignView,
+  surfaceChanges: () => surfaceChanges,
   syncContextFiles: () => syncContextFiles,
   technologyName: () => technologyName,
+  technologyPackages: () => technologyPackages,
   technologyTokens: () => technologyTokens,
   toMarkdown: () => toMarkdown,
   transportExportKind: () => transportExportKind,
@@ -3989,22 +3996,22 @@ function sampleOf(file) {
     if (fd !== void 0) fs.closeSync(fd);
   }
 }
-function attributeMatches(pattern, relative20) {
+function attributeMatches(pattern, relative22) {
   const glob = pattern.replace(/^\//, "");
-  const target = glob.includes("/") ? relative20 : path.posix.basename(relative20);
+  const target = glob.includes("/") ? relative22 : path.posix.basename(relative22);
   const source = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\//g, "\0").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\u0000/g, "(?:.*/)?");
   return new RegExp(`^${source}$`).test(target);
 }
 function attributeEol(attributesFile, file) {
   const text3 = readFileOrNull(attributesFile);
   if (text3 === null) return null;
-  const relative20 = path.relative(path.dirname(attributesFile), file).split(path.sep).join("/");
+  const relative22 = path.relative(path.dirname(attributesFile), file).split(path.sep).join("/");
   let eol = null;
   for (const raw of text3.split(/\r?\n/)) {
     const line = raw.trim();
     if (line === "" || line.startsWith("#")) continue;
     const [pattern, ...attrs] = line.split(/\s+/);
-    if (!attributeMatches(pattern, relative20)) continue;
+    if (!attributeMatches(pattern, relative22)) continue;
     for (const attr of attrs) {
       if (attr === "eol=crlf") eol = "\r\n";
       else if (attr === "eol=lf") eol = "\n";
@@ -4285,7 +4292,7 @@ function defaultTargetConfig(type) {
     enabled: true
   };
 }
-var WAIRON_VERSION = "5.1.1-dev.107";
+var WAIRON_VERSION = "5.1.1-dev.108";
 var GITHUB_REPO = "SYW-Apps/Waffle-AIron";
 var ARCHITECT_AGENT_ID = "agent-architect";
 var ARCHITECT_TEMPLATE_ID = "architect";
@@ -4406,7 +4413,7 @@ function cacheRoot() {
   return root;
 }
 function git(args, cwd) {
-  return (0, import_child_process.execFileSync)("git", args, {
+  return (0, import_child_process.execFileSync)("git", ["-c", "core.longpaths=true", ...args], {
     cwd,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
@@ -4504,6 +4511,20 @@ function repositoryRoot(directory) {
     at = up;
   }
 }
+function lastCommitOf(directory, pathspec) {
+  try {
+    return git(["log", "-1", "--format=%H", "--", pathspec], directory).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function commitOf(directory, ref) {
+  try {
+    return git(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], directory).trim() || null;
+  } catch {
+    return null;
+  }
+}
 
 // src/utils/yaml.ts
 var yaml2 = __toESM(require("js-yaml"));
@@ -5838,23 +5859,23 @@ function childrenOf(tokens, index) {
   }
   return out;
 }
-function locateScalar(tokens, path49) {
+function locateScalar(tokens, path50) {
   let region = tokens;
-  for (let k = 0; k < path49.length; k += 1) {
-    const segment = path49[k];
-    if (region.length === 0) return `nothing is nested at ${path49.slice(0, k).join(".")}`;
+  for (let k = 0; k < path50.length; k += 1) {
+    const segment = path50[k];
+    if (region.length === 0) return `nothing is nested at ${path50.slice(0, k).join(".")}`;
     const base = Math.min(...region.map((t) => t.col));
-    const last = k === path49.length - 1;
+    const last = k === path50.length - 1;
     let at;
     const items = region.map((t, i) => ({ t, i })).filter(({ t }) => t.kind === "item" && t.col === base);
     if (items.length === 0) {
       at = region.findIndex((t) => t.kind === "key" && t.col === base && t.name === segment);
-      if (at < 0) return `no block key "${segment}" at ${path49.slice(0, k).join(".") || "the document root"}`;
+      if (at < 0) return `no block key "${segment}" at ${path50.slice(0, k).join(".") || "the document root"}`;
       if (last) return region[at].valueStart !== void 0 ? region[at] : `"${segment}" holds no inline scalar`;
     } else {
-      if (!/^\d+$/.test(segment)) return `"${segment}" is not a sequence index at ${path49.slice(0, k).join(".") || "the document root"}`;
+      if (!/^\d+$/.test(segment)) return `"${segment}" is not a sequence index at ${path50.slice(0, k).join(".") || "the document root"}`;
       const index = Number(segment);
-      if (index >= items.length) return `no block sequence item ${segment} at ${path49.slice(0, k).join(".")}`;
+      if (index >= items.length) return `no block sequence item ${segment} at ${path50.slice(0, k).join(".")}`;
       at = items[index].i;
       if (last) {
         const value = region[at + 1];
@@ -5902,10 +5923,10 @@ function writeScalar(value, style) {
   if (style === "plain" && /^[A-Za-z0-9_][A-Za-z0-9_./-]*$/.test(value)) return value;
   return `'${value.replace(/'/g, "''")}'`;
 }
-function setAt(document, path49, value) {
+function setAt(document, path50, value) {
   let node = document;
-  for (const segment of path49.slice(0, -1)) node = node[segment];
-  node[path49[path49.length - 1]] = value;
+  for (const segment of path50.slice(0, -1)) node = node[segment];
+  node[path50[path50.length - 1]] = value;
 }
 function rewriteScalarsInText(text3, edits, root) {
   const refuse4 = (why2) => {
@@ -6396,9 +6417,9 @@ function registryOver(store, root) {
           const next = rekeyAnchor(rename, { spec: entry.spec, at, covers });
           const base = ["rules", "conformance", "carried", String(g), "findings", String(f)];
           const named2 = { code: String(entry.code), spec: entry.spec, at: at ?? "" };
-          const change = (path49, field, from, to) => {
+          const change = (path50, field, from, to) => {
             if (from === to) return;
-            edits.push({ path: [...base, ...path49], from, to });
+            edits.push({ path: [...base, ...path50], from, to });
             rekeys.push({ ...named2, field, from, to });
           };
           change(["spec"], "spec", entry.spec, next.spec);
@@ -7472,7 +7493,12 @@ var MethodParamSchema = import_zod5.z.object({
    */
   type: import_zod5.z.string(),
   description: import_zod5.z.string().optional(),
-  optional: import_zod5.z.boolean().optional()
+  optional: import_zod5.z.boolean().optional(),
+  /**
+   * The parameter's rename trace: every name it held before, oldest first —
+   * written by the rename-param tool, shown as `formerly` in the design export.
+   */
+  previousNames: import_zod5.z.array(import_zod5.z.string().min(1)).optional()
 });
 var FindingDeclarationSchema = import_zod5.z.object({
   /** UPPER_SNAKE and unique within the method; a pack's codes carry the pack prefix (<PACK>_<CODE>). */
@@ -8301,6 +8327,32 @@ function componentDesignView(component) {
 function subsystemDesignView(subsystem) {
   return withoutFields(subsystem, outOfApproval("subsystem"));
 }
+function withoutUnknownKeys(raw, parsed) {
+  if (Array.isArray(raw)) {
+    if (!Array.isArray(parsed) || parsed.length !== raw.length) return raw;
+    return raw.map((item, i) => withoutUnknownKeys(item, parsed[i]));
+  }
+  if (!raw || typeof raw !== "object" || !parsed || typeof parsed !== "object" || Array.isArray(parsed)) return raw;
+  const out = {};
+  for (const [key2, value] of Object.entries(raw)) {
+    if (key2 in parsed) out[key2] = withoutUnknownKeys(value, parsed[key2]);
+  }
+  return out;
+}
+var SCHEMA_OF_KIND = {
+  implementation: ImplementationSpecSchema,
+  type: TypeSpecSchema,
+  component: ComponentSpecSchema,
+  subsystem: SubsystemSpecSchema,
+  interface: InterfaceSpecSchema
+};
+function asSchemaReads(kind, doc) {
+  const parsed = SCHEMA_OF_KIND[kind].safeParse(doc);
+  if (!parsed.success) return doc;
+  const kept = withoutUnknownKeys(doc, parsed.data);
+  if (kind === "component" && "mounts" in doc) kept.mounts = doc.mounts;
+  return kept;
+}
 function interfaceDesignView(contract) {
   return withoutFields(contract, outOfApproval("interface"));
 }
@@ -8441,6 +8493,19 @@ var SurfaceTypeDefSchema = import_zod5.z.object({
   values: import_zod5.z.array(EnumValueSchema).optional(),
   /** A named scalar's one primitive, in place of fields; only on a value-object that declares it. */
   holds: import_zod5.z.string().optional(),
+  /**
+   * The type's own methods (its checked constructors, its pure operations),
+   * each with its signature, params and returns, so a binding written against
+   * the pin knows them. Carried, never digested: a pin taken before they were
+   * carried lacks them and reads as stale (re-pin), never as incompatible.
+   */
+  methods: import_zod5.z.array(import_zod5.z.object({
+    name: import_zod5.z.string(),
+    signature: import_zod5.z.string(),
+    params: import_zod5.z.array(import_zod5.z.object({ name: import_zod5.z.string(), type: import_zod5.z.string(), description: import_zod5.z.string().optional(), optional: import_zod5.z.boolean().optional() })).optional(),
+    returns: import_zod5.z.string(),
+    description: import_zod5.z.string().optional()
+  })).optional(),
   /**
    * The type's rename trace as the producer recorded it (previousIds), so a
    * consumer pinned to a former name reads a rename rather than a removal.
@@ -8875,6 +8940,29 @@ var TemplateSchema = import_zod8.z.object({
   version: import_zod8.z.string().default("1.0.0")
 });
 
+// src/models/technology-packages.ts
+var TECHNOLOGY_PACKAGES = [
+  { names: ["postgres", "postgresql", "pg"], packages: ["pg", "postgres", "pg-promise", "@neondatabase/serverless", "@vercel/postgres"] },
+  { names: ["mysql", "mariadb"], packages: ["mysql2", "mysql", "mariadb"] },
+  { names: ["redis", "valkey"], packages: ["redis", "ioredis", "@redis/client"] },
+  { names: ["mongodb", "mongo"], packages: ["mongodb", "mongoose"] },
+  { names: ["sqlite", "sqlite3"], packages: ["better-sqlite3", "sqlite3", "sqlite"] },
+  { names: ["kafka"], packages: ["kafkajs", "node-rdkafka"] },
+  { names: ["rabbitmq", "amqp"], packages: ["amqplib", "amqp-connection-manager"] }
+];
+var lookupKey = (name) => name.toLowerCase().replace(/[^a-z0-9]+/g, "");
+function technologyPackages(tech, contributed = {}) {
+  const key2 = lookupKey(technologyName(tech));
+  const out = new Set(technologyTokens(tech).map((t) => t.toLowerCase()));
+  for (const entry of TECHNOLOGY_PACKAGES) {
+    if (entry.names.some((n) => lookupKey(n) === key2)) for (const p of entry.packages) out.add(p);
+  }
+  for (const [name, packages] of Object.entries(contributed)) {
+    if (lookupKey(name) === key2) for (const p of packages) out.add(p.toLowerCase());
+  }
+  return [...out];
+}
+
 // src/models/type-grammar.ts
 var PRIMITIVE_TYPES = ["string", "int", "float", "bool", "bytes", "date", "datetime", "duration", "void", "any"];
 var PRIMITIVES = new Set(PRIMITIVE_TYPES);
@@ -9547,13 +9635,13 @@ var Canonicalizer = class {
     this.problems = [];
   }
   /** One position: its canonical text when it has one, else the text as written, recorded either way. */
-  read(text3, position, path49, omittable2 = false) {
+  read(text3, position, path50, omittable2 = false) {
     const parse = parseTypePosition(text3, position, omittable2);
     if (parse.problem) {
-      this.problems.push({ ...parse.problem, specId: this.specId, kind: this.kind, path: path49 });
+      this.problems.push({ ...parse.problem, specId: this.specId, kind: this.kind, path: path50 });
       return text3;
     }
-    if (parse.canonical !== text3) this.respellings.push({ specId: this.specId, kind: this.kind, path: path49, written: text3, stored: parse.canonical });
+    if (parse.canonical !== text3) this.respellings.push({ specId: this.specId, kind: this.kind, path: path50, written: text3, stored: parse.canonical });
     return parse.canonical;
   }
   params(params, position, prefix) {
@@ -9638,8 +9726,8 @@ function namesAnInteger(name) {
   const words2 = name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[\s_\-.]+/).filter(Boolean);
   return words2.some((word) => INTEGER_WORDS.has(word));
 }
-function positionNameOf(path49) {
-  const segments = path49.split(".");
+function positionNameOf(path50) {
+  const segments = path50.split(".");
   const last = segments[segments.length - 1];
   return last === "returns" && segments.length >= 3 ? segments[segments.length - 2] : last;
 }
@@ -10007,10 +10095,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 join29 = fallNext(s.endStep);
+    const join31 = 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, join29);
+      if (armEnd !== void 0 && armEnd >= entries[i]) armEndJoin.set(armEnd, join31);
     }
   }
   const successorsOf = (n) => {
@@ -10488,7 +10576,10 @@ function carriedFactChanges(pinned, live) {
   const liveTypes = new Map(live.types.map((t) => [t.id, t]));
   for (const def of pinned.types) {
     const now = liveTypes.get(def.id);
-    if (now) differs(`rename trace of ${def.id}`, def.formerly, now.formerly);
+    if (!now) continue;
+    differs(`rename trace of ${def.id}`, def.formerly, now.formerly);
+    const methods = (d) => (d.methods ?? []).map((m) => ({ name: m.name, params: (m.params ?? []).map((p) => ({ type: p.type, optional: p.optional === true })), returns: m.returns }));
+    differs(`methods of ${def.id}`, def.methods?.length ? methods(def) : void 0, now.methods?.length ? methods(now) : void 0);
   }
   const unresolved = (snapshot) => [...snapshot.unresolvedExports ?? []].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
   differs("the unresolved re-exports", unresolved(pinned), unresolved(live));
@@ -10518,6 +10609,77 @@ function memberDigest(snapshot, publicName, member) {
   if (!method) return null;
   return sha256(canonicalize({ method: methodShape(snapshot, method), closure: closureShapes(snapshot, methodTypeRefs(method)) }));
 }
+function shownSignature(method) {
+  return method.signature || `${method.name}(${(method.params ?? []).map((p) => `${p.name}${p.optional ? "?" : ""}: ${p.type}`).join(", ")}): ${method.returns}`;
+}
+function surfaceChanges(newer, older) {
+  const out = [];
+  const oldEntries = new Map(older.interfaces.map((e) => [e.id, e]));
+  const oldTypes = new Map((older.exportedTypes ?? []).map((t) => [t.id, t]));
+  const consumed = /* @__PURE__ */ new Set();
+  const formerOf = (formerly, has) => (formerly ?? []).find((f) => has(f) && !consumed.has(f));
+  for (const entry of newer.interfaces) {
+    let before = oldEntries.get(entry.id);
+    if (!before) {
+      const from = formerOf(entry.formerly, (n) => oldEntries.has(n) && !newer.interfaces.some((e) => e.id === n));
+      if (from === void 0) {
+        out.push({ kind: "added", name: entry.id, detail: `added: ${entry.type} contract with ${entry.methods.length} method(s), audience ${entry.audience}` });
+        continue;
+      }
+      consumed.add(from);
+      before = oldEntries.get(from);
+      out.push({ kind: "renamed", name: entry.id, from, detail: `renamed from "${from}"` });
+    }
+    if (before.audience !== entry.audience) out.push({ kind: "changed", name: entry.id, detail: `audience ${before.audience} \u2192 ${entry.audience}` });
+    const oldMethods = new Map(before.methods.map((m) => [m.name, m]));
+    const usedOld = /* @__PURE__ */ new Set();
+    for (const method of entry.methods) {
+      let was = oldMethods.get(method.name);
+      if (!was) {
+        const from = (method.formerly ?? []).find((f) => oldMethods.has(f) && !entry.methods.some((m) => m.name === f));
+        if (from === void 0) {
+          out.push({ kind: "added", name: entry.id, member: method.name, detail: `method added: ${shownSignature(method)}` });
+          continue;
+        }
+        was = oldMethods.get(from);
+        out.push({ kind: "renamed", name: entry.id, member: method.name, from, detail: `method renamed from "${from}"` });
+      }
+      usedOld.add(was.name);
+      const a = memberDigest(older, before.id, was.name);
+      const b = memberDigest(newer, entry.id, method.name);
+      const sameShape = a === b || memberDigest({ ...newer, interfaces: newer.interfaces.map((e) => e !== entry ? e : { ...e, id: before.id, methods: e.methods.map((m) => m === method ? { ...m, name: was.name } : m) }) }, before.id, was.name) === a;
+      if (!sameShape) out.push({ kind: "changed", name: entry.id, member: method.name, detail: `signature ${shownSignature(was)} \u2192 ${shownSignature(method)}` });
+    }
+    for (const m of before.methods) {
+      if (!usedOld.has(m.name)) out.push({ kind: "removed", name: entry.id, member: m.name, detail: `method removed: ${shownSignature(m)}` });
+    }
+  }
+  for (const t of newer.exportedTypes ?? []) {
+    let before = oldTypes.get(t.id);
+    if (!before) {
+      const def = newer.types.find((d) => d.id === t.type);
+      const from = formerOf(def?.formerly, (n) => oldTypes.has(n) && !(newer.exportedTypes ?? []).some((x) => x.id === n));
+      if (from === void 0) {
+        out.push({ kind: "added", name: t.id, detail: `type added (${def?.kind ?? "type"}), audience ${t.audience}` });
+        continue;
+      }
+      consumed.add(from);
+      before = oldTypes.get(from);
+      out.push({ kind: "renamed", name: t.id, from, detail: `type renamed from "${from}"` });
+    }
+    if (before.audience !== t.audience) out.push({ kind: "changed", name: t.id, detail: `audience ${before.audience} \u2192 ${t.audience}` });
+    const a = memberDigest(older, before.id, "type");
+    const b = memberDigest(newer, t.id, "type");
+    if (a !== b && before.id === t.id) out.push({ kind: "changed", name: t.id, detail: "type shape changed (fields, values, held primitive or a type it names)" });
+  }
+  for (const e of older.interfaces) {
+    if (!newer.interfaces.some((x) => x.id === e.id) && !consumed.has(e.id)) out.push({ kind: "removed", name: e.id, detail: `removed: ${e.type} contract with ${e.methods.length} method(s)` });
+  }
+  for (const t of older.exportedTypes ?? []) {
+    if (!(newer.exportedTypes ?? []).some((x) => x.id === t.id) && !consumed.has(t.id)) out.push({ kind: "removed", name: t.id, detail: "type removed" });
+  }
+  return out.sort((x, y) => x.name === y.name ? (x.member ?? "") < (y.member ?? "") ? -1 : (x.member ?? "") > (y.member ?? "") ? 1 : 0 : x.name < y.name ? -1 : 1);
+}
 
 // src/models/exports.ts
 var PUBLIC_NAME_RE = /^[a-z0-9_-]+$/;
@@ -10731,9 +10893,9 @@ function shortestPath(from, to, members, edges, rank) {
     const v = queue.shift();
     for (const w of [...edges.get(v) ?? []].filter((x) => members.has(x)).sort((a, b) => rank(a) - rank(b))) {
       if (w === to) {
-        const path49 = [w];
-        for (let at = v; at !== from; at = prev.get(at)) path49.unshift(at);
-        return path49;
+        const path50 = [w];
+        for (let at = v; at !== from; at = prev.get(at)) path50.unshift(at);
+        return path50;
       }
       if (seen.has(w)) continue;
       seen.add(w);
@@ -10774,7 +10936,9 @@ var DesignParamSchema = import_zod9.z.object({
   name: import_zod9.z.string(),
   type: DesignTypeRefSchema,
   optional: import_zod9.z.boolean(),
-  description: import_zod9.z.string().optional()
+  description: import_zod9.z.string().optional(),
+  /** The parameter's rename trace (its previousNames), oldest first; absent when never renamed. */
+  formerly: import_zod9.z.array(import_zod9.z.string()).optional()
 }).passthrough();
 var DesignFieldSchema = import_zod9.z.object({
   name: import_zod9.z.string(),
@@ -16220,7 +16384,12 @@ var externalsFileAdapter = {
     return parsed.data;
   },
   writeLock(lock) {
-    writeAtomically(lockPath2(getProjectRoot()), serializeYaml(sortedLock(lock)));
+    const file = lockPath2(getProjectRoot());
+    if (Object.keys(lock.externals).length === 0 && lock.parent === void 0) {
+      if (fs8.existsSync(file)) fs8.unlinkSync(file);
+      return;
+    }
+    writeAtomically(file, serializeYaml(sortedLock(lock)));
   },
   readSnapshot(alias) {
     const file = snapshotPath(getProjectRoot(), alias);
@@ -16944,7 +17113,8 @@ function projectParams(params, position, keys, owner) {
     name: p.name,
     type: typeRef(p.type, position, keys, owner),
     optional: p.optional === true,
-    ...p.description !== void 0 ? { description: p.description } : {}
+    ...p.description !== void 0 ? { description: p.description } : {},
+    ...p.previousNames && p.previousNames.length > 0 ? { formerly: [...p.previousNames] } : {}
   }));
 }
 function exportEntry(e, keys) {
@@ -16993,7 +17163,8 @@ function memberDependency(member, lock, keys) {
     projectId: member.projectId,
     role: "member",
     ...digest3 !== void 0 ? { digest: digest3 } : {},
-    uses: [...keys.used.get(member.alias) ?? []].sort(compareOrdinal)
+    // Every public name a reference reaches (the graph's), and every one the projection wrote.
+    uses: [.../* @__PURE__ */ new Set([...member.referenced ?? [], ...keys.used.get(member.alias) ?? []])].sort(compareOrdinal)
   };
 }
 function directMembers(family) {
@@ -17014,7 +17185,8 @@ function directMembers(family) {
         for (const key2 of bound2(target)) if (!names.has(key2)) names.set(key2, name);
       }
     }
-    return { alias, projectId: n.id ?? alias, names };
+    const referenced = [...new Set(family.references.filter((r) => r.consumer === "" && r.producer === n.namespace && r.publicName !== void 0).map((r) => r.publicName))];
+    return { alias, projectId: n.id ?? alias, names, referenced };
   }).sort((a, b) => compareOrdinal(a.alias, b.alias));
 }
 function subsystemSection(s, table, keys) {
@@ -17324,6 +17496,8 @@ function computeTypeClosure(entries, types, exported = []) {
       ...t.kind === "enum" ? { values: (t.values ?? []).map((v) => ({ name: v.name, ...v.description ? { description: v.description } : {} })) } : {},
       // A named scalar travels with the primitive it holds.
       ...t.holds !== void 0 ? { holds: t.holds } : {},
+      // Its own methods (checked constructors, pure operations) travel with it — carried, never digested.
+      ...t.methods && t.methods.length ? { methods: t.methods.map((m) => ({ name: m.name, signature: m.signature, ...m.params ? { params: m.params.map(describe2) } : {}, returns: m.returns, ...m.description ? { description: m.description } : {} })) } : {},
       // A renamed type travels with its rename trace — provenance, outside every digest.
       ...formerlyOf(t.previousIds, t.id)
     };
@@ -17438,7 +17612,8 @@ function canonicalReferences(snapshot) {
       ...def,
       fields: def.fields.map((f) => ({ ...f, type: canon(f.type) })),
       ...def.params ? { params: def.params.map((p) => ({ ...p, type: canon(p.type) })) } : {},
-      ...def.returns !== void 0 ? { returns: canon(def.returns) } : {}
+      ...def.returns !== void 0 ? { returns: canon(def.returns) } : {},
+      ...def.methods ? { methods: def.methods.map((m) => ({ ...m, returns: canon(m.returns), ...m.params ? { params: m.params.map((p) => ({ ...p, type: canon(p.type) })) } : {} })) } : {}
     }))
   };
 }
@@ -17608,9 +17783,17 @@ function exportResult(snapshot, renderedSet, writtenPaths) {
     ...writtenPaths.length ? { writtenPaths } : {}
   };
 }
+var OpenApiNotApplicableError = class extends Error {
+  constructor(snapshot, maxAudience) {
+    const kinds = [...new Set(snapshot.interfaces.map((e) => e.type))].sort();
+    super(snapshot.interfaces.length ? `OpenAPI does not apply to "${snapshot.projectName}": it exposes no HTTP Portal at audience \u2265 ${maxAudience} \u2014 its ${snapshot.interfaces.length} exported interface(s) are ${kinds.join(", ")}${kinds.includes("InProcess") ? " (an in-process library is called, not requested over HTTP)" : ""}, which no OpenAPI document describes. Nothing was written; export the native snapshot (\`--format native\`) instead.` : `OpenAPI does not apply to "${snapshot.projectName}": it exports no interface at audience \u2265 ${maxAudience}. Nothing was written.`);
+    this.name = "OpenApiNotApplicableError";
+  }
+};
 function exportSurface(maxAudience, format, outPath, portalId) {
   const snapshot = projectOwnSurface(maxAudience);
   let renderedSet = format === "openapi" ? toOpenApiSet(snapshot) : void 0;
+  if (renderedSet && renderedSet.length === 0 && outPath) throw new OpenApiNotApplicableError(snapshot, maxAudience);
   if (renderedSet && portalId) renderedSet = selectPortalSpec(renderedSet, portalId);
   const writtenPaths = outPath ? writeSurfaceFile(outPath, snapshot, renderedSet) : [];
   return exportResult(snapshot, renderedSet, writtenPaths);
@@ -17697,22 +17880,57 @@ function producerUnreadable(external) {
   return null;
 }
 function projectProducer(external) {
-  const snapshot = runWithProjectRoot(external.directory, () => projectOwnSurface(external.audience));
+  const snapshot = runWithProjectRoot(external.directory, () => {
+    const projected = projectOwnSurface(external.audience);
+    const broken = getLoaderIssues().find((i) => i.code === "SCHEMA_VALIDATION_ERROR");
+    if (broken) throw new Error(unreadableReason(broken.message));
+    return projected;
+  });
   return { ...snapshot, audience: external.audience };
 }
-function usedDigests(usage, snapshot) {
+var PRODUCER_UNREADABLE = "producer unreadable";
+function unreadableReason(message) {
+  const parsed = /^Failed to parse (?:\w+ )?spec(?: "([^"]+)")?: ([\s\S]*)$/.exec(message);
+  if (!parsed) return `${PRODUCER_UNREADABLE}: ${message}`;
+  return `${PRODUCER_UNREADABLE}: ${parsed[1] ?? "its system spec"}: ${parsed[2]}`;
+}
+function readFailure(e) {
+  const detail = e instanceof Error ? e.message : String(e);
+  return detail.startsWith(PRODUCER_UNREADABLE) ? detail : `the producer could not be read: ${detail}`;
+}
+function usedDigests(usage, snapshot, alias) {
   const used = {};
   const missing = [];
+  const uncarried = [];
   for (const use of usage?.used ?? []) {
     const members = {};
     for (const member of use.members) {
       const digest3 = memberDigest(snapshot, use.publicName, member);
-      if (digest3 === null) missing.push(`${use.publicName}.${member}`);
-      else members[member] = digest3;
+      if (digest3 !== null) {
+        members[member] = digest3;
+        continue;
+      }
+      missing.push(`${use.publicName}.${member}`);
+      uncarried.push({
+        specId: use.specs?.[0] ?? "",
+        position: "uncarried",
+        target: `${alias}::${use.publicName}`,
+        ...member !== "type" ? { member } : {},
+        consumer: usage?.consumer ?? "",
+        producer: alias,
+        authored: `${alias}::${use.publicName}`
+      });
     }
     used[use.publicName] = members;
   }
-  return { used, missing };
+  return { used, missing, uncarried };
+}
+function pinDetail(missing, usedNames, alias) {
+  if (missing.length) return { detail: `used members the snapshot does not carry cannot be pinned: ${missing.join(", ")}` };
+  if (usedNames === 0) {
+    return { detail: `no spec references "${alias}" yet, so this pin records none of its uses \u2014 it fills on the next pin (\`wairon externals pin ${alias}\` / sdd_pin_externals) once a spec writes \`${alias}::<name>\`; until then each new reference reads "used now, but not in the lock"` };
+  }
+  return {};
 }
 function pinBinding(binding, lock) {
   const { external } = binding;
@@ -17723,14 +17941,13 @@ function pinBinding(binding, lock) {
     if (unreadable) throw new Error(unreadable);
     snapshot = projectProducer(external);
   } catch (e) {
-    const detail = e instanceof Error ? e.message : String(e);
-    return { pin: { alias: external.alias, outcome: "unreachable", project: external.project, usedNames: 0, unexported, detail: `the producer could not be read: ${detail}; its previous pin stays` }, changed: false };
+    return { pin: { alias: external.alias, outcome: "unreachable", project: external.project, usedNames: 0, unexported, detail: `${readFailure(e)}; its previous pin stays` }, changed: false };
   }
   const digest3 = contentDigest(snapshot);
   const pinned = externalsRepository.readSnapshot(external.alias);
   const snapshotChanged = !pinned || contentDigest(pinned) !== digest3 || pinnedContentKey(pinned) !== pinnedContentKey(snapshot);
   if (snapshotChanged) externalsRepository.saveSnapshot(external.alias, snapshot);
-  const { used, missing } = usedDigests(binding.usage, snapshot);
+  const { used, missing, uncarried } = usedDigests(binding.usage, snapshot, external.alias);
   const entry = {
     project: external.project,
     snapshot: `.wai/externals/${external.alias}.yaml`,
@@ -17749,8 +17966,8 @@ function pinBinding(binding, lock) {
       snapshot: entry.snapshot,
       digest: digest3,
       usedNames: Object.keys(used).length,
-      unexported,
-      ...missing.length ? { detail: `used members the snapshot does not carry cannot be pinned: ${missing.join(", ")}` } : {}
+      unexported: [...unexported, ...uncarried],
+      ...pinDetail(missing, Object.keys(used).length, external.alias)
     },
     changed: entryChanged
   };
@@ -17914,6 +18131,13 @@ function compareUses(entry, usage, live) {
     }
   }
   for (const ref of usage?.unexported ?? []) {
+    const spelled = ref.authored.split("::");
+    const name = spelled.length === 2 ? spelled[1] : spelled.length === 1 ? spelled[0] : void 0;
+    if (name !== void 0 && !liveHas(name) && !uses.some((u) => u.publicName === name && (u.member === ref.member || u.member === void 0))) {
+      const gone = goneUse(live, name, ref.member, void 0);
+      uses.push(gone);
+      continue;
+    }
     uses.push({ member: ref.member, state: "unavailable", code: CHECK_UNAVAILABLE, detail: `"${ref.specId}" reaches "${ref.target}", which the producer does not export \u2014 nothing to compare` });
   }
   return uses;
@@ -17946,7 +18170,7 @@ function externalStatus(binding, lock) {
     try {
       live = projectProducer(external);
     } catch (e) {
-      reason = `the producer could not be read: ${e instanceof Error ? e.message : String(e)}`;
+      reason = readFailure(e);
     }
   }
   if (!live) {
@@ -18011,6 +18235,23 @@ function listExternals() {
   }));
   return [...declared, ...orphans];
 }
+function listConsumers2(search) {
+  return listConsumers(search);
+}
+function diff(against) {
+  const current2 = projectOwnSurface("project");
+  let baseline;
+  let label7;
+  if (against !== void 0 && fs9.existsSync(against) && fs9.statSync(against).isFile()) {
+    baseline = SurfaceSnapshotSchema.parse(parseYaml(fs9.readFileSync(against, "utf8"), against));
+    label7 = `the saved surface ${path14.resolve(against)}`;
+  } else {
+    const revision = approvedRevision(against);
+    baseline = runWithProjectRoot(revision.directory, () => projectOwnSurface("project"));
+    label7 = revision.label;
+  }
+  return { project: current2.projectId ?? current2.projectName, against: label7, changes: surfaceChanges(current2, baseline) };
+}
 function pinnedContentKey(snapshot) {
   const { stateId: _s, generatedAt: _g, origin: _o, ...content } = SurfaceSnapshotSchema.parse(JSON.parse(JSON.stringify(snapshot)));
   return canonicalize({ ...content, interfaces: content.interfaces.map((e) => ({ ...e, component: lastSegment2(e.component) })) });
@@ -18188,8 +18429,8 @@ function remove(alias, dryRun) {
   }
   if (dryRun) return { alias, removed: false, unpinned: pinned };
   const removed = declared ? removeExternal(alias) : false;
-  const unpinned = unpin(alias);
-  return { alias, removed, unpinned };
+  const unpinned2 = unpin(alias);
+  return { alias, removed, unpinned: unpinned2 };
 }
 function currentUse(declaration2) {
   const use = typeof declaration2 === "object" && declaration2 !== null ? declaration2.use : void 0;
@@ -18287,6 +18528,12 @@ function removeExternal2(alias, dryRun) {
 function updateExternalUse(request) {
   return updateUse(request);
 }
+function listConsumers3(search) {
+  return listConsumers2(search);
+}
+function diffSurface(against) {
+  return diff(against);
+}
 
 // src/core/family-validation.ts
 var fs11 = __toESM(require("fs"));
@@ -18394,12 +18641,12 @@ function findingChanges(before, after) {
 }
 
 // src/core/rules/reach-model-projector.ts
-function underBase(basePath, path49) {
+function underBase(basePath, path50) {
   const base = (basePath ?? "").trim().replace(/\/+$/, "");
-  if (base === "" || base === "/") return path49;
+  if (base === "" || base === "/") return path50;
   const head2 = base.startsWith("/") ? base : `/${base}`;
-  if (path49 === head2 || path49.startsWith(`${head2}/`)) return path49;
-  return `${head2}${path49.startsWith("/") ? "" : "/"}${path49}`;
+  if (path50 === head2 || path50.startsWith(`${head2}/`)) return path50;
+  return `${head2}${path50.startsWith("/") ? "" : "/"}${path50}`;
 }
 function bindingLine(endpoint, basePath) {
   if (!endpoint) return void 0;
@@ -18521,6 +18768,7 @@ function project(ctx, network) {
     ...c.subsystem !== void 0 ? { subsystem: c.subsystem } : {},
     componentType: c.componentType
   }));
+  const subsystems = ctx.subsystems.map((s) => s.id).filter((id) => !ctx.isInChainedSubproject(id)).sort();
   const topics = [];
   const addEnd = (component, topic, emits) => {
     if (!topics.some((t) => t.component === component && t.topic === topic && t.emits === emits)) topics.push({ component, topic, emits });
@@ -18540,7 +18788,8 @@ function project(ctx, network) {
     verbs: verbs.sort(byVerb),
     calls: calls.sort(byCall),
     placements: placements.sort(byPlacement),
-    topics: topics.sort(byTopic)
+    topics: topics.sort(byTopic),
+    subsystems
   };
 }
 function qualify(projectKey, local) {
@@ -18577,7 +18826,9 @@ function compose(models, family, networks) {
   const calls = [];
   const placements = [];
   const topics = [];
+  const subsystems = [];
   for (const [key2, model] of models) {
+    for (const s of model.subsystems ?? []) subsystems.push(qualify(key2, s));
     for (const p of model.placements ?? []) {
       placements.push({
         ...p,
@@ -18639,7 +18890,8 @@ function compose(models, family, networks) {
     verbs: verbs.sort(byVerb),
     calls: calls.sort(byCall),
     placements: placements.sort(byPlacement),
-    topics: topics.sort(byTopic)
+    topics: topics.sort(byTopic),
+    subsystems: subsystems.sort()
   };
 }
 
@@ -18668,6 +18920,7 @@ function judge(model) {
     out.push({ severity, code, message, specId: v.portal, at: v.verb });
   };
   const family = model.scope === "family";
+  const bypassed = /* @__PURE__ */ new Map();
   const byPortal = /* @__PURE__ */ new Map();
   for (const v of model.verbs) byPortal.set(v.portal, [...byPortal.get(v.portal) ?? [], v]);
   for (const v of model.verbs) {
@@ -18676,12 +18929,7 @@ function judge(model) {
     if (entry) {
       const scope = entry.scope ?? "outside";
       if (scope === "outside" && v.network !== void 0 && !v.gateway) {
-        verbFinding(
-          "error",
-          "GATEWAY_BYPASSED",
-          v,
-          `Portal verb "${verbName(v)}" sits inside ${networkName(v.network)} and is entered from outside it, but "${v.portal}" is not a gateway: callers from outside a network reach it only through its gateway. Make the Portal a gateway (variant: gateway), or route the outside callers through the network's gateway and narrow this entry to scope network.`
-        );
+        bypassed.set(v.portal, [...bypassed.get(v.portal) ?? [], v]);
       }
       if (scope === "network" && v.network === void 0 && family) {
         verbFinding(
@@ -18735,9 +18983,27 @@ function judge(model) {
       at: call.evidence
     });
   }
+  for (const [portal, verbs] of bypassed) {
+    const network = verbs[0].network;
+    const gatewayless = (model.networks.find((n) => n.id === network)?.gateways.length ?? 0) === 0;
+    const names = verbs.map((v) => `"${v.verb}"`).join(", ");
+    const subject = verbs.length === 1 ? `Portal verb "${verbName(verbs[0])}"` : `Portal "${portal}" (${verbs.length} verbs: ${names})`;
+    const way = gatewayless ? ` ${networkName(network).replace(/^t/, "T")} has no gateway yet: in a project that runs as one process, the Portal its callers enter IS the gateway \u2014 mark "${portal}" variant: gateway. Otherwise route the outside callers through the network's gateway and narrow ${verbs.length === 1 ? "this entry" : "these entries"} to scope network.` : ` Make the Portal a gateway (variant: gateway), or route the outside callers through the network's gateway and narrow ${verbs.length === 1 ? "this entry" : "these entries"} to scope network.`;
+    out.push({
+      severity: "error",
+      code: "GATEWAY_BYPASSED",
+      message: `${subject} sits inside ${networkName(network)} and is entered from outside it, but "${portal}" is not a gateway: callers from outside a network reach it only through its gateway.${way}`,
+      specId: portal,
+      ...verbs.length === 1 ? { at: verbs[0].verb } : { covers: verbs.map((v) => v.verb) }
+    });
+  }
+  const localName3 = (key2) => key2.includes("::") ? key2.slice(key2.lastIndexOf("::") + 2) : key2;
+  const byLocal = (a, b) => localName3(a).localeCompare(localName3(b)) || a.localeCompare(b);
   for (const n of model.networks) {
     if (n.gateways.length < 2) continue;
-    const first = [...n.gateways].sort()[0];
+    const ownProject = (g) => model.verbs.some((v) => v.portal === g && v.project === n.id);
+    const own2 = n.gateways.filter(ownProject);
+    const first = [...own2.length > 0 ? own2 : n.gateways].sort(byLocal)[0];
     out.push({
       severity: "notice",
       code: "MULTIPLE_GATEWAYS",
@@ -18753,6 +19019,8 @@ var FAMILY_SEVERITY = {
   EXTERNAL_INCOMPATIBLE: "error",
   EXTERNAL_DRIFTED: "notice",
   EXTERNAL_CHECK_UNAVAILABLE: "warning",
+  // A used external never pinned: nothing records what it is judged against, so the composed gate fails.
+  EXTERNAL_UNPINNED: "error",
   // The advisory live comparison (advise): printed and counted, never part of a failure decision.
   EXTERNAL_LIVE_INCOMPATIBLE: "warning",
   EXTERNAL_LIVE_UNCOMPARED: "notice",
@@ -18763,6 +19031,8 @@ var FAMILY_SEVERITY = {
   MEMBER_DRIFTED: "warning",
   PROJECT_ID_DEFAULTED: "notice",
   PROJECT_ID_AMBIGUOUS: "warning",
+  // A family-only re-export from another project that no project of the family reaches: dead.
+  EXPORT_UNREACHED: "notice",
   // Governance: a required pack not adopted blocks; a member's deviation from
   // an adopted pack's settings is visible and never fails --ci.
   POLICY_NOT_ADOPTED: "error",
@@ -18986,7 +19256,16 @@ function judgeExternal(status, project3, config) {
       project3
     ));
   }
-  for (const use of status.uses.filter((u) => u.state === "unavailable" || u.state === "unlocked")) {
+  const neverPinned = status.pinnedDigest === void 0 ? status.uses.filter((u) => u.state === "unlocked") : [];
+  if (neverPinned.length > 0) {
+    out.push(finding(
+      config,
+      "EXTERNAL_UNPINNED",
+      `${named(project3)} uses ${neverPinned.map(useName).join(", ")} of ${who}, which was never pinned: nothing records what its design is judged against, so a producer change that breaks it cannot be told. Pin it (\`wairon externals pin ${status.alias}\`) \u2014 and \`wairon lock\` refuses until it is.`,
+      project3
+    ));
+  }
+  for (const use of status.uses.filter((u) => u.state === "unavailable" || u.state === "unlocked" && !neverPinned.includes(u))) {
     const why2 = use.detail ?? (use.state === "unlocked" ? "used now, but not in the lock" : "nothing to compare");
     out.push(finding(
       config,
@@ -19184,11 +19463,54 @@ function checkMembers(family) {
       ref.parent
     ));
   }
+  out.push(...unreachedReexports(family, config));
   for (const entry of projectApprovals()) {
     if (present.has(entry.key) && entry.as !== "part") out.push(approvalFinding(entry, config));
   }
   return out.filter((f) => f !== null);
 }
+function aliasTargets(node) {
+  const out = new Map(node.aliases);
+  for (const e of node.externals) if (e.sourceKind === "family" && e.producer !== void 0 && !out.has(e.alias)) out.set(e.alias, e.producer);
+  return out;
+}
+function unreachedReexports(family, config) {
+  const out = [];
+  const keys = new Set(family.nodes.map((n) => n.namespace));
+  const reached = /* @__PURE__ */ new Map();
+  for (const ref of family.authoredReferences) {
+    const owner = family.nodes.find((n) => n.namespace === (family.owners.get(ref.specId) ?? ""));
+    if (!owner) continue;
+    const targets = aliasTargets(owner);
+    const via = ref.form === "import" ? (ref.importedVia ?? "").split(", ") : [ref.authored.split("::")[0]];
+    const name = ref.form === "import" ? ref.authored : ref.authored.split("::")[1];
+    for (const alias of via) {
+      const project3 = targets.get(alias);
+      if (project3 === void 0 || project3 === owner.namespace || name === void 0) continue;
+      reached.set(project3, (reached.get(project3) ?? /* @__PURE__ */ new Set()).add(name));
+    }
+  }
+  for (const node of family.nodes) {
+    let entries;
+    try {
+      entries = resolveProjectExports(node.namespace || void 0).entries;
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const from = entry.via[0];
+      if ((entry.audience ?? "instance") !== "project" || from === void 0 || from === node.namespace || !keys.has(from)) continue;
+      if (reached.get(node.namespace)?.has(entry.publicName)) continue;
+      out.push(finding(
+        config,
+        "EXPORT_UNREACHED",
+        `${named(node.namespace)} re-exports "${entry.publicName}" from ${named(from)} at audience project \u2014 the family only \u2014 but no project of the family reaches it through ${named(node.namespace)}: a dead re-export. Drop the entry from its L0 export table (or widen its audience if a consumer outside the family uses it).`,
+        node.namespace
+      ));
+    }
+  }
+  return out;
+}
 function subjectOf(record) {
   return `${record.stateId.algorithm}:${record.stateId.digest}`;
 }
@@ -19569,6 +19891,10 @@ function checkReach(family, models) {
   return out;
 }
 function reachModel(options) {
+  if (options.memberDepth !== 0) {
+    const enclosing2 = enclosingFamilyModel(options);
+    if (enclosing2) return enclosing2;
+  }
   const family = graph();
   const root = path15.resolve(getProjectRoot());
   const ceiling = reachCeiling(root, options.family);
@@ -19580,7 +19906,44 @@ function reachModel(options) {
   const scoped = narrowed(family, selected);
   return within2(root, ceiling, () => {
     const model = compose(models, scoped, networksOf(scoped));
-    return { ...model, findings: judgedFindings(model, scoped) };
+    const config = configOrNull();
+    const externals = Object.keys(config?.externals ?? {});
+    return {
+      ...model,
+      findings: judgedFindings(model, scoped),
+      ...config?.id !== void 0 ? { rootProject: config.id } : {},
+      ...externals.length > 0 ? { externals } : {},
+      ...formerNamesOf(scoped)
+    };
+  });
+}
+function formerNamesOf(family) {
+  const out = {};
+  for (const node of family.nodes) {
+    if (node.namespace === "") continue;
+    const previous = runWithProjectRoot(node.directory, configOrNull)?.previousIds ?? [];
+    for (const id of previous) {
+      const former = keyIn(node.parent ?? "", id);
+      if (former !== node.namespace && !family.nodes.some((n) => n.namespace === former)) out[former] = node.namespace;
+    }
+  }
+  return Object.keys(out).length > 0 ? { formerNames: out } : {};
+}
+function enclosingFamilyModel(options) {
+  const bound2 = path15.resolve(getProjectRoot());
+  let top = null;
+  let parent = resolveChainingParent();
+  for (let hops = 0; parent && hops < 32; hops++) {
+    top = path15.resolve(parent.parentRoot);
+    parent = runWithProjectRoot(top, resolveChainingParent);
+  }
+  if (top === null) return null;
+  const topRoot = top;
+  return runWithProjectRoot(topRoot, () => {
+    const member = graph().nodes.find((n) => path15.resolve(n.directory) === bound2);
+    if (!member || member.namespace === "") return null;
+    const model = reachModel({ ...options, memberDepth: void 0 });
+    return { ...model, focus: member.namespace, judgedAt: topRoot };
   });
 }
 function judgedFindings(model, family) {
@@ -19603,7 +19966,8 @@ function judgedFindings(model, family) {
       code: f.code,
       message: f.message,
       ...f.specId !== void 0 ? { specId: f.specId } : {},
-      ...f.at !== void 0 ? { at: f.at } : {}
+      ...f.at !== void 0 ? { at: f.at } : {},
+      ...f.covers !== void 0 ? { covers: f.covers } : {}
     });
   }
   return out;
@@ -19929,6 +20293,13 @@ var DeclarativePackSchema = import_zod10.z.object({
    * builtin + declared are flagged UNKNOWN_GUARANTEE by the validator.
    */
   guarantees: import_zod10.z.array(import_zod10.z.string().min(1)).default([]),
+  /**
+   * Package names a technology's code is imported by, keyed by the
+   * technology's name — extending the built-in table the code twin of the
+   * leakage rule (TECH_LEAKAGE_IN_CODE) compares imports with, for a driver or
+   * SDK the table does not know. Data only.
+   */
+  technologyPackages: import_zod10.z.record(import_zod10.z.array(import_zod10.z.string().min(1))).default({}),
   /**
    * Connecting-agent guidance appended to wairon's own MCP `initialize`
    * instructions, attributed to this pack, in pack load order.
@@ -19963,7 +20334,7 @@ function globalPacksEnabled(config) {
   return config.extensions?.useGlobalPacks ?? GLOBAL_PACKS_DEFAULT;
 }
 function emptyExtensions() {
-  return { packNames: [], packs: [], rules: [], profiles: {}, languages: {}, skills: [], patterns: [], guarantees: [], assertions: [], instructions: [], errors: [], selectionFailures: [], deprecations: [] };
+  return { packNames: [], packs: [], rules: [], profiles: {}, languages: {}, skills: [], patterns: [], guarantees: [], technologyPackages: {}, assertions: [], instructions: [], errors: [], selectionFailures: [], deprecations: [] };
 }
 var FOREIGN_BUILTINS_RETIRED = "nothing replaces it: contracts are written in the neutral type grammar and a language is chosen at L4, so the foreign-builtin check it fed is retired";
 function globalPacksDir() {
@@ -20035,6 +20406,10 @@ function mergePack(out, pack, ref, scope, packDir) {
   for (const s of pack.skills) out.skills.push({ ...s, pack: pack.name, packVersion: pack.version, sourcePath: path17.resolve(packDir, s.source) });
   for (const p of pack.patterns) out.patterns.push({ ...p, pack: pack.name });
   out.guarantees = [.../* @__PURE__ */ new Set([...out.guarantees, ...pack.guarantees])];
+  for (const [tech, packages] of Object.entries(pack.technologyPackages ?? {})) {
+    const key2 = tech.toLowerCase();
+    out.technologyPackages[key2] = [.../* @__PURE__ */ new Set([...out.technologyPackages[key2] ?? [], ...packages.map((p) => p.toLowerCase())])];
+  }
   for (const a of pack.assertions) out.assertions.push({ ...a, pack: pack.name, fullCode: assertionFullCode(pack.name, a.code) });
   for (const b of pack.instructions) out.instructions.push({ ...b, pack: pack.name });
 }
@@ -20067,6 +20442,7 @@ function readManifest(target, resolveFrom) {
     skills: mod.skills ?? [],
     patterns: mod.patterns ?? [],
     guarantees: mod.guarantees ?? [],
+    technologyPackages: mod.technologyPackages ?? {},
     assertions: mod.assertions ?? [],
     instructions: mod.instructions ?? [],
     applyByDefault: mod.applyByDefault ?? false
@@ -20377,21 +20753,21 @@ function buildCodeIndex(model) {
   const declarations = /* @__PURE__ */ new Map();
   const anchors = /* @__PURE__ */ new Map();
   const findingAnchors = /* @__PURE__ */ new Map();
-  const namesAt = (cache, path49, make) => {
-    const cached = cache.get(path49);
+  const namesAt = (cache, path50, make) => {
+    const cached = cache.get(path50);
     if (cached) return cached;
-    const f = facts.get(path49);
+    const f = facts.get(path50);
     if (!f) return NO_NAMES;
     const built = make(f);
-    cache.set(path49, built);
+    cache.set(path50, built);
     return built;
   };
   const republished = /* @__PURE__ */ new Map();
-  const republishedFrom = (path49) => {
-    const cached = republished.get(path49);
+  const republishedFrom = (path50) => {
+    const cached = republished.get(path50);
     if (cached) return cached;
-    const out = /* @__PURE__ */ new Set([path49]);
-    const queue = [path49];
+    const out = /* @__PURE__ */ new Set([path50]);
+    const queue = [path50];
     while (queue.length) {
       const from = queue.pop();
       const f = facts.get(from);
@@ -20404,7 +20780,7 @@ function buildCodeIndex(model) {
         }
       }
     }
-    republished.set(path49, out);
+    republished.set(path50, out);
     return out;
   };
   const NO_ORIGIN = /* @__PURE__ */ new Set();
@@ -20413,9 +20789,9 @@ function buildCodeIndex(model) {
     return to ? republishedFrom(to) : NO_ORIGIN;
   };
   const scopeOf2 = (site, from) => {
-    const path49 = pathKey(site.from ?? from);
-    const f = facts.get(path49);
-    return f?.status === "analyzed" && f.analysisGrade === "exact" ? { path: path49, facts: f } : void 0;
+    const path50 = pathKey(site.from ?? from);
+    const f = facts.get(path50);
+    return f?.status === "analyzed" && f.analysisGrade === "exact" ? { path: path50, facts: f } : void 0;
   };
   const originOf2 = (site, from) => {
     const resolved = scopeOf2(site, from);
@@ -20457,6 +20833,8 @@ function buildCodeIndex(model) {
         const target = aliasTargetOf(decl.facts, decl.name);
         if (target !== void 0) widenThroughAt(decl.path, target, typeBindingOf(decl.facts, target));
       }
+      const declared = declaringModule(at, atFacts, typeName);
+      if (declared) for (const implementor of implementorsOf(declared.path, declared.name)) out.add(implementor);
     };
     if (site.field) for (const typeName of fieldTypesOf(f, site.field)) widenThroughType(typeName);
     if (site.receiverPath && site.receiverPath.length >= 2) {
@@ -20529,8 +20907,43 @@ function buildCodeIndex(model) {
     }
     return found;
   };
+  const moduleKey = (p) => pathKey(p).replace(/\.(d\.)?(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/, "").replace(/\/index$/, "");
+  const declaringModule = (at, atFacts, typeName) => {
+    const specifier = typeBindingOf(atFacts, typeName);
+    if (specifier === void 0) return { path: at, name: typeName };
+    const name = importBindingOf(atFacts, typeName)?.imported ?? typeName;
+    const resolved = resolveImport(at, specifier, paths, packages);
+    if (resolved) return { path: resolved, name };
+    if (!specifier.startsWith(".")) return void 0;
+    const dir = pathKey(at).split("/").slice(0, -1);
+    for (const part of specifier.split("/")) {
+      if (part === "..") dir.pop();
+      else if (part !== "." && part !== "") dir.push(part);
+    }
+    return { path: dir.join("/"), name };
+  };
+  let implementors;
+  const implementorsOf = (path50, typeName) => {
+    if (!implementors) {
+      implementors = /* @__PURE__ */ new Map();
+      for (const [file, f] of facts) {
+        if (f.status !== "analyzed" || f.analysisGrade !== "exact" || !f.implementsClauses) continue;
+        for (const names of Object.values(f.implementsClauses)) {
+          for (const name of names) {
+            const declared = declaringModule(file, f, name);
+            if (!declared) continue;
+            const key2 = `${moduleKey(declared.path)}#${declared.name}`;
+            const set = implementors.get(key2) ?? /* @__PURE__ */ new Set();
+            set.add(file);
+            implementors.set(key2, set);
+          }
+        }
+      }
+    }
+    return implementors.get(`${moduleKey(path50)}#${typeName}`) ?? NO_NAMES;
+  };
   const holdsMemberBody = (f, name, container) => f.status === "analyzed" && f.analysisGrade === "exact" && !!f.functionBodies && Object.prototype.hasOwnProperty.call(f.functionBodies, name) && f.functionBodies[name].some((b) => b.container === container);
-  const declarationsAt = (path49) => namesAt(declarations, pathKey(path49), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames]));
+  const declarationsAt = (path50) => namesAt(declarations, pathKey(path50), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames]));
   const forwardsOf = (start, name, container) => {
     const out = [];
     const listed = /* @__PURE__ */ new Set();
@@ -20574,12 +20987,13 @@ function buildCodeIndex(model) {
     paths,
     exactPaths,
     packages,
-    factsAt: (path49) => facts.get(pathKey(path49)),
+    factsAt: (path50) => facts.get(pathKey(path50)),
     declarationsAt,
-    anchorsAt: (path49) => namesAt(anchors, pathKey(path49), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames, ...f.anchoredNames])),
-    findingAnchorsAt: (path49) => namesAt(findingAnchors, pathKey(path49), (f) => new Set(f.anchoredNames)),
+    anchorsAt: (path50) => namesAt(anchors, pathKey(path50), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames, ...f.anchoredNames])),
+    findingAnchorsAt: (path50) => namesAt(findingAnchors, pathKey(path50), (f) => new Set(f.anchoredNames)),
     originOf: originOf2,
     possibleOriginsOf,
+    implementorsOf,
     forwardsOf,
     // Realization has begun once any named file is one the run analyzed or
     // could read: missing and escaped are the only statuses that hold nothing.
@@ -20622,10 +21036,10 @@ function buildRealizationIndex(ctx) {
   return {
     paths,
     implementationsOf: (compId) => implsByComponent.get(compId) ?? NONE_IMPL,
-    implementationsAt: (path49) => implsByPath.get(pathKey(path49)) ?? NONE_IMPL,
+    implementationsAt: (path50) => implsByPath.get(pathKey(path50)) ?? NONE_IMPL,
     filesOf: (compId) => filesByComponent.get(compId) ?? NONE_PATH,
     filesIn: (subsystemId) => filesBySubsystem.get(subsystemId) ?? NONE_PATH,
-    componentsAt: (path49) => componentsByPath.get(pathKey(path49)) ?? NONE_COMP
+    componentsAt: (path50) => componentsByPath.get(pathKey(path50)) ?? NONE_COMP
   };
 }
 function buildImportGraph(index, universe) {
@@ -20637,22 +21051,22 @@ function buildImportGraph(index, universe) {
       if (to && to !== from) into.add(to);
     }
   };
-  const importsOf = (path49) => {
-    const cached = imports.get(path49);
+  const importsOf = (path50) => {
+    const cached = imports.get(path50);
     if (cached) return cached;
-    const facts = index.factsAt(path49);
+    const facts = index.factsAt(path50);
     const out = /* @__PURE__ */ new Set();
-    if (facts?.status === "analyzed") resolveAll(path49, facts.imports, out);
-    imports.set(path49, out);
+    if (facts?.status === "analyzed") resolveAll(path50, facts.imports, out);
+    imports.set(path50, out);
     return out;
   };
-  const tracesOf = (path49) => {
-    const cached = traces.get(path49);
+  const tracesOf = (path50) => {
+    const cached = traces.get(path50);
     if (cached) return cached;
-    const facts = index.factsAt(path49);
-    const out = new Set(importsOf(path49));
-    if (facts?.status === "analyzed") resolveAll(path49, facts.reexports, out);
-    traces.set(path49, out);
+    const facts = index.factsAt(path50);
+    const out = new Set(importsOf(path50));
+    if (facts?.status === "analyzed") resolveAll(path50, facts.reexports, out);
+    traces.set(path50, out);
     return out;
   };
   return {
@@ -21139,6 +21553,105 @@ var signatureTypeReferencesRule = {
   }
 };
 
+// src/core/rules/integrity/implements-contracts.ts
+var implementsContractsRule = {
+  name: "implements-contracts",
+  judges: "design",
+  description: "An interface that declares `implements: alias::name` realizes another project's extension point, so it must declare every method of that contract with the same params and returns, read from the export the reference resolves to (a contained member's live table, or a declared external's pin). Types are compared semantically, never by spelling: the producer's own bare name and the consumer's `alias::name` (or the bare name its `use` imports) are one type. Whether the reference resolves and names an entry exported with role implement is project-boundaries' finding (EXTERNAL_NOT_EXPORTED); this rule judges the shape once it resolves. Extra methods are the implementer's own and are not reported.",
+  codes: [
+    { code: "IMPLEMENTS_MISMATCH", defaultSeverity: "error", summary: "An interface implementing an extension point lacks one of its methods, or declares one with different params or returns" }
+  ],
+  check(ctx) {
+    for (const intf of ctx.interfaces) {
+      if (intf.implements === void 0 || !ctx.isSpecInScope(intf.id)) continue;
+      const point = extensionPoint(ctx, intf.id, intf.implements);
+      if (!point) continue;
+      const { methods: contract, publicNames } = point;
+      const alias = intf.implements.split("::")[0];
+      const expectedType = (t) => respelled(t, (n) => publicNames.get(lastName(n)) ?? lastName(n));
+      const ownType = (t) => respelled(t, (n) => n.startsWith(`${alias}::`) ? lastName(n.slice(alias.length + 2)) : n);
+      const draft = intf.status === "draft" || intf.status === "design" || ctx.isComponentDraft(intf.component);
+      for (const expected of contract) {
+        const own2 = intf.methods.find((m) => m.name === expected.name);
+        const differs = own2 ? difference(expected, own2, expectedType, ownType) : "is not declared";
+        if (!differs) continue;
+        const former = own2 ? void 0 : (expected.formerly ?? []).find((f) => intf.methods.some((m) => m.name === f));
+        const renamedFrom = former ? ` It was renamed from "${former}" (the producer's rename trace), which this interface still declares \u2014 rename it to "${expected.name}".` : "";
+        ctx.addIssue(
+          "error",
+          "IMPLEMENTS_MISMATCH",
+          `Interface "${intf.id}" implements "${intf.implements}", whose method "${expected.name}" ${differs === "is not declared" ? "it does not declare" : `it declares with ${differs}`}.${renamedFrom} An implementation of an extension point declares every method of it with the same signature: ${expected.name}(${(expected.params ?? []).map((p) => `${p.name}${p.optional ? "?" : ""}: ${p.type}`).join(", ")}): ${expected.returns}.`,
+          intf.id,
+          draft,
+          void 0,
+          { at: expected.name }
+        );
+      }
+    }
+  }
+};
+function lastName(name) {
+  return name.split("::").pop().split(".").pop();
+}
+function renamed(expr, rename) {
+  const args = expr.args.map((a) => renamed(a, rename));
+  return expr.form === "named" || expr.form === "applied" ? { ...expr, name: rename(expr.name), args } : { ...expr, args };
+}
+function respelled(text3, rename) {
+  const keep = (name) => isTypeVocabulary(name) ? name : rename(name);
+  const parsed = parseTypeExpression(text3, "returns");
+  if (parsed.expression) return canonicalTypeText(renamed(parsed.expression, keep));
+  return text3.replace(/[A-Za-z_][A-Za-z0-9_-]*(?:(?:::|\.)[A-Za-z_][A-Za-z0-9_-]*)*/g, keep);
+}
+function difference(expected, own2, expectedType, ownType) {
+  const shape = (m, as) => (m.params ?? []).map((p) => `${as(p.type)}${p.optional ? "?" : ""}`).join(", ");
+  const written = (m) => (m.params ?? []).map((p) => `${p.type}${p.optional ? "?" : ""}`).join(", ");
+  if (shape(expected, expectedType) !== shape(own2, ownType)) return `params (${written(own2)}) instead of (${written(expected)})`;
+  if (expectedType(expected.returns) !== ownType(own2.returns)) return `returns ${own2.returns} instead of ${expected.returns}`;
+  return void 0;
+}
+function extensionPoint(ctx, specId, ref) {
+  const resolution = ctx.resolveCrossProject(specId, "implements", ref);
+  if (resolution && resolution.outcome !== "resolved") return void 0;
+  const surface = ctx.resolveSurfaceRef(ref);
+  if (surface.kind === "resolved") {
+    if (surface.entry.role !== "implement") return void 0;
+    const publicNames2 = /* @__PURE__ */ new Map();
+    for (const t of surface.snapshot.exportedTypes ?? []) publicNames2.set(lastName(t.type), t.id);
+    return { methods: surface.entry.methods, publicNames: publicNames2 };
+  }
+  const [alias, name] = ref.split("::");
+  if (name === void 0) return void 0;
+  const bound2 = ctx.projectFamily?.nodes.find((n) => n.namespace === "");
+  const key2 = bound2?.aliases.get(alias);
+  if (key2 === void 0) return void 0;
+  const table = (ctx.exportTables ?? []).find((t) => t.level === "project" && t.owner === key2);
+  const entry = table?.entries.find((e) => e.kind === "component" && e.publicName === name);
+  if (!entry || entry.role !== "implement" || !entry.component) return void 0;
+  const methods = entry.interface ? ctx.interfaceMap.get(entry.interface)?.methods : ctx.interfaceMethodsOf(entry.component);
+  if (!methods) return void 0;
+  const traced2 = methods.map((m) => ({ ...m, formerly: (m.previousNames ?? []).map((k) => k.slice(k.lastIndexOf(".") + 1)) }));
+  const publicNames = /* @__PURE__ */ new Map();
+  for (const e of table?.entries ?? []) {
+    if (e.kind === "type" && e.typeDef) publicNames.set(lastName(e.typeDef), e.publicName);
+  }
+  return { methods: traced2, publicNames };
+}
+function renamedExportMethod(ctx, source) {
+  const dot = source.lastIndexOf(".");
+  if (dot <= 0 || !source.includes("::")) return void 0;
+  const [head2, method] = [source.slice(0, dot), source.slice(dot + 1)];
+  const surface = ctx.resolveSurfaceRef(head2);
+  if (surface.kind === "resolved") return surface.entry.methods.find((m) => (m.formerly ?? []).includes(method))?.name;
+  const [alias, name] = head2.split("::");
+  const key2 = ctx.projectFamily?.nodes.find((n) => n.namespace === "")?.aliases.get(alias);
+  if (key2 === void 0 || name === void 0) return void 0;
+  const entry = (ctx.exportTables ?? []).find((t) => t.level === "project" && t.owner === key2)?.entries.find((e) => e.kind === "component" && e.publicName === name);
+  if (!entry?.component) return void 0;
+  const methods = entry.interface ? ctx.interfaceMap.get(entry.interface)?.methods : ctx.interfaceMethodsOf(entry.component);
+  return methods?.find((m) => (m.previousNames ?? []).some((k) => k.slice(k.lastIndexOf(".") + 1) === method))?.name;
+}
+
 // src/core/rules/integrity/signature-sources.ts
 function draftContext(ctx, interfaceId, component) {
   const intf = ctx.interfaceMap.get(interfaceId);
@@ -21165,17 +21678,20 @@ var signatureSourcesRule = {
       const where = `Method "${fact.method}" on interface "${fact.interfaceId}"`;
       const at = { at: fact.method };
       switch (fact.outcome) {
-        case "unresolved":
+        case "unresolved": {
+          const renamed2 = renamedExportMethod(ctx, fact.source);
+          const rename = renamed2 ? ` It was renamed to "${renamed2}" (the producer's rename trace) \u2014 follow the rename: take it from "${fact.source.slice(0, fact.source.lastIndexOf("."))}.${renamed2}".` : "";
           ctx.addIssue(
             "error",
             "SIGNATURE_SOURCE_UNRESOLVED",
-            `${where} takes its signature from "${fact.source}", which names ${fact.detail ? `no contract method, and ${fact.detail}` : "no contract method and no signature type"}. A source is a \`component.method\` the component reaches, or a type of kind signature.`,
+            `${where} takes its signature from "${fact.source}", which names ${fact.detail ? `no contract method, and ${fact.detail}` : "no contract method and no signature type"}.${rename} A source is a \`component.method\` the component reaches, an exported contract's method (\`alias::name.method\`), or a type of kind signature.`,
             fact.interfaceId,
             isDraft,
             void 0,
             at
           );
           continue;
+        }
         case "ambiguous":
           ctx.addIssue(
             "error",
@@ -21330,12 +21846,12 @@ function draftContext3(ctx, specId, kind) {
   const sub = type?.subsystem ? ctx.subsystems.find((s) => s.id === type.subsystem) : void 0;
   return !!sub && (sub.status === "draft" || sub.status === "design");
 }
-function siteOf(path49) {
-  const [head2, name] = path49.split(".");
-  return (head2 === "methods" || head2 === "fields") && name ? name : path49;
+function siteOf(path50) {
+  const [head2, name] = path50.split(".");
+  return (head2 === "methods" || head2 === "fields") && name ? name : path50;
 }
-function located(kind, specId, path49) {
-  return `${path49 ? `"${path49}" of ` : ""}${kind ?? "spec"} "${specId}"`;
+function located(kind, specId, path50) {
+  return `${path50 ? `"${path50}" of ` : ""}${kind ?? "spec"} "${specId}"`;
 }
 function problemMessage(problem, specId) {
   const where = located(problem.kind, specId, problem.path);
@@ -21616,88 +22132,6 @@ var publicSurfaceConsumersRule = {
   }
 };
 
-// src/core/rules/integrity/implements-contracts.ts
-var implementsContractsRule = {
-  name: "implements-contracts",
-  judges: "design",
-  description: "An interface that declares `implements: alias::name` realizes another project's extension point, so it must declare every method of that contract with the same params and returns, read from the export the reference resolves to (a contained member's live table, or a declared external's pin). Types are compared semantically, never by spelling: the producer's own bare name and the consumer's `alias::name` (or the bare name its `use` imports) are one type. Whether the reference resolves and names an entry exported with role implement is project-boundaries' finding (EXTERNAL_NOT_EXPORTED); this rule judges the shape once it resolves. Extra methods are the implementer's own and are not reported.",
-  codes: [
-    { code: "IMPLEMENTS_MISMATCH", defaultSeverity: "error", summary: "An interface implementing an extension point lacks one of its methods, or declares one with different params or returns" }
-  ],
-  check(ctx) {
-    for (const intf of ctx.interfaces) {
-      if (intf.implements === void 0 || !ctx.isSpecInScope(intf.id)) continue;
-      const point = extensionPoint(ctx, intf.id, intf.implements);
-      if (!point) continue;
-      const { methods: contract, publicNames } = point;
-      const alias = intf.implements.split("::")[0];
-      const expectedType = (t) => respelled(t, (n) => publicNames.get(lastName(n)) ?? lastName(n));
-      const ownType = (t) => respelled(t, (n) => n.startsWith(`${alias}::`) ? lastName(n.slice(alias.length + 2)) : n);
-      const draft = intf.status === "draft" || intf.status === "design" || ctx.isComponentDraft(intf.component);
-      for (const expected of contract) {
-        const own2 = intf.methods.find((m) => m.name === expected.name);
-        const differs = own2 ? difference(expected, own2, expectedType, ownType) : "is not declared";
-        if (!differs) continue;
-        ctx.addIssue(
-          "error",
-          "IMPLEMENTS_MISMATCH",
-          `Interface "${intf.id}" implements "${intf.implements}", whose method "${expected.name}" ${differs === "is not declared" ? "it does not declare" : `it declares with ${differs}`}. An implementation of an extension point declares every method of it with the same signature: ${expected.name}(${(expected.params ?? []).map((p) => `${p.name}${p.optional ? "?" : ""}: ${p.type}`).join(", ")}): ${expected.returns}.`,
-          intf.id,
-          draft,
-          void 0,
-          { at: expected.name }
-        );
-      }
-    }
-  }
-};
-function lastName(name) {
-  return name.split("::").pop().split(".").pop();
-}
-function renamed(expr, rename) {
-  const args = expr.args.map((a) => renamed(a, rename));
-  return expr.form === "named" || expr.form === "applied" ? { ...expr, name: rename(expr.name), args } : { ...expr, args };
-}
-function respelled(text3, rename) {
-  const keep = (name) => isTypeVocabulary(name) ? name : rename(name);
-  const parsed = parseTypeExpression(text3, "returns");
-  if (parsed.expression) return canonicalTypeText(renamed(parsed.expression, keep));
-  return text3.replace(/[A-Za-z_][A-Za-z0-9_-]*(?:(?:::|\.)[A-Za-z_][A-Za-z0-9_-]*)*/g, keep);
-}
-function difference(expected, own2, expectedType, ownType) {
-  const shape = (m, as) => (m.params ?? []).map((p) => `${as(p.type)}${p.optional ? "?" : ""}`).join(", ");
-  const written = (m) => (m.params ?? []).map((p) => `${p.type}${p.optional ? "?" : ""}`).join(", ");
-  if (shape(expected, expectedType) !== shape(own2, ownType)) return `params (${written(own2)}) instead of (${written(expected)})`;
-  if (expectedType(expected.returns) !== ownType(own2.returns)) return `returns ${own2.returns} instead of ${expected.returns}`;
-  return void 0;
-}
-function extensionPoint(ctx, specId, ref) {
-  const resolution = ctx.resolveCrossProject(specId, "implements", ref);
-  if (resolution && resolution.outcome !== "resolved") return void 0;
-  const surface = ctx.resolveSurfaceRef(ref);
-  if (surface.kind === "resolved") {
-    if (surface.entry.role !== "implement") return void 0;
-    const publicNames2 = /* @__PURE__ */ new Map();
-    for (const t of surface.snapshot.exportedTypes ?? []) publicNames2.set(lastName(t.type), t.id);
-    return { methods: surface.entry.methods, publicNames: publicNames2 };
-  }
-  const [alias, name] = ref.split("::");
-  if (name === void 0) return void 0;
-  const bound2 = ctx.projectFamily?.nodes.find((n) => n.namespace === "");
-  const key2 = bound2?.aliases.get(alias);
-  if (key2 === void 0) return void 0;
-  const table = (ctx.exportTables ?? []).find((t) => t.level === "project" && t.owner === key2);
-  const entry = table?.entries.find((e) => e.kind === "component" && e.publicName === name);
-  if (!entry || entry.role !== "implement" || !entry.component) return void 0;
-  const methods = entry.interface ? ctx.interfaceMap.get(entry.interface)?.methods : ctx.interfaceMethodsOf(entry.component);
-  if (!methods) return void 0;
-  const publicNames = /* @__PURE__ */ new Map();
-  for (const e of table?.entries ?? []) {
-    if (e.kind === "type" && e.typeDef) publicNames.set(lastName(e.typeDef), e.publicName);
-  }
-  return { methods, publicNames };
-}
-
 // src/core/rules/integrity/public-surface-bound-contract.ts
 var publicSurfaceBoundContractRule = {
   name: "public-surface-bound-contract",
@@ -23003,11 +23437,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 path49 = [...keys].sort(byCodeUnit).join(" \u2192 ");
+      const path50 = [...keys].sort(byCodeUnit).join(" \u2192 ");
       ctx.addIssue(
         "warning",
         "UNCONDITIONAL_CALL_CYCLE",
-        `Call cycle with no guard: ${path49} \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: ${path50} \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))
       );
@@ -23306,7 +23740,8 @@ var portalsRule = {
               "ENDPOINT_TRANSPORT_MISMATCH",
               `Method "${m.name}" on interface "${intf.id}" declares a "${m.endpoint.transport}" endpoint, but its Portal "${comp.id}" has transport "${comp.transport}" (expects transport "${expected}").`,
               intf.id,
-              isDraftCtx || isIntfDraft
+              // A contradiction, not unfinished work: never downgraded on a draft.
+              false
             );
           }
         }
@@ -25890,7 +26325,9 @@ var eventTopologyRule = {
         "UNCONSUMED_TOPIC",
         `Component "${e.compId}" emits topic "${e.topic}" (${e.vias.join(", ")}), but nothing in this tree subscribes to it \u2014 the event goes nowhere. Wire a subscriber (subscribesTo, or a MessageBus subscribe endpoint), fix the topic name, or lint.allow with the external consumer named.`,
         e.compId,
-        ctx.isComponentDraft(e.compId)
+        ctx.isComponentDraft(e.compId),
+        void 0,
+        { at: e.topic }
       );
     }
     for (const s of subscribers) {
@@ -25900,7 +26337,9 @@ var eventTopologyRule = {
         "UNSOURCED_SUBSCRIPTION",
         `Component "${s.compId}" subscribes to topic "${s.topic}" (${s.vias.join(", ")}), but nothing in this tree emits it \u2014 the handler can never fire from inside this system. Wire the emitter (emits, or a MessageBus publish endpoint), fix the topic name, or lint.allow with the external source named.`,
         s.compId,
-        ctx.isComponentDraft(s.compId)
+        ctx.isComponentDraft(s.compId),
+        void 0,
+        { at: s.topic }
       );
     }
   }
@@ -25914,13 +26353,13 @@ function plannedCode(ctx) {
 var sourceFileLinkageRule = {
   name: "source-file-linkage",
   judges: "code",
-  description: "Code\u2194spec Level 1: every source file an implementation names \u2014 its own sourcePath and each method's \u2014 is checked against the code on disk. A named file that is not on disk is PLANNED (SOURCE_FILE_PLANNED, a notice \u2014 planned, not written yet), at method level as at implementation level and whether or not the implementation's realization has begun: a design names the file a method will live in before the method is written, and code linkage, outside the approval since format 3, costs nothing to declare. Whether the realization has BEGUN (code_index.holdsAny over the files it names: at least one exists) decides only how an unlinked method is reported: before that, an implementation that names no file is unlinked design (MISSING_SOURCE_PATH, a notice), so a design-only tree passes `validate --ci`; once it has begun, a contract method that names no file while others do is unlinked (METHOD_SOURCE_PATH_MISSING, a warning), and a method its named, existing file does not hold is method-realization's UNREALIZED_METHOD. A team that wants CI to demand code for every designed implementation sets rules.conformance.requireCode, which reports the two notices at error, naming the setting. A file that escapes the root or cannot be analyzed is reported once and blocks only the methods realized in it. A run in which TypeScript/JavaScript files were analyzed below exact grade reports that once (CONFORMANCE_DEGRADED). Implementations under chained subsystems (projectPath) validate standalone in their own project run and are skipped here.",
+  description: "Code\u2194spec Level 1: every source file an implementation names \u2014 its own sourcePath and each method's \u2014 is checked against the code on disk. A named file that is not on disk is PLANNED (SOURCE_FILE_PLANNED, a notice \u2014 planned, not written yet), at method level as at implementation level and whether or not the implementation's realization has begun: a design names the file a method will live in before the method is written, and code linkage, outside the approval since format 3, costs nothing to declare. The planned files of one implementation are one notice naming them all, so a planned design reads as one line per component, never one per file. Whether the realization has BEGUN (code_index.holdsAny over the files it names: at least one exists) decides only how an unlinked method is reported: before that, an implementation that names no file is unlinked design (MISSING_SOURCE_PATH, a notice), so a design-only tree passes `validate --ci`; once it has begun, a contract method that names no file while others do is unlinked (METHOD_SOURCE_PATH_MISSING, a warning), and a method its named, existing file does not hold is method-realization's UNREALIZED_METHOD. A team that wants CI to demand code for every designed implementation sets rules.conformance.requireCode, which reports the two notices at error, naming the setting. A file that escapes the root or cannot be analyzed is reported once and blocks only the methods realized in it. A run in which TypeScript/JavaScript files were analyzed below exact grade reports that once (CONFORMANCE_DEGRADED). Implementations under chained subsystems (projectPath) validate standalone in their own project run and are skipped here.",
   codes: [
     { code: "MISSING_SOURCE_PATH", defaultSeverity: "notice", summary: "An implementation whose realization has not begun names no source file (for itself or for some contract methods) \u2014 designed, not linked to code yet; an error under rules.conformance.requireCode" },
     { code: "SOURCE_PATH_ESCAPES_ROOT", defaultSeverity: "error", summary: "A source file an implementation or one of its methods names is absolute or escapes the project root (containment refusal)" },
     { code: "CONFORMANCE_ANALYSIS_SKIPPED", defaultSeverity: "warning", summary: "A source file an implementation or one of its methods names could not be analyzed (binary/unreadable) \u2014 realization of the methods in it was not checked" },
     { code: "CONFORMANCE_DEGRADED", defaultSeverity: "warning", summary: "TypeScript/JavaScript files were analyzed below exact grade (compiler not resolvable) \u2014 dependency conformance skips them" },
-    { code: "SOURCE_FILE_PLANNED", defaultSeverity: "notice", summary: "A source file an implementation or one of its methods names is not on disk \u2014 planned, not written yet, whether or not another file it names exists; method-realization judges the methods in it once it does. An error under rules.conformance.requireCode" },
+    { code: "SOURCE_FILE_PLANNED", defaultSeverity: "notice", summary: "Source files an implementation or its methods name are not on disk \u2014 planned, not written yet, whether or not another file it names exists; one notice per implementation naming every planned file, and method-realization judges the methods in each once it exists. An error under rules.conformance.requireCode" },
     { code: "METHOD_SOURCE_PATH_MISSING", defaultSeverity: "warning", summary: "An implementation whose realization has begun leaves contract methods without a source file \u2014 structural conformance cannot link them to code" }
   ],
   check(ctx) {
@@ -25972,6 +26411,7 @@ var sourceFileLinkageRule = {
         }
       }
       const reported = /* @__PURE__ */ new Set();
+      const plannedFiles = [];
       for (const file of implementationSourceFiles(impl)) {
         const key2 = pathKey(file);
         if (reported.has(key2)) continue;
@@ -25990,13 +26430,7 @@ var sourceFileLinkageRule = {
             draft
           );
         } else if (facts.status === "missing") {
-          ctx.addIssue(
-            planned.severity,
-            "SOURCE_FILE_PLANNED",
-            `${owner} sourcePath "${file}" is planned, not written yet \u2014 method-realization judges the methods in it once it exists${planned.note}.`,
-            impl.id,
-            draft
-          );
+          plannedFiles.push(users.length === 0 ? `"${file}"` : `"${file}" (${users.length === 1 ? "method" : "methods"} ${quoteList(users)})`);
         } else {
           ctx.addIssue(
             "warning",
@@ -26007,6 +26441,16 @@ var sourceFileLinkageRule = {
           );
         }
       }
+      if (plannedFiles.length > 0) {
+        const one = plannedFiles.length === 1;
+        ctx.addIssue(
+          planned.severity,
+          "SOURCE_FILE_PLANNED",
+          `Implementation "${impl.id}" plans ${one ? "a source file" : `${plannedFiles.length} source files`} not written yet: ${plannedFiles.join(", ")} \u2014 method-realization judges the methods in ${one ? "it" : "each"} once it exists${planned.note}.`,
+          impl.id,
+          draft
+        );
+      }
     }
   }
 };
@@ -26420,11 +26864,11 @@ var hiddenStateRule = {
         byPath.set(key2, list);
       }
     }
-    for (const path49 of code.exactPaths) {
-      const facts = code.factsAt(path49);
+    for (const path50 of code.exactPaths) {
+      const facts = code.factsAt(path50);
       const bindings = facts.topLevelMutableBindings ?? [];
       if (bindings.length === 0) continue;
-      const mapped = byPath.get(path49) ?? [];
+      const mapped = byPath.get(path50) ?? [];
       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];
@@ -26441,15 +26885,17 @@ var hiddenStateRule = {
 };
 
 // src/core/rules/conformance/dependency-conformance.ts
+var import_path = require("path");
 var dependencyConformanceRule = {
   name: "dependency-conformance",
   judges: "code",
-  description: "Code\u2194spec Level 2: runtime import edges between component-mapped source files (a component maps to every file its implementations and their methods name) must be justified by declared relations \u2014 a direct dependsOn/owns pair, a shared component, membership in a depended-on pattern, or (across subsystems) a declared edge to the target subsystem's published surface (UNDECLARED_DEPENDENCY). A type-only import alone never accuses \u2014 type coupling is allowed \u2014 but a CALL of a modelled contract method through a collaborator whose declared type comes from another component's file is runtime collaboration whatever the import's form, and the same justification is owed (UNDECLARED_DEPENDENCY on that edge). Conversely, a declared dependsOn/owns edge between components realized in different files should be visible as an import between any file of the source and any file of the target (UNREALIZED_DEPENDENCY \u2014 DI indirection can defeat this, hence warning); a type-only import realizes it, since `import type` is what dependency injection writes down. Two twins of design rules are judged on the same code: a Portal file calling a write- or lifecycle-effect contract method of a Repository, Index, Store or Registry is the persistence shortcut the design rule PORTAL_WRITE_SHORTCUT refuses, unless the Portal's own narrative already claims that call (the design rule's finding then) (PORTAL_WRITE_SHORTCUT_IN_CODE); and a file importing a technology's package \u2014 a bare specifier whose package name is one of the technology's declared tokens (its name, or its `matches` when it declares them), compared exactly, never guessed \u2014 while no component it realizes is that technology's home is the leak TECH_LEAKAGE refuses in the design (TECH_LEAKAGE_IN_CODE). Only exact-grade analyzed files participate; chained subprojects validate standalone.",
+  description: "Code\u2194spec Level 2: runtime import edges between component-mapped source files (a component maps to every file its implementations and their methods name) must be justified by declared relations \u2014 a direct dependsOn/owns pair, a shared component, membership in a depended-on pattern, or (across subsystems) a declared edge to the target subsystem's published surface (UNDECLARED_DEPENDENCY). A type-only import alone never accuses \u2014 type coupling is allowed \u2014 but a CALL of a modelled contract method through a collaborator whose declared type comes from another component's file is runtime collaboration whatever the import's form, and the same justification is owed (UNDECLARED_DEPENDENCY on that edge). Conversely, a declared dependsOn/owns edge between components realized in different files should be visible as an import between any file of the source and any file of the target (UNREALIZED_DEPENDENCY \u2014 DI indirection can defeat this, hence warning); a type-only import realizes it, since `import type` is what dependency injection writes down. An Adapter's edge to a Portal reached over an out-of-process transport (HTTP, gRPC, a bus, a CLI\u2026) is the link the design models: the Adapter's transport client realizes it, never an import, so it is never UNREALIZED_DEPENDENCY \u2014 and nothing asks for an import across that boundary, which would couple two deployables' builds. Two twins of design rules are judged on the same code: a Portal file calling a write- or lifecycle-effect contract method of a Repository, Index, Store or Registry is the persistence shortcut the design rule PORTAL_WRITE_SHORTCUT refuses, unless the Portal's own narrative already claims that call (the design rule's finding then) (PORTAL_WRITE_SHORTCUT_IN_CODE). A receiver is followed through a non-null assertion, parentheses, `satisfies`, a cast to a named type and a local alias or destructuring of a field exactly as through the field itself (a cast to any or unknown says nothing, and is not followed), and a call in a Portal's own file whose receiver the analysis cannot follow at all, under the name of a write- or lifecycle-effect method of a data component in the Portal's own subsystem or one it depends into, is said so rather than passed in silence (PORTAL_CALL_UNRESOLVED). And a file importing a technology's package while no component it realizes is that technology's home is the leak TECH_LEAKAGE refuses in the design (TECH_LEAKAGE_IN_CODE): a technology's packages are its declared tokens (its name, or its `matches`), the curated built-in table of the common packages its name is known by (postgres: pg, postgres, @neondatabase/serverless, @vercel/postgres; mysql: mysql2, mysql; redis: redis, ioredis; mongodb: mongodb, mongoose; sqlite: better-sqlite3, sqlite3; kafka: kafkajs; rabbitmq: amqplib \u2014 an HTTP client is never a technology leak), and the packages a loaded pack contributes for it, each compared exactly with an import's package name. Only exact-grade analyzed files participate; chained subprojects validate standalone.",
   codes: [
     { code: "UNDECLARED_DEPENDENCY", defaultSeverity: "warning", summary: "A runtime import, or a call through a type-only-imported collaborator, between component-mapped files has no declared dependsOn/owns (or published-surface) justification" },
     { code: "PORTAL_WRITE_SHORTCUT_IN_CODE", defaultSeverity: "error", summary: "A Portal's code calls a write- or lifecycle-effect method of a data component (Repository, Index, Store, Registry) directly \u2014 the code twin of PORTAL_WRITE_SHORTCUT: mutations route through an Orchestrator" },
     { code: "TECH_LEAKAGE_IN_CODE", defaultSeverity: "warning", summary: "A source file imports a technology's package although no component it realizes binds that technology \u2014 the code twin of TECH_LEAKAGE" },
-    { code: "UNREALIZED_DEPENDENCY", defaultSeverity: "warning", summary: "A declared dependsOn/owns edge between components in different files is realized by no import between any of their files" }
+    { code: "UNREALIZED_DEPENDENCY", defaultSeverity: "warning", summary: "A declared dependsOn/owns edge between components in different files is realized by no import between any of their files" },
+    { code: "PORTAL_CALL_UNRESOLVED", defaultSeverity: "notice", summary: "A call in a Portal's own file, under the name of a data component's write- or lifecycle-effect method, goes through a receiver the analysis cannot follow at all \u2014 neither proven a shortcut nor cleared, and said so rather than passed in silence" }
   ],
   check(ctx) {
     const code = ctx.codeIndex();
@@ -26493,7 +26939,7 @@ var dependencyConformanceRule = {
       }
       return false;
     };
-    const draftAt = (path49) => realization.implementationsAt(path49).some((impl) => ctx.isImplementationDraft(impl));
+    const draftAt = (path50) => realization.implementationsAt(path50).some((impl) => ctx.isImplementationDraft(impl));
     for (const fromPath of mappedPaths) {
       const fromComponents = realization.componentsAt(fromPath);
       for (const toPath of graph2.importsOf(fromPath)) {
@@ -26515,16 +26961,16 @@ var dependencyConformanceRule = {
       }
     }
     const typeTraces = /* @__PURE__ */ new Map();
-    const typeTracesOf = (path49) => {
-      let out = typeTraces.get(path49);
+    const typeTracesOf = (path50) => {
+      let out = typeTraces.get(path50);
       if (out) return out;
       out = /* @__PURE__ */ new Set();
-      const facts = code.factsAt(path49);
+      const facts = code.factsAt(path50);
       for (const specifier of new Set(Object.values(facts?.typeOnlyBindings ?? {}))) {
-        const to = resolveImport(path49, specifier, mappedPaths, code.packages);
-        if (to && to !== path49) out.add(to);
+        const to = resolveImport(path50, specifier, mappedPaths, code.packages);
+        if (to && to !== path50) out.add(to);
       }
-      typeTraces.set(path49, out);
+      typeTraces.set(path50, out);
       return out;
     };
     const typeConnects = (from, to) => from.some((f) => {
@@ -26539,6 +26985,7 @@ var dependencyConformanceRule = {
       for (const targetId of declaredTargets) {
         const target = ctx.componentMap.get(targetId);
         if (!target) continue;
+        if (component.componentType === "Adapter" && target.componentType === "Portal" && target.transport !== void 0 && target.transport !== "InProcess") continue;
         const crossSubsystem = component.subsystem !== target.subsystem;
         const toFiles = crossSubsystem ? realization.filesIn(target.subsystem).filter((p) => isExact(p) && !fromFiles.includes(p)) : filesOf(targetId);
         if (toFiles.length === 0) continue;
@@ -26594,12 +27041,44 @@ var dependencyConformanceRule = {
         if (!specifier) continue;
         const toPath = resolveImport(scope, specifier, mappedPaths, code.packages);
         if (toPath && toPath !== scope) out.push({ toPath, typeOnly: typeOnly !== void 0 });
+        const declaredAt = resolveImport(scope, specifier, code.paths, code.packages) ?? (specifier.startsWith(".") ? import_path.posix.join(import_path.posix.dirname(scope), specifier) : void 0);
+        const published = importBindingOf(facts, typeName)?.imported ?? typeName;
+        if (declaredAt) {
+          for (const implementor of code.implementorsOf(declaredAt, published)) {
+            if (mappedPaths.has(implementor) && implementor !== scope) out.push({ toPath: implementor, typeOnly: typeOnly !== void 0 });
+          }
+        }
       }
       return out;
     };
+    const unfollowable = (site, file) => {
+      const facts = code.factsAt(pathKey(site.from ?? file));
+      if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") return false;
+      if (site.field) return fieldTypesOf(facts, site.field).length === 0;
+      if (site.via) return !importBindingOf(facts, site.via) && localTypesOf(facts, site.via).length === 0;
+      return !site.constructed && !site.returnedBy && !site.enclosingClass && !site.receiverPath;
+    };
+    const dataWrites = /* @__PURE__ */ new Map();
+    for (const c of ctx.components) {
+      if (!DATA_COMPONENTS2.has(c.componentType)) continue;
+      for (const m of ctx.interfaceMethodsOf(c.id)) {
+        if (m.effect !== "write" && m.effect !== "lifecycle") continue;
+        const names = /* @__PURE__ */ new Set([m.name]);
+        for (const impl of realization.implementationsOf(c.id)) {
+          const bound2 = impl.methods.find((x) => x.name === m.name)?.symbol;
+          if (bound2) names.add(bound2);
+        }
+        for (const name of names) {
+          const list = dataWrites.get(name) ?? [];
+          list.push({ component: c.id, method: m.name });
+          dataWrites.set(name, list);
+        }
+      }
+    }
     const calledAt = (toPath, name) => realization.componentsAt(toPath).map((c) => ({ component: c, method: calledMethodOf(c.id, name) })).filter((c) => c.method !== void 0);
     const reportedEdges = /* @__PURE__ */ new Set();
     const reportedWrites = /* @__PURE__ */ new Set();
+    const reportedUnresolved = /* @__PURE__ */ new Set();
     for (const fromPath of mappedPaths) {
       const facts = code.factsAt(fromPath);
       const fromComponents = realization.componentsAt(fromPath);
@@ -26612,6 +27091,23 @@ var dependencyConformanceRule = {
             for (const site of sites) {
               if (!site.member || pathKey(site.from ?? fromPath) !== fromPath) continue;
               const landings = /* @__PURE__ */ new Set([...typedLandings(site, fromPath).map((l) => l.toPath), ...code.originOf(site, fromPath)]);
+              if (landings.size === 0 && unfollowable(site, fromPath)) {
+                const near = /* @__PURE__ */ new Set([portal.subsystem, ...portal.dependsOn.map((d) => ctx.componentMap.get(d)?.subsystem)]);
+                const candidates = (dataWrites.get(site.name) ?? []).filter((w) => near.has(ctx.componentMap.get(w.component)?.subsystem) && !claims(portal.id, w.component, w.method));
+                const at = `${fromPath} -> ${site.name}`;
+                if (candidates.length > 0 && !reportedUnresolved.has(at)) {
+                  reportedUnresolved.add(at);
+                  ctx.addIssue(
+                    "notice",
+                    "PORTAL_CALL_UNRESOLVED",
+                    `Portal "${portal.id}": its method "${method.name}" in "${fromPath}" calls \`${site.via ?? (site.field ? `this.${site.field}` : "<receiver>")}.${site.name}(\u2026)\` through a receiver this analysis cannot follow (nothing in the file declares its type), and ${candidates.map((w) => `${w.component}.${w.method}`).join(", ")} \u2014 a data component's write \u2014 carries that name. Neither proven a persistence shortcut nor cleared: give the receiver a declared type (a field or parameter annotation) so the call can be judged.`,
+                    impl.id,
+                    draftAt(fromPath),
+                    void 0,
+                    { at }
+                  );
+                }
+              }
               for (const toPath of landings) {
                 if (toPath === fromPath) continue;
                 for (const { component: target, method: called } of calledAt(toPath, site.name)) {
@@ -26672,7 +27168,7 @@ var dependencyConformanceRule = {
       const facade = ownerOf4.get(owner.id);
       if (facade) members.add(facade.id);
       for (const technology of technologies) {
-        for (const token of technologyTokens(technology)) {
+        for (const token of technologyPackages(technology, ctx.ext.technologyPackages)) {
           const key2 = token.toLowerCase();
           const entry = homes.get(key2) ?? { label: technologyName(technology), home: /* @__PURE__ */ new Set() };
           for (const id of members) entry.home.add(id);
@@ -26740,7 +27236,7 @@ var portalImportsRule = {
       }
       return files;
     };
-    const draftAt = (path49) => realization.implementationsAt(path49).some((impl) => ctx.isImplementationDraft(impl));
+    const draftAt = (path50) => realization.implementationsAt(path50).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 graph2.importsOf(fromPath)) {
@@ -26983,20 +27479,48 @@ function ownerOf2(type, file) {
 var typeRealizationRule = {
   name: "type-realization",
   judges: "code",
-  description: "Code\u2194spec Level 1 for the data model: a type that names a sourcePath is claiming code. Until that claim has BEGUN (code_index.holdsAny over the type's own file and its methods' files) a named file that is not on disk is PLANNED (SOURCE_FILE_PLANNED, a notice; an error under rules.conformance.requireCode). Once it has begun, every file it names must resolve to a real, readable file inside the project root (MISSING_SOURCE_FILE, an error, otherwise), its file must PUBLISH its declaration (an exported name at exact grade, the declaration tier below it, under its `symbol` when the code-level name differs from the type's name \u2014 and a pure re-export barrel publishes nothing of its own, so a claim on one is never realized), and each of its pure methods must appear in its own file (the method's sourcePath, else the type's) at the declaration tier, under the method's `symbol`, else the method's name. A type that names no sourcePath claims nothing and is never reported. Findings carry the analysis grade, a file that escapes the root or could not be analyzed is reported once and blocks only what it would have realized, and types under chained subsystems (projectPath) validate standalone in their own project run.",
+  description: "Code\u2194spec Level 1 for the data model: a type that names a sourcePath is claiming code. Until that claim has BEGUN (code_index.holdsAny over the type's own file and its methods' files) a named file that is not on disk is PLANNED (SOURCE_FILE_PLANNED, a notice; an error under rules.conformance.requireCode). Once it has begun, every file it names must resolve to a real, readable file inside the project root (MISSING_SOURCE_FILE, an error, otherwise), its file must PUBLISH its declaration (an exported name at exact grade, the declaration tier below it, under its `symbol` when the code-level name differs from the type's name \u2014 and a pure re-export barrel publishes nothing of its own, so a claim on one is never realized), and each of its pure methods must appear in its own file (the method's sourcePath, else the type's) at the declaration tier, under the method's `symbol`, else the method's name. A type that names no sourcePath of its own claims no code, so nothing ever compares its shape with the code \u2014 and that is said, never left silent: before the code of the type's subsystem has begun (no file an implementation of that subsystem names exists; for a type no subsystem owns, no file of any implementation) it is unlinked design (MISSING_TYPE_SOURCE_PATH, a notice \u2014 plan the type's sourcePath with the implementations'), and once that code exists it is a type no check reads (a warning). rules.conformance.requireCode reports the notice at error, naming the setting. Findings carry the analysis grade, a file that escapes the root or could not be analyzed is reported once and blocks only what it would have realized, and types under chained subsystems (projectPath) validate standalone in their own project run.",
   codes: [
     { code: "UNREALIZED_TYPE", defaultSeverity: "warning", summary: "A type names a sourcePath but its declaration is nowhere in that file \u2014 the claim points at code that does not hold it" },
     { code: "UNREALIZED_TYPE_METHOD", defaultSeverity: "warning", summary: "A pure method of a claimed type is nowhere in its own source file (the method's sourcePath, else the type's)" },
     { code: "MISSING_SOURCE_FILE", defaultSeverity: "error", summary: "A source file a type or one of its methods names does not resolve to a file on disk although the type's realization has begun (another file it names exists)" },
     { code: "SOURCE_PATH_ESCAPES_ROOT", defaultSeverity: "error", summary: "A source file a type or one of its methods names is absolute or escapes the project root (containment refusal)" },
     { code: "CONFORMANCE_ANALYSIS_SKIPPED", defaultSeverity: "warning", summary: "A source file a type or one of its methods names could not be analyzed (binary/unreadable) \u2014 what it would have realized was not checked" },
-    { code: "SOURCE_FILE_PLANNED", defaultSeverity: "notice", summary: "A source file a type names is not on disk and none of its named files is \u2014 planned, not written yet; an error under rules.conformance.requireCode" }
+    { code: "SOURCE_FILE_PLANNED", defaultSeverity: "notice", summary: "A source file a type names is not on disk and none of its named files is \u2014 planned, not written yet; an error under rules.conformance.requireCode" },
+    { code: "MISSING_TYPE_SOURCE_PATH", defaultSeverity: "notice", summary: "A type names no sourcePath of its own, so its shape is never compared with code \u2014 a notice while its subsystem has no code yet (plan the path with the implementations'), a warning once it has; an error under rules.conformance.requireCode" }
   ],
   check(ctx) {
     const code = ctx.codeIndex();
+    const begunIn = /* @__PURE__ */ new Map();
+    const codeBegunFor = (subsystem) => {
+      const key2 = subsystem ?? "";
+      let begun = begunIn.get(key2);
+      if (begun === void 0) {
+        begun = ctx.implementations.some((impl) => {
+          if (subsystem !== void 0) {
+            const owner = ctx.componentMap.get(ctx.interfaceMap.get(impl.contract)?.component ?? "");
+            if (owner?.subsystem !== subsystem) return false;
+          }
+          return code.holdsAny(implementationSourceFiles(impl));
+        });
+        begunIn.set(key2, begun);
+      }
+      return begun;
+    };
     for (const type of ctx.types) {
-      if (!type.sourcePath) continue;
       if (type.subsystem && ctx.isInChainedSubproject(type.subsystem)) continue;
+      if (!type.sourcePath) {
+        const begunHere = codeBegunFor(type.subsystem);
+        const planned = plannedCode(ctx);
+        const methods = typeSourceFiles(type).length > 0 ? " (only its methods name files)" : "";
+        ctx.addIssue(
+          begunHere ? "warning" : planned.severity,
+          "MISSING_TYPE_SOURCE_PATH",
+          begunHere ? `Type "${type.id}" names no sourcePath of its own${methods}, and the code of ${type.subsystem ? `subsystem "${type.subsystem}"` : "this project"} exists \u2014 so nothing compares its fields with the code: it is data no check reads. Name the file that declares it (sourcePath, and symbol when the code name differs).` : `Type "${type.id}" names no sourcePath of its own${methods} \u2014 designed, not linked to code yet, so its shape will never be compared with the code. Plan its sourcePath now, with the implementations': code linkage is not part of the approval, so it costs no re-lock${planned.note}.`,
+          type.id
+        );
+        continue;
+      }
       const blocked3 = /* @__PURE__ */ new Set();
       const begun = code.holdsAny(typeSourceFiles(type));
       for (const file of typeSourceFiles(type)) {
@@ -28203,7 +28727,7 @@ function contractIdentifiers(m) {
 var technologyRule = {
   name: "technology-boundaries",
   judges: "design",
-  description: "Technology stays behind its owning boundary: an L4 that declares `technologies` (e.g. [mysql]) makes its component's ownership tree the technology's home. References outside that tree are leakage, and L3 contract identifiers must stay intent-language \u2014 the contract is the swap seam, so the vendor name is wrong even on the owning component's own interface. A technology is matched by its name, or \u2014 when it declares `matches` because its name is also an ordinary word of the tree (a package named after the file format it reads) \u2014 by those tokens alone.",
+  description: "Technology stays behind its owning boundary: an L4 that declares `technologies` (e.g. [mysql]) makes its component's ownership tree the technology's home. References outside that tree are leakage, and L3 contract identifiers must stay intent-language \u2014 the contract is the swap seam, so the vendor name is wrong even on the owning component's own interface. A technology is matched by its name, or \u2014 when it declares `matches` because its name is also an ordinary word of the tree (a package named after the file format it reads) \u2014 by those tokens alone. Two declarations of one technology are one home whichever notation each is written in: a component binding it as a bare name and one binding it as `{name, matches}` are both inside it, even when one form's tokens police nothing.",
   codes: [
     { code: "TECH_LEAKAGE", defaultSeverity: "warning", summary: "Technology referenced outside its owning boundary" },
     { code: "VENDOR_NAME_IN_CONTRACT", defaultSeverity: "warning", summary: "Technology name in L3 contract identifiers" }
@@ -28268,7 +28792,6 @@ var technologyRule = {
     const homes = /* @__PURE__ */ new Map();
     for (const { comp, name, tokens } of declarations) {
       const matchers = tokens.map(makeMatcher).filter((m) => m !== null);
-      if (!matchers.length) continue;
       const key2 = name.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean).join("");
       const home = homes.get(key2) ?? newHome(name);
       home.matchers.push(...matchers);
@@ -28276,6 +28799,7 @@ var technologyRule = {
       for (const id of scopeOf2(comp)) home.scope.add(id);
       homes.set(key2, home);
     }
+    for (const [key2, home] of homes) if (home.matchers.length === 0) homes.delete(key2);
     if (homes.size === 0) return;
     const ownersDesc = (h) => [...h.ownerComponents].map((c) => `"${c}"`).join(", ");
     for (const home of homes.values()) {
@@ -28421,10 +28945,25 @@ function getBaseId(id) {
   return parts[parts.length - 1];
 }
 var isAllUppercase = (s) => /^[A-Z0-9_]+$/.test(s);
+function implementedNames(ctx, ref) {
+  if (ref === void 0) return /* @__PURE__ */ new Set();
+  const surface = ctx.resolveSurfaceRef(ref);
+  if (surface.kind === "resolved") {
+    return surface.entry.role === "implement" ? new Set(surface.entry.methods.map((m) => m.name)) : /* @__PURE__ */ new Set();
+  }
+  const [alias, name] = ref.split("::");
+  if (name === void 0) return /* @__PURE__ */ new Set();
+  const key2 = ctx.projectFamily?.nodes.find((n) => n.namespace === "")?.aliases.get(alias);
+  if (key2 === void 0) return /* @__PURE__ */ new Set();
+  const entry = (ctx.exportTables ?? []).find((t) => t.level === "project" && t.owner === key2)?.entries.find((e) => e.kind === "component" && e.publicName === name);
+  if (!entry || entry.role !== "implement" || !entry.component) return /* @__PURE__ */ new Set();
+  const methods = entry.interface ? ctx.interfaceMap.get(entry.interface)?.methods : ctx.interfaceMethodsOf(entry.component);
+  return new Set((methods ?? []).map((m) => m.name));
+}
 var namingRule = {
   name: "naming-conventions",
   judges: "design",
-  description: "Enforces naming conventions (casing styles or regular expressions) for subsystem, component, interface, type (differentiating entities and value-objects), method, variables/parameters, fields, and constants names/IDs, plus stereotype-specific naming patterns. A method name is judged by naming_rule_config.methodCasingFor the subsystem's effective targetLanguage: the configured methods casing when set, else the language's own convention, so a Rust tree is snake_case without configuring anything, and the authoring and rename tools accept exactly what this rule accepts.",
+  description: "Enforces naming conventions (casing styles or regular expressions) for subsystem, component, interface, type (differentiating entities and value-objects), method, variables/parameters, fields, and constants names/IDs, plus stereotype-specific naming patterns. A method name is judged by naming_rule_config.methodCasingFor the subsystem's effective targetLanguage: the configured methods casing when set, else the language's own convention, so a Rust tree is snake_case without configuring anything, and the authoring and rename tools accept exactly what this rule accepts. A contract that implements another project's extension point (`implements`) takes the names of the methods it implements \u2014 and of their parameters \u2014 from the producer, whose language they are spelled in: those methods, on the contract and on its implementations, are exempt from the casing rule, and the rename tools accept them.",
   codes: [
     { code: "NAMING_CONVENTION_VIOLATION", defaultSeverity: "warning", summary: "Item name or ID does not match the configured casing pattern or regex" },
     { code: "STEREOTYPE_NAMING_VIOLATION", defaultSeverity: "warning", summary: "Component name or ID does not match stereotype suffix/prefix/regex rules" },
@@ -28508,7 +29047,9 @@ var namingRule = {
         checkNamedValue(ctx, intf.name, namingConfig.interfaces, `Interface Name "${intf.name}" does not match naming convention "${namingConfig.interfaces}".`, intf.id, isDraft);
       }
       const methodCasing = methodCasingFor(namingConfig, ctx.targetLanguageFor(comp?.subsystem));
+      const dictated = implementedNames(ctx, intf.implements);
       for (const m of intf.methods) {
+        if (dictated.has(m.name)) continue;
         checkNamedValue(ctx, m.name, methodCasing, `Interface method "${m.name}" on "${intf.id}" does not match naming convention "${methodCasing}"${namingConfig?.methods ? "" : " (its target language's convention)"}.`, intf.id, isDraft);
         if (namingConfig?.variables) {
           for (const param of m.params ?? []) {
@@ -28523,7 +29064,9 @@ var namingRule = {
       const namingConfig = ctx.namingConfigFor(comp?.subsystem);
       const isDraft = ctx.isImplementationDraft(impl);
       const methodCasing = methodCasingFor(namingConfig, ctx.targetLanguageFor(comp?.subsystem));
+      const dictated = implementedNames(ctx, intf?.implements);
       for (const m of impl.methods) {
+        if (dictated.has(m.name)) continue;
         checkNamedValue(ctx, m.name, methodCasing, `Implementation method "${m.name}" on "${impl.id}" does not match naming convention "${methodCasing}".`, impl.id, isDraft);
       }
     }
@@ -29502,7 +30045,8 @@ function walkExact(ts, sourceText, fileName) {
   const fieldTypes = /* @__PURE__ */ new Map();
   const localTypes = /* @__PURE__ */ new Map();
   const memberTypes = /* @__PURE__ */ new Map();
-  const aliasTargets = /* @__PURE__ */ new Map();
+  const aliasTargets2 = /* @__PURE__ */ new Map();
+  const implementsClauses = /* @__PURE__ */ new Map();
   const typeShapes = /* @__PURE__ */ new Map();
   const functionParams = /* @__PURE__ */ new Map();
   const functionRoutes = /* @__PURE__ */ new Map();
@@ -29561,7 +30105,13 @@ function walkExact(ts, sourceText, fileName) {
   const typeReferenceName = (type) => {
     let at = type;
     for (let depth = 0; at && depth < 4; depth++) {
-      if (!ts.isTypeReferenceNode(at) || !ts.isIdentifier(at.typeName)) return void 0;
+      while (at && ts.isParenthesizedTypeNode(at)) at = at.type;
+      if (at && ts.isUnionTypeNode(at)) {
+        const present = at.types.filter((t) => !(t.kind === ts.SyntaxKind.UndefinedKeyword || t.kind === ts.SyntaxKind.NullKeyword || ts.isLiteralTypeNode(t) && t.literal.kind === ts.SyntaxKind.NullKeyword));
+        if (present.length !== 1) return void 0;
+        at = present[0];
+      }
+      if (!at || !ts.isTypeReferenceNode(at) || !ts.isIdentifier(at.typeName)) return void 0;
       const name = at.typeName.text;
       if (!MEMBER_PRESERVING.has(name) || !at.typeArguments?.length) return name;
       at = at.typeArguments[0];
@@ -29756,6 +30306,29 @@ function walkExact(ts, sourceText, fileName) {
     const addSite = (site) => {
       callees.set(siteKey(site), site);
     };
+    const namedCast = (type) => ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName);
+    const unwrapped = (expression) => {
+      let at = expression;
+      while (ts.isNonNullExpression(at) || ts.isParenthesizedExpression(at) || typeof ts.isSatisfiesExpression === "function" && ts.isSatisfiesExpression(at) || (ts.isAsExpression(at) || ts.isTypeAssertionExpression(at)) && namedCast(at.type)) at = at.expression;
+      return at;
+    };
+    const fieldAliases = /* @__PURE__ */ new Map();
+    const collectAliases = (node) => {
+      if (ts.isVariableDeclaration(node) && node.initializer) {
+        const init = unwrapped(node.initializer);
+        if (ts.isIdentifier(node.name) && ts.isPropertyAccessExpression(init) && unwrapped(init.expression).kind === ts.SyntaxKind.ThisKeyword && ts.isIdentifier(init.name)) {
+          fieldAliases.set(node.name.text, init.name.text);
+        } else if (ts.isObjectBindingPattern(node.name) && init.kind === ts.SyntaxKind.ThisKeyword) {
+          for (const element of node.name.elements) {
+            if (element.dotDotDotToken || !ts.isIdentifier(element.name)) continue;
+            const property = element.propertyName ? propertyNameText(element.propertyName) : element.name.text;
+            if (property) fieldAliases.set(element.name.text, property);
+          }
+        }
+      }
+      ts.forEachChild(node, collectAliases);
+    };
+    if (fn.body) collectAliases(fn.body);
     const count = (node) => {
       if (namedFunctionName(node) !== void 0) return;
       if (ts.isIfStatement(node) || ts.isConditionalExpression(node) || ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node) || ts.isWhileStatement(node) || ts.isDoStatement(node) || ts.isCaseClause(node) || ts.isCatchClause(node)) {
@@ -29769,10 +30342,12 @@ function walkExact(ts, sourceText, fileName) {
         const callee = node.expression;
         if (ts.isIdentifier(callee)) addSite({ name: callee.text, member: false });
         else if (ts.isPropertyAccessExpression(callee)) {
-          const receiver = callee.expression;
+          const receiver = unwrapped(callee.expression);
           const name = callee.name.text;
-          if (ts.isIdentifier(receiver)) addSite({ name, member: true, via: receiver.text });
-          else if (ts.isPropertyAccessExpression(receiver) && receiver.expression.kind === ts.SyntaxKind.ThisKeyword) {
+          if (ts.isIdentifier(receiver) && fieldAliases.has(receiver.text)) {
+            addSite({ name, member: true, field: fieldAliases.get(receiver.text) });
+          } else if (ts.isIdentifier(receiver)) addSite({ name, member: true, via: receiver.text });
+          else if (ts.isPropertyAccessExpression(receiver) && unwrapped(receiver.expression).kind === ts.SyntaxKind.ThisKeyword) {
             addSite({ name, member: true, field: receiver.name.text });
           } else if (ts.isNewExpression(receiver) && ts.isIdentifier(receiver.expression)) {
             addSite({ name, member: true, constructed: receiver.expression.text });
@@ -29786,7 +30361,7 @@ function walkExact(ts, sourceText, fileName) {
             let at = receiver;
             while (ts.isPropertyAccessExpression(at) && !at.questionDotToken && ts.isIdentifier(at.name)) {
               chain.unshift(at.name.text);
-              at = at.expression;
+              at = unwrapped(at.expression);
             }
             if (ts.isIdentifier(at)) chain.unshift(at.text);
             else if (at.kind === ts.SyntaxKind.ThisKeyword) chain.unshift("this");
@@ -29944,13 +30519,15 @@ function walkExact(ts, sourceText, fileName) {
         (clause) => clause.token === ts.SyntaxKind.ExtendsKeyword
       );
       recordDeclaredShape(node.name.text, node.members, extendsOther);
+      const implemented = (node.heritageClauses ?? []).filter((clause) => clause.token === ts.SyntaxKind.ImplementsKeyword).flatMap((clause) => clause.types.map((t) => ts.isIdentifier(t.expression) ? t.expression.text : void 0)).filter((name) => name !== void 0);
+      if (implemented.length > 0 && !implementsClauses.has(node.name.text)) implementsClauses.set(node.name.text, implemented);
     } else if (ts.isTypeAliasDeclaration(node)) {
       if (ts.isTypeLiteralNode(node.type)) recordDeclaredShape(node.name.text, node.type.members, false);
       else {
         if (!aliasTypes.has(node.name.text)) aliasTypes.set(node.name.text, node.type.getText(sf));
         const named2 = typeReferenceName(node.type);
-        if (named2 !== void 0 && named2 !== node.name.text && !aliasTargets.has(node.name.text)) {
-          aliasTargets.set(node.name.text, named2);
+        if (named2 !== void 0 && named2 !== node.name.text && !aliasTargets2.has(node.name.text)) {
+          aliasTargets2.set(node.name.text, named2);
         }
         const constant = inferredSchemaConstant(node.type);
         if (constant) derivedAliases.push({ name: node.name.text, constant });
@@ -30117,7 +30694,7 @@ function walkExact(ts, sourceText, fileName) {
     importBindings.set(name, fact);
   }
   for (const alias of propertyAliases) if (exported.has(alias.container)) exportAliases.push(alias);
-  return { declared, anchors, exported, imports, reexports, starExports, namedReexports, exportAliases, returnTypes, complexity, calls, bodies, importBindings, typeOnlyBindings, fieldTypes, localTypes, memberTypes, aliasTargets, typeShapes, functionParams, functionRoutes, asyncFunctions, enumValues, aliasTypes, mutableBindings, reexportOnly };
+  return { declared, anchors, exported, imports, reexports, starExports, namedReexports, exportAliases, returnTypes, complexity, calls, bodies, importBindings, typeOnlyBindings, fieldTypes, localTypes, memberTypes, aliasTargets: aliasTargets2, implementsClauses, typeShapes, functionParams, functionRoutes, asyncFunctions, enumValues, aliasTypes, mutableBindings, reexportOnly };
 }
 var NO_PACKAGES = /* @__PURE__ */ new Map();
 function resolveModule(fromFile, specifier, packages) {
@@ -30491,6 +31068,7 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
             localTypes: Object.fromEntries([...facts.localTypes].map(([k, v]) => [k, [...v]])),
             memberTypes: Object.fromEntries([...facts.memberTypes].map(([k, v]) => [k, [...v]])),
             aliasTargets: Object.fromEntries(facts.aliasTargets),
+            ...facts.implementsClauses.size > 0 ? { implementsClauses: Object.fromEntries(facts.implementsClauses) } : {},
             typeShapes: Object.fromEntries(facts.typeShapes),
             functionParams: Object.fromEntries(facts.functionParams),
             functionRoutes: Object.fromEntries([...facts.functionRoutes].map(([k, v]) => [k, [...v.values()]])),
@@ -30674,6 +31252,8 @@ var DEPTH_GATED_CODES = {
   // L4 expectations: implementations and their code linkage.
   MISSING_IMPLEMENTATION_METHOD: "implementations",
   MISSING_SOURCE_PATH: "implementations",
+  MISSING_TYPE_SOURCE_PATH: "implementations",
+  PORTAL_CALL_UNRESOLVED: "implementations",
   METHOD_SOURCE_PATH_MISSING: "implementations",
   SOURCE_FILE_PLANNED: "implementations",
   PORTAL_AUTH_UNMET: "implementations",
@@ -30715,6 +31295,7 @@ var COMPLETENESS_RULES = /* @__PURE__ */ new Set([
   // Structural conformance: a draft tree is allowed to name code that does
   // not exist yet — the findings gate only once the specs claim completeness.
   "MISSING_SOURCE_PATH",
+  "MISSING_TYPE_SOURCE_PATH",
   "METHOD_SOURCE_PATH_MISSING",
   "MISSING_SOURCE_FILE",
   "SOURCE_FILE_PLANNED",
@@ -31342,7 +31923,7 @@ function buildRuleContext(opts) {
     documentationConfigFor,
     namingConfigFor,
     isBuiltinType,
-    ext: { profiles: extensions.profiles, languages: extensions.languages, patterns: extensions.patterns, guarantees: extensions.guarantees, assertions: extensions.assertions, packSelections: opts.packSelections ?? [], selectionFailures: extensions.selectionFailures ?? [], packRequirements: opts.packRequirements ?? [], deprecations: extensions.deprecations ?? [] },
+    ext: { profiles: extensions.profiles, languages: extensions.languages, patterns: extensions.patterns, guarantees: extensions.guarantees, technologyPackages: extensions.technologyPackages ?? {}, assertions: extensions.assertions, packSelections: opts.packSelections ?? [], selectionFailures: extensions.selectionFailures ?? [], packRequirements: opts.packRequirements ?? [], deprecations: extensions.deprecations ?? [] },
     variants: opts.variants ?? [],
     surfaceSnapshots,
     ...opts.projectIdentity ? { projectIdentity: opts.projectIdentity } : {},
@@ -32905,11 +33486,22 @@ function crossReferences(family, specs) {
   for (const ref of family.authoredReferences) {
     if (ref.position === "type") addRaw(ref, "type");
     else if (ref.position === "auth") addRaw(ref, "auth");
-    else if (ref.position === "implements") addRaw(ref, "implements");
-    else if (ref.position === "calls") addRaw(ref, "calls", calledMethod.get(`${ref.specId}|${ref.authored}`), callerOf2.get(ref.specId));
+    else if (ref.position === "implements") {
+      for (const method of implementedMethods(ref.specId, ref.authored)) addRaw(ref, "implements", method);
+    } else if (ref.position === "calls") addRaw(ref, "calls", calledMethod.get(`${ref.specId}|${ref.authored}`), callerOf2.get(ref.specId));
   }
   return out;
 }
+function implementedMethods(interfaceId, implemented) {
+  const intf = loadInterfaceSpecs().find((i) => i.id === interfaceId);
+  const out = /* @__PURE__ */ new Set();
+  for (const method of intf?.methods ?? []) {
+    const source = method.signatureFrom;
+    const dot = source?.lastIndexOf(".") ?? -1;
+    out.add(source !== void 0 && dot > 0 && source.slice(0, dot) === implemented ? source.slice(dot + 1) : method.name);
+  }
+  return [...out];
+}
 function projectFamilyGraph() {
   const roots = listProjectRoots();
   const cached = memo.get(roots);
@@ -32943,9 +33535,12 @@ function projectFamilyGraph() {
 // src/core/exports.ts
 var CONSUMABLE = /* @__PURE__ */ new Set(["Portal", "Observer"]);
 var IMPLEMENTABLE = /* @__PURE__ */ new Set(["Portal", "Adapter"]);
-function exportKindOf(comp, authored) {
+function exportKindOf(comp, authored, role) {
   if (comp.componentType === "Portal" && comp.transport === "InProcess") return "InProcess";
   if (comp.componentType === "Portal" && comp.transport) return transportExportKind(comp.transport);
+  if (role === "implement" && comp.componentType === "Adapter") {
+    return !comp.transport || comp.transport === "InProcess" ? "InProcess" : transportExportKind(comp.transport);
+  }
   return authored;
 }
 function localName2(id) {
@@ -33117,7 +33712,7 @@ function bindOwn(world, sub, pi, problems) {
     component: comp.id,
     ...narrowed2 ? { interface: narrowed2 } : {},
     componentType: comp.componentType,
-    ...exportKindOf(comp, pi.type) ? { type: exportKindOf(comp, pi.type) } : {},
+    ...exportKindOf(comp, pi.type, pi.role) ? { type: exportKindOf(comp, pi.type, pi.role) } : {},
     ...pi.details !== void 0 ? { details: pi.details } : {},
     ...pi.role ? { role: pi.role } : {},
     via: []
@@ -33470,7 +34065,8 @@ function exportUsageOf(consumer, producer) {
       unexported.push(ref);
       continue;
     }
-    const slot = used.get(entry.publicName) ?? { kind: entry.kind, members: /* @__PURE__ */ new Set() };
+    const slot = used.get(entry.publicName) ?? { kind: entry.kind, members: /* @__PURE__ */ new Set(), specs: /* @__PURE__ */ new Set() };
+    slot.specs.add(ref.specId);
     if (entry.kind === "type") slot.members.add("type");
     else if (ref.member !== void 0) slot.members.add(ref.member);
     used.set(entry.publicName, slot);
@@ -33478,7 +34074,7 @@ function exportUsageOf(consumer, producer) {
   return {
     consumer,
     producer,
-    used: [...used.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([publicName, u]) => ({ publicName, kind: u.kind, members: [...u.members].sort() })),
+    used: [...used.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([publicName, u]) => ({ publicName, kind: u.kind, members: [...u.members].sort(), specs: [...u.specs].sort() })),
     unexported
   };
 }
@@ -33488,6 +34084,7 @@ function importedName(authored, use) {
 }
 function membersAt(ref) {
   if (ref.position === "type") return ["type"];
+  if (ref.position === "implements") return implementedMethods(ref.specId, ref.authored);
   if (ref.position === "narrative" || ref.position === "calls") {
     const impl = loadImplementationSpecs().find((i) => i.id === ref.specId);
     const out = [];
@@ -33520,14 +34117,15 @@ function pinnedUsageOf(consumer, alias) {
   const used = /* @__PURE__ */ new Map();
   for (const ref of through) {
     const publicName = ref.form === "import" ? importedName(ref.authored, use) : ref.authored.slice(alias.length + 2);
-    const slot = used.get(publicName) ?? { kind: ref.position === "type" ? "type" : "component", members: /* @__PURE__ */ new Set() };
+    const slot = used.get(publicName) ?? { kind: ref.position === "type" ? "type" : "component", members: /* @__PURE__ */ new Set(), specs: /* @__PURE__ */ new Set() };
+    slot.specs.add(ref.specId);
     for (const member of membersAt(ref)) slot.members.add(member);
     used.set(publicName, slot);
   }
   return {
     consumer,
     producer: alias,
-    used: [...used.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([publicName, u]) => ({ publicName, kind: u.kind, members: [...u.members].sort() })),
+    used: [...used.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([publicName, u]) => ({ publicName, kind: u.kind, members: [...u.members].sort(), specs: [...u.specs].sort() })),
     unexported: []
   };
 }
@@ -33697,7 +34295,8 @@ var UNKNOWN_KEY_HINTS = {
   "system.exports": "The L0 export table is `publicInterfaces` (sdd_set_public_interfaces writes it).",
   "system.export": "The L0 export table is `publicInterfaces` (sdd_set_public_interfaces writes it).",
   "subsystem.exports": "A subsystem publishes through `publicInterfaces`.",
-  "component.type": "A component's stereotype is `componentType`."
+  "component.type": "A component's stereotype is `componentType`.",
+  "implementation.symbol": "A symbol names the code realizing ONE contract method: set it on that method (`methods[].symbol`)."
 };
 function unknownKeysIn(raw, parsed, at, out) {
   if (Array.isArray(raw)) {
@@ -34488,7 +35087,7 @@ function resolveFamilyTables(raws) {
   const byKey3 = new Map(raws.map((r) => [r.record.namespace, r]));
   const done = /* @__PURE__ */ new Set();
   const resolving = /* @__PURE__ */ new Set();
-  const resolve41 = (raw) => {
+  const resolve42 = (raw) => {
     const key2 = raw.record.namespace;
     if (done.has(key2)) return raw.record.exports;
     if (resolving.has(key2)) return null;
@@ -34503,7 +35102,7 @@ function resolveFamilyTables(raws) {
         const producerKey = source !== void 0 ? raw.record.aliases.get(source) : void 0;
         if (producerKey === void 0 || producerTables.has(producerKey)) continue;
         const producer = byKey3.get(producerKey);
-        producerTables.set(producerKey, producer ? resolve41(producer) : null);
+        producerTables.set(producerKey, producer ? resolve42(producer) : null);
         audienceOf.set(producerKey, "project");
       }
       raw.record.subsystemExports = subsystemTables;
@@ -34524,7 +35123,7 @@ function resolveFamilyTables(raws) {
       resolving.delete(key2);
     }
   };
-  raws.forEach((raw) => resolve41(raw));
+  raws.forEach((raw) => resolve42(raw));
 }
 function bindAuthored(raw, raws, readables, authored) {
   const key2 = raw.record.namespace;
@@ -35232,13 +35831,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, key2) => prefix ? `${prefix}.${key2}` : key2;
-  const say = (path49, why2) => {
-    out.push(`${path49} \u2014 ${why2}`);
+  const say = (path50, why2) => {
+    out.push(`${path50} \u2014 ${why2}`);
   };
-  const walkValue = (d, m, s, path49, field) => {
+  const walkValue = (d, m, s, path50, field) => {
     if (Array.isArray(d)) {
       if (!Array.isArray(m)) {
-        say(path49, "the level does not have this field, so the write dropped it");
+        say(path50, "the level does not have this field, so the write dropped it");
         return;
       }
       if (field === "narrative" && d.some(carriesEditMarker)) return;
@@ -35246,32 +35845,32 @@ function ineffectiveDeltaPaths(delta, merged, stored) {
         if (carriesEditMarker(element)) continue;
         const key2 = reportIdentityOf(field, element);
         if (key2 === null) {
-          if (!same(m, d)) say(path49, "the level does not keep this value, so the write dropped it");
-          else if (same(s, d)) say(path49, "the stored spec already held this value");
+          if (!same(m, d)) say(path50, "the level does not keep this value, so the write dropped it");
+          else if (same(s, d)) say(path50, "the stored spec already held this value");
           return;
         }
         const mMatch = m.find((i) => reportIdentityOf(field, i) === key2);
         const sMatch = Array.isArray(s) ? s.find((i) => reportIdentityOf(field, i) === key2) : void 0;
         if (mMatch === void 0) {
-          say(at(path49, key2), "the write did not store this element");
+          say(at(path50, key2), "the write did not store this element");
           continue;
         }
-        walk2(element, mMatch, sMatch, at(path49, key2), field);
+        walk2(element, mMatch, sMatch, at(path50, key2), field);
       }
       return;
     }
     if (isPlain(d)) {
       if (!isPlain(m)) {
-        say(path49, "the level does not have this field, so the write dropped it");
+        say(path50, "the level does not have this field, so the write dropped it");
         return;
       }
-      walk2(d, m, s, path49, field);
+      walk2(d, m, s, path50, field);
       return;
     }
-    if (!same(m, d)) say(path49, "the write did not store it \u2014 the level's schema does not keep this value");
-    else if (same(s, d)) say(path49, "the stored spec already held this value");
+    if (!same(m, d)) say(path50, "the write did not store it \u2014 the level's schema does not keep this value");
+    else if (same(s, d)) say(path50, "the stored spec already held this value");
   };
-  function walk2(d, m, s, path49, container) {
+  function walk2(d, m, s, path50, container) {
     for (const [key2, value] of Object.entries(d)) {
       if (DELTA_VERBS.has(key2) || JUMP_LABEL_TWINS.has(key2)) continue;
       if (key2 === "label" && LABEL_TWIN_CONTAINERS.has(container)) continue;
@@ -35281,13 +35880,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(path49, name), "unset named a field the stored spec did not have");
-          else if (still) say(at(path49, name), "unset did not remove it");
+          if (!had) say(at(path50, name), "unset named a field the stored spec did not have");
+          else if (still) say(at(path50, name), "unset did not remove it");
         }
         continue;
       }
       if (value === void 0 || value === null) continue;
-      const here = at(path49, key2);
+      const here = at(path50, key2);
       const mValue = isPlain(m) ? m[key2] : void 0;
       const sValue = isPlain(s) ? s[key2] : void 0;
       if (mValue === void 0) {
@@ -36545,12 +37144,12 @@ var SpecWorkspace = class {
     return this.relativizeSpec("interface", stored);
   }
   prepareImplementationForWrite(spec, carry = true) {
-    const relative20 = this.relativizeSpec("implementation", spec, carry);
+    const relative22 = this.relativizeSpec("implementation", spec, carry);
     const member = this.getSubprojectPrefix(spec.id);
     const memberRoot = member ? this.resolveSubprojectForNamespace(member) : null;
-    if (memberRoot) return childRelativeFilePaths(relative20, this.rootDir, memberRoot);
+    if (memberRoot) return childRelativeFilePaths(relative22, this.rootDir, memberRoot);
     const partDir = this.partHolding(this.getImplementationPath(spec.id, spec.contract))?.part.directory;
-    return partDir ? partRelativeFilePaths(relative20, this.rootDir, partDir) : relative20;
+    return partDir ? partRelativeFilePaths(relative22, this.rootDir, partDir) : relative22;
   }
   /**
    * A type written in its stored form — every type position canonical (one
@@ -37582,7 +38181,7 @@ var SpecWorkspace = class {
       out[DELTA_JUMP_PINS] = pins;
       return out;
     };
-    const unpinned = (step) => {
+    const unpinned2 = (step) => {
       const out = { ...step };
       delete out[DELTA_JUMP_PINS];
       for (const lf of JUMP_LIST_FIELDS) {
@@ -37792,7 +38391,7 @@ var SpecWorkspace = class {
           }
         }
       }
-      return steps.map(unpinned).sort((a, b) => a.stepNumber - b.stepNumber);
+      return steps.map(unpinned2).sort((a, b) => a.stepNumber - b.stepNumber);
     };
     const isPlainObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
     const mergeExt = (existing, delta2) => {
@@ -39111,6 +39710,7 @@ function unregisterDomain(id) {
 }
 
 // src/core/external-producers.ts
+var fs16 = __toESM(require("fs"));
 var path23 = __toESM(require("path"));
 function hostedOnlyProducer(id) {
   return `hosted-only producer \`${id}\`: available only through the hosted server`;
@@ -39224,9 +39824,15 @@ function resolveCandidate(alias, declaration2) {
     reachable: whole
   };
 }
-function listConsumers() {
+function listConsumers(search) {
   const bound2 = path23.resolve(getProjectRoot());
   const { top } = climb(bound2);
+  const family = familyConsumers(bound2, top);
+  const seen = new Set(family.map((c) => dirKey(c.directory)));
+  const found = searchedConsumers(bound2, search ?? []).filter((c) => !seen.has(dirKey(c.directory)));
+  return [...family, ...found];
+}
+function familyConsumers(bound2, top) {
   return runWithProjectRoot(top, () => {
     const family = graph();
     const producer = consumerNode(family, bound2);
@@ -39245,16 +39851,76 @@ function listConsumers() {
         directory: node.directory,
         alias,
         section: external ? "externals" : "members",
-        names: usage.used.map((u) => u.publicName).sort()
+        names: usage.used.map((u) => u.publicName).sort(),
+        ...brokenNames(usage)
       });
     }
     return consumers.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
   });
 }
+function brokenNames(usage) {
+  const names = [...new Set(usage.unexported.map((r) => r.authored.split("::").pop() ?? r.authored))].sort();
+  return names.length ? { broken: names } : {};
+}
+function projectRootsUnder(folder) {
+  const isRoot = (dir) => fs16.existsSync(path23.join(dir, ".wai", "project.yaml"));
+  const at = path23.resolve(folder);
+  if (!fs16.existsSync(at)) return [];
+  if (isRoot(at)) return [at];
+  return fs16.readdirSync(at, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".") && d.name !== "node_modules").map((d) => path23.join(at, d.name)).filter(isRoot);
+}
+function searchedConsumers(bound2, search) {
+  if (search.length === 0) return [];
+  if (getHostedLookup() !== null) throw new Error("searching folders for consumers is a local read: a hosted request reads no folder outside its project");
+  const producerId = runWithProjectRoot(bound2, () => {
+    const config = consumerConfig(bound2);
+    return config ? effectiveProjectId(config) : null;
+  });
+  const roots = [...new Set(search.flatMap(projectRootsUnder).map((r) => path23.resolve(r)))].filter((r) => dirKey(r) !== dirKey(bound2));
+  const out = [];
+  for (const root of roots) {
+    const answer = runWithProjectRoot(root, () => {
+      let config;
+      try {
+        config = consumerConfig(root);
+      } catch {
+        return null;
+      }
+      if (!config) return null;
+      const declared = declaredExternals(config).find((e) => !e.problem && (e.sourcePath !== void 0 && dirKey(path23.resolve(root, e.sourcePath)) === dirKey(bound2) || e.sourceGit !== void 0 && producerId !== null && e.project === producerId));
+      if (!declared) return null;
+      const node = consumerNode(graph(), root);
+      const usage = node ? pinnedUsage(node.namespace, declared.alias) : null;
+      return {
+        project: effectiveProjectId(config) ?? path23.basename(root),
+        key: node?.namespace ?? "",
+        directory: root,
+        alias: declared.alias,
+        section: "externals",
+        names: (usage?.used ?? []).map((u) => u.publicName).sort(),
+        found: "search"
+      };
+    });
+    if (answer) out.push(answer);
+  }
+  return out.sort((a, b) => a.directory < b.directory ? -1 : a.directory > b.directory ? 1 : 0);
+}
+function approvedRevision(against) {
+  const bound2 = path23.resolve(getProjectRoot());
+  const repo = repositoryRoot(bound2);
+  if (!repo) throw new Error(`${bound2} is in no git work tree, so there is no earlier revision to compare with \u2014 pass a saved surface snapshot (\`--against <file>\`) instead`);
+  const commit2 = against !== void 0 ? commitOf(bound2, against) : lastCommitOf(bound2, path23.join(".wai", "lock.json"));
+  if (!commit2) {
+    throw new Error(against !== void 0 ? `"${against}" names no commit of the repository at ${repo}` : "no approval of this project was ever committed (.wai/lock.json is in no commit) \u2014 lock and commit first, or name a revision (`--against <ref>`)");
+  }
+  const relative22 = path23.relative(repo, bound2);
+  const directory = fetch(repo, commit2, relative22 === "" ? void 0 : relative22);
+  return { directory, commit: commit2, label: against !== void 0 ? `${against} (${commit2.slice(0, 12)})` : `the last approval, committed at ${commit2.slice(0, 12)}` };
+}
 
 // src/core/part-context.ts
 var crypto6 = __toESM(require("crypto"));
-var fs16 = __toESM(require("fs"));
+var fs17 = __toESM(require("fs"));
 var path24 = __toESM(require("path"));
 var PartContextUnavailable = class extends WaironError {
   constructor(message) {
@@ -39265,7 +39931,7 @@ var PartContextUnavailable = class extends WaironError {
 function sameDirectory(a, b) {
   const canonical3 = (d) => {
     try {
-      return fs16.realpathSync.native(d);
+      return fs17.realpathSync.native(d);
     } catch {
       return path24.resolve(d);
     }
@@ -39393,7 +40059,7 @@ function excerpt() {
   if (!isPart(config) || !partOf) throw new PartContextUnavailable(`${partRoot} is not a part: its configuration declares no partOf`);
   if (partOf.path === void 0) throw new PartContextUnavailable(`the part at ${partRoot} records no path to its parent "${partOf.project}"`);
   const parentRoot = path24.resolve(partRoot, partOf.path);
-  if (!fs16.existsSync(parentRoot)) throw new PartContextUnavailable(`the parent "${partOf.project}" is not on disk at ${parentRoot}`);
+  if (!fs17.existsSync(parentRoot)) throw new PartContextUnavailable(`the parent "${partOf.project}" is not on disk at ${parentRoot}`);
   const read2 = runWithProjectRoot(parentRoot, () => readParent(parentRoot, partRoot, partOf.project));
   const { commit: _provenance, ...content } = read2;
   const digest3 = `sha256:${crypto6.createHash("sha256").update(canonicalize(content)).digest("hex")}`;
@@ -39401,7 +40067,7 @@ function excerpt() {
 }
 
 // src/core/provision.ts
-var fs17 = __toESM(require("fs"));
+var fs18 = __toESM(require("fs"));
 var path25 = __toESM(require("path"));
 function defaultProjectConfig(name, now, id) {
   const declared = id ?? effectiveProjectId({ name });
@@ -39452,7 +40118,7 @@ function provisionProject(name) {
 function ensureProjectInitialized(fallbackName, id, vision) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const paths = aiPathsAt(getProjectRoot());
-  const hasSystem = fs17.existsSync(paths.specsSystem());
+  const hasSystem = fs18.existsSync(paths.specsSystem());
   let name = fallbackName;
   if (hasSystem) {
     const existing = loadSystemSpec();
@@ -39472,7 +40138,7 @@ function ensureProjectInitialized(fallbackName, id, vision) {
   return { wroteConfig, wroteSystem };
 }
 function isPartDirectory(dir) {
-  return fs17.existsSync(dir) && !holdsProjectContent(dir);
+  return fs18.existsSync(dir) && !holdsProjectContent(dir);
 }
 function memberDeclarationsAt2(dir) {
   let config = null;
@@ -39489,7 +40155,7 @@ function memberDeclarationsAt2(dir) {
     out.push({ alias: member.alias, path: member.path, form: "members" });
   }
   const specsDir = aiPathsAt(dir).specsDir();
-  if (!fs17.existsSync(specsDir)) return out;
+  if (!fs18.existsSync(specsDir)) return out;
   for (const file of listFilesRecursive(specsDir, ".yaml")) {
     let raw;
     try {
@@ -39540,7 +40206,7 @@ function listDirectChainedSubprojects(projectRoot) {
   return out;
 }
 function childHasSpecsButNoConfig(childDir) {
-  return fs17.existsSync(aiPathsAt(childDir).specsDir()) && !projectConfigRepositoryAt(childDir).exists();
+  return fs18.existsSync(aiPathsAt(childDir).specsDir()) && !projectConfigRepositoryAt(childDir).exists();
 }
 function findChainingSubprojectsMissingConfig(projectRoot) {
   const missing = [];
@@ -39612,7 +40278,7 @@ function createMember(alias, source, description, as) {
 }
 function holdsProjectContent(dir) {
   const paths = aiPathsAt(dir);
-  if (fs17.existsSync(paths.specsSystem()) || fs17.existsSync(path25.join(paths.root(), "lock.json"))) return true;
+  if (fs18.existsSync(paths.specsSystem()) || fs18.existsSync(path25.join(paths.root(), "lock.json"))) return true;
   try {
     return projectConfigRepositoryAt(dir).load()?.id !== void 0;
   } catch {
@@ -39736,14 +40402,14 @@ function moveMember(alias, newPath) {
   const oldDir = assertContainedProjectPath(root, currentPath);
   const newDir = assertContainedProjectPath(root, nextPath);
   if (oldDir !== newDir) {
-    if (!fs17.existsSync(oldDir)) {
+    if (!fs18.existsSync(oldDir)) {
       throw new WaironError(`Member directory not found at its current path: ${oldDir}`);
     }
-    if (fs17.existsSync(newDir)) {
+    if (fs18.existsSync(newDir)) {
       throw new WaironError(`Target directory already exists: ${newDir}`);
     }
     ensureDir(path25.dirname(newDir));
-    fs17.renameSync(oldDir, newDir);
+    fs18.renameSync(oldDir, newDir);
   }
   projectConfigRepository.setMemberPath(alias, nextPath);
   invalidateSpecCache();
@@ -39756,13 +40422,13 @@ function moveSibling(alias, currentPath, newPath, isPart2) {
   }
   const oldDir = path25.resolve(root, currentPath);
   const newDir = path25.resolve(root, nextPath);
-  if (!fs17.existsSync(oldDir)) throw new WaironError(`Member directory not found at its current path: ${oldDir}`);
-  if (fs17.existsSync(newDir)) throw new WaironError(`Target directory already exists: ${newDir}`);
+  if (!fs18.existsSync(oldDir)) throw new WaironError(`Member directory not found at its current path: ${oldDir}`);
+  if (fs18.existsSync(newDir)) throw new WaironError(`Target directory already exists: ${newDir}`);
   ensureDir(path25.dirname(newDir));
-  if (fs17.statSync(oldDir).dev !== fs17.statSync(path25.dirname(newDir)).dev) {
+  if (fs18.statSync(oldDir).dev !== fs18.statSync(path25.dirname(newDir)).dev) {
     throw new WaironError(`Refusing to move the member "${alias}" to ${newDir}: it lies on another volume, and a rename across volumes is not atomic.`);
   }
-  fs17.renameSync(oldDir, newDir);
+  fs18.renameSync(oldDir, newDir);
   if (isPart2) {
     const parentId = effectiveProjectId(projectConfigRepository.load() ?? { name: loadSystemSpec()?.name ?? "" });
     if (parentId !== null) runWithProjectRoot(newDir, () => projectConfigRepository.setPartOf({ project: parentId, path: toPosixPath(path25.relative(newDir, root)) || "." }));
@@ -39792,8 +40458,8 @@ function isWithinDir2(dir, file) {
 }
 var MOVED_REF_POSITIONS = /* @__PURE__ */ new Set(["component", "interface"]);
 var INTO_MEMBER_POSITIONS = /* @__PURE__ */ new Set([...MOVED_REF_POSITIONS, "type"]);
-function externalizeSubsystem(subsystemId, path49, as) {
-  return externalizeInto(subsystemId, path49, as);
+function externalizeSubsystem(subsystemId, path50, as) {
+  return externalizeInto(subsystemId, path50, as);
 }
 function externalizeInto(subsystemId, partPath, as) {
   if (subsystemId.includes("::")) {
@@ -39820,7 +40486,7 @@ function externalizeInto(subsystemId, partPath, as) {
   if (holdsProjectContent(partDir)) throw new WaironError(`cannot externalize "${subsystemId}": ${partDir} already holds a project.`);
   const joined = bound2?.parts.find((p) => p.directory !== void 0 && path25.resolve(p.directory) === path25.resolve(partDir));
   const alias = joined?.alias ?? subsystemId;
-  if (!joined && fs17.existsSync(aiPathsAt(partDir).projectConfig())) {
+  if (!joined && fs18.existsSync(aiPathsAt(partDir).projectConfig())) {
     throw new WaironError(`cannot externalize "${subsystemId}": ${partDir} already holds a configuration (.wai/project.yaml) \u2014 a new part's directory holds none; creating one never overwrites it.`);
   }
   if (!joined && (declaredMembers(projectConfigRepository.load() ?? {}).some((m) => m.alias === alias) || projectConfigRepository.load()?.externals?.[alias] !== void 0)) {
@@ -39828,10 +40494,10 @@ function externalizeInto(subsystemId, partPath, as) {
   }
   const partSpecsDir = aiPathsAt(partDir).specsDir();
   const targetDir = path25.join(partSpecsDir, subsystemId);
-  if (owned.home !== void 0 && fs17.existsSync(targetDir)) throw new WaironError(`target already contains a "${subsystemId}" subsystem: ${targetDir}`);
+  if (owned.home !== void 0 && fs18.existsSync(targetDir)) throw new WaironError(`target already contains a "${subsystemId}" subsystem: ${targetDir}`);
   const destinationOf = (file) => path25.join(partSpecsDir, path25.relative(parentSpecsDir, file));
   const strays = owned.files.filter((f) => !(owned.home !== void 0 && isWithinDir2(owned.home, f)));
-  const taken = strays.filter((f) => fs17.existsSync(destinationOf(f)));
+  const taken = strays.filter((f) => fs18.existsSync(destinationOf(f)));
   if (taken.length > 0) throw new WaironError(`cannot externalize "${subsystemId}": the part already holds ${taken.map((f) => toPosixPath(path25.relative(partDir, destinationOf(f)))).join(", ")}.`);
   if (as === "project") {
     if (joined) throw new WaironError(`cannot externalize "${subsystemId}" as a project into the existing part "${joined.alias}": externalize it into the part, then promote the part (\`wairon member promote ${joined.alias}\`).`);
@@ -39842,13 +40508,13 @@ function externalizeInto(subsystemId, partPath, as) {
   const moved = [];
   if (owned.home !== void 0) {
     ensureDir(path25.dirname(targetDir));
-    fs17.renameSync(owned.home, targetDir);
+    fs18.renameSync(owned.home, targetDir);
     moved.push(...specFilesUnder(targetDir));
   }
   for (const file of strays) {
     const to = destinationOf(file);
     ensureDir(path25.dirname(to));
-    fs17.renameSync(file, to);
+    fs18.renameSync(file, to);
     moved.push(to);
     removeEmptyDirsUpTo(path25.dirname(file), parentSpecsDir);
   }
@@ -39859,10 +40525,10 @@ function externalizeInto(subsystemId, partPath, as) {
 }
 function subsystemFiles(subsystemId, specsDir) {
   const subPath = getSubsystemPath(subsystemId);
-  const nested = subPath.endsWith(".index.yaml") && path25.resolve(path25.dirname(subPath)) === path25.resolve(path25.join(specsDir, subsystemId)) && fs17.existsSync(subPath);
+  const nested = subPath.endsWith(".index.yaml") && path25.resolve(path25.dirname(subPath)) === path25.resolve(path25.join(specsDir, subsystemId)) && fs18.existsSync(subPath);
   const home = nested ? path25.dirname(subPath) : void 0;
   const files = new Set(home !== void 0 ? specFilesUnder(home).map((f) => path25.resolve(f)) : []);
-  if (!nested && fs17.existsSync(subPath)) files.add(path25.resolve(subPath));
+  if (!nested && fs18.existsSync(subPath)) files.add(path25.resolve(subPath));
   const l0 = path25.resolve(aiPathsAt(getProjectRoot()).specsSystem());
   const others = () => specFilesUnder(specsDir).filter((f) => path25.resolve(f) !== l0 && !files.has(path25.resolve(f)));
   const add2 = (file) => {
@@ -39890,13 +40556,13 @@ function subsystemFiles(subsystemId, specsDir) {
 function removeEmptyDirsUpTo(dir, stop) {
   let at = path25.resolve(dir);
   const end = path25.resolve(stop);
-  while (at !== end && isWithinDir2(end, at) && fs17.existsSync(at) && fs17.readdirSync(at).length === 0) {
-    fs17.rmdirSync(at);
+  while (at !== end && isWithinDir2(end, at) && fs18.existsSync(at) && fs18.readdirSync(at).length === 0) {
+    fs18.rmdirSync(at);
     at = path25.dirname(at);
   }
 }
 function specFilesUnder(dir) {
-  return fs17.existsSync(dir) ? listFilesRecursive(dir, ".yaml") : [];
+  return fs18.existsSync(dir) ? listFilesRecursive(dir, ".yaml") : [];
 }
 function ownSpecFiles(family, except) {
   const root = getProjectRoot();
@@ -40029,7 +40695,7 @@ function rewriteRefsIn(specs, remap, record) {
   return rewritten;
 }
 function patchKeepingStamp(file, mutate) {
-  if (!fs17.existsSync(file)) return;
+  if (!fs18.existsSync(file)) return;
   const raw = readYamlFile(file);
   if (mutate(raw)) writeYamlFile(file, raw);
 }
@@ -40074,7 +40740,7 @@ function promoteMember(alias, id) {
     patchKeepingStamp(s.file, (raw) => raw.parentSystem === projectName ? false : (raw.parentSystem = projectName, true));
   }
   if (declaration2?.as === "part") projectConfigRepository.updateMember(alias, { as: "" });
-  const result = { respelled: [], memberRespelled: [], exported: [], imported: [], consumersDropped: [], entriesDeclared: [], topicsCrossing: [] };
+  const result = { respelled: [], memberRespelled: [], exported: [], imported: [], consumersDropped: [], entriesDeclared: [], topicsCrossing: [], pathsRebased: [], signaturesRederived: [] };
   const parentSide = rewriteRefsIn(crossing.in.map((c) => c.spec).filter(unique), (ref, position) => INTO_MEMBER_POSITIONS.has(position) && crossing.insideTargets.has(ref) ? `${alias}::${ref}` : ref, { result, member: false });
   const climbs = climbsOf(family, crossing.insideIds, parentId).map;
   const climbing = inside.filter((s) => family.authoredReferences.some((r) => r.form === "super" && r.specId === s.id));
@@ -40107,8 +40773,71 @@ function promoteMember(alias, id) {
     });
   }
   invalidateSpecCache();
+  rebaseEscapingPaths(dir, getProjectRoot(), result);
+  rederiveSignatures(new Set(result.respelled.map((r) => r.specId)), result.signaturesRederived);
+  runWithProjectRoot(dir, () => {
+    invalidateSpecCache();
+    rederiveSignatures(new Set(result.memberRespelled.map((r) => localIn(r.specId, memberKey ?? alias))), result.signaturesRederived);
+  });
+  invalidateSpecCache();
   return result;
 }
+function rebaseEscapingPaths(memberDir, familyRoot, result) {
+  const shownMember = toPosixPath(path25.relative(familyRoot, memberDir)) || ".";
+  for (const file of specFilesUnder(aiPathsAt(memberDir).specsDir())) {
+    let raw;
+    try {
+      raw = readYamlFile(file);
+    } catch {
+      continue;
+    }
+    if (!raw || typeof raw !== "object") continue;
+    const isImplementation = "contract" in raw;
+    if (!isImplementation && specKind(raw) !== "type") continue;
+    let changed = false;
+    const rebase = (holder, key2, where) => {
+      const p = holder[key2];
+      if (typeof p !== "string" || p === "" || path25.isAbsolute(p)) return;
+      const absolute = path25.resolve(memberDir, p);
+      if (isWithinDir2(memberDir, absolute)) return;
+      const next = toPosixPath(path25.relative(familyRoot, absolute));
+      if (next.startsWith("..") || path25.isAbsolute(next)) return;
+      holder[key2] = next;
+      changed = true;
+      result.pathsRebased.push(`${raw.id} ${where}: ${p} \u2192 ${next} (the code is not moved: it is planned there until ${next} of the parent moves into ${shownMember})`);
+    };
+    for (const key2 of isImplementation ? ["sourcePath", "simPath"] : ["sourcePath"]) rebase(raw, key2, key2);
+    if (Array.isArray(raw.methods)) {
+      for (const method of raw.methods) {
+        if (method && typeof method === "object") rebase(method, "sourcePath", `${method.name} sourcePath`);
+      }
+    }
+    if (changed) writeYamlFile(file, raw);
+  }
+  invalidateSpecCache();
+}
+function rederiveSignatures(touched, lines) {
+  if (touched.size === 0) return;
+  invalidateSpecCache();
+  const stale = signatureFacts().staleTexts.filter((t) => touched.has(t.specId));
+  if (stale.length === 0) return;
+  const saved = /* @__PURE__ */ new Set();
+  for (const t of stale) {
+    const key2 = `${t.kind}:${t.specId}`;
+    if (!saved.has(key2)) {
+      saved.add(key2);
+      if (t.kind === "interface") {
+        const intf = loadInterfaceSpec(t.specId);
+        if (intf) saveInterfaceSpec(intf);
+      } else {
+        const type = loadTypeSpec(t.specId);
+        if (type) saveSpec("type", type);
+      }
+    }
+    lines.push(`${t.specId}.${t.method}: ${t.stored} \u2192 ${t.derived}`);
+  }
+  invalidateSpecCache();
+}
 function callsInto2(callers, portals) {
   const componentOf = new Map(callers.filter((s) => s.kind === "interface").map((s) => [s.id, String(s.raw.component ?? "")]));
   const out = /* @__PURE__ */ new Map();
@@ -40269,7 +40998,7 @@ function respellQualified(inside, outside, names, result) {
   };
   for (const [specs, side] of [[inside, "inside"], [outside, "outside"]]) {
     for (const spec of specs) {
-      if (!fs17.existsSync(spec.file)) continue;
+      if (!fs18.existsSync(spec.file)) continue;
       const raw = readYamlFile(spec.file);
       if (!raw || typeof raw !== "object") continue;
       const edits = [];
@@ -40333,24 +41062,99 @@ function dropCrossingConsumers(inside, outside, result) {
     }
   }
 }
+function audienceRank4(audience) {
+  const idx = SURFACE_AUDIENCES.indexOf(audience ?? "instance");
+  return idx === -1 ? SURFACE_AUDIENCES.indexOf("instance") : idx;
+}
 function exportReExported(inside, memberDir, alias, result) {
   invalidateSpecCache();
-  const entries = (loadSystemSpec()?.publicInterfaces ?? []).filter((e) => e.from === alias);
-  if (entries.length === 0) return;
-  const targets = entries.map((e) => e.component ?? e.typeDef).filter((t) => t !== void 0);
-  const whole = entries.some((e) => e.component === void 0 && e.typeDef === void 0);
+  const parent = loadSystemSpec();
+  const parentEntries = parent?.publicInterfaces ?? [];
+  const entries = parentEntries.filter((e) => e.from === alias);
+  if (!parent || entries.length === 0) return;
+  const parentId = effectiveProjectId(projectConfigRepository.load() ?? { name: parent.name }) ?? parent.name;
+  const repointed = /* @__PURE__ */ new Map();
   runWithProjectRoot(memberDir, () => {
-    for (const name of exportItems(targets)) result.exported.push(`${alias} L0: ${name} (re-exported by the parent)`);
-    if (!whole) return;
     invalidateSpecCache();
     const system = loadSystemSpec();
     if (!system) return;
-    const own2 = system.publicInterfaces ?? [];
-    const added = inside.filter((s) => s.kind === "subsystem" && !own2.some((e) => e.from === s.id && e.component === void 0 && e.typeDef === void 0)).map((s) => ({ from: s.id, audience: "project" }));
-    if (added.length === 0) return;
-    saveSystemSpec({ ...system, publicInterfaces: [...own2, ...added] });
-    for (const e of added) result.exported.push(`${alias} L0: everything ${e.from} exports (re-exported whole by the parent)`);
+    const own2 = [...system.publicInterfaces ?? []];
+    const types = loadTypeSpecs();
+    let changed = false;
+    for (const e of entries) {
+      const audience = e.audience ?? "instance";
+      if (e.component === void 0 && e.typeDef === void 0 && e.interface === void 0) {
+        for (const s of inside.filter((x) => x.kind === "subsystem")) {
+          const whole = own2.find((x) => x.from === s.id && x.component === void 0 && x.typeDef === void 0 && x.interface === void 0);
+          if (whole) {
+            if (audienceRank4(whole.audience) < audienceRank4(audience)) {
+              whole.audience = audience;
+              changed = true;
+              result.exported.push(`${alias} L0: everything ${s.id} exports widened to ${audience} (re-exported whole by the parent)`);
+            }
+            continue;
+          }
+          own2.push({ from: s.id, audience });
+          changed = true;
+          result.exported.push(`${alias} L0: everything ${s.id} exports at ${audience} (re-exported whole by the parent)`);
+        }
+        continue;
+      }
+      const type = e.typeDef !== void 0 ? types.find((t) => t.id === localIn(e.typeDef, alias)) : void 0;
+      const interfaceId = e.interface !== void 0 ? localIn(e.interface, alias) : void 0;
+      const componentId = e.component !== void 0 ? localIn(e.component, alias) : interfaceId !== void 0 ? loadInterfaceSpec(interfaceId)?.component : void 0;
+      const component = type === void 0 && componentId !== void 0 ? loadComponentSpec(componentId) : null;
+      if (type === void 0 && !component) continue;
+      const field = type ? "typeDef" : "component";
+      const item = type ? type.id : component.id;
+      const publicName = e.as ?? e.id ?? (interfaceId ?? item);
+      if (type?.subsystem) exportTypeFromSubsystem(type.subsystem, type.id);
+      const held = own2.find((x) => x[field] === item && (interfaceId === void 0 || x.interface === void 0 || x.interface === interfaceId));
+      if (held) {
+        if (audienceRank4(held.audience ?? "project") < audienceRank4(audience)) {
+          held.audience = audience;
+          changed = true;
+        }
+        const name = held.as ?? held.id ?? (held.interface ?? item);
+        result.exported.push(`${alias} L0: ${item} as ${name} at ${held.audience} (re-exported by the parent)`);
+        repointed.set(e, { name, field, item });
+        continue;
+      }
+      const subsystem = type ? type.subsystem : component.subsystem;
+      own2.push({
+        ...subsystem ? { from: subsystem } : {},
+        [field]: item,
+        ...interfaceId !== void 0 && !type ? { interface: interfaceId } : {},
+        ...publicName !== (interfaceId ?? item) ? { as: publicName } : {},
+        ...e.details !== void 0 ? { details: e.details } : {},
+        audience
+      });
+      changed = true;
+      result.exported.push(`${alias} L0: ${item}${publicName !== item ? ` as ${publicName}` : ""} at ${audience} (re-exported by the parent)`);
+      repointed.set(e, { name: publicName, field, item });
+    }
+    if (changed) saveSystemSpec({ ...system, publicInterfaces: own2 });
+    invalidateSpecCache();
+    const table = resolveProjectExports();
+    for (const [e, to] of repointed) {
+      const interfaceId = e.interface !== void 0 ? localIn(e.interface, alias) : void 0;
+      const bound2 = table.entries.find((x) => to.field === "typeDef" ? x.typeDef === to.item : x.component === to.item && (interfaceId === void 0 || x.interface === void 0 || x.interface === interfaceId));
+      if (bound2) to.name = bound2.publicName;
+    }
+  });
+  invalidateSpecCache();
+  if (repointed.size === 0) return;
+  const next = parentEntries.map((e) => {
+    const to = repointed.get(e);
+    if (!to) return e;
+    const { component: _c, interface: _i, typeDef: _t, ...rest } = e;
+    const before = e.interface ?? e.component ?? e.typeDef;
+    const out = { ...rest, [to.field]: to.name, ...e.as === void 0 && to.name !== before ? { as: before } : {} };
+    const shownAs = out.as ?? to.name;
+    result.exported.push(`${parentId} L0: ${shownAs} re-exported through ${alias} as ${to.name} at ${e.audience ?? "instance"} (was ${before} from subsystem ${alias})`);
+    return out;
   });
+  saveSystemSpec({ ...parent, publicInterfaces: next });
   invalidateSpecCache();
 }
 function promotedVision(id, parentName) {
@@ -40522,7 +41326,7 @@ function internalizeRefusals(scan, destination) {
   const specsDir = aiPathsAt(getProjectRoot()).specsDir();
   const memberSpecs = aiPathsAt(scan.memberDir).specsDir();
   const skip = path25.resolve(aiPathsAt(scan.memberDir).specsSystem());
-  const taken = (fs17.existsSync(memberSpecs) ? listFilesRecursive(memberSpecs, "") : []).filter((f) => path25.resolve(f) !== skip && fs17.existsSync(path25.join(specsDir, path25.relative(memberSpecs, f)))).map((f) => toPosixPath(path25.relative(memberSpecs, f)));
+  const taken = (fs18.existsSync(memberSpecs) ? listFilesRecursive(memberSpecs, "") : []).filter((f) => path25.resolve(f) !== skip && fs18.existsSync(path25.join(specsDir, path25.relative(memberSpecs, f)))).map((f) => toPosixPath(path25.relative(memberSpecs, f)));
   if (taken.length > 0) out.push(`its specs would land on this project's ${taken.join(", ")}`);
   out.push(...aliasConflicts(scan, bound2));
   if (destination.packs === void 0) {
@@ -40540,7 +41344,7 @@ function internalizeRefusals(scan, destination) {
     if (held !== void 0 && held !== scan.alias) out.push(`the export "${name}" is a public name this project already exports for ${held}`);
   }
   const wai = path25.join(scan.memberDir, ".wai");
-  for (const entry of fs17.existsSync(wai) ? fs17.readdirSync(wai) : []) {
+  for (const entry of fs18.existsSync(wai) ? fs18.readdirSync(wai) : []) {
     if (entry === "specs" || entry === "transactions" || MEMBER_WAI_GROUPS.has(entry)) continue;
     out.push(`its .wai holds "${entry}", which this write does not recognise \u2014 move or delete it by hand`);
   }
@@ -40751,15 +41555,15 @@ function carryPacks(scan, destination, result) {
 }
 function deleteMemberWai(memberDir) {
   const wai = path25.join(memberDir, ".wai");
-  if (!fs17.existsSync(wai)) return [];
+  if (!fs18.existsSync(wai)) return [];
   const deleted = listFilesRecursive(wai, "").filter((f) => !path25.relative(wai, f).split(path25.sep).includes("transactions")).map((f) => {
     const rel2 = toPosixPath(path25.relative(wai, f));
     return `${MEMBER_WAI_GROUPS.get(rel2.split("/")[0]) ?? "L0 (its pieces placed)"}: .wai/${rel2}`;
   });
-  for (const entry of fs17.readdirSync(wai)) {
-    if (entry !== "transactions") fs17.rmSync(path25.join(wai, entry), { recursive: true, force: true });
+  for (const entry of fs18.readdirSync(wai)) {
+    if (entry !== "transactions") fs18.rmSync(path25.join(wai, entry), { recursive: true, force: true });
   }
-  if (fs17.readdirSync(wai).length === 0) fs17.rmdirSync(wai);
+  if (fs18.readdirSync(wai).length === 0) fs18.rmdirSync(wai);
   return deleted.sort();
 }
 function memberToDemote(family, alias) {
@@ -40772,7 +41576,7 @@ function memberToDemote(family, alias) {
     throw new WaironError(`demote refused: the member "${alias}" is fetched from git \u2014 its files are the fetch cache's. Demote it from a checkout of its repository.`);
   }
   if (referenced?.sourceKind === "hosted") throw new WaironError(`demote refused: the member "${alias}" is a hosted record of its own \u2014 a part is part of its parent's record, so it must live in this project's tree.`);
-  if (referenced?.directory !== void 0 && fs17.existsSync(referenced.directory)) return { dir: referenced.directory, contained: false };
+  if (referenced?.directory !== void 0 && fs18.existsSync(referenced.directory)) return { dir: referenced.directory, contained: false };
   throw new WaironError(`demote refused: this project declares no project member "${alias}".`);
 }
 function localsOf(root) {
@@ -40804,7 +41608,7 @@ function demoteRefusals(scan, destination, memberIds, family) {
     if (held !== void 0 && held !== scan.alias) out.push(`the export "${name}" is a public name this project already exports for ${held}`);
   }
   const wai = path25.join(scan.memberDir, ".wai");
-  for (const entry of fs17.existsSync(wai) ? fs17.readdirSync(wai) : []) {
+  for (const entry of fs18.existsSync(wai) ? fs18.readdirSync(wai) : []) {
     if (entry === "specs" || entry === "transactions" || MEMBER_WAI_GROUPS.has(entry)) continue;
     out.push(`its .wai holds "${entry}", which this write does not recognise \u2014 move or delete it by hand`);
   }
@@ -40832,7 +41636,7 @@ function demoteMember(alias, destination) {
     refusals.push(`its metadata needs a home subsystem (--home) \u2014 ${home === "" ? "none was named" : `"${home}" is no subsystem of the member or of this project`}; its subsystems are ${subsystems.join(", ") || "none"}`);
   }
   if (refusals.length > 0) throw new WaironError(`demote refused: "${alias}" cannot become a part \u2014 ${refusals.join("; ")}.`);
-  const result = { subsystems, types, placed: [], externals: [], deleted: [], notCarried: [], consumersRestored: [] };
+  const result = { subsystems, types, placed: [], externals: [], deleted: [], notCarried: [], consumersRestored: [], signaturesRederived: [] };
   const intoMember = localsOf(dir);
   const backOut = localsOf(root);
   invalidateSpecCache();
@@ -40875,6 +41679,7 @@ function demoteMember(alias, destination) {
   invalidateSpecCache();
   for (const spec of [...parentSide, ...memberSide]) if (spec.kind !== "system") normalizeReferences(spec.kind, spec.id);
   invalidateSpecCache();
+  rederiveSignatures(new Set([...parentSide, ...memberSide].map((s) => s.id)), result.signaturesRederived ??= []);
   return result;
 }
 function respellQualifiedBack(parentSide, memberSide, aliases, tables, crossed) {
@@ -40899,7 +41704,7 @@ function respellQualifiedBack(parentSide, memberSide, aliases, tables, crossed)
       return to;
     };
     for (const spec of specs) {
-      if (!fs17.existsSync(spec.file)) continue;
+      if (!fs18.existsSync(spec.file)) continue;
       const raw = readYamlFile(spec.file);
       if (!raw || typeof raw !== "object") continue;
       let changed = false;
@@ -40954,16 +41759,16 @@ function deleteProjectContent(memberDir) {
   const wai = path25.join(memberDir, ".wai");
   const deleted = [];
   const l0 = aiPathsAt(memberDir).specsSystem();
-  if (fs17.existsSync(l0)) {
-    fs17.rmSync(l0);
+  if (fs18.existsSync(l0)) {
+    fs18.rmSync(l0);
     deleted.push(`L0 (its pieces placed): .wai/${toPosixPath(path25.relative(wai, l0))}`);
   }
-  for (const entry of fs17.existsSync(wai) ? fs17.readdirSync(wai) : []) {
+  for (const entry of fs18.existsSync(wai) ? fs18.readdirSync(wai) : []) {
     if (entry === "specs" || entry === "transactions") continue;
     const at = path25.join(wai, entry);
-    const files = fs17.statSync(at).isDirectory() ? listFilesRecursive(at, "") : [at];
+    const files = fs18.statSync(at).isDirectory() ? listFilesRecursive(at, "") : [at];
     for (const f of files) deleted.push(`${MEMBER_WAI_GROUPS.get(entry) ?? "derived outputs"}: .wai/${toPosixPath(path25.relative(wai, f))}`);
-    fs17.rmSync(at, { recursive: true, force: true });
+    fs18.rmSync(at, { recursive: true, force: true });
   }
   return deleted.sort();
 }
@@ -40993,7 +41798,7 @@ function specContents(dir) {
   const out = /* @__PURE__ */ new Map();
   if (dir === null) return out;
   const specsDir = aiPathsAt(dir).specsDir();
-  for (const f of specFilesUnder(specsDir)) out.set(toPosixPath(path25.relative(dir, f)), fs17.readFileSync(f, "utf8").replace(/\r\n/g, "\n"));
+  for (const f of specFilesUnder(specsDir)) out.set(toPosixPath(path25.relative(dir, f)), fs18.readFileSync(f, "utf8").replace(/\r\n/g, "\n"));
   return out;
 }
 function advanceMember(alias, ref, commit2, dryRun) {
@@ -41032,16 +41837,16 @@ function crossingReferences(family, from, to) {
   return out;
 }
 function moveTreeInto(src, dst, skip) {
-  if (!fs17.existsSync(src)) return [];
+  if (!fs18.existsSync(src)) return [];
   const files = listFilesRecursive(src, "").filter((f) => !skip.has(path25.resolve(f)));
   const targets = files.map((f) => path25.join(dst, path25.relative(src, f)));
-  const taken = targets.filter((t) => fs17.existsSync(t));
+  const taken = targets.filter((t) => fs18.existsSync(t));
   if (taken.length > 0) {
     throw new WaironError(`cannot internalize: the member's specs would overwrite ${taken.map((t) => path25.relative(dst, t)).join(", ")} in this project.`);
   }
   files.forEach((file, i) => {
     ensureDir(path25.dirname(targets[i]));
-    fs17.renameSync(file, targets[i]);
+    fs18.renameSync(file, targets[i]);
   });
   return targets;
 }
@@ -41139,7 +41944,7 @@ function rebaseImplementationPaths(specsDir, fromRoot, toRoot, only) {
   }
 }
 function patchSubsystemIndex(indexPath, mutate) {
-  if (!fs17.existsSync(indexPath)) return;
+  if (!fs18.existsSync(indexPath)) return;
   const raw = readYamlFile(indexPath);
   mutate(raw);
   raw.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -41226,7 +42031,7 @@ function moveRenamedSpecs(componentId, newId, component, movingInterface, moving
   if (movedImplementation) {
     const oldFile = getImplementationPath(movedImplementation.id);
     if (path25.resolve(getImplementationPath(implementationId, movedImplementation.contract)) === path25.resolve(oldFile)) {
-      fs17.unlinkSync(oldFile);
+      fs18.unlinkSync(oldFile);
     }
     saveImplementationSpec({ ...movedImplementation, id: implementationId, previousIds: traced(movedImplementation.previousIds, movedImplementation.id) });
   }
@@ -41283,17 +42088,17 @@ function keepPublicNames(specsDir, derives, dryRun = false) {
   return { names: [...new Set(names)], specs };
 }
 function removeSpecFile2(file, id) {
-  if (!fs17.existsSync(file)) return;
+  if (!fs18.existsSync(file)) return;
   try {
     if (readYamlFile(file)?.id !== id) return;
   } catch {
     return;
   }
-  fs17.unlinkSync(file);
+  fs18.unlinkSync(file);
   const specsRoot = path25.resolve(aiPathsAt(getProjectRoot()).specsDir());
   for (let dir = path25.dirname(path25.resolve(file)); dir !== specsRoot && isWithinDir2(specsRoot, dir); dir = path25.dirname(dir)) {
-    if (fs17.readdirSync(dir).length > 0) break;
-    fs17.rmdirSync(dir);
+    if (fs18.readdirSync(dir).length > 0) break;
+    fs18.rmdirSync(dir);
   }
 }
 var METHOD_CASINGS = {
@@ -41340,8 +42145,9 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
     );
   }
   const casing = methodCasingOf(component);
-  if (!methodNameFits(newName, casing)) {
-    throw new WaironError(`invalid-name: "${newName}" is not an identifier in this tree's method casing (${casing}).`);
+  const dictated = loadInterfaceSpecs().some((i) => i.component === componentId && i.implements !== void 0);
+  if (dictated ? !IDENTIFIER.test(newName) : !methodNameFits(newName, casing)) {
+    throw new WaironError(dictated ? `invalid-name: "${newName}" is not an identifier (a letter or underscore, then letters, digits or underscores).` : `invalid-name: "${newName}" is not an identifier in this tree's method casing (${casing}).`);
   }
   const contracts = loadInterfaceSpecs().filter((i) => i.component === componentId);
   const moving = contracts.filter((i) => i.methods.some((m) => m.name === methodName));
@@ -41707,6 +42513,64 @@ function renameField(typeId, field, newName) {
   invalidateSpecCache();
   return { type: qualifiedTypeId(type), from: field, to: newName, rewritten };
 }
+function renameParam(componentId, methodName, param, newName) {
+  const component = loadComponentSpec(componentId);
+  if (!component) throw new WaironError(`component-missing: no component has the id "${componentId}".`);
+  if (componentId.includes("::")) {
+    throw new WaironError(
+      `chained-component: "${componentId}" lives in another project; rename its parameter from that project's own root. ${memberRootWay(componentId, `sdd_rename_param ${componentId.slice(componentId.lastIndexOf("::") + 2)} ${methodName} ${param} <new name>`)}`
+    );
+  }
+  const contracts = loadInterfaceSpecs().filter((i) => i.component === componentId);
+  const moving = contracts.filter((i) => i.methods.some((m) => m.name === methodName));
+  if (moving.length === 0) throw new WaironError(`method-missing: no contract of "${componentId}" declares the method "${methodName}".`);
+  for (const contract of moving) {
+    const method = contract.methods.find((m) => m.name === methodName);
+    const params = method.params ?? [];
+    if (method.signatureFrom !== void 0) {
+      throw new WaironError(`param-missing: "${contract.id}.${methodName}" takes its parameters from ${method.signatureFrom}; rename the parameter there.`);
+    }
+    if (!params.some((p) => p.name === param)) {
+      throw new WaironError(`param-missing: "${contract.id}.${methodName}" declares no parameter "${param}"${params.length ? ` (it declares ${params.map((p) => p.name).join(", ")})` : ""}.`);
+    }
+    if (params.some((p) => p.name === newName && p.name !== param)) {
+      throw new WaironError(`name-taken: "${contract.id}.${methodName}" already has a parameter "${newName}".`);
+    }
+    const retired = params.find((p) => p.name !== param && (p.previousNames ?? []).includes(newName));
+    if (retired) {
+      throw new WaironError(`name-retired: parameter "${retired.name}" of "${contract.id}.${methodName}" lists "${newName}" in its previousNames \u2014 the name is retired on this method. Unsetting that previousNames releases it.`);
+    }
+  }
+  if (!IDENTIFIER.test(newName)) {
+    throw new WaironError(`invalid-name: "${newName}" is not an identifier (a letter or underscore, then letters, digits or underscores).`);
+  }
+  const variables = projectConfigRepository.load()?.rules?.naming?.variables;
+  const dictated = contracts.some((i) => i.implements !== void 0);
+  if (variables && !dictated && !methodNameFits(newName, variables)) {
+    throw new WaironError(`invalid-name: "${newName}" does not match this tree's parameter naming (rules.naming.variables: ${variables}).`);
+  }
+  if (newName === param) return { component: componentId, method: methodName, from: param, to: newName, movedIn: [], rewritten: [] };
+  assertSpecsInReach(moving.map((i) => ({ kind: "interface", id: i.id })), `renaming parameter "${param}" of "${componentId}.${methodName}"`, false);
+  const rewritten = [];
+  const placeholder = `{${param}}`;
+  for (const contract of moving) {
+    saveInterfaceSpec({
+      ...contract,
+      methods: contract.methods.map((m) => {
+        if (m.name !== methodName) return m;
+        const params = (m.params ?? []).map((p) => p.name === param ? { ...p, name: newName, previousNames: [...p.previousNames ?? [], param] } : p);
+        let endpoint = m.endpoint;
+        if (endpoint && endpoint.transport === "HTTP" && endpoint.path.includes(placeholder)) {
+          endpoint = { ...endpoint, path: endpoint.path.split(placeholder).join(`{${newName}}`) };
+          rewritten.push(`${contract.id}.${methodName}: {${param}} -> {${newName}}`);
+        }
+        return { ...m, params, ...endpoint ? { endpoint } : {} };
+      })
+    });
+  }
+  invalidateSpecCache();
+  return { component: componentId, method: methodName, from: param, to: newName, movedIn: moving.map((i) => i.id), rewritten };
+}
 function typeFileOf(id, type) {
   return getTypePath(id, type.subsystem, type.group);
 }
@@ -41733,7 +42597,7 @@ function externalSourceOf(declaration2) {
 }
 
 // src/core/detection.ts
-var fs18 = __toESM(require("fs"));
+var fs19 = __toESM(require("fs"));
 var path26 = __toESM(require("path"));
 var PACKAGE_MARKERS = [
   "package.json",
@@ -41785,7 +42649,7 @@ function deduplicateIds(candidates, existingIds = /* @__PURE__ */ new Set()) {
   });
 }
 function parseGitmodules(filePath) {
-  const content = fs18.readFileSync(filePath, "utf-8");
+  const content = fs19.readFileSync(filePath, "utf-8");
   const entries = [];
   let current2 = {};
   for (const line of content.split("\n")) {
@@ -41808,7 +42672,7 @@ function parseGitmodules(filePath) {
 }
 function detectGitSubmodules(projectRoot) {
   const gitmodulesPath = path26.join(projectRoot, ".gitmodules");
-  if (!fs18.existsSync(gitmodulesPath)) return [];
+  if (!fs19.existsSync(gitmodulesPath)) return [];
   return parseGitmodules(gitmodulesPath).map((entry) => ({
     suggestedId: pathToId(entry.path),
     suggestedName: pathToName(entry.path),
@@ -41826,7 +42690,7 @@ function walkForGit(projectRoot, currentDir, depth, results) {
   if (depth > MAX_SCAN_DEPTH) return;
   let entries;
   try {
-    entries = fs18.readdirSync(currentDir, { withFileTypes: true });
+    entries = fs19.readdirSync(currentDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -41837,7 +42701,7 @@ function walkForGit(projectRoot, currentDir, depth, results) {
     const relPath = normalizePath(path26.relative(projectRoot, fullPath));
     if (relPath === "" || relPath === ".") continue;
     const gitPath = path26.join(fullPath, ".git");
-    if (fs18.existsSync(gitPath)) {
+    if (fs19.existsSync(gitPath)) {
       results.push({
         suggestedId: pathToId(relPath),
         suggestedName: pathToName(relPath),
@@ -41859,7 +42723,7 @@ function walkForPackages(projectRoot, currentDir, depth, results) {
   if (depth > MAX_SCAN_DEPTH) return;
   let entries;
   try {
-    entries = fs18.readdirSync(currentDir, { withFileTypes: true });
+    entries = fs19.readdirSync(currentDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -41869,7 +42733,7 @@ function walkForPackages(projectRoot, currentDir, depth, results) {
     const fullPath = path26.join(currentDir, entry.name);
     const relPath = normalizePath(path26.relative(projectRoot, fullPath));
     if (relPath === "" || relPath === ".") continue;
-    const hasMarker = PACKAGE_MARKERS.some((m) => fs18.existsSync(path26.join(fullPath, m)));
+    const hasMarker = PACKAGE_MARKERS.some((m) => fs19.existsSync(path26.join(fullPath, m)));
     if (hasMarker) {
       results.push({
         suggestedId: pathToId(relPath),
@@ -41883,8 +42747,8 @@ function walkForPackages(projectRoot, currentDir, depth, results) {
   }
 }
 function pathToId(relPath) {
-  const basename13 = path26.basename(relPath);
-  return basename13.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const basename14 = path26.basename(relPath);
+  return basename14.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
 function pathToName(relPath) {
   const id = pathToId(relPath);
@@ -41895,7 +42759,7 @@ function normalizePath(p) {
 }
 
 // src/core/variants.ts
-var fs19 = __toESM(require("fs"));
+var fs20 = __toESM(require("fs"));
 var os4 = __toESM(require("os"));
 var path27 = __toESM(require("path"));
 var import_zod11 = require("zod");
@@ -41921,7 +42785,7 @@ function builtinVariantsDir() {
     path27.resolve(__dirname, "templates", "variants")
     // dist (library entry)
   ];
-  return candidates.find((dir) => fs19.existsSync(dir)) ?? candidates[0];
+  return candidates.find((dir) => fs20.existsSync(dir)) ?? candidates[0];
 }
 function projectVariantsDir() {
   return path27.join(getProjectRoot(), ".wai", "variants");
@@ -41929,7 +42793,7 @@ function projectVariantsDir() {
 function variantFiles(dir) {
   let entries;
   try {
-    entries = fs19.readdirSync(dir, { withFileTypes: true });
+    entries = fs20.readdirSync(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -42045,7 +42909,7 @@ function rebasedText(content, fromBase, toBase, rebasedContent) {
 
 // src/core/agent_resolver.ts
 var path29 = __toESM(require("path"));
-var fs20 = __toESM(require("fs"));
+var fs21 = __toESM(require("fs"));
 
 // src/core/templates.ts
 var path28 = __toESM(require("path"));
@@ -42215,7 +43079,7 @@ function resolveBudget(profile, config, agentId) {
 // src/core/agent_resolver.ts
 var projectFilesCache = /* @__PURE__ */ new Map();
 function listFilesRecursiveSafe(dirPath, ext) {
-  if (!fs20.existsSync(dirPath)) return [];
+  if (!fs21.existsSync(dirPath)) return [];
   const nameLower = path29.basename(dirPath).toLowerCase();
   const IGNORED_DIRS = /* @__PURE__ */ new Set([
     "node_modules",
@@ -42231,7 +43095,7 @@ function listFilesRecursiveSafe(dirPath, ext) {
     ".vscode"
   ]);
   if (IGNORED_DIRS.has(nameLower)) return [];
-  const entries = fs20.readdirSync(dirPath, { withFileTypes: true });
+  const entries = fs21.readdirSync(dirPath, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     const fullPath = path29.join(dirPath, entry.name);
@@ -42628,7 +43492,7 @@ function composeAgentBrief(agentId) {
   const shared = ownFence && isSubsystemOwner(record) ? sharedProjectFiles(ownFence) : [];
   const codeFence = ownFence ? [...ownFence, ...shared] : ownFence;
   if (codeFence) {
-    const shown2 = (p) => /[*?]/.test(p) || fs20.existsSync(path29.resolve(getProjectRoot(), p)) ? `- \`${p}\`` : `- \`${p}\` (planned \u2014 create it)`;
+    const shown2 = (p) => /[*?]/.test(p) || fs21.existsSync(path29.resolve(getProjectRoot(), p)) ? `- \`${p}\`` : `- \`${p}\` (planned \u2014 create it)`;
     const own2 = ownFence ?? [];
     const sharedSection = shared.length > 0 ? `
 Shared with the other subsystem owners (the project's setup and shared code; coordinate edits):
@@ -42756,18 +43620,18 @@ function memberHop(agentId) {
   const alias = agentId.slice(0, at);
   const member = graph().nodes.find((n) => n.parent === "" && n.mountAlias === alias);
   if (!member) return null;
-  const relative20 = path29.relative(getProjectRoot(), member.directory).split(path29.sep).join("/");
-  return { alias, rest: agentId.slice(at + 2), directory: member.directory, relative: relative20 };
+  const relative22 = path29.relative(getProjectRoot(), member.directory).split(path29.sep).join("/");
+  return { alias, rest: agentId.slice(at + 2), directory: member.directory, relative: relative22 };
 }
-function throughMount(brief, alias, relative20) {
-  const under = (p) => path29.posix.join(relative20, p);
+function throughMount(brief, alias, relative22) {
+  const under = (p) => path29.posix.join(relative22, p);
   return {
     ...brief,
     agentId: `${alias}::${brief.agentId}`,
     ownedPaths: brief.ownedPaths.map(under),
     ...brief.codeFence ? { codeFence: brief.codeFence.map(under) } : {},
     ...brief.readPaths ? { readPaths: brief.readPaths.map(under) } : {},
-    root: brief.root ? under(brief.root) : relative20
+    root: brief.root ? under(brief.root) : relative22
   };
 }
 function loadRegistry() {
@@ -42804,7 +43668,7 @@ function sharedProjectFiles(fence) {
     if (!claimed.has(file) && !out.includes(file)) out.push(file);
   };
   for (const file of [...SHARED_SETUP_FILES, ...SHARED_ROOT_FILES]) {
-    if (fs20.existsSync(path29.join(root, file))) add2(file);
+    if (fs21.existsSync(path29.join(root, file))) add2(file);
   }
   for (const type of loadTypeSpecs()) {
     if (type.subsystem) continue;
@@ -43097,7 +43961,7 @@ function resolveTargetConfig(agentTarget, projectConfig) {
 }
 
 // src/core/treetransfer.ts
-var fs21 = __toESM(require("fs"));
+var fs22 = __toESM(require("fs"));
 var path34 = __toESM(require("path"));
 var sdkPortal = __toESM(require_dist());
 var STAGING_PREFIX = ".wai-staging-";
@@ -43134,8 +43998,8 @@ function hasAuthoredSpecs(root) {
 }
 function createStagingDir(destDir) {
   const root = path34.resolve(destDir);
-  fs21.mkdirSync(root, { recursive: true });
-  const stagingDir = fs21.mkdtempSync(path34.join(root, STAGING_PREFIX));
+  fs22.mkdirSync(root, { recursive: true });
+  const stagingDir = fs22.mkdtempSync(path34.join(root, STAGING_PREFIX));
   return stagingDir;
 }
 function commitStagedTree(stagingDir, destDir, roots, backupExisting) {
@@ -43143,22 +44007,22 @@ function commitStagedTree(stagingDir, destDir, roots, backupExisting) {
   const backupDir = path34.join(root, BACKUP_DIR, timestampSlug());
   let backedUp = false;
   for (const rootRel of roots) {
-    const relative20 = rootRel === "." ? "" : rootRel;
-    const stagedSpecDir = path34.join(stagingDir, relative20, ".wai");
-    if (!fs21.existsSync(stagedSpecDir)) continue;
-    const liveSpecDir = liveSpecDirFor(path34.join(root, relative20));
-    if (backupExisting && liveSpecDir && fs21.existsSync(liveSpecDir)) {
-      const backupTarget = path34.join(backupDir, relative20, path34.basename(liveSpecDir));
-      fs21.mkdirSync(path34.dirname(backupTarget), { recursive: true });
-      fs21.renameSync(liveSpecDir, backupTarget);
+    const relative22 = rootRel === "." ? "" : rootRel;
+    const stagedSpecDir = path34.join(stagingDir, relative22, ".wai");
+    if (!fs22.existsSync(stagedSpecDir)) continue;
+    const liveSpecDir = liveSpecDirFor(path34.join(root, relative22));
+    if (backupExisting && liveSpecDir && fs22.existsSync(liveSpecDir)) {
+      const backupTarget = path34.join(backupDir, relative22, path34.basename(liveSpecDir));
+      fs22.mkdirSync(path34.dirname(backupTarget), { recursive: true });
+      fs22.renameSync(liveSpecDir, backupTarget);
       backedUp = true;
-    } else if (liveSpecDir && fs21.existsSync(liveSpecDir)) {
-      fs21.rmSync(liveSpecDir, { recursive: true, force: true });
+    } else if (liveSpecDir && fs22.existsSync(liveSpecDir)) {
+      fs22.rmSync(liveSpecDir, { recursive: true, force: true });
     }
-    const target = path34.join(root, relative20, ".wai");
-    fs21.mkdirSync(path34.dirname(target), { recursive: true });
-    if (fs21.existsSync(target)) fs21.rmSync(target, { recursive: true, force: true });
-    fs21.renameSync(stagedSpecDir, target);
+    const target = path34.join(root, relative22, ".wai");
+    fs22.mkdirSync(path34.dirname(target), { recursive: true });
+    if (fs22.existsSync(target)) fs22.rmSync(target, { recursive: true, force: true });
+    fs22.renameSync(stagedSpecDir, target);
   }
   if (backedUp) {
     return backupDir;
@@ -43167,7 +44031,7 @@ function commitStagedTree(stagingDir, destDir, roots, backupExisting) {
 }
 function discardStagingDir(stagingDir) {
   try {
-    fs21.rmSync(stagingDir, { recursive: true, force: true });
+    fs22.rmSync(stagingDir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -43244,9 +44108,9 @@ function importSpecTree(archive, options) {
 }
 function liveSpecDirFor(rootDir) {
   const modern = path34.join(rootDir, ".wai");
-  if (fs21.existsSync(modern)) return modern;
+  if (fs22.existsSync(modern)) return modern;
   const legacy = path34.join(rootDir, ".wairon");
-  if (fs21.existsSync(legacy)) return legacy;
+  if (fs22.existsSync(legacy)) return legacy;
   return null;
 }
 function timestampSlug() {
@@ -43484,8 +44348,8 @@ var RETIRED_CODES = /* @__PURE__ */ new Set([
 var RENAMED_CODES = { MISSING_PORTAL_TYPE: "MISSING_PORTAL_TRANSPORT" };
 var WRITE_ORDER = ["component", "interface", "implementation", "subsystem", "type", "system"];
 var own = (id) => !id.includes("::");
-function liesUnder(path49, prefix) {
-  return path49 === prefix || path49.startsWith(prefix + "/");
+function liesUnder(path50, prefix) {
+  return path50 === prefix || path50.startsWith(prefix + "/");
 }
 function prefixPhrase(prefixes) {
   return prefixes.length > 0 ? prefixes.map((p) => `"${p}"`).join(", ") : "no prefix";
@@ -43776,12 +44640,15 @@ function designDigest(kind, content) {
   if (memo2 !== void 0) return memo2;
   const parsed = parsedSpec(content);
   if (!parsed) return digest(content);
-  const out = viewDigest(designViewOf(kind, parsed));
+  const out = viewDigest(designViewOf(kind, schemaRead(kind, parsed)));
   if (designDigestMemo.size > 2e4) designDigestMemo.clear();
   designDigestMemo.set(key2, out);
   return out;
 }
 var STATUS_CANDIDATES = [void 0, "draft", "design", "complete"];
+function schemaRead(kind, parsed) {
+  return kind ? asSchemaReads(kind, parsed) : parsed;
+}
 function designViewOf(kind, parsed) {
   switch (kind) {
     case "implementation":
@@ -43813,10 +44680,12 @@ function viewDigest(view3) {
 function statusApprovedIn(kind, content, recorded) {
   const parsed = parsedSpec(content);
   if (!parsed) return void 0;
-  const view3 = designViewOf(kind, parsed);
-  for (const status of STATUS_CANDIDATES) {
-    const candidate = status === void 0 ? view3 : { ...view3, status };
-    if (viewDigest(candidate) === recorded) return status ?? null;
+  const views = [designViewOf(kind, schemaRead(kind, parsed)), designViewOf(kind, parsed)];
+  for (const view3 of views) {
+    for (const status of STATUS_CANDIDATES) {
+      const candidate = status === void 0 ? view3 : { ...view3, status };
+      if (viewDigest(candidate) === recorded) return status ?? null;
+    }
   }
   return void 0;
 }
@@ -43908,19 +44777,31 @@ function diffAgainstApproval(root = getProjectRoot()) {
   for (const rel2 of Object.keys(approved)) {
     if (current2[rel2] === void 0) removed.push(rel2);
   }
+  const moved = [];
+  const unpaired = [...removed].sort();
+  for (const rel2 of [...added].sort()) {
+    const at = unpaired.findIndex((old2) => approved[old2] === current2[rel2]);
+    if (at < 0) continue;
+    const [old] = unpaired.splice(at, 1);
+    moved.push(`${old} -> ${rel2}`);
+    added.splice(added.indexOf(rel2), 1);
+    removed.splice(removed.indexOf(old), 1);
+    unchangedPaths.push(rel2);
+  }
   return {
     added: added.sort(),
     changed: changed.sort(),
     removed: removed.sort(),
-    unchangedPaths: unchangedPaths.sort()
+    unchangedPaths: unchangedPaths.sort(),
+    moved
   };
 }
 function approvalRecord(root = getProjectRoot()) {
   return readLockRecordAt(root);
 }
 function settledSpecPaths(root = getProjectRoot()) {
-  const diff2 = diffAgainstApproval(root);
-  return diff2 ? new Set(diff2.unchangedPaths) : null;
+  const diff3 = diffAgainstApproval(root);
+  return diff3 ? new Set(diff3.unchangedPaths) : null;
 }
 var REEXPRESSED_BY = "wairon doctor --fix";
 function reexpress(gate) {
@@ -43941,8 +44822,8 @@ function reexpress(gate) {
     };
   }
   if (fromReading !== "content" || !record.specs) return null;
-  const diff2 = diffAgainstApproval();
-  if (!diff2 || diffSize(diff2) > 0) return null;
+  const diff3 = diffAgainstApproval();
+  if (!diff3 || diffSize(diff3) > 0) return null;
   return { ...record, specs: captureApprovedSpecs(), specsReading: "design", format: 3, reexpressed };
 }
 function approvedStatuses(record, root = getProjectRoot()) {
@@ -43964,11 +44845,11 @@ function approvalVerdict(approvals) {
     const approval = approvalRecord();
     if (!approval) return quiet;
     const by = describeApprover(approval.lockedBy);
-    const diff2 = diffAgainstApproval();
-    const notes = memberNotes(approvals ?? [], approval, diff2);
+    const diff3 = diffAgainstApproval();
+    const notes = memberNotes(approvals ?? [], approval, diff3);
     const pinDrift = notes.drift;
     const childNote = notes.text;
-    if (!diff2) {
+    if (!diff3) {
       return {
         text: `
 Approved: ${approval.lockedAt} by ${by} \u2014 this lock predates per-spec approval, so drift is only visible at whole-tree level. Re-lock to record it.${childNote}
@@ -43979,7 +44860,7 @@ Approved: ${approval.lockedAt} by ${by} \u2014 this lock predates per-spec appro
     const own2 = (approvals ?? []).find((a) => a.key === "");
     const carry = isContentReadingRecord(approval) && own2?.state === "approved" ? `
 ${REEXPRESS_HINT}` : "";
-    if (diffSize(diff2) === 0) {
+    if (diffSize(diff3) === 0) {
       return {
         text: `
 Approved: ${approval.lockedAt} by ${by} \u2014 no spec has changed since.${childNote}${carry}
@@ -43988,21 +44869,21 @@ Approved: ${approval.lockedAt} by ${by} \u2014 no spec has changed since.${child
       };
     }
     const parts = [];
-    if (diff2.changed.length) parts.push(`${diff2.changed.length} changed`);
-    if (diff2.added.length) parts.push(`${diff2.added.length} added`);
-    if (diff2.removed.length) parts.push(`${diff2.removed.length} removed`);
-    const named2 = [...diff2.changed, ...diff2.added, ...diff2.removed].slice(0, 5);
-    const rest = diffSize(diff2) - named2.length;
-    const n = diffSize(diff2);
+    if (diff3.changed.length) parts.push(`${diff3.changed.length} changed`);
+    if (diff3.added.length) parts.push(`${diff3.added.length} added`);
+    if (diff3.removed.length) parts.push(`${diff3.removed.length} removed`);
+    const named2 = [...diff3.changed, ...diff3.added, ...diff3.removed].slice(0, 5);
+    const rest = diffSize(diff3) - named2.length;
+    const n = diffSize(diff3);
     const noun = `${n} spec${n === 1 ? "" : "s"}`;
-    const headline = parts.length === 1 ? `${noun} ${parts[0].slice(String(diffSize(diff2)).length + 1)} since approval` : `${noun} changed since approval (${parts.join(", ")})`;
+    const headline = parts.length === 1 ? `${noun} ${parts[0].slice(String(diffSize(diff3)).length + 1)} since approval` : `${noun} changed since approval (${parts.join(", ")})`;
     return {
       text: `
 ${headline} \u2014 approved ${approval.lockedAt} by ${by}:
 ` + named2.map((p) => `  ${p}`).join("\n") + (rest > 0 ? `
   \u2026 and ${rest} more` : "") + childNote + carry + "\n",
       drifted: true,
-      moved: [...diff2.changed.map((p) => `~ ${p}`), ...diff2.added.map((p) => `+ ${p}`), ...diff2.removed.map((p) => `- ${p}`)]
+      moved: [...diff3.changed.map((p) => `~ ${p}`), ...diff3.added.map((p) => `+ ${p}`), ...diff3.removed.map((p) => `- ${p}`)]
     };
   } catch {
     return quiet;
@@ -44015,7 +44896,7 @@ var REEXPRESS_HINT = "This approval predates lock format 3 and is read in its or
 var FORMAT2_STALE_NOTE = "it was taken before code linkage (sourcePath, symbol, simPath and the like) left the approval, and something it covered moved since \u2014 the design, or only code linkage, which this record can no longer tell apart. One `wairon lock` clears it for good: from then on linkage never drifts the approval";
 var GATE_UPGRADE_NOTE = "the gate identity gained inputs in this release (members' composition subjects, `composition`; code conformance moved beside the claim)";
 var GATE_MOVED_NOTE = "no own spec file changed since it was taken \u2014 not even its code linkage \u2014 so what moved is the gate it was judged under: the design rules this wairon release judges by, or the project's rule tuning, `composition`, network declaration, consumed contracts or a member's approval. One `wairon lock` re-approves the unchanged design under the current gate";
-function memberNotes(approvals, record, diff2) {
+function memberNotes(approvals, record, diff3) {
   const own2 = approvals.find((a) => a.key === "");
   const direct = approvals.filter((a) => a.parent === "" && a.as !== "part");
   const moved = direct.filter((a) => a.pinned === "moved");
@@ -44023,7 +44904,7 @@ function memberNotes(approvals, record, diff2) {
   const lines = [];
   if (own2?.upgraded) {
     const by = record?.validatorVersion ? ` (taken by wairon ${record.validatorVersion})` : "";
-    lines.push(diff2 && diffSize(diff2) === 0 ? `This approval no longer matches${by}: ${GATE_MOVED_NOTE}.` : record && record.format === 2 ? `This approval no longer matches: ${FORMAT2_STALE_NOTE}.` : `This approval was taken under an earlier gate identity \u2014 ${GATE_UPGRADE_NOTE}. Re-lock once.`);
+    lines.push(diff3 && diffSize(diff3) === 0 ? `This approval no longer matches${by}: ${GATE_MOVED_NOTE}.` : record && record.format === 2 ? `This approval no longer matches: ${FORMAT2_STALE_NOTE}.` : `This approval was taken under an earlier gate identity \u2014 ${GATE_UPGRADE_NOTE}. Re-lock once.`);
   }
   if (moved.length) {
     lines.push(`${moved.length} member pin(s) moved since approval: ${moved.map((a) => a.alias ?? a.key).join(", ")} \u2014 re-lock to approve them.`);
@@ -44075,7 +44956,7 @@ function localApprover() {
 }
 
 // src/utils/ai-guide.ts
-var fs22 = __toESM(require("fs"));
+var fs23 = __toESM(require("fs"));
 var os6 = __toESM(require("os"));
 var path36 = __toESM(require("path"));
 
@@ -44165,10 +45046,10 @@ ${versionStamp()}
 ${body}
 ${GUIDE_MARKER_END}
 `;
-  const existing = fs22.existsSync(filePath) ? fs22.readFileSync(filePath, "utf-8") : "";
+  const existing = fs23.existsSync(filePath) ? fs23.readFileSync(filePath, "utf-8") : "";
   const stripped = stripGuideSection(existing);
   const newContent = stripped.trimEnd() + section;
-  fs22.mkdirSync(path36.dirname(filePath), { recursive: true });
+  fs23.mkdirSync(path36.dirname(filePath), { recursive: true });
   writeFile(filePath, newContent);
 }
 function stripGuideSection(content) {
@@ -44213,7 +45094,7 @@ Refer to the rules in [.cursor/rules/](.cursor/rules/) for full instructions.
     writeFile(filePath, content);
   } else if (targetType === "copilot") {
     const filePath = path36.join(projectRoot, ".github", "copilot-instructions.md");
-    fs22.mkdirSync(path36.dirname(filePath), { recursive: true });
+    fs23.mkdirSync(path36.dirname(filePath), { recursive: true });
     const content = `# Wairon SDD Project
 
 This project uses the Wairon Spec-Driven Development (SDD) framework.
@@ -44244,6 +45125,22 @@ function reinjectLocalGuides(projectRoot, targetTypes) {
   }
   return written;
 }
+function registerProjectServer(projectRoot) {
+  const file = path36.join(projectRoot, ".mcp.json");
+  let settings = {};
+  if (fs23.existsSync(file)) {
+    try {
+      settings = JSON.parse(fs23.readFileSync(file, "utf8"));
+    } catch {
+      return null;
+    }
+  }
+  const servers = settings.mcpServers ?? {};
+  if (servers.wairon !== void 0) return null;
+  settings.mcpServers = { ...servers, wairon: { command: "wairon", args: ["mcp", "serve"] } };
+  writeFile(file, JSON.stringify(settings, null, 2) + "\n");
+  return file;
+}
 
 // src/core/context.ts
 function contextDir(...segments) {
@@ -44612,8 +45509,14 @@ function getStatusReport(options = {}, decor) {
 `;
   }
   const own2 = options.approvals?.find((a) => a.key === "");
-  if (own2) output += `${mark.layer("system", "Approval:")} this project is ${OWN_APPROVAL_WORDS[own2.state]}${own2.upgraded ? " (locked under an earlier gate identity \u2014 re-lock once)" : ""}
+  const nothingDesigned = own2?.state === "never" && loadSubsystemSpecs().length === 0 && !(options.approvals ?? []).some((a) => a.key !== "" && a.parent === "" && a.as !== "part");
+  if (own2 && nothingDesigned) {
+    output += `${mark.layer("system", "Approval:")} nothing to approve yet \u2014 the tree holds the L0 and nothing below it (add a subsystem, then \`wairon lock\`)
 `;
+  } else if (own2) {
+    output += `${mark.layer("system", "Approval:")} this project is ${OWN_APPROVAL_WORDS[own2.state]}${own2.upgraded ? " (locked under an earlier gate identity \u2014 re-lock once)" : ""}
+`;
+  }
   return { text: output, failed: false };
 }
 
@@ -44706,7 +45609,7 @@ var logger = {
 
 // src/core/skills.ts
 var path38 = __toESM(require("path"));
-var fs23 = __toESM(require("fs"));
+var fs24 = __toESM(require("fs"));
 
 // src/core/instructions.ts
 function governingProfile() {
@@ -44846,6 +45749,22 @@ function packSkillId(skill) {
 function packNamespace(pack) {
   return pack.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
+function extensionsFor(builtin, packSkills) {
+  return packSkills.filter((s) => s.extends === builtin && fs24.existsSync(s.sourcePath));
+}
+function composeBuiltinSkill(name, packSkills) {
+  const srcPath = skillTemplatePath(name);
+  const base = fs24.existsSync(srcPath) ? fs24.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 = fs24.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 match2 = /^---\r?\n([\s\S]*?)\r?\n---/.exec(raw);
   const block2 = match2 ? match2[1] : "";
@@ -44861,6 +45780,63 @@ function builtinSkillsDir() {
 function skillTemplatePath(name) {
   return path38.join(builtinSkillsDir(), `${name}.md`);
 }
+function skillDestPath(type, destDir, name) {
+  if (type === "claude" || type === "codex" || type === "gemini" || type === "agy") {
+    return path38.join(destDir, name, "SKILL.md");
+  }
+  return path38.join(destDir, `${name}.md`);
+}
+function skillsDirForTarget(type) {
+  switch (type) {
+    case "claude":
+      return fromProjectRoot(".claude", "skills");
+    case "gemini":
+    // Gemini-based Antigravity
+    case "agy":
+    case "codex":
+      return fromProjectRoot(".agents", "skills");
+    case "cursor":
+      return fromProjectRoot(".cursor", "skills");
+    default:
+      return null;
+  }
+}
+function exportSddSkills(targetTypes) {
+  const types = targetTypes ?? activeTargetTypes2();
+  const destinations = [];
+  const skipped = [];
+  let fileCount = 0;
+  const packSkills = loadProjectExtensions().skills;
+  for (const type of types) {
+    const destDir = skillsDirForTarget(type);
+    if (!destDir) {
+      skipped.push(type);
+      continue;
+    }
+    ensureDir(destDir);
+    destinations.push(destDir);
+    for (const name of SKILL_NAMES) {
+      if (!fs24.existsSync(skillTemplatePath(name))) continue;
+      const content = composeBuiltinSkill(name, packSkills.filter((s) => s.targets.includes(type)));
+      const destPath = skillDestPath(type, destDir, name);
+      ensureDir(path38.dirname(destPath));
+      writeFileIfChanged(destPath, content);
+      fileCount++;
+    }
+    for (const skill of packSkills) {
+      if (skill.extends !== void 0) continue;
+      if (!skill.targets.includes(type)) continue;
+      if (!fs24.existsSync(skill.sourcePath)) continue;
+      const id = packSkillId(skill);
+      const content = fs24.readFileSync(skill.sourcePath, "utf-8");
+      const destPath = skillDestPath(type, destDir, id);
+      ensureDir(path38.dirname(destPath));
+      writeFileIfChanged(destPath, content);
+      fileCount++;
+    }
+  }
+  return { destinations, fileCount, skipped };
+}
 function activeTargetTypes2() {
   const config = loadProjectConfig();
   if (!config) return [];
@@ -44869,7 +45845,7 @@ function activeTargetTypes2() {
 var SKILL_RESOURCE_SCHEME = "wairon-skill";
 var RESOURCE_SKILL_IDS = [...SKILL_NAMES].sort();
 function readSkillFrontmatter(name) {
-  return readFrontmatter(fs23.readFileSync(skillTemplatePath(name), "utf-8"), name);
+  return readFrontmatter(fs24.readFileSync(skillTemplatePath(name), "utf-8"), name);
 }
 function listSkillResources() {
   const builtin = RESOURCE_SKILL_IDS.map((id) => {
@@ -44883,9 +45859,9 @@ function listSkillResources() {
       defaultForHostedMcp: true
     };
   });
-  const pack = loadProjectExtensions().skills.filter((s) => s.extends === void 0 && fs23.existsSync(s.sourcePath)).map((skill) => {
+  const pack = loadProjectExtensions().skills.filter((s) => s.extends === void 0 && fs24.existsSync(s.sourcePath)).map((skill) => {
     const id = packSkillId(skill);
-    const fm = readFrontmatter(fs23.readFileSync(skill.sourcePath, "utf-8"), id);
+    const fm = readFrontmatter(fs24.readFileSync(skill.sourcePath, "utf-8"), id);
     return {
       id,
       name: fm.name,
@@ -44906,7 +45882,7 @@ var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod12 = require("zod");
 var import_types16 = require("@modelcontextprotocol/sdk/types.js");
-var path48 = __toESM(require("path"));
+var path49 = __toESM(require("path"));
 var crypto10 = __toESM(require("crypto"));
 
 // src/core/adapters/authoring-core.ts
@@ -45169,6 +46145,16 @@ function carryInto(restatement, existing, candidate) {
       method.previousNames = prev.previousNames;
       carried.push(`previousNames (${String(method.name)})`);
     }
+    for (const method of candidate.methods) {
+      const prev = stored.find((p) => p.name === method.name);
+      const prevParams = Array.isArray(prev?.params) ? prev.params : [];
+      for (const param of Array.isArray(method.params) ? method.params : []) {
+        const before = prevParams.find((p) => p.name === param.name);
+        if (before?.previousNames === void 0 || param.previousNames !== void 0) continue;
+        param.previousNames = before.previousNames;
+        carried.push(`previousNames (param ${String(method.name)}.${String(param.name)})`);
+      }
+    }
   }
   if (restatement.kind === "type" && Array.isArray(candidate.fields)) {
     const stored = existing.fields ?? [];
@@ -45382,6 +46368,9 @@ function updateSpecGated(kind, id, delta, dryRun) {
   const stored = loadSpec(kind, id);
   const gate = componentCandidateGate(bound2, stored?.subsystem, stored);
   const report3 = updateSpec(kind, id, delta, gate, dryRun);
+  if (kind === "component" && typeof delta?.transport === "string" && report3.changes.some((c) => c.path === "transport")) {
+    report3.notices.push(...adapterTransportImpact(id, delta.transport));
+  }
   const changed = changedMethods(report3);
   if (changed.length > 0 && testRoots.length > 0) {
     const written = Array.isArray(delta?.methods) ? delta.methods : [];
@@ -45389,6 +46378,19 @@ function updateSpecGated(kind, id, delta, dryRun) {
   }
   return report3;
 }
+function adapterTransportImpact(portal, transport) {
+  const components = loadComponentSpecs();
+  if (components.find((c) => c.id === portal)?.componentType !== "Portal") return [];
+  const names = (ref) => ref === portal || ref !== void 0 && ref.endsWith(`::${portal}`);
+  const calledByStep = /* @__PURE__ */ new Set();
+  for (const impl of loadImplementationSpecs()) {
+    const owner = loadSpec("interface", impl.contract)?.component;
+    if (owner === void 0) continue;
+    const steps = impl.methods.flatMap((m) => m.narrative ?? []);
+    if (steps.some((s) => (s.type === "call" || s.type === "register" || s.type === "dispatch") && names(s.targetComponent))) calledByStep.add(owner);
+  }
+  return components.filter((c) => c.componentType === "Adapter" && c.transport !== void 0 && c.transport !== transport).filter((c) => (c.dependsOn ?? []).some(names) || calledByStep.has(c.id)).map((c) => `ADAPTER_TRANSPORT_MISMATCH would follow: Adapter "${c.id}" states transport "${c.transport}" and calls "${portal}", whose transport becomes "${transport}" \u2014 state "${transport}" on "${c.id}", or unset its transport so it follows the Portal.`);
+}
 function changedMethods(report3) {
   const named2 = /* @__PURE__ */ new Set();
   for (const change of report3.changes) {
@@ -45425,12 +46427,12 @@ function moveMethods2(from, to, methods, dryRun) {
 }
 
 // src/mcp/build.ts
-var fs24 = __toESM(require("fs"));
+var fs25 = __toESM(require("fs"));
 var path39 = __toESM(require("path"));
 var import_child_process3 = require("child_process");
 function captureBuildStamp(entryPath) {
   try {
-    const s = fs24.statSync(entryPath);
+    const s = fs25.statSync(entryPath);
     return { path: entryPath, mtimeMs: s.mtimeMs, size: s.size };
   } catch {
     return null;
@@ -45439,7 +46441,7 @@ function captureBuildStamp(entryPath) {
 function isBuildStale(stamp) {
   if (!stamp) return false;
   try {
-    const s = fs24.statSync(stamp.path);
+    const s = fs25.statSync(stamp.path);
     return s.mtimeMs !== stamp.mtimeMs || s.size !== stamp.size;
   } catch {
     return false;
@@ -45447,7 +46449,7 @@ function isBuildStale(stamp) {
 }
 var fingerprintCache = /* @__PURE__ */ new Map();
 function readBuildFingerprint(stamp) {
-  const current2 = fs24.statSync(stamp.path);
+  const current2 = fs25.statSync(stamp.path);
   const key2 = `${stamp.path}|${current2.mtimeMs}|${current2.size}`;
   const cached = fingerprintCache.get(key2);
   if (cached !== void 0) return cached;
@@ -45473,9 +46475,9 @@ function fingerprintModuleFor(entryPath) {
   let dir = path39.dirname(entryPath);
   for (; ; ) {
     const manifest = path39.join(dir, "package.json");
-    if (fs24.existsSync(manifest)) {
+    if (fs25.existsSync(manifest)) {
       try {
-        const pkg = JSON.parse(fs24.readFileSync(manifest, "utf8"));
+        const pkg = JSON.parse(fs25.readFileSync(manifest, "utf8"));
         const inDist = path39.relative(path39.join(dir, "dist"), entryPath);
         if (pkg.name === "@wairon/cli" && pkg.main && !inDist.startsWith("..") && !path39.isAbsolute(inDist)) {
           return path39.resolve(dir, pkg.main);
@@ -45491,6 +46493,9 @@ function fingerprintModuleFor(entryPath) {
 }
 
 // src/core/skills-portal.ts
+function exportSddSkills2(targetTypes) {
+  return exportSddSkills(targetTypes);
+}
 function buildServerInstructions3() {
   return buildServerInstructions2();
 }
@@ -45582,10 +46587,10 @@ function findingLine(f) {
 }
 function markFlows(flows3, f) {
   if (f.specId === void 0) return;
-  const onVerb = (flow) => flow.from.scope !== void 0 && flow.to.component === f.specId && (f.at === void 0 || flow.to.verb === f.at);
+  const onVerb = (flow) => flow.from.scope !== void 0 && flow.to.component === f.specId && (f.at !== void 0 ? flow.to.verb === f.at : f.covers === void 0 || f.covers.includes(flow.to.verb ?? ""));
   const onCall = (flow) => flow.from.scope === void 0 && flow.from.component === f.specId && f.at !== void 0 && flow.evidence.includes(`call ${f.at}`);
   for (const flow of flows3.filter((x) => onVerb(x) || onCall(x))) {
-    const field = f.severity === "error" ? "refusedBy" : "flaggedBy";
+    const field = f.severity === "error" ? "refusedBy" : f.severity === "notice" ? "notedBy" : "flaggedBy";
     const list = flow[field] ?? [];
     if (!list.includes(findingLine(f))) list.push(findingLine(f));
     flow[field] = list;
@@ -45608,7 +46613,10 @@ function project2(model) {
   }
   const marked = [...flows3.values()];
   for (const f of model.findings ?? []) markFlows(marked, f);
-  return marked.sort(byCalleeThenCaller);
+  const focus = model.focus;
+  const inside = (party) => focus !== void 0 && party.project !== void 0 && (party.project === focus || party.project.startsWith(`${focus}::`));
+  const kept = focus === void 0 ? marked : marked.filter((f) => inside(f.from) || inside(f.to));
+  return kept.sort(byCalleeThenCaller);
 }
 function networkName2(id) {
   return id === "" ? "(root network)" : id;
@@ -45618,7 +46626,7 @@ function chainOf(flow) {
   for (const network of flow.crosses) lines.push(`enters network ${networkName2(network)}`);
   if (flow.via !== void 0) lines.push(`through gateway ${flow.via}`);
   lines.push(`reaches ${key(flow.to)} over ${flow.transport}${flow.binding ? ` (${flow.binding})` : ""}`);
-  for (const flag of flow.flaggedBy ?? []) lines.push(`marked by the gate: ${flag}`);
+  for (const flag of [...flow.flaggedBy ?? [], ...flow.notedBy ?? []]) lines.push(`marked by the gate: ${flag}`);
   return lines;
 }
 function verbParty(v) {
@@ -45627,8 +46635,14 @@ function verbParty(v) {
 function reachesOverNetwork(model, to) {
   return model.verbs.some((v) => transportKind(v.transport) === "network" && isNamed(verbParty(v), to));
 }
+function throughExternal(model, name) {
+  const at = name.indexOf("::");
+  const alias = at > 0 ? name.slice(0, at) : name;
+  return (model.externals ?? []).includes(alias) ? alias : void 0;
+}
 function isKnown(model, name) {
   if (name === "outside" || name === "network") return true;
+  if ((model.subsystems ?? []).some((s) => s === name || s.startsWith(`${name}::`)) || throughExternal(model, name) !== void 0) return true;
   if (name.startsWith("network:")) return model.networks.some((n) => n.id === name.slice("network:".length));
   const placed = (model.placements ?? []).some((p) => isNamed({ project: p.project, ...p.subsystem !== void 0 ? { subsystem: p.subsystem } : {}, component: p.component }, name));
   return placed || model.verbs.some((v) => isNamed(verbParty(v), name)) || model.calls.some((c) => isNamed(callerOf(c), name));
@@ -45642,6 +46656,18 @@ function notAllowed(model, flows3, refused3, from, to) {
     return { allowed: false, flows: [], chain: chain2, refusedBy };
   }
   if (!reachesOverNetwork(model, to)) {
+    const alias = throughExternal(model, to);
+    if (alias !== void 0) {
+      return {
+        allowed: false,
+        flows: [],
+        inProcess: true,
+        chain: [
+          `${to} is consumed through the external "${alias}": this design's network model holds no verb of it, so it neither allows nor forbids a network flow to it here`,
+          `a library is reached in-process; a network producer's flows are derived and judged in its own project (\`wairon network flows\` there)`
+        ]
+      };
+    }
     return {
       allowed: false,
       flows: [],
@@ -45689,17 +46715,31 @@ function codeOf(line) {
 }
 function gateCell(flow) {
   if (refusedFlow(flow)) return `REFUSED: ${[...new Set(flow.refusedBy.map(codeOf))].join("; ")}`;
-  return [...new Set((flow.flaggedBy ?? []).map(codeOf))].join("; ");
+  return [...new Set([...flow.flaggedBy ?? [], ...flow.notedBy ?? []].map(codeOf))].join("; ");
 }
 function gateFindingsOf(flows3) {
   const errors = /* @__PURE__ */ new Set();
   const flags = /* @__PURE__ */ new Set();
+  const notes = /* @__PURE__ */ new Set();
   for (const f of flows3) {
     for (const line of f.refusedBy ?? []) errors.add(line);
     for (const line of f.flaggedBy ?? []) flags.add(line);
+    for (const line of f.notedBy ?? []) notes.add(line);
   }
   const withSeverity = (line, severity) => `${codeOf(line)} (${severity})${line.slice(codeOf(line).length)}`;
-  return [...[...errors].map((l) => withSeverity(l, "error")), ...[...flags].map((l) => withSeverity(l, "warning"))];
+  return [
+    ...[...errors].map((l) => withSeverity(l, "error")),
+    ...[...flags].map((l) => withSeverity(l, "warning")),
+    ...[...notes].map((l) => withSeverity(l, "notice"))
+  ];
+}
+function namedRoot(flow, rootProject) {
+  const party = (p) => ({
+    ...p,
+    ...p.project === "" ? { project: rootProject } : {},
+    ...p.network === "" ? { network: rootProject } : {}
+  });
+  return { ...flow, from: party(flow.from), to: party(flow.to), crosses: flow.crosses.map((n) => n === "" ? rootProject : n) };
 }
 function networkName3(id) {
   return id === "" ? "(root network)" : id;
@@ -45734,11 +46774,11 @@ function markdownOf(flows3) {
   const warning = refused3.length > 0 ? [`> **The design fails the gate:** ${refused3.length} row(s) marked REFUSED are refused by \`wairon validate\`, not allowed. Fix the design before trusting this matrix.`, ...gateFindingsOf(flows3).map((l) => `> - ${l.replace(/\n/g, " ")}`), ""] : [];
   return [...warning, ...header, ...rows].join("\n") + "\n" + (flows3.length === 0 ? "\n_No network-transport flows: in-process and local verbs never produce one._\n" : "");
 }
-function encodeFlows(flows3, format) {
+function encodeFlows(flows3, format, rootProject) {
   const gate = { gateFindings: gateFindingsOf(flows3), refused: flows3.some(refusedFlow) };
   switch (format) {
     case "json":
-      return { format, content: JSON.stringify(sortedKeys2(flows3), null, 2) + "\n", unbound: [], ...gate };
+      return { format, content: JSON.stringify(sortedKeys2(rootProject ? flows3.map((f) => namedRoot(f, rootProject)) : flows3), null, 2) + "\n", unbound: [], ...gate };
     case "csv":
       return { format, content: csvOf(flows3), unbound: [], ...gate };
     default:
@@ -45750,13 +46790,24 @@ function encodeFlows(flows3, format) {
 function flows(options, format) {
   const model = reachModel2(options);
   const matrix = project2(model);
-  return encodeFlows(matrix, format);
+  const doc = encodeFlows(matrix, format, model.rootProject);
+  return withFamilyNote(doc, model);
+}
+function withFamilyNote(doc, model) {
+  if (model.focus === void 0 || model.judgedAt === void 0) return doc;
+  const note = `"${model.focus}" is a member: this is its enclosing family's network, declared and proven at the family root ${model.judgedAt}, narrowed to the flows that start or land inside it \u2014 the same rows \`wairon network\` derives there.`;
+  return { ...doc, notes: [note, ...doc.notes ?? []] };
 }
 function why(options, from, to) {
   const model = reachModel2(options);
-  const matrix = project2(model);
+  const matrix = project2(unfocused(model));
   return explain(matrix, from, to, model);
 }
+function unfocused(model) {
+  if (model.focus === void 0) return model;
+  const { focus: _focus, ...whole } = model;
+  return whole;
+}
 
 // src/mcp/network.ts
 function lands(flow, to) {
@@ -45772,10 +46823,16 @@ function explain2(from, to) {
   return why({}, from, to);
 }
 function declare2(declared, description) {
-  const network = declared ? description ? { description } : {} : null;
+  const held = declared ? loadProjectConfig()?.network : void 0;
+  const kept = description ?? (typeof held === "object" && held !== null ? held.description ?? null : null);
+  const network = declared ? kept ? { description: kept } : {} : null;
   return setNetwork(network);
 }
 
+// src/mcp/migrations.ts
+var fs30 = __toESM(require("fs"));
+var path48 = __toESM(require("path"));
+
 // src/migrations/orchestrator.ts
 var path47 = __toESM(require("path"));
 
@@ -46828,12 +47885,12 @@ function pin(p, log) {
 }
 
 // src/migrations/membership.ts
-var fs26 = __toESM(require("fs"));
+var fs27 = __toESM(require("fs"));
 var path43 = __toESM(require("path"));
 
 // src/migrations/family-files.ts
 var crypto8 = __toESM(require("crypto"));
-var fs25 = __toESM(require("fs"));
+var fs26 = __toESM(require("fs"));
 var nodePath = __toESM(require("path"));
 var WAI = ".wai";
 var TRANSACTIONS = "transactions";
@@ -46846,7 +47903,7 @@ function pause(ms) {
 }
 function readOnly(target) {
   try {
-    return (fs25.statSync(target).mode & 128) === 0;
+    return (fs26.statSync(target).mode & 128) === 0;
   } catch {
     return false;
   }
@@ -46872,7 +47929,7 @@ function waiFiles(owner) {
   const walk2 = (dir, rel2) => {
     let entries;
     try {
-      entries = fs25.readdirSync(dir, { withFileTypes: true });
+      entries = fs26.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -46892,7 +47949,7 @@ function waiOwners(root) {
   const walk2 = (dir) => {
     let entries;
     try {
-      entries = fs25.readdirSync(dir, { withFileTypes: true });
+      entries = fs26.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -46916,7 +47973,7 @@ function areaFiles(owner, area) {
     const abs = nodePath.join(owner, ...rel2.split("/"));
     let stat;
     try {
-      stat = fs25.lstatSync(abs);
+      stat = fs26.lstatSync(abs);
     } catch {
       return;
     }
@@ -46926,7 +47983,7 @@ function areaFiles(owner, area) {
       return;
     }
     if (!stat.isDirectory()) return;
-    for (const name of fs25.readdirSync(abs)) walk2(`${rel2}/${name}`);
+    for (const name of fs26.readdirSync(abs)) walk2(`${rel2}/${name}`);
   };
   walk2(area.split(nodePath.sep).join("/").replace(/\/+$/, ""));
   return out.sort();
@@ -46936,7 +47993,7 @@ function everyFile(owner) {
   const walk2 = (dir, rel2) => {
     let entries;
     try {
-      entries = fs25.readdirSync(dir, { withFileTypes: true });
+      entries = fs26.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -46980,22 +48037,22 @@ function assertPlaceable(familyRoot, base, owner) {
 }
 function nearestExisting(p) {
   let at = nodePath.resolve(p);
-  while (!fs25.existsSync(at) && at !== nodePath.dirname(at)) at = nodePath.dirname(at);
+  while (!fs26.existsSync(at) && at !== nodePath.dirname(at)) at = nodePath.dirname(at);
   return at;
 }
 function copyFiles(owner, rels, at, digests) {
-  fs25.mkdirSync(at, { recursive: true });
+  fs26.mkdirSync(at, { recursive: true });
   for (const rel2 of rels) {
     const live = nodePath.join(owner, ...rel2.split("/"));
     let bytes;
     try {
-      bytes = fs25.readFileSync(live);
+      bytes = fs26.readFileSync(live);
     } catch (e) {
       throw new Error(`could not copy ${live} into the rehearsal: ${e instanceof Error ? e.message : String(e)}`);
     }
     const copy = nodePath.join(at, ...rel2.split("/"));
-    fs25.mkdirSync(nodePath.dirname(copy), { recursive: true });
-    fs25.writeFileSync(copy, bytes);
+    fs26.mkdirSync(nodePath.dirname(copy), { recursive: true });
+    fs26.writeFileSync(copy, bytes);
     digests.set(live, sha2562(bytes));
   }
 }
@@ -47004,7 +48061,7 @@ function compare4(rehearsal) {
   const seen = /* @__PURE__ */ new Set();
   for (const [live, copyRoot, rel2] of comparedFiles(rehearsal)) {
     seen.add(nodePath.join(live, ...rel2.split("/")));
-    const change = changeOf(rehearsal, live, rel2, sha2562(fs25.readFileSync(nodePath.join(copyRoot, ...rel2.split("/")))));
+    const change = changeOf(rehearsal, live, rel2, sha2562(fs26.readFileSync(nodePath.join(copyRoot, ...rel2.split("/")))));
     if (change) changes.push(change);
   }
   for (const [liveFile, base] of rehearsal.baseDigests) {
@@ -47039,7 +48096,7 @@ function ownerOf3(rehearsal, liveFile) {
 }
 function move(from, to) {
   const rels = everyFile(from);
-  const taken = rels.find((rel2) => fs25.existsSync(nodePath.join(to, ...rel2.split("/"))));
+  const taken = rels.find((rel2) => fs26.existsSync(nodePath.join(to, ...rel2.split("/"))));
   if (taken !== void 0) throw new Error(`cannot move ${from} to ${to}: ${nodePath.join(to, ...taken.split("/"))} already exists`);
   for (const rel2 of rels) {
     const target = nodePath.join(to, ...rel2.split("/"));
@@ -47049,45 +48106,45 @@ function move(from, to) {
   for (const rel2 of rels) prune2(nodePath.dirname(nodePath.join(from, ...rel2.split("/"))), nodePath.dirname(from));
   prune2(from, nodePath.dirname(from));
 }
-function read(path49) {
+function read(path50) {
   try {
-    return fs25.readFileSync(path49);
+    return fs26.readFileSync(path50);
   } catch (e) {
     if (e.code === "ENOENT") return null;
-    throw new Error(`could not read ${path49}: ${e instanceof Error ? e.message : String(e)}`);
+    throw new Error(`could not read ${path50}: ${e instanceof Error ? e.message : String(e)}`);
   }
 }
-function digest2(path49) {
-  const bytes = read(path49);
+function digest2(path50) {
+  const bytes = read(path50);
   return bytes === null ? null : sha2562(bytes);
 }
 function replace(source, target) {
-  retrying("replace", target, () => fs25.renameSync(source, target));
+  retrying("replace", target, () => fs26.renameSync(source, target));
 }
-function place(path49, bytes) {
-  fs25.mkdirSync(nodePath.dirname(path49), { recursive: true });
-  const tmp = `${path49}.wairon-restore`;
-  const fd = fs25.openSync(tmp, "w");
+function place(path50, bytes) {
+  fs26.mkdirSync(nodePath.dirname(path50), { recursive: true });
+  const tmp = `${path50}.wairon-restore`;
+  const fd = fs26.openSync(tmp, "w");
   try {
-    fs25.writeSync(fd, bytes);
-    fs25.fsyncSync(fd);
+    fs26.writeSync(fd, bytes);
+    fs26.fsyncSync(fd);
   } finally {
-    fs25.closeSync(fd);
+    fs26.closeSync(fd);
   }
   try {
-    retrying("place", path49, () => fs25.renameSync(tmp, path49));
+    retrying("place", path50, () => fs26.renameSync(tmp, path50));
   } catch (e) {
     try {
-      fs25.unlinkSync(tmp);
+      fs26.unlinkSync(tmp);
     } catch {
     }
     throw e;
   }
 }
-function remove2(path49) {
-  retrying("remove", path49, () => {
+function remove2(path50) {
+  retrying("remove", path50, () => {
     try {
-      fs25.unlinkSync(path49);
+      fs26.unlinkSync(path50);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
@@ -47096,13 +48153,13 @@ function remove2(path49) {
 function makeDirs(dir) {
   const missing = [];
   let at = nodePath.resolve(dir);
-  while (!fs25.existsSync(at)) {
+  while (!fs26.existsSync(at)) {
     missing.unshift(at);
     const up = nodePath.dirname(at);
     if (up === at) break;
     at = up;
   }
-  for (const d of missing) fs25.mkdirSync(d);
+  for (const d of missing) fs26.mkdirSync(d);
   return missing;
 }
 function prune2(dir, stopAt) {
@@ -47112,47 +48169,47 @@ function prune2(dir, stopAt) {
   while (at !== stop && within3(stop, at)) {
     let entries;
     try {
-      entries = fs25.readdirSync(at);
+      entries = fs26.readdirSync(at);
     } catch {
       break;
     }
     if (entries.length > 0) break;
-    fs25.rmdirSync(at);
+    fs26.rmdirSync(at);
     removed.push(at);
     at = nodePath.dirname(at);
   }
   return removed;
 }
-function resolve35(root, path49) {
-  const dir = lexicalTarget(root, path49);
+function resolve35(root, path50) {
+  const dir = lexicalTarget(root, path50);
   return dir !== null && landsWithin(root, dir) ? dir : null;
 }
 function strictlyWithin(root, dir) {
   const rel2 = nodePath.relative(root, dir);
   return rel2 !== "" && !rel2.startsWith("..") && !nodePath.isAbsolute(rel2);
 }
-function lexicalTarget(root, path49) {
-  if (!path49 || nodePath.isAbsolute(path49) || nodePath.win32.isAbsolute(path49)) return null;
-  const dir = nodePath.resolve(root, path49);
+function lexicalTarget(root, path50) {
+  if (!path50 || nodePath.isAbsolute(path50) || nodePath.win32.isAbsolute(path50)) return null;
+  const dir = nodePath.resolve(root, path50);
   return strictlyWithin(root, dir) ? dir : null;
 }
 function landsWithin(root, dir) {
   let at = dir;
-  while (!fs25.existsSync(at) && at !== nodePath.dirname(at)) at = nodePath.dirname(at);
+  while (!fs26.existsSync(at) && at !== nodePath.dirname(at)) at = nodePath.dirname(at);
   try {
-    const real = fs25.realpathSync(at);
-    const realRoot = fs25.realpathSync(root);
+    const real = fs26.realpathSync(at);
+    const realRoot = fs26.realpathSync(root);
     return real === realRoot || strictlyWithin(realRoot, real);
   } catch {
     return false;
   }
 }
 function holdsProject(dir) {
-  return fs25.existsSync(nodePath.join(dir, ".wai", "project.yaml"));
+  return fs26.existsSync(nodePath.join(dir, ".wai", "project.yaml"));
 }
 function sameVolume(a, b) {
   try {
-    return fs25.statSync(a).dev === fs25.statSync(b).dev;
+    return fs26.statSync(a).dev === fs26.statSync(b).dev;
   } catch {
     return false;
   }
@@ -47167,7 +48224,7 @@ function emptyPlan(family, request) {
   const whole = !(reach2 !== null && !reach2.parentReach);
   return { request, familyRoot: familyNode(family, "").directory, whole, edits: [], refusals: [], changes: [], relock: [], notes: [] };
 }
-var posix5 = (p) => p.split(path43.sep).join("/");
+var posix6 = (p) => p.split(path43.sep).join("/");
 var refuse = (plan6, code, project3, detail) => {
   plan6.refusals.push({ code, project: project3, detail });
 };
@@ -47195,7 +48252,7 @@ function hasSystemAt(dir) {
 }
 function occupied(dir) {
   try {
-    return !fs26.statSync(dir).isDirectory() || fs26.readdirSync(dir).length > 0;
+    return !fs27.statSync(dir).isDirectory() || fs27.readdirSync(dir).length > 0;
   } catch {
     return false;
   }
@@ -47245,7 +48302,7 @@ function attachEdits(plan6, family, bound2, dir, alias, bindingConfig) {
     edit(plan6, key2, "id", `id: ${id} (declared${approved !== void 0 ? ", the id its lock approved" : ""})`, { root: dir, call: "setId", args: [id] });
   }
   if (!attached) plan6.notes.push(`${dir} has no project.yaml of its own \u2014 \`wairon doctor --fix\` writes one declaring "${alias}" as its id`);
-  const relPath = posix5(path43.relative(familyNode(family, bound2).directory, dir));
+  const relPath = posix6(path43.relative(familyNode(family, bound2).directory, dir));
   const declaration2 = { path: relPath, ...plan6.request.description !== void 0 ? { description: plan6.request.description } : {} };
   edit(plan6, bound2, "member", `members: ${alias} \u2192 ${relPath} (an existing project, kept as it is)`, { root: familyNode(family, bound2).directory, call: "declareMember", args: [alias, declaration2] });
   for (const requirement of requiredPolicies(bindingConfig)) {
@@ -47292,8 +48349,8 @@ function planDetach(family, bound2, request) {
   if (plan6.request.widen) planWidening(plan6, member, narrow);
   if (plan6.refusals.length > 0) return plan6;
   const boundDir = familyNode(family, bound2).directory;
-  const held = memberDeclarationOf(configAt3(boundDir)?.members?.[alias] ?? posix5(path43.relative(boundDir, member.directory)));
-  const declared = { ...held, path: memberLocationOf(held) ?? posix5(path43.relative(boundDir, member.directory)) };
+  const held = memberDeclarationOf(configAt3(boundDir)?.members?.[alias] ?? posix6(path43.relative(boundDir, member.directory)));
+  const declared = { ...held, path: memberLocationOf(held) ?? posix6(path43.relative(boundDir, member.directory)) };
   detachEdits(plan6, family, bound2, member, alias, declared, consumers, outward);
   return plan6;
 }
@@ -47333,7 +48390,7 @@ function planWidening(plan6, member, narrow) {
 function detachEdits(plan6, family, bound2, member, alias, declared, consumers, outward) {
   const boundDir = familyNode(family, bound2).directory;
   const relocation = plan6.request.relocation;
-  const sourceTo = (from, producer) => relocation ? { hosted: producer.id ?? producer.mountAlias ?? producer.namespace } : { path: posix5(path43.relative(from, producer.directory)) };
+  const sourceTo = (from, producer) => relocation ? { hosted: producer.id ?? producer.mountAlias ?? producer.namespace } : { path: posix6(path43.relative(from, producer.directory)) };
   const where = (source) => source.hosted !== void 0 ? `hosted record ${source.hosted}` : source.path;
   edit(plan6, bound2, "member", `members: ${alias} removed (${declared.path} ${relocation ? `moves to ${relocation.to}` : "stays as it is"})`, { root: boundDir, call: "removeMember", args: [alias] });
   const boundSource = relocation ? sourceTo(boundDir, member) : { path: declared.path };
@@ -47407,7 +48464,7 @@ function adoptEdits(plan6, family, bound2, alias, external, dir, at = dir) {
   edit(plan6, bound2, "pin", `pin ${alias} removed (the family supplies it now)`, { root: boundDir, call: "unpin", args: [alias] });
   edit(plan6, bound2, "external", `externals: ${alias} removed`, { root: boundDir, call: "removeExternal", args: [alias] });
   const declaration2 = {
-    path: posix5(path43.relative(boundDir, at)),
+    path: posix6(path43.relative(boundDir, at)),
     ...external.description !== void 0 ? { description: external.description } : {},
     ...external.use && external.use.length > 0 ? { use: external.use } : {}
   };
@@ -47597,6 +48654,11 @@ function planRename(family, bound2, request) {
   edit2(plan6, target.namespace, "id", `id: ${oldId} \u2192 ${newId} (${oldId} kept in previousIds)`, { root: target.directory, call: "renameId", args: [oldId, newId] });
   for (const h of holders.filter((x) => x.external)) planPin(plan6, h, oldId, newId);
   plan6.notes.push(`Consumers outside the family that name "${oldId}" by path are not found by a rename: each must rewrite its own external (its next gate reports the id change).`);
+  if (target.namespace !== "" && target.mountAlias === oldId) {
+    const oldKey = target.namespace;
+    const newKey = target.parent ? `${target.parent}::${newId}` : newId;
+    plan6.notes.push(`Deployment names: a network bindings file and an observed-flow export name this project's workloads by its key \u2014 rename the bindings keys "${oldKey}" and every "${oldKey}::\u2026" (its subsystems and Portals) to "${newKey}" and "${newKey}::\u2026", and the telemetry names that follow them. Until then \`wairon network policy\` and \`check\` resolve them through previousIds and print a NOTE naming each key.`);
+  }
   if (approved !== void 0 && target.mountAlias === newId) {
     plan6.notes.push(`${label5(target.namespace)} kept "${oldId}" where its alias is "${newId}" because its lock approved "${approved}" (id-locked): the rename resolves it \u2014 PROJECT_ID_RENAMED until the re-lock approves "${newId}".`);
   }
@@ -47746,7 +48808,7 @@ function emptyPlan3(family, request) {
   const whole = !(reach2 !== null && !reach2.parentReach);
   return { request, familyRoot: familyNode(family, "").directory, whole, edits: [], refusals: [], changes: [], relock: [], notes: [] };
 }
-var posix6 = (p) => p.split(path45.sep).join("/");
+var posix7 = (p) => p.split(path45.sep).join("/");
 var label6 = (key2) => key2 === "" ? "the top project" : `"${key2}"`;
 var refuse3 = (plan6, code, project3, detail) => {
   plan6.refusals.push({ code, project: project3, detail });
@@ -47956,7 +49018,7 @@ function respellConsumer(plan6, family, c, own2) {
 function repointConsumer(plan6, c, boundNode2) {
   const declared = configAt5(c.node.directory)?.externals?.[c.alias];
   const project3 = boundNode2.id !== void 0 && boundNode2.id !== c.alias ? boundNode2.id : null;
-  const source = declared?.source ? { path: posix6(path45.relative(c.node.directory, boundNode2.directory)) } : null;
+  const source = declared?.source ? { path: posix7(path45.relative(c.node.directory, boundNode2.directory)) } : null;
   edit3(plan6, c.node.namespace, "external", `externals: ${c.alias} names ${boundNode2.id ?? "the top project"}${source ? ` at ${source.path}` : ""}`, { root: c.node.directory, call: "repointExternal", args: [c.alias, project3, source] });
   plan6.notes.push(`${label6(c.node.namespace)}'s pin of "${c.alias}" is taken again against ${boundNode2.id ?? "the top project"}: the producer changed, so its lock reads drifted until it is re-locked.`);
   return c;
@@ -47992,8 +49054,8 @@ function planExternalize(family, bound2, request) {
       plan6,
       bound2,
       "move",
-      `externalize ${id}: its specs into ${joined ? `the part "${joined.alias}"` : `a part at ${posix6(path45.relative(node.directory, dir))}, declared as "${id}"`} \u2014 a storage move; no reference, export or pin changes`,
-      { root: node.directory, call: "externalizeSubsystem", args: [id, posix6(path45.relative(node.directory, dir))] }
+      `externalize ${id}: its specs into ${joined ? `the part "${joined.alias}"` : `a part at ${posix7(path45.relative(node.directory, dir))}, declared as "${id}"`} \u2014 a storage move; no reference, export or pin changes`,
+      { root: node.directory, call: "externalizeSubsystem", args: [id, posix7(path45.relative(node.directory, dir))] }
     );
     plan6.notes.push("Source code is not moved: move the subsystem's code yourself if it should live beside its specs.");
     return plan6;
@@ -48002,7 +49064,7 @@ function planExternalize(family, bound2, request) {
   crossingsBack(plan6, family, bound2, subKey);
   checkSiblings(plan6, family, bound2, id, subKey, table);
   if (plan6.refusals.length > 0) return plan6;
-  edit3(plan6, bound2, "move", `externalize ${id} as a project: its specs into a member at ${posix6(path45.relative(node.directory, dir))}, declared as "${id}", then promoted`, { root: node.directory, call: "externalizeSubsystem", args: [id, posix6(path45.relative(node.directory, dir)), "project"] });
+  edit3(plan6, bound2, "move", `externalize ${id} as a project: its specs into a member at ${posix7(path45.relative(node.directory, dir))}, declared as "${id}", then promoted`, { root: node.directory, call: "externalizeSubsystem", args: [id, posix7(path45.relative(node.directory, dir)), "project"] });
   edit3(plan6, id, "pin", `pin the new member's externals (its external for ${node.id ?? "this project"}, when its specs reference it)`, { root: dir, call: "pinExternals", args: [[]] });
   repinIntactConsumers2(plan6, family, bound2, [dir]);
   plan6.notes.push("Source code is not moved: move the subsystem's code into the member yourself.");
@@ -48212,6 +49274,7 @@ function write5(plan6, rehearsal) {
   for (const e of planned.filter((x) => x.write.call === "demoteMember")) {
     const demoted = writeOne3(rehearsal, e.write);
     for (const line of demoted?.consumersRestored ?? []) plan6.edits.push({ project: e.project, kind: "reference", detail: `consumers across the old boundary restored: ${line}` });
+    for (const line of demoted?.signaturesRederived ?? []) plan6.edits.push({ project: e.project, kind: "reference", detail: `signature text re-derived \u2014 ${line}` });
   }
   for (const e of planned.filter((x) => x.write.call === "unpin")) writeOne3(rehearsal, e.write);
 }
@@ -48261,6 +49324,8 @@ function recordCrossing(plan6, bound2, member, result) {
   for (const line of crossed.exported) plan6.edits.push({ project: bound2, kind: "export", detail: `export ${line}` });
   for (const line of crossed.imported) plan6.edits.push({ project: bound2, kind: "external", detail: `import: ${line}` });
   for (const line of crossed.consumersDropped) plan6.edits.push({ project: bound2, kind: "reference", detail: `consumers across the boundary to ${member} dropped: ${line}` });
+  for (const line of crossed.pathsRebased ?? []) plan6.edits.push({ project: member, kind: "reference", detail: `path re-expressed under the new root \u2014 ${line}` });
+  for (const line of crossed.signaturesRederived ?? []) plan6.edits.push({ project: bound2, kind: "reference", detail: `signature text re-derived \u2014 ${line}` });
   for (const line of crossed.entriesDeclared ?? []) plan6.edits.push({ project: member, kind: "reference", detail: `entry declared for the callers left across the boundary \u2014 ${line}` });
   const topics = crossed.topicsCrossing ?? [];
   if (topics.length > 0) {
@@ -48298,11 +49363,11 @@ function writeOne3(rehearsal, w) {
 
 // src/migrations/transaction.ts
 var crypto9 = __toESM(require("crypto"));
-var fs28 = __toESM(require("fs"));
+var fs29 = __toESM(require("fs"));
 var path46 = __toESM(require("path"));
 
 // src/migrations/transaction-files.ts
-var fs27 = __toESM(require("fs"));
+var fs28 = __toESM(require("fs"));
 var os7 = __toESM(require("os"));
 var nodePath2 = __toESM(require("path"));
 var yaml4 = __toESM(require("js-yaml"));
@@ -48316,7 +49381,7 @@ function pause2(ms) {
 function removeTree(dir) {
   for (let attempt = 1; ; attempt++) {
     try {
-      fs27.rmSync(dir, { recursive: true, force: true });
+      fs28.rmSync(dir, { recursive: true, force: true });
       return;
     } catch (e) {
       const code = e.code;
@@ -48326,20 +49391,20 @@ function removeTree(dir) {
   }
 }
 function writeDurably(file, bytes) {
-  fs27.mkdirSync(nodePath2.dirname(file), { recursive: true });
+  fs28.mkdirSync(nodePath2.dirname(file), { recursive: true });
   const tmp = `${file}.tmp`;
   try {
-    const fd = fs27.openSync(tmp, "w");
+    const fd = fs28.openSync(tmp, "w");
     try {
-      fs27.writeSync(fd, typeof bytes === "string" ? Buffer.from(bytes, "utf8") : bytes);
-      fs27.fsyncSync(fd);
+      fs28.writeSync(fd, typeof bytes === "string" ? Buffer.from(bytes, "utf8") : bytes);
+      fs28.fsyncSync(fd);
     } finally {
-      fs27.closeSync(fd);
+      fs28.closeSync(fd);
     }
-    fs27.renameSync(tmp, file);
+    fs28.renameSync(tmp, file);
   } catch (e) {
     try {
-      fs27.unlinkSync(tmp);
+      fs28.unlinkSync(tmp);
     } catch {
     }
     throw e;
@@ -48349,18 +49414,18 @@ function writeDurably(file, bytes) {
 function syncDirectory(dir) {
   if (process.platform === "win32") return;
   try {
-    const fd = fs27.openSync(dir, "r");
+    const fd = fs28.openSync(dir, "r");
     try {
-      fs27.fsyncSync(fd);
+      fs28.fsyncSync(fd);
     } finally {
-      fs27.closeSync(fd);
+      fs28.closeSync(fd);
     }
   } catch {
   }
 }
 function openRehearsal(id) {
   const dir = rehearsalDir(id);
-  fs27.mkdirSync(dir);
+  fs28.mkdirSync(dir);
   return dir;
 }
 function dropRehearsal(id) {
@@ -48371,14 +49436,14 @@ function dropRehearsal(id) {
 }
 function saveJournal(journal) {
   const ignore = nodePath2.join(transactionsDir(journal.owner), ".gitignore");
-  if (!fs27.existsSync(ignore)) writeDurably(ignore, "*\n");
+  if (!fs28.existsSync(ignore)) writeDurably(ignore, "*\n");
   writeDurably(nodePath2.join(transactionDir(journal.owner, journal.id), "journal.yaml"), yaml4.dump(journal, { noRefs: true, lineWidth: 200 }));
 }
 function readJournal(owner, id) {
   const file = nodePath2.join(transactionDir(owner, id), "journal.yaml");
   let text3;
   try {
-    text3 = fs27.readFileSync(file, "utf8");
+    text3 = fs28.readFileSync(file, "utf8");
   } catch (e) {
     if (e.code === "ENOENT") return null;
     throw e;
@@ -48393,7 +49458,7 @@ function listJournals(owner) {
   const dir = transactionsDir(owner);
   let names;
   try {
-    names = fs27.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+    names = fs28.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
   } catch {
     return [];
   }
@@ -48410,26 +49475,26 @@ function listJournals(owner) {
     startedAt: ""
   });
 }
-function putFile(owner, id, area, path49, bytes) {
-  writeDurably(locate(owner, id, area, path49), bytes);
+function putFile(owner, id, area, path50, bytes) {
+  writeDurably(locate(owner, id, area, path50), bytes);
 }
-function readFile(owner, id, area, path49) {
+function readFile(owner, id, area, path50) {
   try {
-    return fs27.readFileSync(locate(owner, id, area, path49));
+    return fs28.readFileSync(locate(owner, id, area, path50));
   } catch (e) {
     if (e.code === "ENOENT") return null;
     throw e;
   }
 }
-function locate(owner, id, area, path49) {
-  return nodePath2.join(transactionDir(owner, id), area, ...path49.split("/"));
+function locate(owner, id, area, path50) {
+  return nodePath2.join(transactionDir(owner, id), area, ...path50.split("/"));
 }
 function close(owner, id) {
   removeTree(transactionDir(owner, id));
   const dir = transactionsDir(owner);
   let left;
   try {
-    left = fs27.readdirSync(dir);
+    left = fs28.readdirSync(dir);
   } catch {
     return;
   }
@@ -48437,11 +49502,11 @@ function close(owner, id) {
   removeTree(dir);
   const wai = nodePath2.dirname(dir);
   try {
-    if (fs27.readdirSync(wai).length === 0) fs27.rmdirSync(wai);
+    if (fs28.readdirSync(wai).length === 0) fs28.rmdirSync(wai);
   } catch {
   }
   try {
-    if (fs27.readdirSync(owner).length === 0) fs27.rmdirSync(owner);
+    if (fs28.readdirSync(owner).length === 0) fs28.rmdirSync(owner);
   } catch {
   }
 }
@@ -48463,14 +49528,14 @@ var transactionStore = {
   listJournals(owner) {
     return listJournals(owner);
   },
-  putFile(owner, id, area, path49, bytes) {
-    putFile(owner, id, area, path49, bytes);
+  putFile(owner, id, area, path50, bytes) {
+    putFile(owner, id, area, path50, bytes);
   },
-  readFile(owner, id, area, path49) {
-    return readFile(owner, id, area, path49);
+  readFile(owner, id, area, path50) {
+    return readFile(owner, id, area, path50);
   },
-  locate(owner, id, area, path49) {
-    return locate(owner, id, area, path49);
+  locate(owner, id, area, path50) {
+    return locate(owner, id, area, path50);
   },
   close(owner, id) {
     close(owner, id);
@@ -48492,14 +49557,14 @@ var transactionRepository = {
   listJournals(owner) {
     return transactionStore.listJournals(owner);
   },
-  putFile(owner, id, area, path49, bytes) {
-    transactionStore.putFile(owner, id, area, path49, bytes);
+  putFile(owner, id, area, path50, bytes) {
+    transactionStore.putFile(owner, id, area, path50, bytes);
   },
-  readFile(owner, id, area, path49) {
-    return transactionStore.readFile(owner, id, area, path49);
+  readFile(owner, id, area, path50) {
+    return transactionStore.readFile(owner, id, area, path50);
   },
-  locate(owner, id, area, path49) {
-    return transactionStore.locate(owner, id, area, path49);
+  locate(owner, id, area, path50) {
+    return transactionStore.locate(owner, id, area, path50);
   },
   close(owner, id) {
     transactionStore.close(owner, id);
@@ -48562,7 +49627,7 @@ function commonAncestor(paths) {
   }
   return at;
 }
-function diff(rehearsal) {
+function diff2(rehearsal) {
   return compare4(rehearsal);
 }
 function discard(rehearsal) {
@@ -48647,7 +49712,7 @@ function missingDirs(owner, entries) {
   for (const entry of entries.filter((e) => e.action === "create")) {
     const missing = [];
     let at = path46.dirname(liveOf(owner, entry.path));
-    while (!fs28.existsSync(at) && at !== path46.dirname(at)) {
+    while (!fs29.existsSync(at) && at !== path46.dirname(at)) {
       missing.unshift(at);
       at = path46.dirname(at);
     }
@@ -48681,7 +49746,7 @@ function stageBytes(rehearsal, journal, entry) {
 function checkVolume(journal, entry, target) {
   const staged = transactionRepository.locate(journal.owner, journal.id, "staged", entry.path);
   let nearest = path46.dirname(target);
-  while (!fs28.existsSync(nearest) && nearest !== path46.dirname(nearest)) nearest = path46.dirname(nearest);
+  while (!fs29.existsSync(nearest) && nearest !== path46.dirname(nearest)) nearest = path46.dirname(nearest);
   if (!sameVolume(staged, nearest)) {
     throw new StagingError(`cross-volume: ${target} lies on another volume than its staged copy; a rename across volumes is not atomic`);
   }
@@ -48765,7 +49830,7 @@ function recover(root, fix) {
 var coordinatorRoot = (journal) => path46.resolve(journal.owner, journal.coordinator);
 function journalAt(owner, id) {
   try {
-    const journal = fs28.existsSync(owner) ? transactionRepository.readJournal(owner, id) : null;
+    const journal = fs29.existsSync(owner) ? transactionRepository.readJournal(owner, id) : null;
     return journal ? { ...journal, owner } : null;
   } catch {
     return null;
@@ -48797,7 +49862,7 @@ function resolveOne(journal) {
     for (const owner of [...owners.filter((o) => o !== coordinator.owner), coordinator.owner]) transactionRepository.close(owner, journal.id);
     return { ...base, owners, phase, action: "cleaned", detail: "it had committed; its transaction directories were removed" };
   }
-  const absent = phase === "staging" ? [] : owners.filter((o) => !fs28.existsSync(o));
+  const absent = phase === "staging" ? [] : owners.filter((o) => !fs29.existsSync(o));
   if (absent.length > 0) {
     return { ...base, owners, phase, action: "refused", detail: `owner(s) out of reach: ${absent.join(", ")}` };
   }
@@ -48923,7 +49988,7 @@ function rehearse2(plan6) {
     const detail = e instanceof Error ? e.message : String(e);
     return { ...plan6, refusals: [...plan6.refusals, { code: `${plan6.request.verb}-refused`, project: "", detail }] };
   }
-  const changes = diff(rehearsal);
+  const changes = diff2(rehearsal);
   const refused3 = [
     ...unwritableOwners(changes).map((o) => ({ code: "family-partial", project: o, detail: `the plan must write ${o}, which this request may not write` })),
     ...deniedSubsystems(changes)
@@ -48932,7 +49997,7 @@ function rehearse2(plan6) {
     discard(rehearsal);
     return { ...plan6, refusals: [...plan6.refusals, ...refused3] };
   }
-  return { ...plan6, rehearsal, changes, relock: relockOf(plan6, changes) };
+  return { ...plan6, rehearsal, changes, relock: relockOf(plan6, changes, rehearsal) };
 }
 function movedOf(plan6) {
   const relocation = plan6.request.relocation;
@@ -49035,12 +50100,25 @@ function onCopy(rehearsal, run3) {
   const top = reach2.topRoot !== void 0 ? rehearsalRoot(rehearsal, reach2.topRoot) : rehearsal.directory;
   return runWithProjectBinding(rehearsalRoot(rehearsal, getProjectRoot()), { topRoot: top, parentReach: reach2.parentReach, ...reach2.narrowed ? { narrowed: true } : {} }, run3);
 }
-function relockOf(plan6, changes) {
+function relockOf(plan6, changes, rehearsal) {
   const ended = new Set(changes.filter((c) => c.action === "delete" && c.path === ".wai/project.yaml").map((c) => path47.resolve(c.project)));
   const owners = [...new Set(changes.map((c) => path47.resolve(c.project)))].filter((o) => !ended.has(o));
   const moved = movedOf(plan6);
   const relocated = moved !== null && approvalRecord(moved.from) !== null ? [moved.to] : [];
-  if (plan6.request.verb !== "rename") return [...owners.filter((owner) => approvalRecord(owner) !== null), ...relocated];
+  if (plan6.request.verb !== "rename") {
+    const locked = owners.filter((owner) => approvalRecord(owner) !== null);
+    const storageMove = plan6.request.verb === "externalize" && plan6.request.as !== "project";
+    const stillApproved = (owner) => {
+      if (!storageMove || !rehearsal) return false;
+      try {
+        const diff3 = diffAgainstApproval(rehearsalRoot(rehearsal, owner));
+        return diff3 !== null && diff3.added.length + diff3.changed.length + diff3.removed.length === 0;
+      } catch {
+        return false;
+      }
+    };
+    return [...locked.filter((owner) => !stillApproved(owner)), ...relocated];
+  }
   const renamed2 = plan6.edits.find((e) => e.write?.call === "renameId")?.write?.root;
   const first = renamed2 !== void 0 ? path47.resolve(renamed2) : void 0;
   return [...owners.filter((o) => o === first), ...owners.filter((o) => o !== first)];
@@ -49086,7 +50164,34 @@ function run2(request, dryRun) {
     discard3(planned);
     return { plan: planned, applied: false, relock: [] };
   }
-  return apply2(planned);
+  const report3 = apply2(planned);
+  const made = report3.applied ? madeProjectRoot(report3) : null;
+  if (made !== null) report3.sessionScaffold = scaffoldSession(made);
+  return report3;
+}
+function madeProjectRoot(report3) {
+  const { request, changes } = report3.plan;
+  if (!(request.verb === "promote" || request.verb === "externalize" && request.as === "project")) return null;
+  const created = changes.find((c) => c.action === "create" && c.path.replace(/\\/g, "/") === ".wai/specs/.index.yaml");
+  const root = created?.project ?? null;
+  return root !== null && fs30.existsSync(path48.join(root, ".wai", "project.yaml")) ? root : null;
+}
+function scaffoldSession(root) {
+  try {
+    return runWithProjectRoot(root, () => {
+      const config = loadProjectConfig();
+      const targets = config ? activeTargetTypes(config) : ["claude"];
+      const written = [...reinjectLocalGuides(root, targets)];
+      written.push(...exportSddSkills2(targets).destinations);
+      if (targets.includes("claude")) {
+        const server = registerProjectServer(root);
+        if (server !== null) written.push(server);
+      }
+      return written.map((f) => path48.relative(root, f).replace(/\\/g, "/") || ".");
+    });
+  } catch (e) {
+    return [`not set up (${e instanceof Error ? e.message : String(e)}): run \`wairon generate\` and \`wairon mcp install --backend claude\` there`];
+  }
 }
 function pending2() {
   const found = recover3(getProjectRoot(), false);
@@ -49113,7 +50218,7 @@ function statusFamilyContext() {
     const members = listDirectChainedSubprojects(root);
     if (members.length > 0) {
       const described = members.map((m) => {
-        const rel2 = path48.relative(root, m.dir).split(path48.sep).join("/") || ".";
+        const rel2 = path49.relative(root, m.dir).split(path49.sep).join("/") || ".";
         return `${m.alias} (${rel2}${m.form === "mount" ? ", legacy L1 mount" : ""})`;
       });
       lines.push(`Family: member projects declared here \u2014 ${described.join(", ")}.`);
@@ -49213,7 +50318,8 @@ function migrationView(report3, dryRun) {
     ...madeAt ? {
       newProject: {
         root: madeAt,
-        next: `The new project at ${madeAt} has no guide, skills or MCP registration of its own yet. The human runs, in that folder: \`wairon generate\` and \`wairon mcp install --backend claude\` (the CLI's \`wairon member promote\` / \`subsystem externalize --as project\` do this themselves). Its own session then designs it \u2014 its specs, L0 export table and project.yaml are written from its own root.`
+        ...report3.sessionScaffold ? { sessionScaffold: report3.sessionScaffold } : {},
+        next: report3.sessionScaffold && !report3.sessionScaffold.some((f) => f.startsWith("not set up")) ? `The new project at ${madeAt} is set up for its own sessions (its guide, skills and .mcp.json, listed under sessionScaffold), as the CLI's \`wairon member promote\` / \`subsystem externalize --as project\` set it up. A session opened in that folder designs it \u2014 its specs, L0 export table and project.yaml are written from its own root.` : `The new project at ${madeAt} has no guide, skills or MCP registration of its own yet. The human runs, in that folder: \`wairon generate\` and \`wairon mcp install --backend claude\` (the CLI's \`wairon member promote\` / \`subsystem externalize --as project\` do this themselves). Its own session then designs it \u2014 its specs, L0 export table and project.yaml are written from its own root.`
       }
     } : {},
     ...report3.outcome ? { outcome: { committed: report3.outcome.committed, restored: report3.outcome.restored, unrestored: report3.outcome.unrestored, ...report3.outcome.failure ? { failure: report3.outcome.failure } : {} } } : {},
@@ -49269,6 +50375,31 @@ var externalRemovalOutput = {
   refusal: import_zod12.z.string().optional().describe("Why nothing was removed, in one sentence."),
   ...staleServerOutput
 };
+var externalConsumersOutput = {
+  consumers: import_zod12.z.array(import_zod12.z.object({
+    project: import_zod12.z.string(),
+    key: import_zod12.z.string(),
+    directory: import_zod12.z.string(),
+    alias: import_zod12.z.string(),
+    section: import_zod12.z.enum(["externals", "members"]),
+    names: import_zod12.z.array(import_zod12.z.string()),
+    broken: import_zod12.z.array(import_zod12.z.string()).optional(),
+    found: import_zod12.z.enum(["search"]).optional()
+  })).describe("Each consumer with the alias and section it declares this project under, the public names its specs use, the names it still writes that this project no longer exports (broken), and found: search for one met in a searched folder outside the family."),
+  ...staleServerOutput
+};
+var surfaceDiffOutput = {
+  project: import_zod12.z.string(),
+  against: import_zod12.z.string().describe("What the surface was compared with: the last committed approval, a named revision, or a saved snapshot file."),
+  changes: import_zod12.z.array(import_zod12.z.object({
+    kind: import_zod12.z.enum(["added", "removed", "renamed", "changed"]),
+    name: import_zod12.z.string(),
+    member: import_zod12.z.string().optional(),
+    from: import_zod12.z.string().optional(),
+    detail: import_zod12.z.string()
+  })).describe("Every public name or contract method added, removed, renamed (traced) or changed in signature, sorted by name."),
+  ...staleServerOutput
+};
 var externalUseChangeOutput = {
   alias: import_zod12.z.string(),
   written: import_zod12.z.boolean().describe("Whether .wai/project.yaml now carries the changed `use` (false on a refusal, a dry run and when nothing changed)."),
@@ -49481,6 +50612,22 @@ var specChangeReportOutput = {
   ),
   ...staleServerOutput
 };
+function statusNetworkLine() {
+  try {
+    const network = loadProjectConfig()?.network;
+    if (network) {
+      const description = typeof network === "object" && network.description ? ` ("${network.description}")` : "";
+      return `Network: declared${description} \u2014 this project and every member below it form one isolated network boundary, and the network rules (GATEWAY_BYPASSED, ENTRY_UNPROVEN, ...) judge the design; sdd_get_network_flows lists who may reach what.
+`;
+    }
+    if (resolveChainingParent()) {
+      return "Network: none declared here \u2014 a network the enclosing family declares is judged at its root, and sdd_get_network_flows reads it from there.\n";
+    }
+    return "Network: none declared \u2014 Portal entries are not narrowed by an isolated network (sdd_set_network declares one).\n";
+  } catch {
+    return "";
+  }
+}
 function externalsSection(advised) {
   if (advised.length === 0) return "";
   const lines = advised.map((i) => `- [${i.code}] ${i.message}`);
@@ -49826,6 +50973,7 @@ var SPEC_WRITE_TOOLS = /* @__PURE__ */ new Set([
   "sdd_rename_method",
   "sdd_rename_type",
   "sdd_rename_field",
+  "sdd_rename_param",
   "sdd_add_component",
   "sdd_define_interface",
   "sdd_set_endpoints",
@@ -50336,7 +51484,7 @@ ${renderChangeReport(report3)}`,
     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 an identifier in the method casing of the tree \u2014 the configured rules.naming.methods, else the convention of its targetLanguage: snake_case for Rust or Python, camelCase for TypeScript (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.",
+      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 an identifier in the method casing of the tree \u2014 the configured rules.naming.methods, else the convention of its targetLanguage: snake_case for Rust or Python, camelCase for TypeScript; for a component one of whose contracts implements another project's extension point, any identifier, since the producer names those methods (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_zod12.z.string().describe("The component whose method is renamed (namespaced if needed)"),
         method: import_zod12.z.string().describe("The method name as it stands"),
@@ -50393,6 +51541,26 @@ ${renderChangeReport(report3)}`,
       }
     }
   );
+  reg(
+    server,
+    "sdd_rename_param",
+    {
+      description: "Rename a parameter of a contract method. The parameter moves on every interface of the component that declares the method, keeping its place, type, description and optionality, and its old name joins the parameter's rename trace (previousNames), which the design export shows as `formerly` so a generator or consumer can tell the rename from a signature change; each signature is re-derived from the params, a method whose signatureFrom names this one follows by itself, and an HTTP endpoint path placeholder `{old}` on the method's own binding is respelled (the URL a caller sends is unchanged). Prose is never rewritten. Refuses, writing nothing: a component that does not exist (component-missing), one inside a chained subproject (chained-component), a method no contract of the component declares (method-missing), a parameter the method does not declare or takes from a signatureFrom (param-missing), a new name that is not an identifier, or not in rules.naming.variables when that is set and the component implements no extension point (invalid-name), and a name another parameter of the method holds (name-taken) or retired (name-retired). Returns the component, method, from and to, the interfaces it moved in and the placeholders respelled. The approval reads the contract as changed until the next `wairon lock`, as with any edit.",
+      inputSchema: {
+        id: import_zod12.z.string().describe("The component whose contract method's parameter is renamed (namespaced if needed)"),
+        method: import_zod12.z.string().describe("The contract method"),
+        param: import_zod12.z.string().describe("The parameter's name as it stands"),
+        newName: import_zod12.z.string().describe("Its new name: an identifier")
+      }
+    },
+    ({ id, method, param, newName }) => {
+      try {
+        return json(renameParam(qualifiedComponentId(id), method, param, newName));
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
   reg(
     server,
     "sdd_move_methods",
@@ -51086,7 +52254,7 @@ ${testsBlock}` : ""}`, deletion);
           memberDepth,
           approvals
         });
-        const family = statusFamilyContext();
+        const family = statusFamilyContext() + statusNetworkLine();
         const verdict = approvalVerdict(approvals);
         return text2(`${banner}${family}${report3.text}${verdict.text}${externalsSection(adviseExternals())}`);
       } catch (e) {
@@ -51210,6 +52378,48 @@ ${testsBlock}` : ""}`, deletion);
       }
     }
   );
+  reg(
+    server,
+    "sdd_list_consumers",
+    {
+      description: `Who consumes the bound project \u2014 the producer's answer to "who breaks if I change my surface": every project of the family in reach that declares it (as an external or a member), and, with search, every project root in (or directly under) the named folders that declares it as an external by a path source reaching it or a git source naming its id \u2014 a sibling checkout outside the family. Each with the alias, the public names its specs use, and the names it still writes that this project no longer exports. A read: writes nothing.`,
+      inputSchema: {
+        search: import_zod12.z.array(import_zod12.z.string()).optional().describe("Folders to scan for consumers outside the family (e.g. the folder holding the sibling checkouts), relative to the bound project root or absolute")
+      },
+      outputSchema: externalConsumersOutput
+    },
+    ({ search }) => {
+      try {
+        const root = getProjectRoot();
+        const consumers = listConsumers3(search?.map((d) => path49.resolve(root, d)));
+        const lines = consumers.length ? consumers.map((c) => `${c.project} (${c.section}.${c.alias})${c.found ? ` [${c.directory}]` : ""}: ${c.names.length ? c.names.join(", ") : "declares it, uses no name yet"}${c.broken?.length ? ` \u2014 still writes ${c.broken.join(", ")} (no longer exported)` : ""}`) : [`No project ${search?.length ? "of the family in reach, nor in the searched folders," : "of the family in reach"} consumes this project.${search?.length ? "" : " Pass search with the folder holding sibling checkouts to look outside the family."}`];
+        return structured(lines.join("\n"), { consumers });
+      } catch (e) {
+        return errMessage(e);
+      }
+    }
+  );
+  reg(
+    server,
+    "sdd_surface_diff",
+    {
+      description: "The bound project's public-surface changelog: its export table now against the same table at its last committed approval (the last commit that changed .wai/lock.json) \u2014 or at a named git revision, or in a saved native surface snapshot file \u2014 as names and contract methods added, removed, renamed (from the rename trace) and changed in signature. What a producer writes release notes from and weighs a breaking change by (pair it with sdd_list_consumers). A read: writes nothing.",
+      inputSchema: {
+        against: import_zod12.z.string().optional().describe("A git revision (branch, tag, commit) or a saved native surface snapshot file to compare with; the last committed approval when omitted")
+      },
+      outputSchema: surfaceDiffOutput
+    },
+    ({ against }) => {
+      try {
+        const diff3 = diffSurface(against);
+        const lines = diff3.changes.length ? diff3.changes.map((c) => `${c.kind} ${c.member ? `${c.name}.${c.member}` : c.name} \u2014 ${c.detail}`) : ["no change \u2014 every exported name, method and signature is as it was"];
+        return structured(`Public surface of "${diff3.project}" against ${diff3.against}:
+${lines.join("\n")}`, { ...diff3 });
+      } catch (e) {
+        return errMessage(e);
+      }
+    }
+  );
   reg(
     server,
     "sdd_get_network_flows",
@@ -51478,6 +52688,7 @@ function loadProjectConfig3() {
   SwitchCaseSchema,
   SystemPublicInterfaceSchema,
   SystemSpecSchema,
+  TECHNOLOGY_PACKAGES,
   TargetConfigSchema,
   TechnologySchema,
   TemplateNotFoundError,
@@ -51508,7 +52719,9 @@ function loadProjectConfig3() {
   approvalKeyIn,
   approvalRecord,
   approvalVerdict,
+  approvedRevision,
   approvedStatuses,
+  asSchemaReads,
   assertContainedProjectPath,
   assertProjectInitialized,
   attachRetiredMounts,
@@ -51756,6 +52969,7 @@ function loadProjectConfig3() {
   reexpress,
   registerExporter,
   registerPackRef,
+  registerProjectServer,
   reinjectLocalGuides,
   relationHealth,
   removeDomain,
@@ -51768,6 +52982,7 @@ function loadProjectConfig3() {
   renameField,
   renameId,
   renameMethod,
+  renameParam,
   renameType,
   renderDiagram,
   repairForeignStepFields,
@@ -51824,8 +53039,10 @@ function loadProjectConfig3() {
   storedMethodSignature,
   storedTypeMethod,
   subsystemDesignView,
+  surfaceChanges,
   syncContextFiles,
   technologyName,
+  technologyPackages,
   technologyTokens,
   toMarkdown,
   transportExportKind,