@wairon/cli 5.1.1-dev.102 → 5.1.1-dev.103

package/dist/index.js

@@ -3566,6 +3566,7 @@ __export(src_exports, {
   aiDir: () => aiDir,
   aiDirAt: () => aiDirAt,
   aiPathsAt: () => aiPathsAt,
+  aliasTargetOf: () => aliasTargetOf,
   ambiguityMessage: () => ambiguityMessage,
   approvalKeyIn: () => approvalKeyIn,
   approvalRecord: () => approvalRecord,
@@ -3751,6 +3752,7 @@ __export(src_exports, {
   memberDeclarationOf: () => memberDeclarationOf,
   memberDigest: () => memberDigest,
   memberLocationOf: () => memberLocationOf,
+  memberTypesOf: () => memberTypesOf,
   methodGenericParameters: () => methodGenericParameters,
   methodSourceFile: () => methodSourceFile,
   methodTypeRefs: () => methodTypeRefs,
@@ -3809,7 +3811,7 @@ __export(src_exports, {
   renameId: () => renameProjectId,
   renameMethod: () => renameMethod,
   renameType: () => renameType,
-  renderDiagram: () => renderDiagram,
+  renderDiagram: () => renderDiagram2,
   repairForeignStepFields: () => repairForeignStepFields,
   repairSignatures: () => repairSignatures,
   repairTypeSpellings: () => repairTypeSpellings,
@@ -3823,6 +3825,7 @@ __export(src_exports, {
   resolveExternals: () => resolveDeclared,
   resolveImport: () => resolveImport,
   resolveInstalledPack: () => resolveInstalledPack,
+  resolveProjectBinding: () => resolveProjectBinding,
   resolveProjectExports: () => resolveProjectExports,
   resolveSignatures: () => resolveSignatures,
   resolveSubprojectForNamespace: () => resolveSubprojectForNamespace,
@@ -3887,7 +3890,7 @@ __export(src_exports, {
   writeFile: () => writeFile,
   writeFileIfChanged: () => writeFileIfChanged,
   writeJsonFile: () => writeJsonFile,
-  writeLockRecord: () => writeLockRecord,
+  writeLockRecord: () => writeLockRecord2,
   writeReachDenials: () => writeReachDenials,
   writeReachPermits: () => writeReachPermits,
   writeRootGuideDelegator: () => writeRootGuideDelegator,
@@ -3906,6 +3909,7 @@ var import_zod4 = require("zod");
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var import_node_async_hooks = require("async_hooks");
+var yaml = __toESM(require("js-yaml"));
 function ensureDir(dirPath) {
   fs.mkdirSync(dirPath, { recursive: true });
 }
@@ -4122,22 +4126,74 @@ function setProjectRoot(dir) {
 function getProjectRootOverride() {
   return projectRootOverride;
 }
-function findSystemRoot(startDir) {
+function holdsSystemSpec(dir) {
+  for (const base of [".wai", ".wairon"]) {
+    const specs = path.join(dir, base, "specs");
+    if (fs.existsSync(path.join(specs, ".index.yaml")) || fs.existsSync(path.join(specs, "system.yaml"))) return true;
+    if (base === ".wai" && fs.existsSync(path.join(dir, ".wai"))) break;
+  }
+  return false;
+}
+function findRepositoryRoot(startDir) {
   let dir = path.resolve(startDir);
   while (true) {
-    const isWai = fs.existsSync(path.join(dir, ".wai"));
-    const isWairon = !isWai && fs.existsSync(path.join(dir, ".wairon"));
-    const base = isWai ? ".wai" : isWairon ? ".wairon" : null;
-    if (base) {
-      if (fs.existsSync(path.join(dir, base, "specs", ".index.yaml")) || fs.existsSync(path.join(dir, base, "specs", "system.yaml"))) {
-        return dir;
-      }
+    if (fs.existsSync(path.join(dir, ".git"))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function isAtOrBelow(outer, inner2) {
+  const rel2 = path.relative(outer, inner2);
+  return rel2 === "" || !rel2.startsWith("..") && !path.isAbsolute(rel2);
+}
+function declaredMemberDirs(projectRoot) {
+  let parsed;
+  try {
+    const text3 = fs.readFileSync(path.join(projectRoot, ".wai", "project.yaml"), "utf-8");
+    parsed = yaml.load(text3);
+  } catch {
+    return [];
+  }
+  const members = parsed?.members;
+  if (!members || typeof members !== "object") return [];
+  const dirs = [];
+  for (const value of Object.values(members)) {
+    const declaration2 = value;
+    const source = typeof declaration2 === "string" ? declaration2 : typeof declaration2?.source === "string" ? declaration2.source : typeof declaration2?.path === "string" ? declaration2.path : void 0;
+    if (!source) continue;
+    const text3 = source.trim();
+    if (text3.startsWith("hosted:") || /^[a-z][a-z0-9+.-]*:\/\//i.test(text3) || /^[\w.-]+@[\w.-]+:/.test(text3) || path.isAbsolute(text3)) continue;
+    dirs.push(path.resolve(projectRoot, text3));
+  }
+  return dirs;
+}
+function resolveProjectBinding(startDir) {
+  const start = path.resolve(startDir);
+  const repositoryRoot2 = findRepositoryRoot(start) ?? void 0;
+  const withRepo = (b) => repositoryRoot2 ? { ...b, repositoryRoot: repositoryRoot2 } : b;
+  let dir = start;
+  while (true) {
+    if (holdsSystemSpec(dir)) return withRepo({ root: dir, via: dir === start ? "here" : "ancestor" });
+    if (repositoryRoot2 && dir === repositoryRoot2) break;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  dir = path.dirname(repositoryRoot2);
+  while (true) {
+    if (holdsSystemSpec(dir)) {
+      const declares2 = declaredMemberDirs(dir).some((member) => isAtOrBelow(repositoryRoot2, member) && isAtOrBelow(member, start));
+      if (declares2) return withRepo({ root: dir, via: "declared-member" });
     }
     const parent = path.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
+function findSystemRoot(startDir) {
+  return resolveProjectBinding(startDir)?.root ?? null;
+}
 function getProjectRoot() {
   const scoped = requestRootStore.getStore()?.root;
   if (scoped) return scoped;
@@ -4187,7 +4243,7 @@ function defaultTargetConfig(type) {
     enabled: true
   };
 }
-var WAIRON_VERSION = "5.1.1-dev.102";
+var WAIRON_VERSION = "5.1.1-dev.103";
 var GITHUB_REPO = "SYW-Apps/Waffle-AIron";
 var ARCHITECT_AGENT_ID = "agent-architect";
 var ARCHITECT_TEMPLATE_ID = "architect";
@@ -4402,17 +4458,17 @@ function repositoryRoot(directory) {
 }
 
 // src/utils/yaml.ts
-var yaml = __toESM(require("js-yaml"));
+var yaml2 = __toESM(require("js-yaml"));
 function parseYaml(content, sourcePath) {
   try {
-    return yaml.load(content);
+    return yaml2.load(content);
   } catch (err) {
     const loc = sourcePath ? ` (${sourcePath})` : "";
     throw new Error(`Failed to parse YAML${loc}: ${String(err)}`);
   }
 }
 function serializeYaml(value) {
-  return yaml.dump(value, {
+  return yaml2.dump(value, {
     indent: 2,
     lineWidth: 100,
     noRefs: true,
@@ -4635,6 +4691,14 @@ var AgentBriefSchema = import_zod2.z.object({
    * agent implements nothing.
    */
   typeMapping: import_zod2.z.array(import_zod2.z.string()).optional(),
+  /**
+   * Where an implementing agent may write CODE: each source file its
+   * implementations name, plus the folder they share below the project root as
+   * `<folder>/**`. Empty when nothing names a file yet (the instructions then
+   * ask the spawning session to name the planned files); absent for an agent
+   * that implements nothing.
+   */
+  codeFence: import_zod2.z.array(import_zod2.z.string()).optional(),
   /**
    * Set only on a brief for a member's agent (an id qualified `<alias>::`): the
    * member's directory relative to the root the brief was asked from. The
@@ -9109,7 +9173,7 @@ function extractTypesFromSignature(signature, returns) {
   let sigCleaned = signature.replace(/\/\/.*$/gm, "").replace(/#.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
   sigCleaned = sigCleaned.replace(/(?<=\S)\s*\([^)]*\)\s*$/, "");
   sigCleaned = sigCleaned.replace(/(?<=\S)\s+[-—:]\s+[a-z\s_-]+$/, "");
-  const returnsCleaned = returns.replace(/\/\/.*$/gm, "").replace(/#.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/[a-zA-Z0-9_-]+\s*\??\s*:/g, "");
+  const returnsCleaned = returns.replace(/\/\/.*$/gm, "").replace(/#.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/(?<![:\w-])[a-zA-Z0-9_-]+\s*\??\s*:(?!:)/g, "");
   types.push(...extractTypeIdentifiers(returnsCleaned));
   const openParen = sigCleaned.indexOf("(");
   const closeParen = sigCleaned.lastIndexOf(")");
@@ -9140,7 +9204,7 @@ function extractTypesFromSignature(signature, returns) {
       const colonIndex = param.indexOf(":");
       if (colonIndex !== -1) {
         const paramType = param.slice(colonIndex + 1).trim();
-        const paramTypeCleaned = paramType.replace(/[a-zA-Z0-9_-]+\s*\??\s*:/g, "");
+        const paramTypeCleaned = paramType.replace(/(?<![:\w-])[a-zA-Z0-9_-]+\s*\??\s*:(?!:)/g, "");
         types.push(...extractTypeIdentifiers(paramTypeCleaned));
       }
     }
@@ -9589,6 +9653,12 @@ function fieldTypesOf(facts, field) {
 function localTypesOf(facts, name) {
   return ownEntry(facts.localTypes, name) ?? NO_DECLARED_TYPES;
 }
+function memberTypesOf(facts, shape, property) {
+  return ownEntry(facts.memberTypes, `${shape}.${property}`) ?? NO_DECLARED_TYPES;
+}
+function aliasTargetOf(facts, name) {
+  return ownEntry(facts.aliasTargets, name);
+}
 function typeBindingOf(facts, name) {
   return ownEntry(facts.typeOnlyBindings, name) ?? ownEntry(facts.importBindings, name)?.from;
 }
@@ -15532,7 +15602,7 @@ function unpin(alias) {
 }
 
 // src/core/openapi.ts
-var yaml2 = __toESM(require("js-yaml"));
+var yaml3 = __toESM(require("js-yaml"));
 var PRIMITIVE_SCHEMAS = {
   string: { type: "string" },
   int: { type: "integer" },
@@ -15817,7 +15887,7 @@ function toOpenApiSet(snapshot) {
 }
 function isOpenApiDocument(body) {
   try {
-    const parsed = yaml2.load(body);
+    const parsed = yaml3.load(body);
     return !!parsed && typeof parsed === "object" && typeof parsed.openapi === "string";
   } catch {
     return false;
@@ -15928,7 +15998,7 @@ function authFromSecurityScheme(scheme) {
 function fromOpenApi(document, projectName) {
   let parsed;
   try {
-    parsed = yaml2.load(document);
+    parsed = yaml3.load(document);
   } catch (e) {
     throw new Error(`Invalid surface document: not parseable as JSON/YAML (${e instanceof Error ? e.message : String(e)})`);
   }
@@ -16758,7 +16828,9 @@ function writeSurfaceFile(targetPath, snapshot, renderedSet) {
   const resolved = path14.resolve(targetPath);
   fs9.mkdirSync(path14.dirname(resolved), { recursive: true });
   if (!renderedSet || renderedSet.length === 0) {
-    writeYamlFile(resolved, snapshot);
+    if (path14.extname(resolved).toLowerCase() === ".json") fs9.writeFileSync(resolved, `${JSON.stringify(snapshot, null, 2)}
+`);
+    else writeYamlFile(resolved, snapshot);
     return [resolved];
   }
   if (renderedSet.length === 1) {
@@ -18695,17 +18767,47 @@ function buildCodeIndex(model) {
   };
   const possibleOriginsOf = (site, from) => {
     const proven = originOf2(site, from);
-    if (!site.field && !site.constructed && !site.via && !site.returnedBy && !site.enclosingClass) return proven;
+    if (!site.field && !site.constructed && !site.via && !site.returnedBy && !site.enclosingClass && !site.receiverPath) {
+      return proven;
+    }
     const resolved = scopeOf2(site, from);
     if (!resolved) return proven;
     const { path: scope, facts: f } = resolved;
     const out = new Set(proven);
-    const widenThrough = (name, specifier) => {
-      const landings = specifier !== void 0 ? landingFrom(scope, specifier) : declarationsAt(scope).has(name) ? republishedFrom(scope) : NO_ORIGIN;
+    const widenThroughAt = (at, name, specifier) => {
+      const landings = specifier !== void 0 ? landingFrom(at, specifier) : declarationsAt(at).has(name) ? republishedFrom(at) : NO_ORIGIN;
       for (const candidate of landings) out.add(candidate);
     };
-    const widenThroughType = (typeName) => widenThrough(typeName, typeBindingOf(f, typeName));
+    const widenThrough = (name, specifier) => widenThroughAt(scope, name, specifier);
+    const widenThroughType = (typeName, at = scope, atFacts = f) => {
+      widenThroughAt(at, typeName, typeBindingOf(atFacts, typeName));
+      for (const decl of typeDeclarationsOf(at, atFacts, typeName)) {
+        const target = aliasTargetOf(decl.facts, decl.name);
+        if (target !== void 0) widenThroughAt(decl.path, target, typeBindingOf(decl.facts, target));
+      }
+    };
     if (site.field) for (const typeName of fieldTypesOf(f, site.field)) widenThroughType(typeName);
+    if (site.receiverPath && site.receiverPath.length >= 2) {
+      const [root, ...rest] = site.receiverPath;
+      const links = [...rest];
+      let current2 = [];
+      if (root === "this") {
+        const field = links.shift();
+        if (field !== void 0) current2 = fieldTypesOf(f, field).map((type) => ({ at: scope, facts: f, type }));
+      } else {
+        current2 = localTypesOf(f, root).map((type) => ({ at: scope, facts: f, type }));
+      }
+      for (const link of links) {
+        const next = [];
+        for (const c of current2) {
+          for (const decl of typeDeclarationsOf(c.at, c.facts, c.type, true)) {
+            for (const type of memberTypesOf(decl.facts, decl.name, link)) next.push({ at: decl.path, facts: decl.facts, type });
+          }
+        }
+        current2 = next;
+      }
+      for (const c of current2) widenThroughType(c.type, c.at, c.facts);
+    }
     if (site.constructed) widenThrough(site.constructed, importBindingOf(f, site.constructed)?.from);
     if (site.via) for (const typeName of localTypesOf(f, site.via)) widenThroughType(typeName);
     if (site.enclosingClass !== void 0 && holdsMemberBody(f, site.name, site.enclosingClass)) {
@@ -18727,6 +18829,34 @@ function buildCodeIndex(model) {
     }
     return out;
   };
+  const typeDeclarationsOf = (at, atFacts, typeName, throughAlias2 = false) => {
+    const found = [];
+    const exactFacts = (p) => {
+      const x = facts.get(p);
+      return x?.status === "analyzed" && x.analysisGrade === "exact" ? x : void 0;
+    };
+    const direct = (where, whereFacts, name) => {
+      if (whereFacts.declaredNames.includes(name) && typeBindingOf(whereFacts, name) === void 0) {
+        return [{ path: where, facts: whereFacts, name }];
+      }
+      const specifier = typeBindingOf(whereFacts, name);
+      if (specifier === void 0) return [];
+      const published = importBindingOf(whereFacts, name)?.imported ?? name;
+      const out = [];
+      for (const candidate of landingFrom(where, specifier)) {
+        const there = exactFacts(candidate);
+        if (there && there.declaredNames.includes(published)) out.push({ path: candidate, facts: there, name: published });
+      }
+      return out;
+    };
+    for (const decl of direct(at, atFacts, typeName)) {
+      found.push(decl);
+      if (!throughAlias2) continue;
+      const target = aliasTargetOf(decl.facts, decl.name);
+      if (target !== void 0) found.push(...direct(decl.path, decl.facts, target));
+    }
+    return found;
+  };
   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 forwardsOf = (start, name, container) => {
@@ -19236,10 +19366,11 @@ var fieldTypeReferencesRule = {
         for (const ref of refs) {
           if (!ctx.isTypeResolved(ref, /* @__PURE__ */ new Set())) {
             const hint = ctx.importHint(ref);
+            const spelled = ctx.aliasSpelling(ref);
             ctx.addIssue(
               "error",
               "UNDEFINED_TYPE_REFERENCE",
-              `Type "${t.id}" field "${field.name}" references undefined type "${ref}" in "${field.type}".${hint ? ` A declared dependency exports it without this project importing it \u2014 add \`${hint}\`.` : ""}`,
+              `Type "${t.id}" field "${field.name}" references undefined type "${ref}" in "${field.type}".${hint ? ` A declared dependency exports it without this project importing it \u2014 add \`${hint}\`.` : ""}${spelled ? ` "${ref.split(".")[0]}" is another project here, not a subsystem of this one \u2014 write \`${spelled}\`.` : ""}`,
               t.id,
               isDraftCtx
             );
@@ -19274,10 +19405,11 @@ var signatureTypeReferencesRule = {
         for (const ref of refs) {
           if (!ctx.isTypeResolved(ref, allGenerics)) {
             const hint = ctx.importHint(ref);
+            const spelled = ctx.aliasSpelling(ref);
             ctx.addIssue(
               "error",
               "UNDEFINED_TYPE_REFERENCE",
-              `Method "${m.name}" on interface "${intf.id}" references undefined type "${ref}" in signature.${hint ? ` A declared dependency exports it without this project importing it \u2014 add \`${hint}\`.` : ""}`,
+              `Method "${m.name}" on interface "${intf.id}" references undefined type "${ref}" in signature.${hint ? ` A declared dependency exports it without this project importing it \u2014 add \`${hint}\`.` : ""}${spelled ? ` "${ref.split(".")[0]}" is another project here, not a subsystem of this one \u2014 write \`${spelled}\`.` : ""}`,
               intf.id,
               isDraftCtx
             );
@@ -19296,10 +19428,11 @@ var signatureTypeReferencesRule = {
       for (const { ref, by } of named2) {
         if (ctx.isTypeResolved(ref, typeGenerics)) continue;
         const hint = ctx.importHint(ref);
+        const spelled = ctx.aliasSpelling(ref);
         ctx.addIssue(
           "error",
           "UNDEFINED_TYPE_REFERENCE",
-          `${by} references undefined type "${ref}" in signature.${hint ? ` A declared dependency exports it without this project importing it \u2014 add \`${hint}\`.` : ""}`,
+          `${by} references undefined type "${ref}" in signature.${hint ? ` A declared dependency exports it without this project importing it \u2014 add \`${hint}\`.` : ""}${spelled ? ` "${ref.split(".")[0]}" is another project here, not a subsystem of this one \u2014 write \`${spelled}\`.` : ""}`,
           t.id,
           isDraftCtx
         );
@@ -24030,19 +24163,40 @@ function closedCallSites(code, file, fn, stopAt, container) {
   return out;
 }
 var anchorKey = (symbol, exportedVia) => exportedVia !== void 0 ? `${exportedVia}.${symbol}` : symbol;
+var bodyKey = (file, symbol, exportedVia) => `${file}|${anchorKey(symbol, exportedVia)}`;
 function resolveCallTarget(ctx, componentId, methodName) {
   const accepted = /* @__PURE__ */ new Set([methodName]);
   const files = /* @__PURE__ */ new Set();
+  const bodies = /* @__PURE__ */ new Set();
+  const anchors = [];
   for (const intf of ctx.interfacesByComponent.get(componentId) ?? []) {
     for (const impl of ctx.implementationsByContract.get(intf.id) ?? []) {
       const method = impl.methods.find((m) => m.name === methodName);
       if (!method && !intf.methods.some((m) => m.name === methodName)) continue;
       if (method?.symbol) accepted.add(method.symbol);
       const file = methodSourceFile(method ?? {}, impl.sourcePath);
-      if (file) files.add(pathKey(file));
+      if (!file) continue;
+      files.add(pathKey(file));
+      bodies.add(bodyKey(pathKey(file), method?.symbol ?? methodName, method?.exportedVia));
+      anchors.push({ file: pathKey(file), symbol: method?.symbol ?? methodName, exportedVia: method?.exportedVia });
     }
   }
-  return { accepted, files };
+  return { accepted, files, bodies, anchors };
+}
+function targetForwards(code, target) {
+  const out = /* @__PURE__ */ new Set();
+  for (const anchor of target.anchors) {
+    for (const p of code.forwardsOf(anchor.file, anchor.symbol, anchor.exportedVia)) out.add(`${p.file}#${p.name}`);
+    if (anchor.exportedVia !== void 0) continue;
+    const facts = code.factsAt(anchor.file);
+    if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
+    const binding = importBindingOf(facts, anchor.symbol);
+    if (!binding || binding.namespace) continue;
+    const module2 = resolveImport(anchor.file, binding.from, code.paths, code.packages);
+    if (!module2) continue;
+    for (const p of code.forwardsOf(module2, binding.imported ?? anchor.symbol)) out.add(`${p.file}#${p.name}`);
+  }
+  return out;
 }
 function isTarget(pairs, target) {
   return pairs.some((p) => target.files.has(p.file) && target.accepted.has(p.name));
@@ -24083,6 +24237,7 @@ function describeSite(site) {
   if (site.field) return `this.${site.field}.${site.name}(\u2026)`;
   if (site.constructed) return `new ${site.constructed}(\u2026).${site.name}(\u2026)`;
   if (site.returnedBy) return `${site.returnedBy}(\u2026).${site.name}(\u2026)`;
+  if (site.receiverPath) return `${site.receiverPath.join(".")}.${site.name}(\u2026)`;
   if (site.enclosingClass) return `this.${site.name}(\u2026)`;
   return `<receiver>.${site.name}(\u2026)`;
 }
@@ -24096,10 +24251,10 @@ function describeMiss(m) {
 var callConformanceRule = {
   name: "call-conformance",
   judges: "code",
-  description: "Code\u2194spec Level 3: the CLAIMED call \u2194 realized call relation, judged both ways against the method's own source file (its sourcePath, else the implementation's), at exact analysis grade only. A method claims a call two ways and they face one check: a narrative `call` step, and an entry of the declared `calls` a narrative-less method reaches its collaborators through. They assert the same thing, and the step number is no part of the claim \u2014 this check never reads order, so it is only how a finding points at one. Forward: every claim must be realized by a call whose callee RESOLVES TO one of the target method's own source files \u2014 the target's contract name or a per-method `symbol` override, closed transitively over the named helpers the realized function calls, and resolved against every file the call CAN have reached: a `this.<field>.<method>()` receiver followed through the field's DECLARED TYPE, a `new Class(...).<method>()` receiver through the module its CLASS NAME came from, a plain `<name>.<method>()` receiver through the type the file ANNOTATES that name with \u2014 a parameter's, or an annotated variable's, which is how a module that wires its collaborators as closures writes every one of its calls \u2014 a `fn(...).<method>()` receiver through the type fn RETURNS where the code settles it, and a `this.<method>()` receiver through the class whose own method it sits in; a package specifier naming a package of this repository resolves like a relative one, and an export alias (`export { a as b }`, an adapter object property `{ b: a }`) forwards by identity like a re-export. A matching call whose origin a pure model cannot resolve is reported apart as CALL_ORIGIN_UNRESOLVED, which NAMES the shape it could not follow and asks for nothing \u2014 a coverage hole in the reader, reported for the reason CONFORMANCE_DEGRADED is: a silently degraded gate is worse than a degraded one. A finding names a landing only from the PROVEN tier so that widening what a call reached can accept a claim but never accuse one, and a target that names no file of its own falls back to name membership. Converse: a call that resolves to a modelled method of ANOTHER component in the SAME file crosses a component boundary while looking local, so the method must claim it \u2014 in a step or in `calls` (UNDECLARED_COLOCATED_CALL) \u2014 judged on the proven tier alone, and a same-file private helper is no modelled method and is never reported; a function forwarding by identity to a modelled method written in another file IS that method, so what it calls is that method's subject. A method that claims nothing at all is judged in neither direction: what it leaves unsaid is UNUSED_*'s subject. Order, arguments and conditions stay unverified, dispatch steps (runtime-table routed) are no claim about a call site, a malformed declared reference is MALFORMED_DECLARED_CALL's finding and names no target here, the conformance dial (off) skips, and weaker analysis grades never guess.",
+  description: "Code\u2194spec Level 3: the CLAIMED call \u2194 realized call relation, judged both ways against the method's own source file (its sourcePath, else the implementation's), at exact analysis grade only. A method claims a call two ways and they face one check: a narrative `call` step, and an entry of the declared `calls` a narrative-less method reaches its collaborators through. They assert the same thing, and the step number is no part of the claim \u2014 this check never reads order, so it is only how a finding points at one. Forward: every claim must be realized by a call whose callee RESOLVES TO one of the target method's own source files \u2014 the target's contract name or a per-method `symbol` override, closed transitively over the named helpers the realized function calls, and resolved against every file the call CAN have reached: a `this.<field>.<method>()` receiver followed through the field's DECLARED TYPE, a `new Class(...).<method>()` receiver through the module its CLASS NAME came from, a plain `<name>.<method>()` receiver through the type the file ANNOTATES that name with \u2014 a parameter's, or an annotated variable's, which is how a module that wires its collaborators as closures writes every one of its calls \u2014 a `fn(...).<method>()` receiver through the type fn RETURNS where the code settles it, and a `this.<method>()` receiver through the class whose own method it sits in, and a receiver CHAIN (`this.<field>.<property>.<method>()`, `<name>.<property>.<method>()`) link by link through each link's declared type \u2014 a declared type read through a member-preserving utility (Pick, Omit, Partial, Required, Readonly) and one alias hop; a package specifier naming a package of this repository resolves like a relative one, and an export alias (`export { a as b }`, an adapter object property `{ b: a }`) forwards by identity like a re-export. A matching call whose origin a pure model cannot resolve is reported apart as CALL_ORIGIN_UNRESOLVED, which NAMES the shape it could not follow and asks for nothing \u2014 a coverage hole in the reader, reported for the reason CONFORMANCE_DEGRADED is: a silently degraded gate is worse than a degraded one. A finding names a landing only from the PROVEN tier so that widening what a call reached can accept a claim but never accuse one, and a target that names no file of its own falls back to name membership. N:1 identity \u2014 a caller that IS the target \u2014 is judged on the body, the same anchor in the same file, never on a shared name: a Portal method forwarding to a same-named Orchestrator method elsewhere must make that call. Converse: a call that resolves to a modelled method of ANOTHER component in the SAME file crosses a component boundary while looking local, so the method must claim it \u2014 in a step or in `calls` (UNDECLARED_COLOCATED_CALL) \u2014 judged on the proven tier alone, and a same-file private helper is no modelled method and is never reported; a function forwarding by identity to a modelled method written in another file IS that method, so what it calls is that method's subject. A method that claims nothing at all is judged in neither direction: what it leaves unsaid is UNUSED_*'s subject. Order, arguments and conditions stay unverified, dispatch steps (runtime-table routed) are no claim about a call site, a malformed declared reference is MALFORMED_DECLARED_CALL's finding and names no target here, the conformance dial (off) skips, and weaker analysis grades never guess.",
   codes: [
     { code: "CALL_STEP_UNREALIZED", defaultSeverity: "warning", summary: "Narrative call step or declared call realized by no call that resolves to the target method's own source file \u2014 the call is absent, or it lands in another module", carryable: true },
-    { code: "CALL_ORIGIN_UNRESOLVED", defaultSeverity: "warning", summary: "Narrative call step or declared call whose target name IS called, but only from call sites written in a shape this analysis cannot resolve to a file \u2014 the claim was not checked, and is neither proven realized nor accused", carryable: true },
+    { code: "CALL_ORIGIN_UNRESOLVED", defaultSeverity: "warning", summary: "Narrative call step or declared call whose target name IS called, but only from call sites written in a shape this analysis cannot resolve to a file \u2014 the claim was not checked, and is neither proven realized nor accused. What resolves is a name bound to a module of THIS project: a bare or namespaced call through such an import binding, a this.<field> receiver whose declared type names one, a receiver chain (this.<field>.<property>, <name>.<property>) each of whose links the code declares a type for, a new Class(\u2026) receiver whose class does, a receiver name the file annotates with such a type, a fn(\u2026) receiver whose return the code settles, and this inside a class's own method \u2014 a declared type read through Pick/Omit/Partial/Required/Readonly and one alias hop. What does not: a third-party package import, a value the module assembled, and a receiver the file declares nothing for", carryable: true },
     { code: "UNDECLARED_COLOCATED_CALL", defaultSeverity: "warning", summary: "The realized function calls a modelled method of another component living in the same source file, and neither a narrative step nor a declared call names it", carryable: true }
   ],
   check(ctx) {
@@ -24127,9 +24282,9 @@ var callConformanceRule = {
       const here = pathKey(file);
       const fnSymbol = implMethod.symbol ?? implMethod.name;
       const colocated = modelledAt.get(here) ?? { byKey: /* @__PURE__ */ new Map(), byName: /* @__PURE__ */ new Map() };
-      const ownerOf4 = (site, bodyKey) => {
+      const ownerOf4 = (site, bodyKey2) => {
         const inHere = pathKey(site.from ?? here) === here;
-        if (inHere && bodyKey !== void 0 && !bodyKey.startsWith("*")) return colocated.byKey.get(bodyKey);
+        if (inHere && bodyKey2 !== void 0 && !bodyKey2.startsWith("*")) return colocated.byKey.get(bodyKey2);
         return colocated.byName.get(site.name);
       };
       const sites = closedCallSites(code, file, fnSymbol, void 0, implMethod.exportedVia);
@@ -24138,7 +24293,9 @@ var callConformanceRule = {
       for (const claim of claimsOf(implMethod)) {
         if (!ctx.componentMap.has(claim.component)) continue;
         const target = resolveCallTarget(ctx, claim.component, claim.method);
-        if (target.accepted.has(fnSymbol)) continue;
+        if (target.bodies.has(bodyKey(here, fnSymbol, implMethod.exportedVia))) continue;
+        const sharedBody = targetForwards(code, target);
+        if (code.forwardsOf(file, fnSymbol, implMethod.exportedVia).some((p) => p.file !== here && sharedBody.has(`${p.file}#${p.name}`))) continue;
         if (isTarget(code.forwardsOf(file, fnSymbol, implMethod.exportedVia), target)) continue;
         const matching = sites.filter((s) => target.accepted.has(s.name));
         const ref = `${claim.component}.${claim.method}`;
@@ -24182,7 +24339,10 @@ var callConformanceRule = {
         ctx.addIssue(
           "warning",
           "CALL_ORIGIN_UNRESOLVED",
-          `Method "${implMethod.name}" in implementation "${impl.id}": ${unresolved.length} ${claimNoun(implMethod)} ARE called by name inside the function "${fnSymbol}" in "${file}", but every site calling them is written in a shape this analysis cannot resolve to a file \u2014 ${unresolved.map(describeMiss).join("; ")}. What resolves is a name bound to a module of THIS project: a bare or namespaced call through such an import binding (a package of this repository included), a \`this.<field>\` receiver whose declared type names one, a \`new Class(\u2026)\` receiver whose class does, a receiver NAME the file annotates with a type that does, a \`fn(\u2026)\` receiver whose function's return the code settles on a type with that method's body, and \`this\` inside a class's own method that has it. What does not: an import from a third-party PACKAGE, a receiver holding a value the module assembled, a receiver this model records no name for, and one the file annotates with nothing. This reports what was not checked, not what is wrong \u2014 the claim is neither proven realized nor accused of being missing, and no working call is asked to be rewritten to suit the reader.`,
+          // The sites, and what the answer means — once. Which receiver
+          // forms resolve is the code's summary and the rule's description
+          // (`wairon rules list`), not prose every finding repeats.
+          `Method "${implMethod.name}" in implementation "${impl.id}": ${unresolved.length} ${claimNoun(implMethod)} not checked \u2014 called by name inside "${fnSymbol}" in "${file}", but only through receivers this analysis cannot resolve to a file: ${unresolved.map(describeMiss).join("; ")}. Neither proven realized nor accused; the receiver forms that do resolve are listed under CALL_ORIGIN_UNRESOLVED in \`wairon rules list\`.`,
           impl.id,
           entry.draftContext,
           void 0,
@@ -24199,8 +24359,8 @@ var callConformanceRule = {
       }
       const crossings = /* @__PURE__ */ new Map();
       const reached = /* @__PURE__ */ new Map();
-      const stopAtModelled = (site, bodyKey) => {
-        const owner = ownerOf4(site, bodyKey);
+      const stopAtModelled = (site, bodyKey2) => {
+        const owner = ownerOf4(site, bodyKey2);
         reached.set(site, owner);
         return owner !== void 0;
       };
@@ -24289,7 +24449,7 @@ var hiddenStateRule = {
 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). 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). Only exact-grade analyzed files participate; type-only imports are exempt; 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). 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 never accuses, but it does realize a declared edge: a constructor-injected collaborator is reached through its type, and `import type` is what dependency injection writes down. Only exact-grade analyzed files participate; chained subprojects validate standalone.",
   codes: [
     { code: "UNDECLARED_DEPENDENCY", defaultSeverity: "warning", summary: "A runtime import between component-mapped files has no declared dependsOn/owns (or published-surface) justification" },
     { 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" }
@@ -24357,6 +24517,23 @@ var dependencyConformanceRule = {
         );
       }
     }
+    const typeTraces = /* @__PURE__ */ new Map();
+    const typeTracesOf = (path49) => {
+      let out = typeTraces.get(path49);
+      if (out) return out;
+      out = /* @__PURE__ */ new Set();
+      const facts = code.factsAt(path49);
+      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);
+      }
+      typeTraces.set(path49, out);
+      return out;
+    };
+    const typeConnects = (from, to) => from.some((f) => {
+      const traces = typeTracesOf(f);
+      return to.some((t) => traces.has(t));
+    });
     for (const component of ctx.components) {
       const fromFiles = filesOf(component.id);
       if (fromFiles.length === 0) continue;
@@ -24370,6 +24547,7 @@ var dependencyConformanceRule = {
         if (toFiles.length === 0) continue;
         if (fromFiles.some((f) => toFiles.includes(f))) continue;
         if (graph2.connects(fromFiles, toFiles, isMountingDeclarer)) continue;
+        if (typeConnects(fromFiles, toFiles)) continue;
         const impls = mappedImplsOf(component.id);
         const declaredDependsOn = component.dependsOn.includes(targetId);
         const declaredOwns = (component.owns ?? []).includes(targetId);
@@ -24378,7 +24556,7 @@ var dependencyConformanceRule = {
         ctx.addIssue(
           "warning",
           "UNREALIZED_DEPENDENCY",
-          `Component "${component.id}" declares ${relation} "${targetId}", but no runtime import connects their source files (${fromFiles.join(", ")} \u219B ${crossSubsystem ? `subsystem ${target.subsystem}` : filesOf(targetId).join(", ")}) \u2014 either the collaboration is wired indirectly (DI) or the declared edge is stale.`,
+          `Component "${component.id}" declares ${relation} "${targetId}", but no import \u2014 runtime or type-only \u2014 connects their source files (${fromFiles.join(", ")} \u219B ${crossSubsystem ? `subsystem ${target.subsystem}` : filesOf(targetId).join(", ")}) \u2014 either the collaboration is wired indirectly (DI) or the declared edge is stale.`,
           impls[0]?.id ?? component.id,
           draft,
           void 0,
@@ -24451,11 +24629,13 @@ var portalImportsRule = {
 var integrationSimDeclarationRule = {
   name: "integration-sim-declaration",
   judges: "code",
-  description: "Once a subsystem has adopted integration sims (its first declared L4 simPath), every OTHER complete, non-leaf implementation of that subsystem must declare one too: its unit suite proves contract shape against mocks, not that the wired components run together. A leaf component's unit suite IS its sim, and a subsystem that has adopted nothing is never flooded.",
+  description: "Once a subsystem has adopted integration sims (its first declared L4 simPath), every OTHER complete, non-leaf implementation of that subsystem must declare one too: its unit suite proves contract shape against mocks, not that the wired components run together. A leaf component's unit suite IS its sim, a subsystem that has adopted nothing is never flooded, and an implementation with no code yet \u2014 no source file named, or only files that are missing \u2014 has nothing to wire and is not asked for a harness.",
   codes: [
     { code: "MISSING_INTEGRATION_SIM", defaultSeverity: "warning", summary: "Complete non-leaf implementation in a sim-adopting subsystem declares no simPath" }
   ],
   check(ctx) {
+    const code = ctx.codeIndex();
+    const hasCode = (files) => files.some((file) => code.factsAt(pathKey(file))?.status !== "missing");
     const adopted = /* @__PURE__ */ new Set();
     for (const impl of ctx.implementations) {
       if (!impl.simPath) continue;
@@ -24474,6 +24654,7 @@ var integrationSimDeclarationRule = {
       if (ctx.isImplementationDraft(impl)) continue;
       const deps = [.../* @__PURE__ */ new Set([...comp.dependsOn, ...comp.owns])].filter((d) => ctx.componentMap.has(d));
       if (deps.length === 0) continue;
+      if (!hasCode(implementationSourceFiles(impl))) continue;
       ctx.addIssue(
         "warning",
         "MISSING_INTEGRATION_SIM",
@@ -25294,7 +25475,7 @@ var NOTHING_PROMISED = /* @__PURE__ */ new Set();
 var exportConformanceRule = {
   name: "export-conformance",
   judges: "code",
-  description: "Code-to-contract for the SURFACE: does this file publish anything the components it realizes never promised, that another component then takes? The rest of the conformance set reads contract-to-code \u2014 it asks whether the code holds what a spec claims \u2014 so a file could export whatever it liked under a component's name and nothing looked. That is one half of the same hole as a contract promising a parameter it never passes. A method's `exportedVia` names the export a consumer imports to REACH it \u2014 the value that composes it, which `symbol` cannot name because `symbol` names the function inside \u2014 and a listener's mount names the router entry it calls to hand a portal its requests; both are declared publication, and a declared handle the file does not actually export is itself a finding, so naming one can never become a free-text suppression. Both questions are asked only of a file read at exact grade, and a taker counts only when its own import specifier resolves to the file it is accused of taking from: below that nothing separates an export from a mention, or a shared word from a shared module.",
+  description: "Code-to-contract for the SURFACE: does this file publish anything the components it realizes never promised, that another component then takes? The rest of the conformance set reads contract-to-code \u2014 it asks whether the code holds what a spec claims \u2014 so a file could export whatever it liked under a component's name and nothing looked. That is one half of the same hole as a contract promising a parameter it never passes. A method's `exportedVia` names the export a consumer imports to REACH it \u2014 the value that composes it, which `symbol` cannot name because `symbol` names the function inside \u2014 and a listener's mount names the router entry it calls to hand a portal its requests; both are declared publication, and a declared handle the file does not actually export is itself a finding, so naming one can never become a free-text suppression. Both questions are asked only of a file read at exact grade, and a taker counts only when its own import specifier resolves to the file it is accused of taking from: below that nothing separates an export from a mention, or a shared word from a shared module. A taker inside the owns fence is no crossing: a pattern constructs the blocks it owns, so the owner's file, or another member of the same pattern, importing a member's class is the owns relation made real.",
   codes: [
     {
       code: "UNDECLARED_EXPORT",
@@ -25316,6 +25497,7 @@ var exportConformanceRule = {
   check(ctx) {
     const code = ctx.codeIndex();
     const realization = ctx.realizationIndex();
+    const ownership = ctx.ownershipIndex();
     const promised = /* @__PURE__ */ new Map();
     const promise = (file, name) => {
       if (!name) return;
@@ -25442,13 +25624,20 @@ var exportConformanceRule = {
       const declared = promised.get(file) ?? NOTHING_PROMISED;
       const taken = takenFrom.get(file);
       const owners = new Set(realization.componentsAt(file).map((c) => c.id));
+      const fence = new Set(owners);
+      for (const id of owners) {
+        const pattern = ownership.ownerOf(id);
+        if (pattern === void 0) continue;
+        fence.add(pattern);
+        for (const member of ownership.ownedMembers) if (ownership.ownerOf(member) === pattern) fence.add(member);
+      }
       const crossed = [];
       for (const name of [...new Set(facts.exportedNames)].sort()) {
         if (declared.has(name)) continue;
         const takers = taken?.get(name);
         if (!takers) continue;
         const crossing = [...takers].some(
-          (taker) => taker !== file && !realization.componentsAt(taker).some((c) => owners.has(c.id))
+          (taker) => taker !== file && !realization.componentsAt(taker).some((c) => fence.has(c.id))
         );
         if (crossing) crossed.push(name);
       }
@@ -27150,6 +27339,8 @@ function walkExact(ts, sourceText, fileName) {
   const typeOnlyBindings = /* @__PURE__ */ new Map();
   const fieldTypes = /* @__PURE__ */ new Map();
   const localTypes = /* @__PURE__ */ new Map();
+  const memberTypes = /* @__PURE__ */ new Map();
+  const aliasTargets = /* @__PURE__ */ new Map();
   const typeShapes = /* @__PURE__ */ new Map();
   const functionParams = /* @__PURE__ */ new Map();
   const functionRoutes = /* @__PURE__ */ new Map();
@@ -27159,7 +27350,7 @@ function walkExact(ts, sourceText, fileName) {
   const mutableBindings = /* @__PURE__ */ new Set();
   const schemaConstants = /* @__PURE__ */ new Map();
   const derivedAliases = [];
-  const receiverKey = (site) => site.via ?? (site.field ? `this.${site.field}` : site.constructed ? `new ${site.constructed}` : site.returnedBy ? `${site.returnedBy}()` : site.enclosingClass ? `this:${site.enclosingClass}` : "");
+  const receiverKey = (site) => site.via ?? (site.field ? `this.${site.field}` : site.constructed ? `new ${site.constructed}` : site.returnedBy ? `${site.returnedBy}()` : site.enclosingClass ? `this:${site.enclosingClass}` : site.receiverPath ? site.receiverPath.join(".") : "");
   const siteKey = (site) => `${site.member ? "m" : "b"}:${receiverKey(site)}:${site.name}`;
   const addBindingNames = (name) => {
     if (ts.isIdentifier(name)) declared.add(name.text);
@@ -27174,7 +27365,34 @@ function walkExact(ts, sourceText, fileName) {
     if (ts.isPrivateIdentifier(name)) return name.text;
     return void 0;
   };
-  const typeReferenceName = (type) => type && ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName) ? type.typeName.text : void 0;
+  const MEMBER_PRESERVING = /* @__PURE__ */ new Set(["Pick", "Omit", "Partial", "Required", "Readonly"]);
+  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;
+      const name = at.typeName.text;
+      if (!MEMBER_PRESERVING.has(name) || !at.typeArguments?.length) return name;
+      at = at.typeArguments[0];
+    }
+    return void 0;
+  };
+  const recordMemberType = (shape, name, type) => {
+    if (!shape) return;
+    const typeName = typeReferenceName(type);
+    if (!typeName) return;
+    const property = propertyNameText(name);
+    if (!property) return;
+    const key = `${shape}.${property}`;
+    const named2 = memberTypes.get(key) ?? /* @__PURE__ */ new Set();
+    named2.add(typeName);
+    memberTypes.set(key, named2);
+  };
+  const shapeNameOf = (holder) => {
+    if (!holder) return void 0;
+    if ((ts.isClassDeclaration(holder) || ts.isInterfaceDeclaration(holder)) && holder.name) return holder.name.text;
+    if (ts.isTypeLiteralNode(holder) && holder.parent && ts.isTypeAliasDeclaration(holder.parent)) return holder.parent.name.text;
+    return void 0;
+  };
   const isParameterProperty = (node) => !!node.modifiers?.some((m) => m.kind === ts.SyntaxKind.PublicKeyword || m.kind === ts.SyntaxKind.PrivateKeyword || m.kind === ts.SyntaxKind.ProtectedKeyword || m.kind === ts.SyntaxKind.ReadonlyKeyword);
   const recordFieldType = (name, type) => {
     const typeName = typeReferenceName(type);
@@ -27371,7 +27589,18 @@ function walkExact(ts, sourceText, fileName) {
           } else if (receiver.kind === ts.SyntaxKind.ThisKeyword) {
             const owner = enclosingClassOf(node);
             addSite(owner !== void 0 ? { name, member: true, enclosingClass: owner } : { name, member: true });
-          } else addSite({ name, member: true });
+          } else {
+            const chain = [];
+            let at = receiver;
+            while (ts.isPropertyAccessExpression(at) && !at.questionDotToken && ts.isIdentifier(at.name)) {
+              chain.unshift(at.name.text);
+              at = at.expression;
+            }
+            if (ts.isIdentifier(at)) chain.unshift(at.text);
+            else if (at.kind === ts.SyntaxKind.ThisKeyword) chain.unshift("this");
+            else chain.length = 0;
+            addSite(chain.length >= 2 ? { name, member: true, receiverPath: chain } : { name, member: true });
+          }
         }
       }
       ts.forEachChild(node, count);
@@ -27506,9 +27735,14 @@ function walkExact(ts, sourceText, fileName) {
         functionRoutes.set(fnName, known);
       }
     }
-    if (ts.isPropertyDeclaration(node)) recordFieldType(node.name, node.type);
-    else if (ts.isParameter(node) && node.parent && ts.isConstructorDeclaration(node.parent) && isParameterProperty(node)) {
+    if (ts.isPropertyDeclaration(node)) {
+      recordFieldType(node.name, node.type);
+      recordMemberType(shapeNameOf(node.parent), node.name, node.type);
+    } else if (ts.isParameter(node) && node.parent && ts.isConstructorDeclaration(node.parent) && isParameterProperty(node)) {
       recordFieldType(node.name, node.type);
+      recordMemberType(shapeNameOf(node.parent.parent), node.name, node.type);
+    } else if (ts.isPropertySignature(node)) {
+      recordMemberType(shapeNameOf(node.parent), node.name, node.type);
     }
     if (ts.isParameter(node) || ts.isVariableDeclaration(node)) recordLocalType(node.name, node.type);
     if (ts.isInterfaceDeclaration(node)) {
@@ -27522,6 +27756,10 @@ function walkExact(ts, sourceText, fileName) {
       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);
+        }
         const constant = inferredSchemaConstant(node.type);
         if (constant) derivedAliases.push({ name: node.name.text, constant });
         const literals = stringLiteralUnion(node.type);
@@ -27682,7 +27920,7 @@ function walkExact(ts, sourceText, fileName) {
   }
   const reexportOnly = sf.statements.length > 0 && sf.statements.every((st) => ts.isExportDeclaration(st) && !!st.moduleSpecifier);
   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, 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, typeShapes, functionParams, functionRoutes, asyncFunctions, enumValues, aliasTypes, mutableBindings, reexportOnly };
 }
 var NO_PACKAGES = /* @__PURE__ */ new Map();
 function resolveModule(fromFile, specifier, packages) {
@@ -28054,6 +28292,8 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
             typeOnlyBindings: Object.fromEntries(facts.typeOnlyBindings),
             fieldTypes: Object.fromEntries([...facts.fieldTypes].map(([k, v]) => [k, [...v]])),
             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),
             typeShapes: Object.fromEntries(facts.typeShapes),
             functionParams: Object.fromEntries(facts.functionParams),
             functionRoutes: Object.fromEntries([...facts.functionRoutes].map(([k, v]) => [k, [...v.values()]])),
@@ -28498,8 +28738,16 @@ function buildRuleContext(opts) {
     }
     if (ownerId && nameKey(first) === nameKey(ownerId)) return ownTypes.some((spec) => typeMatchesRef(spec, rest.join("::")));
     if (ref.includes("::") && authoredTypeRefs.has(ref)) return true;
+    return false;
+  };
+  const aliasSpelling = (ref) => {
+    const segments = ref.split(".");
+    if (segments.length !== 2 || ref.includes("::")) return null;
+    const [first, name] = segments;
+    if (subsystems.some((s) => nameKey(s.id.split("::").pop()) === nameKey(first) && memberOf(s.id) === void 0)) return null;
     const via = aliasOf(first);
-    return via !== void 0 && rest.length === 1 && exportedBy(via, nameKey(rest[0]), "type") !== void 0;
+    const publicName = via ? exportedBy(via, nameKey(name), "type") : void 0;
+    return via && publicName ? `${via.alias}::${publicName}` : null;
   };
   const foreignSurfaceRef = (ref) => {
     const segments = ref.split("::").filter((seg) => seg && seg !== "super");
@@ -28873,6 +29121,7 @@ function buildRuleContext(opts) {
     isImplementationDraft,
     getComponentProfile,
     isTypeResolved,
+    aliasSpelling,
     targetLanguageFor,
     isSpecInScope,
     isInChainedSubproject,
@@ -31404,6 +31653,28 @@ function mapSignatureSource(value, map) {
   const head2 = map("signatureFrom", parts.head);
   return head2 === parts.head ? value : `${head2}.${parts.tail}`;
 }
+var TYPE_EXPRESSION_PATHS = {
+  interface: ["methods.params.type", "methods.returns", "methods.signature", "methods.signatureFrom"],
+  type: ["fields.type", "params.type", "returns", "methods.params.type", "methods.returns", "methods.signature"]
+};
+function typeExpressionSlots(kind, doc) {
+  const out = [];
+  const paths = kind === "interface" || kind === "type" ? TYPE_EXPRESSION_PATHS[kind] : [];
+  const walk2 = (node, segments, at, method) => {
+    if (!node || typeof node !== "object") return;
+    const holder = node;
+    const [head2, ...rest] = segments;
+    if (rest.length === 0) {
+      if (typeof holder[head2] === "string") out.push({ holder, key: head2, path: at, ...method ? { method } : {} });
+      return;
+    }
+    const next = holder[head2];
+    const items = Array.isArray(next) ? next : next && typeof next === "object" ? [next] : [];
+    for (const item of items) walk2(item, rest, at, head2 === "methods" ? item : method);
+  };
+  for (const at of paths) walk2(doc, at.split("."), at, void 0);
+  return out;
+}
 function mapSpecReferences(kind, spec, map) {
   switch (kind) {
     case "subsystem": {
@@ -31494,11 +31765,8 @@ function rawReferences(kind, spec) {
       for (const link of spec.trustedLinks ?? []) add2("trustedLinks", link.subsystem);
       break;
     case "interface":
-      for (const m of spec.methods) {
-        qualifiedTypeNames(m.returns).forEach((t) => add2("type", t));
-        m.params?.forEach((p) => qualifiedTypeNames(p.type).forEach((t) => add2("type", t)));
-        if (m.signatureFrom !== void 0 && !signatureSourceParts(m.signatureFrom)) add2("type", m.signatureFrom);
-      }
+    case "type":
+      typeSlotReferences(kind, spec).forEach((t) => add2("type", t));
       break;
     case "implementation":
       for (const m of spec.methods) {
@@ -31510,19 +31778,36 @@ function rawReferences(kind, spec) {
         }
       }
       break;
-    case "type": {
-      const t = spec;
-      for (const f of t.fields) qualifiedTypeNames(f.type).forEach((n) => add2("type", n));
-      t.params?.forEach((p) => qualifiedTypeNames(p.type).forEach((n) => add2("type", n)));
-      qualifiedTypeNames(t.returns).forEach((n) => add2("type", n));
-      for (const m of t.methods ?? []) m.params?.forEach((p) => qualifiedTypeNames(p.type).forEach((n) => add2("type", n)));
-      break;
-    }
     default:
       break;
   }
   return out;
 }
+function typeSlotReferences(kind, spec) {
+  const out = [];
+  const structured2 = /* @__PURE__ */ new Set();
+  const slots = typeExpressionSlots(kind, spec);
+  for (const slot of slots) {
+    const value = slot.holder[slot.key];
+    if (slot.path === "methods.signature") continue;
+    if (slot.path === "methods.signatureFrom") {
+      if (!signatureSourceParts(value)) out.push(value);
+      continue;
+    }
+    for (const name of qualifiedTypeNames(value)) {
+      out.push(name);
+      structured2.add(name);
+    }
+  }
+  for (const slot of slots.filter((s) => s.path === "methods.signature")) {
+    for (const name of qualifiedTypeNames(slot.holder[slot.key])) {
+      if (structured2.has(name)) continue;
+      structured2.add(name);
+      out.push(name);
+    }
+  }
+  return out;
+}
 var IMPORTABLE_POSITIONS = /* @__PURE__ */ new Set(["dependsOn", "dispatch", "mounts", "narrative"]);
 function bareRawReferences(kind, spec) {
   const out = [];
@@ -31549,7 +31834,11 @@ function bareRawReferences(kind, spec) {
       const t = spec;
       for (const f of t.fields) for (const ref of fieldTypeRefs(t, f.type)) add2("type", ref);
       for (const ref of signatureTypeRefs(t)) add2("type", ref);
-      for (const m of t.methods ?? []) for (const p of m.params ?? []) for (const ref of fieldTypeRefs(t, p.type)) add2("type", ref);
+      const own = lower(typeGenericParameters(t));
+      for (const m of t.methods ?? []) {
+        const generics = /* @__PURE__ */ new Set([...own, ...lower(methodGenericParameters(m))]);
+        for (const ref of methodTypeRefs(m)) add2("type", ref, generics);
+      }
       break;
     }
     case "implementation":
@@ -31562,6 +31851,9 @@ function bareRawReferences(kind, spec) {
   }
   return out;
 }
+function respellTypeNames(typeStr, map) {
+  return mapTypeNames(typeStr, (_position, name) => map(name));
+}
 function mapTypeNames(typeStr, map) {
   if (typeStr === void 0) return void 0;
   return typeStr.replace(
@@ -31585,12 +31877,9 @@ function respellStoredReferences(kind, doc, map) {
     const values = holder[key];
     if (Array.isArray(values)) holder[key] = values.map((v) => typeof v === "string" ? map(position, v) : v);
   };
-  const typed = (holder, key) => {
-    if (typeof holder[key] === "string") holder[key] = mapTypeNames(holder[key], map);
-  };
   const published = (entries) => {
     for (const e of list(entries)) {
-      for (const key of ["from", "component", "interface", "typeDef"]) at(e, key, "publicInterfaces");
+      for (const key of ["from", "subsystem", "component", "interface", "typeDef"]) at(e, key, "publicInterfaces");
       each(e, "consumers", "publicInterfaces");
     }
   };
@@ -31612,14 +31901,7 @@ function respellStoredReferences(kind, doc, map) {
       break;
     case "interface":
       at(doc, "component", "contract");
-      for (const m of list(doc.methods)) {
-        typed(m, "signature");
-        typed(m, "returns");
-        for (const p of list(m.params)) typed(p, "type");
-        if (typeof m.signatureFrom === "string") {
-          m.signatureFrom = signatureSourceParts(m.signatureFrom) ? mapSignatureSource(m.signatureFrom, map) : mapTypeNames(m.signatureFrom, map);
-        }
-      }
+      typedSlots("interface", doc, map);
       break;
     case "implementation":
       at(doc, "contract", "contract");
@@ -31646,34 +31928,33 @@ function respellStoredReferences(kind, doc, map) {
     case "type":
       at(doc, "subsystem", "subsystem");
       at(doc, "group", "group");
-      for (const f of list(doc.fields)) typed(f, "type");
-      for (const p of list(doc.params)) typed(p, "type");
-      typed(doc, "returns");
-      for (const m of list(doc.methods)) for (const p of list(m.params)) typed(p, "type");
+      typedSlots("type", doc, map);
       break;
     default:
       break;
   }
 }
+function typedSlots(kind, doc, map) {
+  for (const slot of typeExpressionSlots(kind, doc)) {
+    const value = slot.holder[slot.key];
+    slot.holder[slot.key] = slot.path === "methods.signatureFrom" && signatureSourceParts(value) ? mapSignatureSource(value, map) : mapTypeNames(value, map);
+  }
+}
 function mapRawReferences(kind, spec, map) {
   switch (kind) {
     case "subsystem": {
       const s = spec;
       return { ...s, trustedLinks: (s.trustedLinks ?? []).map((l) => ({ ...l, subsystem: map("trustedLinks", l.subsystem) })) };
     }
-    case "interface": {
-      const i = spec;
-      return {
-        ...i,
-        methods: i.methods.map((m) => ({
-          ...m,
-          ...m.signature !== void 0 ? { signature: mapTypeNames(m.signature, map) } : {},
-          ...m.returns !== void 0 ? { returns: mapTypeNames(m.returns, map) } : {},
-          ...m.params ? { params: m.params.map((p) => ({ ...p, type: mapTypeNames(p.type, map) })) } : {},
-          // A type source is a raw type position; a method source's head is bound, never raw.
-          ...m.signatureFrom !== void 0 && !signatureSourceParts(m.signatureFrom) ? { signatureFrom: mapTypeNames(m.signatureFrom, map) } : {}
-        }))
-      };
+    case "interface":
+    case "type": {
+      const copy = JSON.parse(JSON.stringify(spec));
+      for (const slot of typeExpressionSlots(kind, copy)) {
+        const value = slot.holder[slot.key];
+        if (slot.path === "methods.signatureFrom" && signatureSourceParts(value)) continue;
+        slot.holder[slot.key] = mapTypeNames(value, map);
+      }
+      return copy;
     }
     case "implementation": {
       const impl = spec;
@@ -31698,17 +31979,6 @@ function mapRawReferences(kind, spec, map) {
         }))
       };
     }
-    case "type": {
-      const t = spec;
-      const typedParams = (params) => params ? { params: params.map((p) => ({ ...p, type: mapTypeNames(p.type, map) })) } : {};
-      return {
-        ...t,
-        fields: t.fields.map((f) => ({ ...f, type: mapTypeNames(f.type, map) })),
-        ...typedParams(t.params),
-        ...t.returns !== void 0 ? { returns: mapTypeNames(t.returns, map) } : {},
-        methods: (t.methods ?? []).map((m) => ({ ...m, ...typedParams(m.params) }))
-      };
-    }
     default:
       return spec;
   }
@@ -36095,6 +36365,12 @@ function readLockState(current2) {
   if (!record) return { state: "unlocked", record: null, current: current2 };
   return { state: stateIdEquals(record.stateId, current2) ? "locked" : "stale", record, current: current2 };
 }
+function writeLockRecord2(record) {
+  writeLockRecord(record);
+}
+function renderDiagram2(format, relations) {
+  return renderDiagram(format, relations);
+}
 function createProjectConfig(config) {
   projectConfigRepository.create(config);
 }
@@ -36928,7 +37204,7 @@ 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) {
-  externalizeInto(subsystemId, path49, as);
+  return externalizeInto(subsystemId, path49, as);
 }
 function externalizeInto(subsystemId, partPath, as) {
   if (subsystemId.includes("::")) {
@@ -36947,7 +37223,8 @@ function externalizeInto(subsystemId, partPath, as) {
   const parentRoot = getProjectRoot();
   const parentSpecsDir = aiPathsAt(parentRoot).specsDir();
   const fooDir = path25.join(parentSpecsDir, subsystemId);
-  if (!fs16.existsSync(fooDir)) throw new WaironError(`subsystem specs directory not found: ${fooDir}`);
+  const owned = subsystemFiles(subsystemId, parentSpecsDir);
+  if (owned.files.length === 0) throw new WaironError(`subsystem specs not found for "${subsystemId}" under ${parentSpecsDir}`);
   const relPath = toPosixPath(partPath);
   const partDir = assertContainedProjectPath(parentRoot, relPath);
   if (path25.resolve(partDir) === path25.resolve(parentRoot)) throw new WaironError(`cannot externalize "${subsystemId}": the path "${relPath}" is the project root itself.`);
@@ -36960,19 +37237,74 @@ function externalizeInto(subsystemId, partPath, as) {
   if (!joined && (declaredMembers(projectConfigRepository.load() ?? {}).some((m) => m.alias === alias) || projectConfigRepository.load()?.externals?.[alias] !== void 0)) {
     throw new WaironError(`cannot externalize "${subsystemId}": this project already declares the alias "${alias}".`);
   }
-  const targetDir = path25.join(aiPathsAt(partDir).specsDir(), subsystemId);
-  if (fs16.existsSync(targetDir)) throw new WaironError(`target already contains a "${subsystemId}" subsystem: ${targetDir}`);
+  const partSpecsDir = aiPathsAt(partDir).specsDir();
+  const targetDir = path25.join(partSpecsDir, subsystemId);
+  if (owned.home !== void 0 && fs16.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) => fs16.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}\`).`);
-    const refusals = promoteRefusals(family, specFilesUnder(fooDir), ownSpecFiles(family, fooDir), alias);
+    const inside = new Set(owned.files.map((f) => path25.resolve(f)));
+    const refusals = promoteRefusals(family, owned.files, ownSpecFiles(family, fooDir).filter((f) => !inside.has(path25.resolve(f))), alias);
     if (refusals.length > 0) throw new WaironError(`cannot externalize "${subsystemId}" as a project: ${refusals.join("; ")}.`);
   }
-  ensureDir(path25.dirname(targetDir));
-  fs16.renameSync(fooDir, targetDir);
-  rebaseImplementationPaths(targetDir, parentRoot, partDir);
+  const moved = [];
+  if (owned.home !== void 0) {
+    ensureDir(path25.dirname(targetDir));
+    fs16.renameSync(owned.home, targetDir);
+    moved.push(...specFilesUnder(targetDir));
+  }
+  for (const file of strays) {
+    const to = destinationOf(file);
+    ensureDir(path25.dirname(to));
+    fs16.renameSync(file, to);
+    moved.push(to);
+    removeEmptyDirsUpTo(path25.dirname(file), parentSpecsDir);
+  }
+  rebaseImplementationPaths(partSpecsDir, parentRoot, partDir, moved);
   if (!joined) projectConfigRepository.declareMember(alias, { source: relPath });
   invalidateSpecCache();
-  if (as === "project") promoteMember(alias);
+  return as === "project" ? promoteMember(alias) : void 0;
+}
+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)) && fs16.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 && fs16.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) => {
+    if (path25.basename(file) === ".index.yaml") for (const f of specFilesUnder(path25.dirname(file))) files.add(path25.resolve(f));
+    else files.add(path25.resolve(file));
+  };
+  for (const file of others()) {
+    let raw;
+    try {
+      raw = readYamlFile(file);
+    } catch {
+      continue;
+    }
+    const kind = raw && typeof raw === "object" ? specKind(raw) : void 0;
+    if (kind === "subsystem" || kind === "system" || raw?.subsystem !== subsystemId) continue;
+    add2(file);
+  }
+  const owned = () => rawSpecs([...files]);
+  const components = new Set(owned().filter((x) => x.kind === "component").map((x) => x.id));
+  for (const spec of rawSpecs(others())) if (spec.kind === "interface" && components.has(spec.raw?.component)) add2(spec.file);
+  const contracts = new Set(owned().filter((x) => x.kind === "interface").map((x) => x.id));
+  for (const spec of rawSpecs(others())) if (spec.kind === "implementation" && contracts.has(spec.raw?.contract)) add2(spec.file);
+  return { home, files: [...files] };
+}
+function removeEmptyDirsUpTo(dir, stop) {
+  let at = path25.resolve(dir);
+  const end = path25.resolve(stop);
+  while (at !== end && isWithinDir2(end, at) && fs16.existsSync(at) && fs16.readdirSync(at).length === 0) {
+    fs16.rmdirSync(at);
+    at = path25.dirname(at);
+  }
 }
 function specFilesUnder(dir) {
   return fs16.existsSync(dir) ? listFilesRecursive(dir, ".yaml") : [];
@@ -36998,7 +37330,8 @@ function rawSpecs(files) {
   return out;
 }
 function typeTokens(expression) {
-  return typeof expression === "string" ? [...expression.matchAll(/[A-Za-z_][A-Za-z0-9_-]*/g)].map((m) => m[0]) : [];
+  if (typeof expression !== "string") return [];
+  return [...expression.matchAll(/(?:::)?[A-Za-z_][A-Za-z0-9_-]*(?:(?:::|\.)[A-Za-z_][A-Za-z0-9_-]*)*/g)].map((m) => m[0]).filter((t) => !t.includes(".") && !t.includes("::"));
 }
 function referencesOf(spec, wholeParams) {
   const out = [];
@@ -37007,13 +37340,13 @@ function referencesOf(spec, wholeParams) {
     return ref;
   });
   const expressions = [];
-  if (spec.kind === "interface") {
-    for (const m of spec.raw.methods ?? []) {
-      expressions.push(m?.returns);
-      for (const p of m?.params ?? []) if (wholeParams || !(typeof p?.type === "string" && /^[A-Za-z_][A-Za-z0-9_-]*$/.test(p.type))) expressions.push(p?.type);
-    }
+  for (const slot of typeExpressionSlots(spec.kind, spec.raw)) {
+    const value = slot.holder[slot.key];
+    if (slot.path === "methods.signatureFrom") continue;
+    if (slot.path === "methods.signature" && Array.isArray(slot.method?.params)) continue;
+    if (slot.path === "methods.params.type" && spec.kind === "interface" && !wholeParams && /^[A-Za-z_][A-Za-z0-9_-]*$/.test(String(value))) continue;
+    expressions.push(slot.path === "methods.signature" ? String(value).replace(/^\s*[A-Za-z_][\w-]*\s*(?:<[^>]*>)?\s*\(/, "(").replace(/(?<![:\w-])[A-Za-z_][\w-]*\s*\??\s*:(?!:)/g, "") : value);
   }
-  if (spec.kind === "type") for (const f of spec.raw.fields ?? []) expressions.push(f?.type);
   for (const token of expressions.flatMap(typeTokens)) out.push({ ref: token, position: "bare-type" });
   return out;
 }
@@ -37021,6 +37354,9 @@ function crossingsOf(inside, outside) {
   const idsOf = (specs) => new Set(specs.filter((s) => s.kind !== "system").map((s) => s.id));
   const insideIds = idsOf(inside);
   const outsideIds = idsOf(outside);
+  const targetsOf2 = (specs) => new Set(specs.filter((s) => s.kind === "component" || s.kind === "interface" || s.kind === "type").map((s) => s.id));
+  const insideTargets = targetsOf2(inside);
+  const outsideTargets = targetsOf2(outside);
   const typeIds = (specs) => new Map(specs.filter((s) => s.kind === "type").map((s) => [nameKey(s.id), s.id]));
   const insideTypes = typeIds(inside);
   const outsideTypes = typeIds(outside);
@@ -37038,13 +37374,14 @@ function crossingsOf(inside, outside) {
     }
     return found;
   };
-  return { out: collect(inside, outsideIds, outsideTypes, true), in: collect(outside, insideIds, insideTypes, false), insideIds, outsideIds };
+  return { out: collect(inside, outsideTargets, outsideTypes, true), in: collect(outside, insideTargets, insideTypes, false), insideIds, outsideIds, insideTargets, outsideTargets };
 }
 function promoteRefusals(family, insideFiles, outsideFiles, id) {
   const out = [];
   const inside = rawSpecs(insideFiles);
   const outside = rawSpecs(outsideFiles);
   const crossing = crossingsOf(inside, outside);
+  out.push(...unreachableUpward(inside, outside));
   const subsystemsIn = new Set(inside.filter((s) => s.kind === "subsystem").map((s) => s.id));
   for (const s of [...inside, ...outside].filter((x) => x.kind === "subsystem")) {
     for (const link of s.raw.trustedLinks ?? []) {
@@ -37086,13 +37423,19 @@ function climbsOf(family, ids, parentId) {
   return { map, refused: [...new Set(refused2)] };
 }
 var PROJECT_ID_RE_LOCAL = /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/;
-function rewriteRefsIn(specs, remap) {
+function rewriteRefsIn(specs, remap, record) {
   const rewritten = [];
   for (const spec of specs) {
     const raw = readYamlFile(spec.file);
-    if (!rewriteSpecRefs(raw, (ref, position) => remap(ref, position))) continue;
+    const edits = [];
+    if (!rewriteSpecRefs(raw, (ref, position) => {
+      const to = remap(ref, position);
+      if (to !== ref) edits.push({ kind: spec.kind, specId: spec.id, position, from: ref, to });
+      return to;
+    })) continue;
     writeYamlFile(spec.file, raw);
     rewritten.push({ kind: spec.kind, id: spec.id });
+    if (record) for (const e of edits) recordRespelling(record.result, e, record.member);
   }
   return rewritten;
 }
@@ -37142,15 +37485,19 @@ 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 parentSide = rewriteRefsIn(crossing.in.map((c) => c.spec).filter(unique), (ref, position) => INTO_MEMBER_POSITIONS.has(position) && crossing.insideIds.has(ref) ? `${alias}::${ref}` : ref);
+  const result = { respelled: [], memberRespelled: [], exported: [], imported: [], consumersDropped: [] };
+  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));
-  const memberSide = rewriteRefsIn([...crossing.out.map((c) => c.spec), ...climbing].filter(unique), (ref, position) => climbs.get(ref) ?? (MOVED_REF_POSITIONS.has(position) && crossing.outsideIds.has(ref) ? `${parentId}::${ref}` : ref));
+  const memberSide = rewriteRefsIn([...crossing.out.map((c) => c.spec), ...climbing].filter(unique), (ref, position) => climbs.get(ref) ?? (MOVED_REF_POSITIONS.has(position) && crossing.outsideTargets.has(ref) ? `${parentId}::${ref}` : ref), { result, member: true });
+  const qualified = respellQualified(inside, outside, { alias, parentId, newId }, result);
   invalidateSpecCache();
-  if (crossing.out.length > 0 || [...climbs.values()].some((t) => t.startsWith(`${parentId}::`))) runWithProjectRoot(dir, () => projectConfigRepository.declareExternal(parentId, {}));
+  dropCrossingConsumers(inside, outside, result);
+  if (crossing.out.length > 0 || qualified.out.length > 0 || [...climbs.values()].some((t) => t.startsWith(`${parentId}::`))) runWithProjectRoot(dir, () => projectConfigRepository.declareExternal(parentId, {}));
   for (const s of inside.filter((x) => x.kind === "subsystem")) restateReExports(s.id, alias);
-  exportCrossings(crossing.out, dir, alias, parentId, "out");
-  exportCrossings(crossing.in, dir, alias, parentId, "in");
+  exportCrossings([...crossing.out, ...qualified.out], dir, alias, parentId, "out", result);
+  exportCrossings([...crossing.in, ...qualified.in], dir, alias, parentId, "in", result);
+  exportReExported(inside, dir, alias, result);
   invalidateSpecCache();
   for (const spec of parentSide) if (spec.kind !== "system") normalizeReferences(spec.kind, spec.id);
   const memberKey = graph().nodes.find((n) => n.parent === "" && n.mountAlias === alias)?.namespace;
@@ -37169,6 +37516,165 @@ function promoteMember(alias, id) {
     });
   }
   invalidateSpecCache();
+  return result;
+}
+function recordRespelling(result, edit4, member) {
+  if (edit4.from === edit4.to) return;
+  const list = member ? result.memberRespelled : result.respelled;
+  if (list.some((e) => e.kind === edit4.kind && e.specId === edit4.specId && e.position === edit4.position && e.from === edit4.from)) return;
+  list.push(edit4);
+}
+function assertedTypeRef(ref) {
+  const at = ref.lastIndexOf(".");
+  return at > 0 && at < ref.length - 1 ? ref.slice(0, at) : void 0;
+}
+function sidedTypes(inside, outside) {
+  const types = [
+    ...inside.filter((s) => s.kind === "type").map((s) => ({ spec: s, side: "inside" })),
+    ...outside.filter((s) => s.kind === "type").map((s) => ({ spec: s, side: "outside" }))
+  ];
+  const subsystems = new Set([...inside, ...outside].filter((s) => s.kind === "subsystem").map((s) => nameKey(s.id)));
+  return {
+    qualified: (token) => {
+      const segments = token.split(/::|\./);
+      if (segments.length !== 2 || segments.some((x) => x === "") || !subsystems.has(nameKey(segments[0]))) return void 0;
+      const found = types.filter((t) => typeof t.spec.raw.subsystem === "string" && nameKey(t.spec.raw.subsystem) === nameKey(segments[0]) && nameKey(t.spec.id) === nameKey(segments[1]));
+      return found.length === 1 ? found[0] : void 0;
+    },
+    bare: (token) => {
+      const found = types.filter((t) => nameKey(t.spec.id) === nameKey(token));
+      return found.length === 1 ? found[0] : void 0;
+    }
+  };
+}
+function unreachableUpward(inside, outside) {
+  const out = [];
+  const types = sidedTypes(inside, outside);
+  const outsideComponents = new Set(outside.filter((x) => x.kind === "component").map((x) => x.id));
+  const target = (ref) => ref.includes(".") || ref.includes("::") ? types.qualified(ref) : types.bare(ref);
+  for (const spec of inside) {
+    if (spec.kind === "interface") {
+      for (const m of spec.raw.methods ?? []) {
+        const source = m?.signatureFrom;
+        if (typeof source !== "string") continue;
+        const head2 = source.includes(".") ? source.slice(0, source.lastIndexOf(".")) : void 0;
+        if (target(source)?.side === "outside" || head2 !== void 0 && outsideComponents.has(head2)) {
+          out.push(`"${spec.id}" method "${m.name}" takes its signature from "${source}", which stays in this project: a signatureFrom is not read across a project boundary \u2014 state its params and returns first`);
+        }
+      }
+    }
+    if (spec.kind === "implementation") {
+      for (const m of spec.raw.methods ?? []) {
+        for (const step of m?.narrative ?? []) {
+          for (const ref of step?.assertsInvariants ?? []) {
+            const typeRef2 = typeof ref === "string" ? assertedTypeRef(ref) : void 0;
+            if (typeRef2 !== void 0 && !typeRef2.includes("::") && target(typeRef2)?.side === "outside") {
+              out.push(`"${spec.id}" asserts the invariant "${ref}" of an entity that stays in this project: an invariant is asserted by its own project's write paths \u2014 move the assertion first`);
+            }
+          }
+        }
+      }
+    }
+  }
+  return out;
+}
+function respellQualified(inside, outside, names, result) {
+  const crossings = { out: [], in: [] };
+  const { qualified: qualifiedTarget, bare: bareTarget } = sidedTypes(inside, outside);
+  const respell = (spec, side, token, target, selfPrefix2) => {
+    if (!target) return token;
+    if (target.side !== side) {
+      const to = `${side === "outside" ? names.alias : names.parentId}::${target.spec.id}`;
+      (side === "inside" ? crossings.out : crossings.in).push({ spec, target: target.spec.id, position: "type" });
+      return to;
+    }
+    return side === "inside" && selfPrefix2 ? target.spec.id : token;
+  };
+  for (const [specs, side] of [[inside, "inside"], [outside, "outside"]]) {
+    for (const spec of specs) {
+      if (!fs16.existsSync(spec.file)) continue;
+      const raw = readYamlFile(spec.file);
+      if (!raw || typeof raw !== "object") continue;
+      const edits = [];
+      const record = (from, to) => {
+        if (from !== to) edits.push({ kind: spec.kind, specId: spec.id, position: "type", from, to });
+      };
+      const mapToken = (token) => {
+        const target = qualifiedTarget(token);
+        const to = respell(spec, side, token, target, nameKey(token.split(/::|\./)[0]) === nameKey(names.newId));
+        record(token, to);
+        return to;
+      };
+      for (const slot of typeExpressionSlots(spec.kind, raw)) {
+        const value = slot.holder[slot.key];
+        if (slot.path === "methods.signatureFrom" && !qualifiedTarget(value)) continue;
+        slot.holder[slot.key] = respellTypeNames(value, mapToken);
+      }
+      if (spec.kind === "implementation") {
+        for (const m of raw.methods ?? []) {
+          for (const step of m?.narrative ?? []) {
+            if (!Array.isArray(step?.assertsInvariants)) continue;
+            step.assertsInvariants = step.assertsInvariants.map((ref) => {
+              const typeRef2 = typeof ref === "string" ? assertedTypeRef(ref) : void 0;
+              if (typeRef2 === void 0 || typeRef2.includes("::") && !qualifiedTarget(typeRef2)) return ref;
+              const target = typeRef2.includes(".") || typeRef2.includes("::") ? qualifiedTarget(typeRef2) : bareTarget(typeRef2);
+              const to = respell(spec, side, typeRef2, target, typeRef2.includes(".") && nameKey(typeRef2.split(".")[0]) === nameKey(names.newId));
+              if (to === typeRef2) return ref;
+              record(ref, `${to}${ref.slice(typeRef2.length)}`);
+              return `${to}${ref.slice(typeRef2.length)}`;
+            });
+          }
+        }
+      }
+      if (edits.length === 0) continue;
+      writeYamlFile(spec.file, raw);
+      for (const e of edits) recordRespelling(result, e, side === "inside");
+    }
+  }
+  return crossings;
+}
+function dropCrossingConsumers(inside, outside, result) {
+  const idsOf = (specs) => new Set(specs.filter((s) => s.kind === "subsystem").map((s) => s.id));
+  const sides = [[inside, idsOf(outside)], [outside, idsOf(inside)]];
+  for (const [specs, across] of sides) {
+    for (const spec of specs.filter((s) => s.kind === "subsystem")) {
+      patchKeepingStamp(spec.file, (raw) => {
+        let changed = false;
+        for (const entry of raw.publicInterfaces ?? []) {
+          if (!Array.isArray(entry?.consumers)) continue;
+          const dropped = entry.consumers.filter((c) => typeof c === "string" && across.has(c));
+          if (dropped.length === 0) continue;
+          const kept = entry.consumers.filter((c) => !dropped.includes(c));
+          if (kept.length > 0) entry.consumers = kept;
+          else delete entry.consumers;
+          changed = true;
+          const what = entry.component ?? entry.typeDef ?? entry.interface ?? entry.from ?? "(entry)";
+          result.consumersDropped.push(`${spec.id} ${what}: ${dropped.join(", ")}${kept.length === 0 ? " (the list is gone: the L0 export table governs who outside may use it)" : ""}`);
+        }
+        return changed;
+      });
+    }
+  }
+}
+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);
+  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 own = system.publicInterfaces ?? [];
+    const added = inside.filter((s) => s.kind === "subsystem" && !own.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: [...own, ...added] });
+    for (const e of added) result.exported.push(`${alias} L0: everything ${e.from} exports (re-exported whole by the parent)`);
+  });
+  invalidateSpecCache();
 }
 function promotedVision(id, parentName) {
   return `Project ${id}, promoted from a part of ${parentName}`;
@@ -37176,43 +37682,57 @@ function promotedVision(id, parentName) {
 function unique(value, index, all) {
   return all.indexOf(value) === index;
 }
-function exportCrossings(crossings, memberDir, alias, parentId, direction) {
+function exportCrossings(crossings, memberDir, alias, parentId, direction, result) {
   const targets = [...new Set(crossings.map((c) => c.target))];
   const bare = [...new Set(crossings.filter((c) => c.position === "bare-type").map((c) => c.target))];
   if (direction === "out") {
-    exportItems(targets);
-    if (bare.length > 0) projectConfigRepositoryAt(memberDir).importNames(parentId, bare);
+    for (const name of exportItems(targets)) result.exported.push(`${parentId} L0: ${name}`);
+    if (bare.length > 0) {
+      projectConfigRepositoryAt(memberDir).importNames(parentId, bare);
+      result.imported.push(`${alias}: externals.${parentId}.use gains ${bare.join(", ")}`);
+    }
   } else {
-    runWithProjectRoot(memberDir, () => exportItems(targets));
-    if (bare.length > 0) projectConfigRepository.importNames(alias, bare);
+    for (const name of runWithProjectRoot(memberDir, () => exportItems(targets))) result.exported.push(`${alias} L0: ${name}`);
+    if (bare.length > 0) {
+      projectConfigRepository.importNames(alias, bare);
+      result.imported.push(`${parentId}: members.${alias}.use gains ${bare.join(", ")}`);
+    }
   }
 }
 function localIn(key, project) {
   return project && key.startsWith(`${project}::`) ? key.slice(project.length + 2) : key;
 }
 function exportItems(ids) {
-  if (ids.length === 0) return;
+  if (ids.length === 0) return [];
   invalidateSpecCache();
   const system = loadSystemSpec();
-  if (!system) return;
+  if (!system) return [];
   const entries = [...system.publicInterfaces ?? []];
   const types = loadTypeSpecs();
+  const added = [];
   for (const id of ids) {
     if (!PUBLIC_NAME_RE.test(id)) continue;
     const type = types.find((t) => t.id === id);
     if (type) {
       if (type.subsystem) exportTypeFromSubsystem(type.subsystem, id);
-      if (!entries.some((e) => e.typeDef === id && e.from === void 0)) entries.push({ typeDef: id, audience: "project" });
+      if (!entries.some((e) => e.typeDef === id && (e.from === void 0 || e.from === type.subsystem))) {
+        entries.push({ ...type.subsystem ? { from: type.subsystem } : {}, typeDef: id, audience: "project" });
+        added.push(type.subsystem ? `${id} (from ${type.subsystem})` : id);
+      }
       continue;
     }
     const component = loadComponentSpec(id);
     if (!component) continue;
     const exported = resolveSubsystemExports(component.subsystem).entries.some((e) => e.kind === "component" && e.component === id);
-    if (exported && !entries.some((e) => e.component === id)) entries.push({ from: component.subsystem, component: id, audience: "project" });
+    if (exported && !entries.some((e) => e.component === id)) {
+      entries.push({ from: component.subsystem, component: id, audience: "project" });
+      added.push(`${id} (from ${component.subsystem})`);
+    }
   }
   if (entries.length !== (system.publicInterfaces ?? []).length) {
     saveSystemSpec({ ...system, publicInterfaces: entries });
   }
+  return added;
 }
 function exportTypeFromSubsystem(subsystemId, typeId) {
   const sub = loadSubsystemSpec(subsystemId);
@@ -37256,7 +37776,7 @@ function internalizeMember(alias, destination) {
   if (refusals.length > 0) {
     throw new WaironError(`cannot internalize "${alias}": the member cannot be taken in whole \u2014 ${refusals.join("; ")}.`);
   }
-  const result = { subsystems: scan.subsystems, types: scan.types, placed: [], externals: [], deleted: [], notCarried: [] };
+  const result = { subsystems: scan.subsystems, types: scan.types, placed: [], externals: [], deleted: [], notCarried: [], consumersRestored: [] };
   const intoMember = crossingReferences(family, "", member.namespace);
   const backOut = crossingReferences(family, member.namespace, "");
   deleteMount(alias);
@@ -37286,7 +37806,7 @@ function internalizePart(alias, part) {
   projectConfigRepository.removeMember(alias);
   const deleted = deleteMemberWai(partDir);
   invalidateSpecCache();
-  return { subsystems: part.subsystems, types, placed: [], externals: [], deleted, notCarried: [] };
+  return { subsystems: part.subsystems, types, placed: [], externals: [], deleted, notCarried: [], consumersRestored: [] };
 }
 function scanMember(family, alias, member, destination) {
   const root = getProjectRoot();
@@ -37635,7 +38155,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: [] };
+  const result = { subsystems, types, placed: [], externals: [], deleted: [], notCarried: [], consumersRestored: [] };
   const intoMember = localsOf(dir);
   const backOut = localsOf(root);
   invalidateSpecCache();
@@ -37652,6 +38172,10 @@ function demoteMember(alias, destination) {
   const parentSide = rewriteRefsIn(ownSpecs, across(/* @__PURE__ */ new Set([alias]), intoMember, false));
   const memberSide = rewriteRefsIn(memberSpecs, across(parentAliases, backOut, true));
   for (const pa of parentAliases) for (const name of config?.externals?.[pa]?.use ?? []) if (name !== "*") crossed.add(backOut.get(name) ?? name);
+  const memberNow = rawSpecs(specFilesUnder(aiPathsAt(dir).specsDir()).filter((f) => path25.resolve(f) !== path25.resolve(aiPathsAt(dir).specsSystem())));
+  const parentNow = rawSpecs(ownSpecFiles(family, aiPathsAt(dir).specsDir()));
+  respellQualifiedBack(parentNow, memberNow, { intoMember: (a) => a === alias, backOut: (a) => parentAliases.has(a) }, { intoMember, backOut }, crossed);
+  restoreCrossingConsumers(memberNow, parentNow, result);
   const parentName = loadSystemSpec()?.name;
   if (parentName) {
     for (const s of memberSpecs.filter((x) => x.kind === "subsystem")) {
@@ -37676,6 +38200,79 @@ function demoteMember(alias, destination) {
   invalidateSpecCache();
   return result;
 }
+function respellQualifiedBack(parentSide, memberSide, aliases, tables, crossed) {
+  const types = [...parentSide, ...memberSide].filter((s) => s.kind === "type");
+  const localForm = (id) => {
+    const found = types.filter((t) => t.id === id);
+    if (found.length !== 1) return void 0;
+    const sub = found[0].raw?.subsystem;
+    return typeof sub === "string" && sub !== "" ? `${sub}.${id}` : id;
+  };
+  for (const [specs, across, table, record] of [
+    [parentSide, aliases.intoMember, tables.intoMember, false],
+    [memberSide, aliases.backOut, tables.backOut, true]
+  ]) {
+    const local = (token) => {
+      const segments = token.split("::");
+      if (segments.length !== 2 || !across(segments[0])) return token;
+      const id = table.get(segments[1]) ?? segments[1];
+      const to = localForm(id);
+      if (to === void 0) return token;
+      if (record) crossed.add(id);
+      return to;
+    };
+    for (const spec of specs) {
+      if (!fs16.existsSync(spec.file)) continue;
+      const raw = readYamlFile(spec.file);
+      if (!raw || typeof raw !== "object") continue;
+      let changed = false;
+      for (const slot of typeExpressionSlots(spec.kind, raw)) {
+        const value = slot.holder[slot.key];
+        const next = respellTypeNames(value, local);
+        if (next !== value) {
+          slot.holder[slot.key] = next;
+          changed = true;
+        }
+      }
+      if (spec.kind === "implementation") {
+        for (const m of raw.methods ?? []) {
+          for (const step of m?.narrative ?? []) {
+            if (!Array.isArray(step?.assertsInvariants)) continue;
+            step.assertsInvariants = step.assertsInvariants.map((ref) => {
+              const typeRef2 = typeof ref === "string" ? assertedTypeRef(ref) : void 0;
+              if (typeRef2 === void 0 || !typeRef2.includes("::")) return ref;
+              const to = local(typeRef2);
+              if (to === typeRef2) return ref;
+              changed = true;
+              return `${to}${ref.slice(typeRef2.length)}`;
+            });
+          }
+        }
+      }
+      if (changed) writeYamlFile(spec.file, raw);
+    }
+  }
+}
+function restoreCrossingConsumers(memberSide, parentSide, result) {
+  const sides = [[memberSide, parentSide], [parentSide, memberSide]];
+  for (const [providers, consumers] of sides) {
+    const dependents = consumers.filter((c) => c.kind === "component" && typeof c.raw?.subsystem === "string" && Array.isArray(c.raw?.dependsOn));
+    for (const spec of providers.filter((x) => x.kind === "subsystem")) {
+      patchKeepingStamp(spec.file, (raw) => {
+        let changed = false;
+        for (const entry of raw.publicInterfaces ?? []) {
+          if (!Array.isArray(entry?.consumers) || entry.consumers.length === 0 || typeof entry.component !== "string") continue;
+          const users = [...new Set(dependents.filter((c) => c.raw.dependsOn.includes(entry.component)).map((c) => c.raw.subsystem))].filter((sub) => sub !== spec.id && !entry.consumers.includes(sub));
+          if (users.length === 0) continue;
+          entry.consumers = [...entry.consumers, ...users];
+          changed = true;
+          result.consumersRestored.push(`${spec.id} ${entry.component}: ${users.join(", ")}`);
+        }
+        return changed;
+      });
+    }
+  }
+}
 function deleteProjectContent(memberDir) {
   const wai = path25.join(memberDir, ".wai");
   const deleted = [];
@@ -37705,9 +38302,9 @@ function retireBoundaryExports(family, used, memberKey) {
   const { publicInterfaces: _dropped, ...rest } = system;
   saveSystemSpec(kept.length > 0 ? { ...rest, publicInterfaces: kept } : rest);
   invalidateSpecCache();
-  for (const e of retired.filter((x) => x.typeDef !== void 0 && x.from === void 0)) {
+  for (const e of retired.filter((x) => x.typeDef !== void 0)) {
     const type = loadTypeSpecs().find((t) => t.id === e.typeDef);
-    if (!type?.subsystem) continue;
+    if (!type?.subsystem || e.from !== void 0 && e.from !== type.subsystem) continue;
     patchKeepingStamp(getSubsystemPath(type.subsystem), (raw) => {
       const before = (raw.publicInterfaces ?? []).length;
       raw.publicInterfaces = (raw.publicInterfaces ?? []).filter((pi) => !(pi?.typeDef === e.typeDef && pi?.from === void 0 && Object.keys(pi).length === 1));
@@ -37876,7 +38473,7 @@ function renameComponent(componentId, newId) {
   }
   if (componentId.includes("::")) {
     throw new WaironError(
-      `chained-component: "${componentId}" lives in a chained subproject; rename it from that project's own root.`
+      `chained-component: "${componentId}" lives in another project; rename it from that project's own root. ${memberRootWay(componentId, `sdd_rename_component ${componentId.slice(componentId.lastIndexOf("::") + 2)} <new id>`)}`
     );
   }
   if (!SpecIdSchema.safeParse(newId).success) {
@@ -38039,7 +38636,7 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
   }
   if (componentId.includes("::")) {
     throw new WaironError(
-      `chained-component: "${componentId}" lives in a chained subproject; rename its method from that project's own root.`
+      `chained-component: "${componentId}" lives in another project; rename its method from that project's own root. ${memberRootWay(componentId, `sdd_rename_method ${componentId.slice(componentId.lastIndexOf("::") + 2)} <method> <new name>`)}`
     );
   }
   if (!METHOD_NAME.test(newName)) {
@@ -38197,18 +38794,29 @@ function respellLike(written, oldId, newId) {
   if (written.includes("-")) return kebab(newId);
   return /^[A-Z]/.test(written) ? pascal(newId) : newId;
 }
+function memberRootWay(qualifiedId, call) {
+  const alias = qualifiedId.slice(0, qualifiedId.indexOf("::"));
+  let folder;
+  try {
+    const node = graph().nodes.find((n) => n.namespace === alias || n.parent === "" && n.mountAlias === alias);
+    if (node) folder = path25.relative(getProjectRoot(), node.directory).split(path25.sep).join("/") || ".";
+  } catch {
+  }
+  const where = folder ? `the member project "${alias}" at ${folder}` : `the member project "${alias}"`;
+  return `It belongs to ${where}: open a session in that folder (its own guide and .mcp.json \u2014 run \`wairon generate\` and \`wairon mcp install --backend claude\` there first if it has none) and call ${call} there.`;
+}
 function renameType(typeId, newId) {
   const all = loadTypeSpecs();
   const cut = typeId.lastIndexOf("::");
   const qualifier = cut >= 0 ? typeId.slice(0, cut) : void 0;
   const ownSubsystem = qualifier !== void 0 && loadSubsystemSpecs().some((s) => s.id === qualifier);
   if (qualifier !== void 0 && !ownSubsystem) {
-    throw new WaironError(`chained-type: "${typeId}" lives in another project; rename it from that project's own root.`);
+    throw new WaironError(`chained-type: "${typeId}" lives in another project; rename it from that project's own root. ${memberRootWay(typeId, `sdd_rename_type ${typeId.slice(cut + 2)} <new id>`)} An exported type keeps its public name through \`as\`, so this project's references do not break.`);
   }
   const type = qualifier !== void 0 ? all.find((t) => t.id === typeId.slice(cut + 2) && t.subsystem === qualifier) ?? null : loadTypeSpec(typeId);
   if (!type) throw new WaironError(`type-missing: no type has the id "${typeId}".`);
   if (type.id.includes("::")) {
-    throw new WaironError(`chained-type: "${type.id}" lives in another project; rename it from that project's own root.`);
+    throw new WaironError(`chained-type: "${type.id}" lives in another project; rename it from that project's own root. ${memberRootWay(type.id, `sdd_rename_type ${type.id.slice(type.id.lastIndexOf("::") + 2)} <new id>`)}`);
   }
   const oldId = type.id;
   if (!SpecIdSchema.safeParse(newId).success) {
@@ -38496,8 +39104,8 @@ function walkForPackages(projectRoot, currentDir, depth, results) {
   }
 }
 function pathToId(relPath) {
-  const basename12 = path26.basename(relPath);
-  return basename12.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const basename13 = path26.basename(relPath);
+  return basename13.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
 function pathToName(relPath) {
   const id = pathToId(relPath);
@@ -38981,7 +39589,7 @@ function isWithinDir3(dir, target) {
   const rel2 = path29.relative(path29.resolve(dir), path29.resolve(target));
   return rel2 === "" || !rel2.startsWith("..") && !path29.isAbsolute(rel2);
 }
-function resolveLayer(delegate) {
+function resolveLayer(delegate, implementers = false) {
   projectFilesCache.clear();
   const system = loadSystemSpec();
   if (!system) return [];
@@ -39112,7 +39720,7 @@ function resolveLayer(delegate) {
       updatedAt: sub.updatedAt
     });
   }
-  if (config.rules.generateComponentImplementers) {
+  if (config.rules.generateComponentImplementers || implementers) {
     for (const comp of components) {
       const compInterfaces = interfaces.filter((i) => i.component === comp.id);
       const compInterfaceIds = compInterfaces.map((i) => i.id);
@@ -39180,7 +39788,7 @@ function resolveLayer(delegate) {
 }
 var UnknownAgentError = class extends WaironError {
   constructor(agentId, knownIds) {
-    super(`Unknown agent id: "${agentId}". Known agent ids: ${knownIds.join(", ")}`);
+    super(`Unknown agent id: "${agentId}". Known agent ids: ${knownIds.join(", ")} \u2014 or any component id of this project, which composes that component's implementer brief.`);
     this.name = "UnknownAgentError";
   }
 };
@@ -39191,7 +39799,7 @@ function composeAgentBrief(agentId) {
     return throughMount(brief, hop.alias, hop.relative);
   }
   const records = resolveAgentTopology();
-  const record = records.find((r) => r.id === agentId);
+  const record = records.find((r) => r.id === agentId) ?? componentImplementer(agentId);
   if (!record) {
     throw new UnknownAgentError(agentId, records.map((r) => r.id));
   }
@@ -39210,6 +39818,17 @@ function composeAgentBrief(agentId) {
     domainName: "",
     variantGuidance: record.variantGuidance ?? ""
   });
+  const codeFence = codeFenceOf(record);
+  if (codeFence) {
+    instructions = `${instructions.trimEnd()}
+
+## Code write fence
+
+${codeFence.length > 0 ? `Write code only here (and tests beside it, as the project lays tests out):
+
+${codeFence.map((p) => `- \`${p}\``).join("\n")}
+` : "No implementation names a source file yet, so no code location is declared. The spawning session must name the file(s) this agent may create (the planned sourcePath); set `sourcePath` on the implementation once the file exists.\n"}`;
+  }
   const guidance = loadAgentOverride(agentId);
   if (guidance !== null) {
     instructions = `${instructions.trimEnd()}
@@ -39244,10 +39863,34 @@ ${typeMapping.map((line) => `- ${line}`).join("\n")}
     instructions,
     variantGuidance: record.variantGuidance || void 0,
     ...typeMapping ? { typeMapping } : {},
+    ...codeFence ? { codeFence } : {},
     profile: budget ? profile : void 0,
     budget
   };
 }
+function componentImplementer(agentId) {
+  const componentId = agentId.endsWith("-implementer") ? agentId.slice(0, -"-implementer".length) : agentId;
+  if (componentId === "" || componentId.includes("::")) return null;
+  return resolveLayer(true, true).find((r) => r.id === `${componentId}-implementer`) ?? null;
+}
+function codeFenceOf(record) {
+  const implementsComponents = record.template === "implementer" || record.template === "domain-owner" && record.creationReason.startsWith("Automatically inferred from L1");
+  if (!implementsComponents) return null;
+  const files = record.ownedPaths.filter((p) => !p.startsWith(".wai/") && !p.includes("/.wai/") && !/[*?]/.test(p));
+  if (files.length === 0) return [];
+  const dirs = files.map((f) => path29.posix.dirname(f.replace(/\\/g, "/")));
+  let shared = dirs[0].split("/");
+  for (const dir of dirs.slice(1)) {
+    const parts = dir.split("/");
+    let i = 0;
+    while (i < shared.length && i < parts.length && shared[i] === parts[i]) i++;
+    shared = shared.slice(0, i);
+  }
+  const folder = shared.join("/");
+  const fence = [...files];
+  if (folder !== "" && folder !== ".") fence.push(`${folder}/**`);
+  return fence;
+}
 function implementationLanguage(record) {
   const owned = new Set(record.ownedPaths);
   const implementations = loadImplementationSpecs().filter((impl) => implementationSourceFiles(impl).some((file) => owned.has(file)));
@@ -39280,6 +39923,7 @@ function throughMount(brief, alias, relative20) {
     ...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
   };
@@ -40009,7 +40653,8 @@ Approved: ${approval.lockedAt} by ${by} \u2014 no spec has changed since.${child
 ${headline} \u2014 approved ${approval.lockedAt} by ${by}:
 ` + named2.map((p) => `  ${p}`).join("\n") + (rest > 0 ? `
   \u2026 and ${rest} more` : "") + childNote + "\n",
-      drifted: true
+      drifted: true,
+      moved: [...diff2.changed.map((p) => `~ ${p}`), ...diff2.added.map((p) => `+ ${p}`), ...diff2.removed.map((p) => `- ${p}`)]
     };
   } catch {
     return quiet;
@@ -40113,13 +40758,13 @@ This project uses **wairon**. System specs live under \`.wai/specs/\` (L0 System
 
 **Do NOT search files or read agent configs to learn about wairon or SDD. Use the context here and the \`sdd-architect\` skill to start.**
 
-**Your first move: call the \`sdd_get_status\` MCP tool** (or \`wairon/sdd_get_status\`) to see the spec tree. Do not parse files or run CLI commands manually.
+**Your first move: call the \`sdd_get_status\` MCP tool** (or \`wairon/sdd_get_status\`) to see the spec tree. Do not parse files or run CLI commands manually. If no \`sdd_*\` tools are available, this folder is not the root of the project this guide came from \u2014 say so instead of guessing.
 
 ### How you operate
 - **To design/modify specs**: Use **\`sdd-architect\`** skill (in \`.claude/skills/\` or \`.gemini/skills/\`).
 - **Manage specs via MCP tools only**: Use \`sdd_initialize_system\`, \`sdd_add_subsystem\`, \`sdd_add_component\`, \`sdd_define_interface\`, \`sdd_write_narrative\`, \`sdd_add_type\`, \`sdd_get_spec\`, \`sdd_delete_spec\`, \`sdd_validate_tree\`, and \`sdd_get_status\` (namespaced if needed). Do not edit specs manually.
 - **Growing a system \u2014 subsystems \u2192 parts \u2192 projects**: boundaries are earned. Start with subsystems in one folder. A piece that needs its own folder or repository but stays the same system is a **part**: declared in \`.wai/project.yaml\` \`members\` by one location key (\`scheduler: services/scheduler\`, \`admin: ../admin\`, \`payments: git@host:acme/payments.git#<commit>\`; long form \`{ source, as, description }\`), its subsystems this project's own \u2014 local ids, this project's lock. \`sdd_add_member\` creates a part by default (\`as: project\` for a project) and \`sdd_externalize_subsystem\` moves a subsystem into one. A **project** is an independent boundary \u2014 its own id, exports, lock \u2014 reached as \`alias::name\`; make one only when it needs its own team, release, approval or public surface: \`sdd_promote_member\` (\`sdd_demote_member\` back). What a member is follows from its content (an id, an L0 or a lock make a project).
-- **Members & cross-project references**: relocate a member with \`sdd_move_member\`. Every other change of the family's shape is a **family migration**, each with \`dryRun\`: promote/demote, make an existing project a member with \`sdd_attach_member\`, take one out and back with \`sdd_detach_member\` / \`sdd_adopt_member\`, rename a project's id with \`sdd_rename_project\` or an alias with \`sdd_rename_member_alias\`, move a subsystem into a part with \`sdd_externalize_subsystem\` and fold a member back in with \`sdd_internalize_member\`. Run it with \`dryRun: true\` first and show the plan; applied, it writes every project it touches or none, and never locks \u2014 it names the projects to re-lock. A project member is never a subsystem of its parent: it has its own \`.wai/\` tree and is designed from its own root.
+- **Members & cross-project references**: relocate a member with \`sdd_move_member\`. Every other change of the family's shape is a **family migration**, each with \`dryRun\`: promote/demote, make an existing project a member with \`sdd_attach_member\`, take one out and back with \`sdd_detach_member\` / \`sdd_adopt_member\`, rename a project's id with \`sdd_rename_project\` or an alias with \`sdd_rename_member_alias\`, move a subsystem into a part with \`sdd_externalize_subsystem\` and fold a member back in with \`sdd_internalize_member\`. Run it with \`dryRun: true\` first and show the plan (the human's CLI calls the same plan \`--report\`); applied, it writes every project it touches or none, and never locks \u2014 it names the projects to re-lock. A project member is never a subsystem of its parent: it has its own \`.wai/\` tree and is designed from its own root \u2014 its specs, its L0 export table and its \`project.yaml\` are written by a session opened in that member's folder (its own guide and \`.mcp.json\`), and the tools here refuse such a write naming that folder.
   - **\`alias::name\`**: An id without \`::\` is local to the project that writes it. Anything another project provides is referenced as \`alias::name\` \u2014 the alias is one of your members or declared \`externals\`, the name a public name in that project's L0 export table. A reference to something it does not export is reported (\`EXTERNAL_NOT_EXPORTED\`).
   - **Deprecated forms** (they still resolve for one release, are reported, and \`wairon doctor --fix\` rewrites them): a leading \`::\` (\`::shared::error-type\`), \`super::\` (\`super::sibling_comp\`), member paths (\`billing::invoice::invoice_portal\`), and an L1 subsystem carrying \`projectPath\` (\`DEPRECATED_MOUNT_FORM\`).
 - **Do not run the \`wairon\` CLI**: Use \`sdd_validate_tree\` and \`sdd_get_status\` instead of CLI commands.
@@ -40164,7 +40809,7 @@ ${GUIDE_MARKER_END}
   const stripped = stripGuideSection(existing);
   const newContent = stripped.trimEnd() + section;
   fs21.mkdirSync(path36.dirname(filePath), { recursive: true });
-  fs21.writeFileSync(filePath, newContent, "utf-8");
+  writeFile(filePath, newContent);
 }
 function stripGuideSection(content) {
   const start = content.indexOf(GUIDE_MARKER_START);
@@ -40187,7 +40832,7 @@ To design or modify the system, invoke the **\`sdd-architect\`** skill
 (in \`.claude/skills/\`). Author and validate specs with the \`sdd_*\` MCP tools;
 the \`wairon\` CLI is the human developer's tool, not yours.
 `;
-    fs21.writeFileSync(filePath, content, "utf-8");
+    writeFile(filePath, content);
   } else if (targetType === "gemini" || targetType === "agy") {
     const filePath = path36.join(projectRoot, "GEMINI.md");
     const content = `# Wairon SDD Project
@@ -40196,7 +40841,7 @@ ${versionStamp()}
 ${LOCAL_GUIDE_BODY}
 ${GUIDE_MARKER_END}
 `;
-    fs21.writeFileSync(filePath, content, "utf-8");
+    writeFile(filePath, content);
   } else if (targetType === "cursor") {
     const filePath = path36.join(projectRoot, ".cursorrules");
     const content = `# Wairon SDD Project
@@ -40205,7 +40850,7 @@ This project uses the Wairon Spec-Driven Development (SDD) framework.
 
 Refer to the rules in [.cursor/rules/](.cursor/rules/) for full instructions.
 `;
-    fs21.writeFileSync(filePath, content, "utf-8");
+    writeFile(filePath, content);
   } else if (targetType === "copilot") {
     const filePath = path36.join(projectRoot, ".github", "copilot-instructions.md");
     fs21.mkdirSync(path36.dirname(filePath), { recursive: true });
@@ -40215,14 +40860,14 @@ This project uses the Wairon Spec-Driven Development (SDD) framework.
 
 Refer to the prompts in [.github/prompts/](.github/prompts/) for instructions.
 `;
-    fs21.writeFileSync(filePath, content, "utf-8");
+    writeFile(filePath, content);
   } else if (targetType === "codex") {
     const filePath = path36.join(projectRoot, ".codexrules");
     const content = `# Wairon SDD Project
 
 Refer to [.codex/agents/](.codex/agents/) for full instructions.
 `;
-    fs21.writeFileSync(filePath, content, "utf-8");
+    writeFile(filePath, content);
   }
 }
 var GUIDE_TARGETS = ["claude", "gemini", "agy", "cursor", "copilot", "codex"];
@@ -40377,9 +41022,17 @@ function syncContextFiles() {
 var path37 = __toESM(require("path"));
 function approvalTag(entry) {
   if (!entry) return "";
-  const state = entry.upgraded ? `${entry.state}, re-lock once` : entry.state;
-  return entry.pinned ? ` [${state} \xB7 pin ${entry.pinned}]` : ` [${state}]`;
-}
+  const words2 = APPROVAL_WORDS[entry.state];
+  const state = entry.upgraded ? `${words2}, re-lock once` : words2;
+  return entry.pinned ? ` [${state} \xB7 ${PIN_WORDS[entry.pinned]}]` : ` [${state}]`;
+}
+var APPROVAL_WORDS = { approved: "approved", drifted: "drifted", never: "never approved" };
+var PIN_WORDS = { matches: "pinned", moved: "pin moved", unpinned: "not pinned" };
+var OWN_APPROVAL_WORDS = {
+  approved: "approved",
+  drifted: "drifted \u2014 its approval no longer covers this tree (`wairon lock` re-approves)",
+  never: "never approved (`wairon lock` approves the design)"
+};
 var asWritten = (text3) => text3;
 function fillDecor(decor) {
   return {
@@ -40465,11 +41118,15 @@ function getStatusReport(options = {}, decor) {
     }
     componentScores.set(comp.id, score);
   }
+  const typeOwners = new Set(loadTypeSpecs().map((t) => t.subsystem).filter((id) => typeof id === "string"));
   const getSubsystemScore = (subId) => {
     const sub = subsystems.find((s) => s.id === subId);
     if (!sub) return 0;
     const subComps = components.filter((c) => c.subsystem === subId);
-    if (subComps.length === 0) return 0;
+    if (subComps.length === 0) {
+      if (!typeOwners.has(subId)) return 0;
+      return sub.status === "complete" ? 100 : 50;
+    }
     const totalScore = subComps.reduce((acc, c) => acc + (componentScores.get(c.id) ?? 0), 0);
     let avg = Math.round(totalScore / subComps.length);
     if (sub.status === "draft" || sub.status === "design") {
@@ -40592,8 +41249,7 @@ function getStatusReport(options = {}, decor) {
 `;
   }
   const own = options.approvals?.find((a) => a.key === "");
-  const hasMembers = (options.approvals ?? []).some((a) => a.key !== "" && a.as !== "part");
-  if (own && (own.state !== "never" || hasMembers)) output += `${mark.layer("system", "Approval:")} this project is ${own.state}${own.upgraded ? " (locked under an earlier gate identity \u2014 re-lock once)" : ""}
+  if (own) output += `${mark.layer("system", "Approval:")} this project is ${OWN_APPROVAL_WORDS[own.state]}${own.upgraded ? " (locked under an earlier gate identity \u2014 re-lock once)" : ""}
 `;
   return { text: output, failed: false };
 }
@@ -43354,9 +44010,33 @@ function planAliasRename(family, bound2, request) {
   if ([...family.owners].some(([key, owner]) => owner === bound2 && key.split("::").pop() === next)) {
     plan6.notes.push(`${label5(bound2)} has a spec whose id is "${next}" \u2014 a local id equal to an alias (LOCAL_ID_SHADOWS_PROJECT reports it)`);
   }
+  repinIntactConsumers(plan6, family, bound2);
   return plan6;
 }
-var PHASES = ["rewriteReferences", "renameAlias", "repointExternal", "renameId", "renamePin"];
+function repinIntactConsumers(plan6, family, bound2) {
+  const boundNode2 = familyNode(family, bound2);
+  for (const node of family.nodes) {
+    if (path44.resolve(node.directory) === path44.resolve(boundNode2.directory)) continue;
+    let statuses = [];
+    try {
+      statuses = runWithProjectRoot(node.directory, () => getExternalsStatus2());
+    } catch {
+      continue;
+    }
+    for (const status of statuses) {
+      const producer = node.aliases.get(status.alias);
+      const pinsBound = producer !== void 0 ? producer === bound2 : boundNode2.id !== void 0 && status.project === boundNode2.id;
+      if (!status.pinned || status.outOfReach || !pinsBound) continue;
+      const broken = status.uses.filter((u) => u.state === "changed" || u.state === "removed");
+      if (broken.length > 0) {
+        plan6.notes.push(`${label5(node.namespace)}'s pin of "${status.alias}" is already incompatible (${broken.map((u) => u.publicName ?? u.member ?? "?").join(", ")}): not re-pinned \u2014 adapt its uses, then run \`wairon externals pin ${status.alias}\` there.`);
+        continue;
+      }
+      edit2(plan6, node.namespace, "pin", `pin ${status.alias} taken again: the names it uses of ${label5(bound2)} are unchanged`, { root: node.directory, call: "pinExternals", args: [[status.alias]] });
+    }
+  }
+}
+var PHASES = ["rewriteReferences", "renameAlias", "repointExternal", "renameId", "renamePin", "pinExternals"];
 function write4(plan6, rehearsal) {
   const planned = plan6.edits.filter((e) => e.write !== void 0);
   const unknown = planned.find((x) => !PHASES.includes(x.write.call));
@@ -43371,6 +44051,7 @@ function write4(plan6, rehearsal) {
     for (const e of planned.filter((x) => x.write.call === "renameId")) writeOne2(rehearsal, e.write);
   }
   for (const e of planned.filter((x) => x.write.call === "renamePin")) writeOne2(rehearsal, e.write);
+  for (const e of planned.filter((x) => x.write.call === "pinExternals")) writeOne2(rehearsal, e.write);
 }
 function referencesBySpec(planned) {
   const out = /* @__PURE__ */ new Map();
@@ -43394,6 +44075,8 @@ function writeOne2(rehearsal, w) {
         return renameProjectId(args[0], args[1]);
       case "renamePin":
         return renamePin2(args[0], args[1], args[2]);
+      case "pinExternals":
+        return pinExternals2(args[0]);
       default:
         throw new Error(`identity_migration makes no "${w.call}" write`);
     }
@@ -43665,6 +44348,7 @@ function planExternalize(family, bound2, request) {
   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, 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.");
   return plan6;
 }
@@ -43793,6 +44477,7 @@ function planPromote(family, bound2, request) {
   );
   edit3(plan6, newId, "pin", `pin the new project's external for ${node.id ?? "this project"} (when its specs reference it)`, { root: part.directory, call: "pinExternals", args: [[]] });
   if (part.storage !== "contained") edit3(plan6, bound2, "pin", `pin ${alias} (a project stored outside ${label6(bound2)} is judged against its pin)`, { root: node.directory, call: "pinExternals", args: [[alias]] });
+  repinIntactConsumers2(plan6, family, bound2, [part.directory]);
   plan6.notes.push(`"${newId}" has no lock yet: lock it at its own root (\`wairon lock\`) once it validates.`);
   return plan6;
 }
@@ -43859,16 +44544,19 @@ function write5(plan6, rehearsal) {
     return;
   }
   if (plan6.request.verb === "externalize") {
-    for (const e of planned.filter((x) => x.write.call === "externalizeSubsystem")) writeOne3(rehearsal, e.write);
+    for (const e of planned.filter((x) => x.write.call === "externalizeSubsystem")) recordCrossing(plan6, e.project, e.write.args[0], writeOne3(rehearsal, e.write));
     for (const e of planned.filter((x) => x.write.call === "pinExternals")) writeOne3(rehearsal, e.write);
     return;
   }
   if (plan6.request.verb === "promote") {
-    for (const e of planned.filter((x) => x.write.call === "promoteMember")) writeOne3(rehearsal, e.write);
+    for (const e of planned.filter((x) => x.write.call === "promoteMember")) recordCrossing(plan6, e.project, e.write.args[1] ?? e.write.args[0], writeOne3(rehearsal, e.write));
     for (const e of planned.filter((x) => x.write.call === "pinExternals")) writeOne3(rehearsal, e.write);
     return;
   }
-  for (const e of planned.filter((x) => x.write.call === "demoteMember")) writeOne3(rehearsal, e.write);
+  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 e of planned.filter((x) => x.write.call === "unpin")) writeOne3(rehearsal, e.write);
 }
 function referencesBySpec2(planned) {
@@ -43881,9 +44569,46 @@ ${id}`) ?? [], ...edits]);
   }
   return out;
 }
+function repinIntactConsumers2(plan6, family, bound2, created) {
+  const boundNode2 = familyNode(family, bound2);
+  const skip = new Set([boundNode2.directory, ...created].map((d) => path45.resolve(d)));
+  for (const node of family.nodes) {
+    if (skip.has(path45.resolve(node.directory))) continue;
+    let statuses = [];
+    try {
+      statuses = runWithProjectRoot(node.directory, () => getExternalsStatus2());
+    } catch {
+      continue;
+    }
+    for (const status of statuses) {
+      const producer = node.aliases.get(status.alias);
+      const pinsBound = producer !== void 0 ? producer === bound2 : boundNode2.id !== void 0 && status.project === boundNode2.id;
+      if (!status.pinned || status.outOfReach || !pinsBound) continue;
+      const broken = status.uses.filter((u) => u.state === "changed" || u.state === "removed");
+      if (broken.length > 0) {
+        plan6.notes.push(`${label6(node.namespace)}'s pin of "${status.alias}" is already incompatible (${broken.map((u) => u.publicName ?? u.member ?? "?").join(", ")}): not re-pinned \u2014 adapt its uses, then run \`wairon externals pin ${status.alias}\` there.`);
+        continue;
+      }
+      edit3(plan6, node.namespace, "pin", `pin ${status.alias} taken again: the names it uses of ${label6(bound2)} only move with the boundary`, { root: node.directory, call: "pinExternals", args: [[status.alias]] });
+    }
+  }
+}
+function recordCrossing(plan6, bound2, member, result) {
+  const crossed = result;
+  if (!crossed) return;
+  for (const r of crossed.respelled) {
+    plan6.edits.push({ project: bound2, kind: "reference", detail: `${r.specId} (${r.position}): ${r.from} \u2192 ${r.to}`, reference: r });
+  }
+  for (const r of crossed.memberRespelled) {
+    plan6.edits.push({ project: member, kind: "reference", detail: `${r.specId} (${r.position}): ${r.from} \u2192 ${r.to}`, reference: r });
+  }
+  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}` });
+}
 function writeOne3(rehearsal, w) {
   const args = w.args;
-  runWithProjectRoot(rehearsalRoot(rehearsal, w.root), () => {
+  return runWithProjectRoot(rehearsalRoot(rehearsal, w.root), () => {
     switch (w.call) {
       case "internalizeMember":
         return internalizeMember(args[0], args[1]);
@@ -43918,7 +44643,7 @@ var path46 = __toESM(require("path"));
 var fs26 = __toESM(require("fs"));
 var os7 = __toESM(require("os"));
 var nodePath2 = __toESM(require("path"));
-var yaml3 = __toESM(require("js-yaml"));
+var yaml4 = __toESM(require("js-yaml"));
 var TRANSACTIONS2 = nodePath2.join(".wai", "transactions");
 var transactionsDir = (owner) => nodePath2.join(owner, TRANSACTIONS2);
 var transactionDir = (owner, id) => nodePath2.join(transactionsDir(owner), id);
@@ -43985,7 +44710,7 @@ function dropRehearsal(id) {
 function saveJournal(journal) {
   const ignore = nodePath2.join(transactionsDir(journal.owner), ".gitignore");
   if (!fs26.existsSync(ignore)) writeDurably(ignore, "*\n");
-  writeDurably(nodePath2.join(transactionDir(journal.owner, journal.id), "journal.yaml"), yaml3.dump(journal, { noRefs: true, lineWidth: 200 }));
+  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");
@@ -43997,7 +44722,7 @@ function readJournal(owner, id) {
     throw e;
   }
   try {
-    return yaml3.load(text3);
+    return yaml4.load(text3);
   } catch (e) {
     throw new Error(`${file} is not a readable transaction journal: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -44816,10 +45541,19 @@ ${body}`);
 }
 function migrationView(report3, dryRun) {
   const plan6 = report3.plan;
+  const request = plan6.request;
+  const madeProject = request.verb === "promote" || request.verb === "externalize" && request.as === "project";
+  const madeAt = madeProject && report3.applied ? plan6.changes.find((c) => c.action === "create" && c.path.replace(/\\/g, "/") === ".wai/project.yaml")?.project : void 0;
   return {
     dryRun,
     applied: report3.applied,
     relock: report3.applied ? report3.relock : plan6.relock,
+    ...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.outcome ? { outcome: { committed: report3.outcome.committed, restored: report3.outcome.restored, unrestored: report3.outcome.unrestored, ...report3.outcome.failure ? { failure: report3.outcome.failure } : {} } } : {},
     plan: {
       verb: plan6.request.verb,
@@ -46612,9 +47346,9 @@ ${testsBlock}` : ""}`, deletion);
     server,
     "sdd_get_agent_brief",
     {
-      description: "Compose the LIVE delegation brief for one resolved agent: the fully rendered instruction body plus the ownedPaths/readPaths scope fence \u2014 the dynamic replacement for generated per-component agent files. Fetch a brief and spawn a generic subagent with it: always fresh after a re-lock, no session restart needed. List agent ids via listAgents or resources/list (the wairon-agent:// entries).",
+      description: "Compose the LIVE delegation brief for one resolved agent: the fully rendered instruction body plus the ownedPaths/readPaths scope fence and the codeFence (where the agent may write CODE: its source files and their shared folder; empty when no file is named yet \u2014 then name the planned files when spawning) \u2014 the dynamic replacement for generated per-component agent files. A COMPONENT id (or `<component>-implementer`) composes that one component's implementer brief, with no agent files and no setting needed. Fetch a brief and spawn a generic subagent with it: always fresh after a re-lock, no session restart needed. List agent ids via listAgents or resources/list (the wairon-agent:// entries).",
       inputSchema: {
-        agentId: import_zod12.z.string().describe("The resolved agent id (list via listAgents or resources/list)")
+        agentId: import_zod12.z.string().describe("The resolved agent id (list via listAgents or resources/list), or a component id for that component's implementer brief")
       }
     },
     ({ agentId }) => {
@@ -46828,6 +47562,7 @@ function loadProjectConfig3() {
   aiDir,
   aiDirAt,
   aiPathsAt,
+  aliasTargetOf,
   ambiguityMessage,
   approvalKeyIn,
   approvalRecord,
@@ -47013,6 +47748,7 @@ function loadProjectConfig3() {
   memberDeclarationOf,
   memberDigest,
   memberLocationOf,
+  memberTypesOf,
   methodGenericParameters,
   methodSourceFile,
   methodTypeRefs,
@@ -47085,6 +47821,7 @@ function loadProjectConfig3() {
   resolveExternals,
   resolveImport,
   resolveInstalledPack,
+  resolveProjectBinding,
   resolveProjectExports,
   resolveSignatures,
   resolveSubprojectForNamespace,