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

package/dist/cli/index.js

@@ -65,7 +65,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.102";
+    WAIRON_VERSION = "5.1.1-dev.103";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     SUPPORTED_ALIASES = ["wai"];
     SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
@@ -219,6 +219,7 @@ __export(fs_exports, {
   listFilesRecursive: () => listFilesRecursive,
   pathExists: () => pathExists,
   readFileOrNull: () => readFileOrNull,
+  resolveProjectBinding: () => resolveProjectBinding,
   runWithHostedLookup: () => runWithHostedLookup,
   runWithProjectBinding: () => runWithProjectBinding,
   runWithProjectRoot: () => runWithProjectRoot,
@@ -441,22 +442,74 @@ function setProjectRoot(dir) {
 function getProjectRootOverride() {
   return projectRootOverride;
 }
-function findSystemRoot(startDir) {
+function holdsSystemSpec(dir) {
+  for (const base of [".wai", ".wairon"]) {
+    const specs = path2.join(dir, base, "specs");
+    if (fs.existsSync(path2.join(specs, ".index.yaml")) || fs.existsSync(path2.join(specs, "system.yaml"))) return true;
+    if (base === ".wai" && fs.existsSync(path2.join(dir, ".wai"))) break;
+  }
+  return false;
+}
+function findRepositoryRoot(startDir) {
   let dir = path2.resolve(startDir);
   while (true) {
-    const isWai = fs.existsSync(path2.join(dir, ".wai"));
-    const isWairon = !isWai && fs.existsSync(path2.join(dir, ".wairon"));
-    const base = isWai ? ".wai" : isWairon ? ".wairon" : null;
-    if (base) {
-      if (fs.existsSync(path2.join(dir, base, "specs", ".index.yaml")) || fs.existsSync(path2.join(dir, base, "specs", "system.yaml"))) {
-        return dir;
-      }
+    if (fs.existsSync(path2.join(dir, ".git"))) return dir;
+    const parent = path2.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function isAtOrBelow(outer, inner2) {
+  const rel2 = path2.relative(outer, inner2);
+  return rel2 === "" || !rel2.startsWith("..") && !path2.isAbsolute(rel2);
+}
+function declaredMemberDirs(projectRoot2) {
+  let parsed;
+  try {
+    const text3 = fs.readFileSync(path2.join(projectRoot2, ".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) || path2.isAbsolute(text3)) continue;
+    dirs.push(path2.resolve(projectRoot2, text3));
+  }
+  return dirs;
+}
+function resolveProjectBinding(startDir) {
+  const start2 = path2.resolve(startDir);
+  const repositoryRoot2 = findRepositoryRoot(start2) ?? void 0;
+  const withRepo = (b) => repositoryRoot2 ? { ...b, repositoryRoot: repositoryRoot2 } : b;
+  let dir = start2;
+  while (true) {
+    if (holdsSystemSpec(dir)) return withRepo({ root: dir, via: dir === start2 ? "here" : "ancestor" });
+    if (repositoryRoot2 && dir === repositoryRoot2) break;
+    const parent = path2.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  dir = path2.dirname(repositoryRoot2);
+  while (true) {
+    if (holdsSystemSpec(dir)) {
+      const declares2 = declaredMemberDirs(dir).some((member) => isAtOrBelow(repositoryRoot2, member) && isAtOrBelow(member, start2));
+      if (declares2) return withRepo({ root: dir, via: "declared-member" });
     }
     const parent = path2.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;
@@ -487,13 +540,14 @@ function aiDirAt(root, ...segments) {
   const base = !fs.existsSync(waiPath) && fs.existsSync(waironPath) ? waironPath : waiPath;
   return path2.join(base, ...segments);
 }
-var fs, path2, import_node_async_hooks, EOL_SAMPLE_BYTES, projectRootOverride, sameRoot, requestRootStore;
+var fs, path2, import_node_async_hooks, yaml, EOL_SAMPLE_BYTES, projectRootOverride, sameRoot, requestRootStore;
 var init_fs = __esm({
   "src/utils/fs.ts"() {
     "use strict";
     fs = __toESM(require("fs"));
     path2 = __toESM(require("path"));
     import_node_async_hooks = require("async_hooks");
+    yaml = __toESM(require("js-yaml"));
     EOL_SAMPLE_BYTES = 64 * 1024;
     projectRootOverride = null;
     sameRoot = (a, b) => path2.resolve(a) === path2.resolve(b);
@@ -638,14 +692,14 @@ var init_git_source = __esm({
 // src/utils/yaml.ts
 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,
@@ -660,11 +714,11 @@ function readYamlFile(filePath) {
 function writeYamlFile(filePath, value) {
   writeFile(filePath, serializeYaml(value));
 }
-var yaml;
+var yaml2;
 var init_yaml = __esm({
   "src/utils/yaml.ts"() {
     "use strict";
-    yaml = __toESM(require("js-yaml"));
+    yaml2 = __toESM(require("js-yaml"));
     init_fs();
   }
 });
@@ -897,6 +951,14 @@ var init_agent = __esm({
        * 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
@@ -5442,7 +5504,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(")");
@@ -5473,7 +5535,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));
       }
     }
@@ -5671,10 +5733,10 @@ function stepGraph(method2) {
     const s = byNum.get(n);
     if (s.type !== "parallel" || s.endStep === void 0 || !s.branches?.length) continue;
     const entries = s.branches.map((b) => b.step).sort((a, b) => a - b);
-    const join64 = fallNext(s.endStep);
+    const join66 = fallNext(s.endStep);
     for (let i = 0; i < entries.length; i++) {
       const armEnd = i + 1 < entries.length ? prevOf(entries[i + 1]) : s.endStep;
-      if (armEnd !== void 0 && armEnd >= entries[i]) armEndJoin.set(armEnd, join64);
+      if (armEnd !== void 0 && armEnd >= entries[i]) armEndJoin.set(armEnd, join66);
     }
   }
   const successorsOf = (n) => {
@@ -5937,6 +5999,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;
 }
@@ -12268,7 +12336,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;
@@ -12378,7 +12446,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)})`);
   }
@@ -12494,11 +12562,11 @@ function fromOpenApi(document, projectName) {
     types
   });
 }
-var yaml2, PRIMITIVE_SCHEMAS, SIGNATURE_EXTENSION, SCALAR_SCHEMA_TYPES;
+var yaml3, PRIMITIVE_SCHEMAS, SIGNATURE_EXTENSION, SCALAR_SCHEMA_TYPES;
 var init_openapi = __esm({
   "src/core/openapi.ts"() {
     "use strict";
-    yaml2 = __toESM(require("js-yaml"));
+    yaml3 = __toESM(require("js-yaml"));
     init_models();
     PRIMITIVE_SCHEMAS = {
       string: { type: "string" },
@@ -13169,7 +13237,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) {
@@ -15249,17 +15319,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 = scopeOf3(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)) {
@@ -15281,6 +15381,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 = (path93) => namesAt(declarations, pathKey(path93), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames]));
   const forwardsOf = (start2, name, container) => {
@@ -15841,10 +15969,11 @@ var init_field_type_references = __esm({
             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
                 );
@@ -15886,10 +16015,11 @@ var init_signature_type_references = __esm({
             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
                 );
@@ -15908,10 +16038,11 @@ var init_signature_type_references = __esm({
           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
             );
@@ -21208,16 +21339,36 @@ function closedCallSites(code, file, fn, stopAt, container) {
 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 method2 = impl.methods.find((m) => m.name === methodName);
       if (!method2 && !intf.methods.some((m) => m.name === methodName)) continue;
       if (method2?.symbol) accepted.add(method2.symbol);
       const file = methodSourceFile(method2 ?? {}, impl.sourcePath);
-      if (file) files.add(pathKey(file));
+      if (!file) continue;
+      files.add(pathKey(file));
+      bodies.add(bodyKey(pathKey(file), method2?.symbol ?? methodName, method2?.exportedVia));
+      anchors.push({ file: pathKey(file), symbol: method2?.symbol ?? methodName, exportedVia: method2?.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));
@@ -21256,6 +21407,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)`;
 }
@@ -21266,21 +21418,22 @@ function describeMiss(m) {
   if (m.miss.kind === "unresolved") return `${head2}, written as ${m.miss.shapes.map((s) => `\`${s}\``).join(" / ")})`;
   return `${head2})`;
 }
-var anchorKey, unitOf, claimNoun, callConformanceRule;
+var anchorKey, bodyKey, unitOf, claimNoun, callConformanceRule;
 var init_call_conformance = __esm({
   "src/core/rules/conformance/call-conformance.ts"() {
     "use strict";
     init_models();
     anchorKey = (symbol, exportedVia) => exportedVia !== void 0 ? `${exportedVia}.${symbol}` : symbol;
+    bodyKey = (file, symbol, exportedVia) => `${file}|${anchorKey(symbol, exportedVia)}`;
     unitOf = (m) => m.step === void 0 ? m.target : `${m.step}:${m.target}`;
     claimNoun = (implMethod) => implMethod.narrative.length ? "narrative call step(s)" : "declared call(s)";
     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) {
@@ -21308,9 +21461,9 @@ var init_call_conformance = __esm({
           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);
@@ -21319,7 +21472,9 @@ var init_call_conformance = __esm({
           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}`;
@@ -21363,7 +21518,10 @@ var init_call_conformance = __esm({
             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,
@@ -21380,8 +21538,8 @@ var init_call_conformance = __esm({
           }
           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;
           };
@@ -21484,7 +21642,7 @@ var init_dependency_conformance = __esm({
     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" }
@@ -21552,6 +21710,23 @@ var init_dependency_conformance = __esm({
             );
           }
         }
+        const typeTraces = /* @__PURE__ */ new Map();
+        const typeTracesOf = (path93) => {
+          let out = typeTraces.get(path93);
+          if (out) return out;
+          out = /* @__PURE__ */ new Set();
+          const facts = code.factsAt(path93);
+          for (const specifier of new Set(Object.values(facts?.typeOnlyBindings ?? {}))) {
+            const to = resolveImport(path93, specifier, mappedPaths, code.packages);
+            if (to && to !== path93) out.add(to);
+          }
+          typeTraces.set(path93, 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;
@@ -21565,6 +21740,7 @@ var init_dependency_conformance = __esm({
             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);
@@ -21573,7 +21749,7 @@ var init_dependency_conformance = __esm({
             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,
@@ -21655,14 +21831,17 @@ var integrationSimDeclarationRule;
 var init_integration_sim_declaration = __esm({
   "src/core/rules/conformance/integration-sim-declaration.ts"() {
     "use strict";
+    init_models();
     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;
@@ -21681,6 +21860,7 @@ var init_integration_sim_declaration = __esm({
           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",
@@ -22578,7 +22758,7 @@ var init_export_conformance = __esm({
     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",
@@ -22600,6 +22780,7 @@ var init_export_conformance = __esm({
       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;
@@ -22726,13 +22907,20 @@ var init_export_conformance = __esm({
           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);
           }
@@ -24528,6 +24716,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();
@@ -24537,7 +24727,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);
@@ -24552,7 +24742,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);
@@ -24749,7 +24966,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);
@@ -24884,9 +25112,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)) {
@@ -24900,6 +25133,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);
@@ -25060,7 +25297,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 };
 }
 function resolveModule(fromFile, specifier, packages) {
   if (!specifier.startsWith(".")) return packages.get(specifier) ?? null;
@@ -25428,6 +25665,8 @@ function buildCodeModel(implementations, types, projectRoot2, sourceRoots = [],
             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()]])),
@@ -25910,8 +26149,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");
@@ -26285,6 +26532,7 @@ function buildRuleContext(opts) {
     isImplementationDraft,
     getComponentProfile,
     isTypeResolved,
+    aliasSpelling,
     targetLanguageFor,
     isSpecInScope,
     isInChainedSubproject,
@@ -28977,6 +29225,24 @@ function mapSignatureSource(value, map) {
   const head2 = map("signatureFrom", parts.head);
   return head2 === parts.head ? value : `${head2}.${parts.tail}`;
 }
+function typeExpressionSlots(kind, doc) {
+  const out = [];
+  const paths = kind === "interface" || kind === "type" ? TYPE_EXPRESSION_PATHS[kind] : [];
+  const walk2 = (node, segments, at, method2) => {
+    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, ...method2 ? { method: method2 } : {} });
+      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 : method2);
+  };
+  for (const at of paths) walk2(doc, at.split("."), at, void 0);
+  return out;
+}
 function mapSpecReferences(kind, spec, map) {
   switch (kind) {
     case "subsystem": {
@@ -29067,11 +29333,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) {
@@ -29083,19 +29346,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;
+}
 function bareRawReferences(kind, spec) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -29121,7 +29401,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":
@@ -29134,6 +29418,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(
@@ -29157,12 +29444,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 list2(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");
     }
   };
@@ -29184,14 +29468,7 @@ function respellStoredReferences(kind, doc, map) {
       break;
     case "interface":
       at(doc, "component", "contract");
-      for (const m of list2(doc.methods)) {
-        typed(m, "signature");
-        typed(m, "returns");
-        for (const p of list2(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");
@@ -29218,34 +29495,33 @@ function respellStoredReferences(kind, doc, map) {
     case "type":
       at(doc, "subsystem", "subsystem");
       at(doc, "group", "group");
-      for (const f of list2(doc.fields)) typed(f, "type");
-      for (const p of list2(doc.params)) typed(p, "type");
-      typed(doc, "returns");
-      for (const m of list2(doc.methods)) for (const p of list2(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;
@@ -29270,17 +29546,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;
   }
@@ -29362,7 +29627,7 @@ function resolveFamilyTables(raws) {
   const byKey3 = new Map(raws.map((r) => [r.record.namespace, r]));
   const done = /* @__PURE__ */ new Set();
   const resolving = /* @__PURE__ */ new Set();
-  const resolve56 = (raw) => {
+  const resolve57 = (raw) => {
     const key = raw.record.namespace;
     if (done.has(key)) return raw.record.exports;
     if (resolving.has(key)) return null;
@@ -29377,7 +29642,7 @@ function resolveFamilyTables(raws) {
         const producerKey = source !== void 0 ? raw.record.aliases.get(source) : void 0;
         if (producerKey === void 0 || producerTables.has(producerKey)) continue;
         const producer = byKey3.get(producerKey);
-        producerTables.set(producerKey, producer ? resolve56(producer) : null);
+        producerTables.set(producerKey, producer ? resolve57(producer) : null);
         audienceOf.set(producerKey, "project");
       }
       raw.record.subsystemExports = subsystemTables;
@@ -29393,7 +29658,7 @@ function resolveFamilyTables(raws) {
       resolving.delete(key);
     }
   };
-  raws.forEach((raw) => resolve56(raw));
+  raws.forEach((raw) => resolve57(raw));
 }
 function bindAuthored(raw, raws, readables, authored) {
   const key = raw.record.namespace;
@@ -30479,6 +30744,12 @@ function readLockState(current2) {
   if (!record2) return { state: "unlocked", record: null, current: current2 };
   return { state: stateIdEquals(record2.stateId, current2) ? "locked" : "stale", record: record2, current: current2 };
 }
+function writeLockRecord2(record2) {
+  writeLockRecord(record2);
+}
+function renderDiagram2(format, relations) {
+  return renderDiagram(format, relations);
+}
 function createProjectConfig(config) {
   projectConfigRepository.create(config);
 }
@@ -30583,7 +30854,7 @@ function assertSpecsInReach(targets, what, projectRung = false) {
 function moveMethods(from, to, methods, hooks, dryRun) {
   return current().moveMethods(from, to, methods, hooks, dryRun);
 }
-var fs14, path21, crypto5, PartReadOnly, SubsystemWriteDenied, PART_FORBIDDEN_FIELDS, IMPORTABLE_POSITIONS, SIGNATURE_TTL_MS, COMPONENT_AUTH_SOURCE, STEP_JUMP_FIELDS, STEP_JUMP_LISTS, DELTA_VERBS, JUMP_LABEL_TWINS, LABEL_TWIN_CONTAINERS, SpecWorkspace, DEFAULT_DEPENDENCY_LIMIT, PROSE_FIELDS, DELTA_JUMP_PINS, workspaces, lastServedBinding;
+var fs14, path21, crypto5, PartReadOnly, SubsystemWriteDenied, PART_FORBIDDEN_FIELDS, TYPE_EXPRESSION_PATHS, IMPORTABLE_POSITIONS, SIGNATURE_TTL_MS, COMPONENT_AUTH_SOURCE, STEP_JUMP_FIELDS, STEP_JUMP_LISTS, DELTA_VERBS, JUMP_LABEL_TWINS, LABEL_TWIN_CONTAINERS, SpecWorkspace, DEFAULT_DEPENDENCY_LIMIT, PROSE_FIELDS, DELTA_JUMP_PINS, workspaces, lastServedBinding;
 var init_specs2 = __esm({
   "src/core/specs.ts"() {
     "use strict";
@@ -30625,6 +30896,10 @@ var init_specs2 = __esm({
       }
     };
     PART_FORBIDDEN_FIELDS = ["members", "externals", "rules", "extensions", "composition", "targets"];
+    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"]
+    };
     IMPORTABLE_POSITIONS = /* @__PURE__ */ new Set(["dependsOn", "dispatch", "mounts", "narrative"]);
     SIGNATURE_TTL_MS = 2e3;
     COMPONENT_AUTH_SOURCE = "component:";
@@ -34597,7 +34872,7 @@ function isWithinDir2(dir, file) {
   return f === d || f.startsWith(d + path25.sep);
 }
 function externalizeSubsystem(subsystemId, path93, as) {
-  externalizeInto(subsystemId, path93, as);
+  return externalizeInto(subsystemId, path93, as);
 }
 function externalizeInto(subsystemId, partPath, as) {
   if (subsystemId.includes("::")) {
@@ -34616,7 +34891,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.`);
@@ -34629,19 +34905,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, stop2) {
+  let at = path25.resolve(dir);
+  const end = path25.resolve(stop2);
+  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") : [];
@@ -34667,7 +34998,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 = [];
@@ -34676,13 +35008,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;
 }
@@ -34690,6 +35022,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);
@@ -34707,13 +35042,14 @@ function crossingsOf(inside, outside) {
     }
     return found;
   };
-  return { out: collect2(inside, outsideIds, outsideTypes, true), in: collect2(outside, insideIds, insideTypes, false), insideIds, outsideIds };
+  return { out: collect2(inside, outsideTargets, outsideTypes, true), in: collect2(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 ?? []) {
@@ -34754,13 +35090,19 @@ function climbsOf(family, ids, parentId) {
   }
   return { map, refused: [...new Set(refused2)] };
 }
-function rewriteRefsIn(specs, remap) {
+function rewriteRefsIn(specs, remap, record2) {
   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 (record2) for (const e of edits) recordRespelling(record2.result, e, record2.member);
   }
   return rewritten;
 }
@@ -34810,15 +35152,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;
@@ -34837,6 +35183,165 @@ function promoteMember(alias, id) {
     });
   }
   invalidateSpecCache();
+  return result;
+}
+function recordRespelling(result, edit4, member) {
+  if (edit4.from === edit4.to) return;
+  const list2 = member ? result.memberRespelled : result.respelled;
+  if (list2.some((e) => e.kind === edit4.kind && e.specId === edit4.specId && e.position === edit4.position && e.from === edit4.from)) return;
+  list2.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 record2 = (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));
+        record2(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;
+              record2(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}`;
@@ -34844,43 +35349,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, project2) {
   return project2 && key.startsWith(`${project2}::`) ? key.slice(project2.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);
@@ -34910,7 +35429,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);
@@ -34940,7 +35459,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();
@@ -35288,7 +35807,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();
@@ -35305,6 +35824,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")) {
@@ -35329,6 +35852,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, record2] 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 (record2) 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 = [];
@@ -35358,9 +35954,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));
@@ -35529,7 +36125,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) {
@@ -35680,7 +36276,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)) {
@@ -35838,18 +36434,29 @@ function respellLike(written, oldId, newId) {
   if (written.includes("-")) return kebab(newId);
   return /^[A-Z]/.test(written) ? pascal(newId) : newId;
 }
+function memberRootWay(qualifiedId2, call) {
+  const alias = qualifiedId2.slice(0, qualifiedId2.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) {
@@ -36177,8 +36784,8 @@ function walkForPackages(projectRoot2, currentDir, depth, results) {
   }
 }
 function pathToId(relPath) {
-  const basename16 = path26.basename(relPath);
-  return basename16.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const basename19 = path26.basename(relPath);
+  return basename19.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
 function pathToName(relPath) {
   const id = pathToId(relPath);
@@ -36708,7 +37315,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 [];
@@ -36839,7 +37446,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);
@@ -36912,7 +37519,7 @@ function composeAgentBrief(agentId) {
     return throughMount(brief, hop.alias, hop.relative);
   }
   const records = resolveAgentTopology();
-  const record2 = records.find((r) => r.id === agentId);
+  const record2 = records.find((r) => r.id === agentId) ?? componentImplementer(agentId);
   if (!record2) {
     throw new UnknownAgentError(agentId, records.map((r) => r.id));
   }
@@ -36931,6 +37538,17 @@ function composeAgentBrief(agentId) {
     domainName: "",
     variantGuidance: record2.variantGuidance ?? ""
   });
+  const codeFence = codeFenceOf(record2);
+  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()}
@@ -36965,10 +37583,34 @@ ${typeMapping.map((line2) => `- ${line2}`).join("\n")}
     instructions,
     variantGuidance: record2.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(record2) {
+  const implementsComponents = record2.template === "implementer" || record2.template === "domain-owner" && record2.creationReason.startsWith("Automatically inferred from L1");
+  if (!implementsComponents) return null;
+  const files = record2.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(record2) {
   const owned = new Set(record2.ownedPaths);
   const implementations = loadImplementationSpecs().filter((impl) => implementationSourceFiles(impl).some((file) => owned.has(file)));
@@ -37001,6 +37643,7 @@ function throughMount(brief, alias, relative28) {
     ...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) : relative28
   };
@@ -37037,7 +37680,7 @@ var init_agent_resolver = __esm({
     projectFilesCache = /* @__PURE__ */ new Map();
     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";
       }
     };
@@ -41217,7 +41860,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: [...diff3.changed.map((p) => `~ ${p}`), ...diff3.added.map((p) => `+ ${p}`), ...diff3.removed.map((p) => `- ${p}`)]
     };
   } catch {
     return quiet;
@@ -41345,7 +41989,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 start2 = content.indexOf(GUIDE_MARKER_START);
@@ -41368,7 +42012,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(projectRoot2, "GEMINI.md");
     const content = `# Wairon SDD Project
@@ -41377,7 +42021,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(projectRoot2, ".cursorrules");
     const content = `# Wairon SDD Project
@@ -41386,7 +42030,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(projectRoot2, ".github", "copilot-instructions.md");
     fs21.mkdirSync(path36.dirname(filePath), { recursive: true });
@@ -41396,14 +42040,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(projectRoot2, ".codexrules");
     const content = `# Wairon SDD Project
 
 Refer to [.codex/agents/](.codex/agents/) for full instructions.
 `;
-    fs21.writeFileSync(filePath, content, "utf-8");
+    writeFile(filePath, content);
   }
 }
 function reinjectLocalGuides(projectRoot2, targetTypes) {
@@ -41427,6 +42071,7 @@ var init_ai_guide = __esm({
     os6 = __toESM(require("os"));
     path36 = __toESM(require("path"));
     init_stamp();
+    init_fs();
     GUIDE_MARKER_START = "<!-- wairon-guide-start -->";
     GUIDE_MARKER_END = "<!-- wairon-guide-end -->";
     GLOBAL_GUIDE_BODY = `## wairon \u2014 Spec-Driven Development (optional)
@@ -41450,13 +42095,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.
@@ -41626,8 +42271,9 @@ var init_context = __esm({
 // src/core/status.ts
 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}]`;
 }
 function fillDecor(decor) {
   return {
@@ -41713,11 +42359,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") {
@@ -41840,12 +42490,11 @@ 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 };
 }
-var path37, asWritten;
+var path37, APPROVAL_WORDS, PIN_WORDS, OWN_APPROVAL_WORDS, asWritten;
 var init_status = __esm({
   "src/core/status.ts"() {
     "use strict";
@@ -41854,6 +42503,13 @@ var init_status = __esm({
     init_specs();
     init_fs();
     init_yaml();
+    APPROVAL_WORDS = { approved: "approved", drifted: "drifted", never: "never approved" };
+    PIN_WORDS = { matches: "pinned", moved: "pin moved", unpinned: "not pinned" };
+    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)"
+    };
     asWritten = (text3) => text3;
   }
 });
@@ -41894,7 +42550,8 @@ var init_core = __esm({
     init_provision();
     init_statehash();
     init_lockfile();
-    init_diagram();
+    init_specs2();
+    init_specs2();
     init_diagram();
     init_diagram();
     init_detection();
@@ -42150,7 +42807,7 @@ function exportSddSkills(targetTypes) {
       const content = composeBuiltinSkill(name, packSkills.filter((s) => s.targets.includes(type)));
       const destPath = skillDestPath(type, destDir, name);
       ensureDir(path38.dirname(destPath));
-      fs22.writeFileSync(destPath, content, "utf-8");
+      writeFileIfChanged(destPath, content);
       fileCount++;
     }
     for (const skill of packSkills) {
@@ -42161,7 +42818,7 @@ function exportSddSkills(targetTypes) {
       const content = fs22.readFileSync(skill.sourcePath, "utf-8");
       const destPath = skillDestPath(type, destDir, id);
       ensureDir(path38.dirname(destPath));
-      fs22.writeFileSync(destPath, content, "utf-8");
+      writeFileIfChanged(destPath, content);
       fileCount++;
     }
   }
@@ -42180,7 +42837,7 @@ function checkSkillFreshness(type) {
     }
     const want = composeBuiltinSkill(name, packSkills);
     const have = fs22.readFileSync(destPath, "utf-8");
-    if (have === want) result.ok.push(name);
+    if (have.replace(/\r\n/g, "\n") === want.replace(/\r\n/g, "\n")) result.ok.push(name);
     else result.stale.push(name);
   }
   return result;
@@ -44890,8 +45547,32 @@ function planAliasRename(family, bound2, request) {
   if ([...family.owners].some(([key, owner]) => owner === bound2 && key.split("::").pop() === next)) {
     plan7.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(plan7, family, bound2);
   return plan7;
 }
+function repinIntactConsumers(plan7, family, bound2) {
+  const boundNode2 = familyNode(family, bound2);
+  for (const node of family.nodes) {
+    if (path46.resolve(node.directory) === path46.resolve(boundNode2.directory)) continue;
+    let statuses = [];
+    try {
+      statuses = runWithProjectRoot(node.directory, () => getExternalsStatus2());
+    } catch {
+      continue;
+    }
+    for (const status2 of statuses) {
+      const producer = node.aliases.get(status2.alias);
+      const pinsBound = producer !== void 0 ? producer === bound2 : boundNode2.id !== void 0 && status2.project === boundNode2.id;
+      if (!status2.pinned || status2.outOfReach || !pinsBound) continue;
+      const broken = status2.uses.filter((u) => u.state === "changed" || u.state === "removed");
+      if (broken.length > 0) {
+        plan7.notes.push(`${label5(node.namespace)}'s pin of "${status2.alias}" is already incompatible (${broken.map((u) => u.publicName ?? u.member ?? "?").join(", ")}): not re-pinned \u2014 adapt its uses, then run \`wairon externals pin ${status2.alias}\` there.`);
+        continue;
+      }
+      edit2(plan7, node.namespace, "pin", `pin ${status2.alias} taken again: the names it uses of ${label5(bound2)} are unchanged`, { root: node.directory, call: "pinExternals", args: [[status2.alias]] });
+    }
+  }
+}
 function write4(plan7, rehearsal) {
   const planned = plan7.edits.filter((e) => e.write !== void 0);
   const unknown = planned.find((x) => !PHASES.includes(x.write.call));
@@ -44906,6 +45587,7 @@ function write4(plan7, 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();
@@ -44929,6 +45611,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`);
     }
@@ -44968,7 +45652,7 @@ var init_identity = __esm({
       group: ["type"],
       type: ["interface", "type", "implementation"]
     };
-    PHASES = ["rewriteReferences", "renameAlias", "repointExternal", "renameId", "renamePin"];
+    PHASES = ["rewriteReferences", "renameAlias", "repointExternal", "renameId", "renamePin", "pinExternals"];
   }
 });
 
@@ -45212,6 +45896,7 @@ function planExternalize(family, bound2, request) {
   if (plan7.refusals.length > 0) return plan7;
   edit3(plan7, bound2, "move", `externalize ${id} as a project: its specs into a member at ${posix6(path47.relative(node.directory, dir))}, declared as "${id}", then promoted`, { root: node.directory, call: "externalizeSubsystem", args: [id, posix6(path47.relative(node.directory, dir)), "project"] });
   edit3(plan7, 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(plan7, family, bound2, [dir]);
   plan7.notes.push("Source code is not moved: move the subsystem's code into the member yourself.");
   return plan7;
 }
@@ -45340,6 +46025,7 @@ function planPromote(family, bound2, request) {
   );
   edit3(plan7, 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(plan7, bound2, "pin", `pin ${alias} (a project stored outside ${label6(bound2)} is judged against its pin)`, { root: node.directory, call: "pinExternals", args: [[alias]] });
+  repinIntactConsumers2(plan7, family, bound2, [part.directory]);
   plan7.notes.push(`"${newId}" has no lock yet: lock it at its own root (\`wairon lock\`) once it validates.`);
   return plan7;
 }
@@ -45406,16 +46092,19 @@ function write5(plan7, rehearsal) {
     return;
   }
   if (plan7.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(plan7, 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 (plan7.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(plan7, 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 line2 of demoted?.consumersRestored ?? []) plan7.edits.push({ project: e.project, kind: "reference", detail: `consumers across the old boundary restored: ${line2}` });
+  }
   for (const e of planned.filter((x) => x.write.call === "unpin")) writeOne3(rehearsal, e.write);
 }
 function referencesBySpec2(planned) {
@@ -45428,9 +46117,46 @@ ${id}`) ?? [], ...edits]);
   }
   return out;
 }
+function repinIntactConsumers2(plan7, family, bound2, created) {
+  const boundNode2 = familyNode(family, bound2);
+  const skip = new Set([boundNode2.directory, ...created].map((d) => path47.resolve(d)));
+  for (const node of family.nodes) {
+    if (skip.has(path47.resolve(node.directory))) continue;
+    let statuses = [];
+    try {
+      statuses = runWithProjectRoot(node.directory, () => getExternalsStatus2());
+    } catch {
+      continue;
+    }
+    for (const status2 of statuses) {
+      const producer = node.aliases.get(status2.alias);
+      const pinsBound = producer !== void 0 ? producer === bound2 : boundNode2.id !== void 0 && status2.project === boundNode2.id;
+      if (!status2.pinned || status2.outOfReach || !pinsBound) continue;
+      const broken = status2.uses.filter((u) => u.state === "changed" || u.state === "removed");
+      if (broken.length > 0) {
+        plan7.notes.push(`${label6(node.namespace)}'s pin of "${status2.alias}" is already incompatible (${broken.map((u) => u.publicName ?? u.member ?? "?").join(", ")}): not re-pinned \u2014 adapt its uses, then run \`wairon externals pin ${status2.alias}\` there.`);
+        continue;
+      }
+      edit3(plan7, node.namespace, "pin", `pin ${status2.alias} taken again: the names it uses of ${label6(bound2)} only move with the boundary`, { root: node.directory, call: "pinExternals", args: [[status2.alias]] });
+    }
+  }
+}
+function recordCrossing(plan7, bound2, member, result) {
+  const crossed = result;
+  if (!crossed) return;
+  for (const r of crossed.respelled) {
+    plan7.edits.push({ project: bound2, kind: "reference", detail: `${r.specId} (${r.position}): ${r.from} \u2192 ${r.to}`, reference: r });
+  }
+  for (const r of crossed.memberRespelled) {
+    plan7.edits.push({ project: member, kind: "reference", detail: `${r.specId} (${r.position}): ${r.from} \u2192 ${r.to}`, reference: r });
+  }
+  for (const line2 of crossed.exported) plan7.edits.push({ project: bound2, kind: "export", detail: `export ${line2}` });
+  for (const line2 of crossed.imported) plan7.edits.push({ project: bound2, kind: "external", detail: `import: ${line2}` });
+  for (const line2 of crossed.consumersDropped) plan7.edits.push({ project: bound2, kind: "reference", detail: `consumers across the boundary to ${member} dropped: ${line2}` });
+}
 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]);
@@ -45557,7 +46283,7 @@ function dropRehearsal(id) {
 function saveJournal(journal) {
   const ignore = nodePath2.join(transactionsDir(journal.owner), ".gitignore");
   if (!fs27.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");
@@ -45569,7 +46295,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)}`);
   }
@@ -45630,14 +46356,14 @@ function close(owner, id) {
   } catch {
   }
 }
-var fs27, os7, nodePath2, yaml3, TRANSACTIONS2, transactionsDir, transactionDir, rehearsalDir;
+var fs27, os7, nodePath2, yaml4, TRANSACTIONS2, transactionsDir, transactionDir, rehearsalDir;
 var init_transaction_files = __esm({
   "src/migrations/transaction-files.ts"() {
     "use strict";
     fs27 = __toESM(require("fs"));
     os7 = __toESM(require("os"));
     nodePath2 = __toESM(require("path"));
-    yaml3 = __toESM(require("js-yaml"));
+    yaml4 = __toESM(require("js-yaml"));
     TRANSACTIONS2 = nodePath2.join(".wai", "transactions");
     transactionsDir = (owner) => nodePath2.join(owner, TRANSACTIONS2);
     transactionDir = (owner, id) => nodePath2.join(transactionsDir(owner), id);
@@ -46481,10 +47207,19 @@ ${body}`);
 }
 function migrationView(report4, dryRun) {
   const plan7 = report4.plan;
+  const request = plan7.request;
+  const madeProject = request.verb === "promote" || request.verb === "externalize" && request.as === "project";
+  const madeAt = madeProject && report4.applied ? plan7.changes.find((c) => c.action === "create" && c.path.replace(/\\/g, "/") === ".wai/project.yaml")?.project : void 0;
   return {
     dryRun,
     applied: report4.applied,
     relock: report4.applied ? report4.relock : plan7.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.`
+      }
+    } : {},
     ...report4.outcome ? { outcome: { committed: report4.outcome.committed, restored: report4.outcome.restored, unrestored: report4.outcome.unrestored, ...report4.outcome.failure ? { failure: report4.outcome.failure } : {} } } : {},
     plan: {
       verb: plan7.request.verb,
@@ -48088,9 +48823,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 }) => {
@@ -48606,7 +49341,7 @@ function geminiGlobalDir(override) {
   return override || process.env["GEMINI_CONFIG_DIR"] || path51.join(os8.homedir(), ".gemini");
 }
 function claudeMcpConfigPath(useGlobal, override) {
-  if (!useGlobal) return path51.join(process.cwd(), ".mcp.json");
+  if (!useGlobal) return path51.join(getProjectRoot(), ".mcp.json");
   const dir = override || process.env["CLAUDE_CONFIG_DIR"];
   return dir ? path51.join(dir, ".claude.json") : path51.join(os8.homedir(), ".claude.json");
 }
@@ -48636,32 +49371,33 @@ function validateConfigDir(dir, backend) {
     );
   }
 }
+function bindingLine(root) {
+  let id = null;
+  try {
+    const config = loadProjectConfig();
+    if (config) id = effectiveProjectId(config);
+  } catch {
+  }
+  return `project ${id ?? path51.basename(root)} at ${root}`;
+}
+function serveRoot(cwd, envDir) {
+  if (envDir && fs30.existsSync(path51.join(envDir, ".wai"))) return { root: path51.resolve(envDir), how: "WAIRON_PROJECT_DIR (pinned at install)" };
+  const binding = resolveProjectBinding(cwd);
+  if (binding?.via === "here") return { root: binding.root, how: "cwd" };
+  if (binding?.via === "ancestor") return { root: binding.root, how: `walked up to ancestor inside the repository \u2014 cwd (${cwd}) holds no project` };
+  if (binding) return { root: binding.root, how: `walked up past the repository root to the project that declares it as a member \u2014 cwd (${cwd})` };
+  if (fs30.existsSync(path51.join(cwd, ".wai"))) return { root: cwd, how: "cwd (its .wai holds no L0 yet)" };
+  return { root: cwd, how: "cwd (no project binds this folder)" };
+}
 async function runMcpServe() {
-  const { setProjectRoot: setProjectRoot2, getProjectRoot: getProjectRoot2, findProjectRoot: findProjectRoot2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+  const { setProjectRoot: setProjectRoot2, getProjectRoot: getProjectRoot2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
   const cwd = path51.resolve(process.cwd());
   const envDir = process.env["WAIRON_PROJECT_DIR"];
-  let resolved;
-  let how;
-  if (envDir && fs30.existsSync(path51.join(envDir, ".wai"))) {
-    resolved = path51.resolve(envDir);
-    how = "WAIRON_PROJECT_DIR (pinned at install)";
-  } else {
-    const found = findProjectRoot2(cwd);
-    if (found && found === cwd) {
-      resolved = found;
-      how = "cwd";
-    } else if (found) {
-      resolved = found;
-      how = `walked up to ancestor \u2014 cwd (${cwd}) has no .wai`;
-    } else {
-      resolved = cwd;
-      how = "cwd (no .wai found anywhere above)";
-    }
-  }
+  const { root: resolved, how } = serveRoot(cwd, envDir);
   setProjectRoot2(resolved);
   const initialized = isProjectInitialized();
   process.stderr.write(
-    `[wairon mcp] v${WAIRON_VERSION} \u2014 project root: ${getProjectRoot2()} [via ${how}] (.wai ${initialized ? "found" : "NOT found \u2014 sdd_* tools will report no project"})
+    `[wairon mcp] v${WAIRON_VERSION} \u2014 ${bindingLine(getProjectRoot2())} [via ${how}] (.wai ${initialized ? "found" : "NOT found \u2014 sdd_* tools will report no project"})
 `
   );
   const { startMcpServer: startMcpServer2 } = (init_server(), __toCommonJS(server_exports));
@@ -48756,7 +49492,7 @@ function resolveInstallTargets(options) {
         configBase = path51.join(geminiGlobalDir(options.configDir), "antigravity-cli");
         settingsPath = path51.join(configBase, "mcp_config.json");
       } else {
-        configBase = path51.join(process.cwd(), ".gemini");
+        configBase = path51.join(root, ".gemini");
         settingsPath = path51.join(configBase, "settings.json");
       }
     } else {
@@ -48829,14 +49565,14 @@ function writeInstallTarget(target) {
   if (target.outsideProject && fs30.existsSync(target.path)) {
     logger.info(`Backed up ${import_chalk3.default.gray(target.path)} to ${import_chalk3.default.cyan(backupBeside(target.path))} before replacing it (outside the project root).`);
   }
-  fs30.writeFileSync(target.path, JSON.stringify(target.settings, null, 2) + "\n");
+  fs30.writeFileSync(target.path, withLineEndings(target.path, JSON.stringify(target.settings, null, 2) + "\n"));
 }
 function reportInstalled(target, agentLabel) {
   const wasStale = target.before !== void 0;
   logger.success(`wairon MCP server ${wasStale ? "updated (was stale)" : "registered"} for ${agentLabel} in ${import_chalk3.default.cyan(target.path)}.`);
   logger.blank();
   logger.info("AI tools using this config get the wairon MCP server: the sdd_* spec-authoring, validation, member and");
-  logger.info('rename tools, plus live agent briefs (sdd_get_agent_brief). The full list is in docs/cli.md ("MCP tools").');
+  logger.info('rename tools, plus live agent briefs (sdd_get_agent_brief). The full list is in docs/cli.md ("MCP tools"), shipped with the package (node_modules/@wairon/cli/docs/cli.md) and at https://github.com/SYW-Apps/Waffle-AIron/blob/main/docs/cli.md');
   logger.blank();
   const restartApp = target.backend === "gemini" ? "Antigravity CLI (agy)" : "claude";
   logger.info(`Restart ${import_chalk3.default.bold(restartApp)} (or reload MCP servers) to activate.`);
@@ -48855,7 +49591,7 @@ function runMcpStatus() {
   if (!projectConfig) throw new ProjectNotInitializedError();
   const claudeProject = claudeMcpConfigPath(false);
   const claudeGlobal = claudeMcpConfigPath(true);
-  const geminiProject = path51.join(process.cwd(), ".gemini", "settings.json");
+  const geminiProject = path51.join(getProjectRoot(), ".gemini", "settings.json");
   const geminiGlobal = path51.join(geminiGlobalDir(), "antigravity-cli", "mcp_config.json");
   logger.blank();
   logger.info(`${import_chalk3.default.bold("wairon MCP Server")}`);
@@ -48938,6 +49674,7 @@ var init_mcp = __esm({
     init_fs();
     init_errors();
     init_defaults();
+    init_project();
   }
 });
 
@@ -49194,32 +49931,99 @@ function checkApproval(strict) {
   }
   const lock = readLockState(computeGateStateId());
   const record2 = lock.record;
+  const members = familyApprovals().filter((a) => a.key !== "" && a.as !== "part");
+  const drifted = members.filter((a) => a.state === "drifted");
+  const never = members.filter((a) => a.state === "never");
+  if (drifted.length > 0) {
+    const where = memberFolders();
+    const own = lock.state === "locked" ? "This project's own approval still covers its design." : lock.state === "stale" ? "This project's own approval is stale too \u2014 run `wairon lock` here afterwards." : "This project itself has no approval on record.";
+    return {
+      state: lock.state === "unlocked" ? "unlocked" : "stale",
+      approved: false,
+      message: `Member project(s) carry spec changes nobody approved: ${drifted.map((m) => describeMemberAt(m, where)).join("; ")}. Nothing says a human has seen what is about to merge in them. Fix: run \`wairon lock\` in each member's own folder and commit its .wai/lock.json. ${own}`
+    };
+  }
   if (lock.state === "stale" && record2.stateId.algorithm !== lock.current.algorithm) return upgradedCheck(record2);
   switch (lock.state) {
-    case "locked":
+    case "locked": {
+      if (strict && never.length > 0) {
+        const where = memberFolders();
+        return {
+          state: "locked",
+          approved: false,
+          message: `This project's own design is approved, but --strict asks for an approved family and member project(s) were never approved by anyone: ${never.map((m) => describeMemberAt(m, where)).join("; ")}. Fix: run \`wairon lock\` in each member's own folder and commit its .wai/lock.json.`
+        };
+      }
+      const approvedMembers = members.length - never.length;
+      const family = members.length === 0 ? "" : ` ${approvedMembers} member project(s) approved at their own roots.` + (never.length > 0 ? ` NOT gated: ${never.map((m) => m.alias ?? m.key).join(", ")} \u2014 never approved by anyone (\`--strict\` fails here).` : "");
       return {
         state: "locked",
         approved: true,
-        message: `The design in this tree is the approved design \u2014 approved ${record2.lockedAt} by ${describeApprover(record2.lockedBy)}.`
+        message: (never.length > 0 ? "This project's own design is the approved design \u2014 " : "The design in this tree is the approved design \u2014 ") + `approved ${record2.lockedAt} by ${describeApprover(record2.lockedBy)}.${family}`
       };
-    case "stale":
+    }
+    case "stale": {
+      const repinned = repinOnly(record2);
+      if (repinned) {
+        return {
+          state: "stale",
+          approved: false,
+          message: `Member project(s) were re-approved at their own roots since this project's approval was taken: ${repinned.join(", ")}. That is how a member's approval is meant to move \u2014 its own approver signed its new design off \u2014 so the member is not in question. What is stale is this project's pin of it: the approval on record (${record2.lockedAt} by ${describeApprover(record2.lockedBy)}) still names the member's earlier approval, so it does not cover the member design about to merge. No own spec file changed. Fix: run \`wairon lock\` here to pin the member(s)' new approval (the same lock records anything else the gate identity covers that moved alongside), and commit the updated .wai/lock.json.`
+        };
+      }
       return {
         state: "stale",
         approved: false,
         message: `The design, or something it was approved under, changed after it was approved (the approval on record is ${record2.lockedAt} by ${describeApprover(record2.lockedBy)}). ${whatMoved(record2)} Nothing says a human has seen what is about to merge. Fix: run \`wairon lock\` on this branch and commit the updated .wai/lock.json.`
       };
+    }
     default:
       return {
         state: "unlocked",
         approved: !strict,
-        message: strict ? "No approval on record (.wai/lock.json is absent), and --strict asks for one. Run `wairon lock` and commit the record." : "No approval on record (.wai/lock.json is absent) \u2014 this project has not opted into the approval gate, so nothing is gated. Run `wairon lock` and commit the record to turn it on, or pass --strict to fail here instead."
+        message: strict ? "No approval on record (.wai/lock.json is absent), and --strict asks for one. Run `wairon lock` and commit the record." : "No approval on record (.wai/lock.json is absent), so nothing is gated: plain `wairon lock-check` fails only a committed approval that no longer matches the design, and a project with no .wai/lock.json \u2014 never locked, or the record deleted \u2014 reads the same. CI should run `wairon lock-check --strict`, which fails here. Run `wairon lock` and commit the record to approve the design."
       };
   }
 }
+function memberFolders() {
+  const folders = /* @__PURE__ */ new Map();
+  try {
+    const family = graph();
+    for (const node of family.nodes) if (node.namespace !== "") folders.set(node.namespace, node.directory);
+    for (const external of family.nodes.find((n) => n.namespace === "")?.externals ?? []) {
+      if (external.role === "member" && external.directory) folders.set(external.alias, external.directory);
+    }
+  } catch {
+  }
+  return folders;
+}
+function describeMemberAt(member, folders) {
+  const dir = folders.get(member.key);
+  const shown2 = dir ? path40.relative(process.cwd(), dir) || "." : void 0;
+  const state = member.state === "drifted" ? member.upgraded ? "approved under an earlier gate identity \u2014 re-lock it once" : "changed since its own approval" : "never approved";
+  return `${member.alias ?? member.key} (${state}${shown2 ? `, in ${shown2}` : ""})`;
+}
+function repinOnly(record2) {
+  const diff3 = diffAgainstApproval();
+  if (!diff3 || diffSize(diff3) > 0) return null;
+  const direct = familyApprovals(1).filter((a) => a.parent === "");
+  const members = direct.filter((a) => a.as !== "part");
+  const current2 = new Set(direct.map((m) => m.alias ?? m.key));
+  if (Object.keys(record2.members ?? {}).some((alias) => !current2.has(alias))) return null;
+  const moved = [];
+  for (const m of members) {
+    if (m.pinned === "unpinned") return null;
+    if (m.pinned !== "moved") continue;
+    if (m.state !== "approved") return null;
+    moved.push(m.alias ?? m.key);
+  }
+  return moved.length > 0 ? moved : null;
+}
 function whatMoved(record2) {
   const diff3 = diffAgainstApproval();
   const own = diff3 ? diffSize(diff3) : null;
-  const members = familyApprovals(1).filter((a) => a.parent === "" && a.as !== "part");
+  const direct = familyApprovals(1).filter((a) => a.parent === "");
+  const members = direct.filter((a) => a.as !== "part");
   const named2 = [];
   for (const m of members) {
     const name = m.alias ?? m.key;
@@ -49227,7 +50031,7 @@ function whatMoved(record2) {
     else if (m.pinned === "moved") named2.push(`${name} (its approval moved since this one was taken${m.state === "approved" ? "" : `; now ${m.state}`})`);
     else if (m.state !== "approved") named2.push(`${name} (${m.state} at its own root)`);
   }
-  const current2 = new Set(members.map((m) => m.alias ?? m.key));
+  const current2 = new Set(direct.map((m) => m.alias ?? m.key));
   for (const alias of Object.keys(record2.members ?? {})) {
     if (!current2.has(alias)) named2.push(`${alias} (removed since the approval)`);
   }
@@ -49344,7 +50148,7 @@ async function runLock(options, gate, captured) {
     members: memberPins(members),
     ...gate.analysis ? { code: withoutCodes(gate.analysis) } : {}
   };
-  writeLockRecord(record2);
+  writeLockRecord2(record2);
   return record2;
 }
 function memberPins(members) {
@@ -49573,6 +50377,7 @@ async function runValidate(options = {}) {
 init_lock();
 init_paths();
 init_fs();
+init_project();
 init_mcp();
 
 // src/commands/status.ts
@@ -49619,7 +50424,7 @@ function refuseUnreadableTree(explanation) {
 function withoutTrailingNewline(text3) {
   return text3.endsWith("\n") ? text3.slice(0, -1) : text3;
 }
-async function runStatus(options = {}) {
+async function runStatus(options = {}, listAll = false) {
   assertProjectInitialized();
   printPendingTransactions();
   let approvals;
@@ -49638,12 +50443,15 @@ async function runStatus(options = {}) {
   const lock = approvalVerdict(approvals);
   if (lock.text.trim()) {
     logger.blank();
-    if (lock.drifted) logger.warn(lock.text.trim());
-    else logger.info(lock.text.trim());
-    logger.info(import_chalk4.default.gray(
-      "The percentages measure authoring readiness (each spec's draft/design/complete status), not approval: approval is the lock record above (.wai/lock.json), and `wairon lock` does not change any spec's status."
-    ));
-  }
+    const lines = lock.text.trim().split("\n");
+    const text3 = listAll && lock.moved && lock.moved.length > 0 ? [lines[0], ...lock.moved.map((p) => `  ${p}`), ...lines.slice(1).filter((l) => !l.startsWith("  "))].join("\n") : lock.text.trim();
+    if (lock.drifted) console.log(import_chalk4.default.yellow(`\u26A0  ${text3}`));
+    else logger.info(text3);
+    if (!listAll && lock.moved && lock.moved.length > 5) logger.info(import_chalk4.default.gray("`wairon status --all` lists every spec that moved."));
+  }
+  logger.info(import_chalk4.default.gray(
+    "The percentages measure authoring progress, not approval: 80% once a component's component, contract and implementation specs are written, 100% once its implementation names source files that exist (capped at 50% while any of them is draft or design). Approval is the lock record (.wai/lock.json); `wairon lock` changes no spec."
+  ));
   logger.blank();
 }
 function printPendingTransactions() {
@@ -49777,14 +50585,14 @@ var http = __toESM(require("http"));
 var https = __toESM(require("https"));
 init_defaults();
 function downloadFile(url, dest) {
-  return new Promise((resolve56, reject) => {
+  return new Promise((resolve57, reject) => {
     const file = fs31.createWriteStream(dest);
     const get4 = url.startsWith("https://") ? https.get : http.get;
     get4(url, { headers: { "User-Agent": `wairon/${WAIRON_VERSION}` }, agent: false }, (res) => {
       if (res.statusCode === 301 || res.statusCode === 302) {
         file.close();
         res.destroy();
-        downloadFile(res.headers.location, dest).then(resolve56).catch(reject);
+        downloadFile(res.headers.location, dest).then(resolve57).catch(reject);
         return;
       }
       if (res.statusCode !== 200) {
@@ -49796,7 +50604,7 @@ function downloadFile(url, dest) {
       res.pipe(file);
       file.on("finish", () => {
         res.destroy();
-        file.close(() => resolve56());
+        file.close(() => resolve57());
       });
       file.on("error", (err) => {
         res.destroy();
@@ -50138,6 +50946,13 @@ function uninstallStorePack(spec) {
 function whichPack(spec) {
   const { name, version } = parseNameAtVersion(spec);
   const resolved = resolveInstalledPack(name, version);
+  const bundled = bundledSelectionRef(name, version);
+  if (bundled) {
+    console.log(`${import_chalk8.default.bold(name)} ${import_chalk8.default.cyan(`v${bundled.version ?? "?"}`)}  ${import_chalk8.default.dim("(bundled in this project \u2014 .wai/packs/)")}`);
+    console.log(`  path     ${import_chalk8.default.dim(bundled.ref)}`);
+    console.log(`  store    ${resolved ? import_chalk8.default.dim(`also installed: v${resolved.version} at ${resolved.path} (the bundle applies here)`) : import_chalk8.default.dim("not installed in the store \u2014 the bundle is all this project needs")}`);
+    return;
+  }
   if (!resolved) {
     logger.error(`No pack "${spec}" is installed in the store (${packStoreDir()}).`);
     const names = [...new Set(listInstalledPacks().map((p) => p.name))];
@@ -50147,6 +50962,24 @@ function whichPack(spec) {
   }
   printInstalled(resolved, version === void 0);
 }
+function bundledSelectionRef(name, version) {
+  try {
+    if (!projectConfigExists()) return null;
+    const root = getProjectRoot();
+    for (const entry of loadProjectConfig()?.extensions?.packs ?? []) {
+      if (typeof entry === "string" || entry.name !== name) continue;
+      if (version !== void 0 && entry.version !== void 0 && entry.version !== version) continue;
+      const ref = packEntryRef(entry, root);
+      if (!ref) continue;
+      const rel2 = path52.relative(path52.join(root, ".wai", "packs"), path52.resolve(root, ref));
+      if (rel2.startsWith("..") || path52.isAbsolute(rel2)) continue;
+      const segments = rel2.split(path52.sep);
+      return { ref, version: entry.version ?? (segments.length > 1 ? segments[1] : void 0) };
+    }
+  } catch {
+  }
+  return null;
+}
 function printInstalled(pack, latestByDefault) {
   console.log(`${import_chalk8.default.bold(pack.name)} ${import_chalk8.default.cyan(`v${pack.version}`)}${latestByDefault ? import_chalk8.default.dim("  (latest installed)") : ""}`);
   console.log(`  path     ${import_chalk8.default.dim(pack.path)}`);
@@ -51139,7 +51972,22 @@ async function statusCommand(opts) {
 `);
     return;
   }
-  await runStatus({ subsystem: opts.subsystem, ...opts.recursive === false ? { memberDepth: 0 } : {} });
+  await runStatus({ subsystem: opts.subsystem, ...opts.recursive === false ? { memberDepth: 0 } : {} }, opts.all === true);
+}
+var ANNOUNCE_SILENT = /* @__PURE__ */ new Set(["init", "host", "remote", "login", "logout", "serve", "dev", "update", "aliases", "help", "mcp serve"]);
+function announceBinding(commandPath) {
+  const first = commandPath.split(" ")[0];
+  if (ANNOUNCE_SILENT.has(first) || ANNOUNCE_SILENT.has(commandPath)) return;
+  const root = getProjectRootOverride() ?? resolveProjectBinding(process.cwd())?.root;
+  if (!root) return;
+  let id = null;
+  try {
+    const config = runWithProjectRoot(root, () => loadProjectConfig());
+    if (config) id = effectiveProjectId(config);
+  } catch {
+  }
+  process.stderr.write(`project ${id ?? path55.basename(root)} at ${root}
+`);
 }
 async function lockCheckCommand(options) {
   const verdict = checkApproval(options.strict === true);
@@ -51196,6 +52044,10 @@ async function runAgent(action, id) {
         logger.info("Owned paths:");
         for (const p of brief.ownedPaths) logger.info(`  ${p}`);
       }
+      if (brief.codeFence) {
+        logger.info(brief.codeFence.length > 0 ? "Code write fence:" : "Code write fence: none declared yet (name the planned files when spawning)");
+        for (const p of brief.codeFence) logger.info(`  ${p}`);
+      }
       if (brief.readPaths && brief.readPaths.length > 0) {
         logger.info("Read paths:");
         for (const p of brief.readPaths) logger.info(`  ${p}`);
@@ -51478,6 +52330,8 @@ var nodePath3 = __toESM(require("path"));
 init_logger();
 init_errors();
 var import_inquirer3 = __toESM(require("inquirer"));
+init_mcp();
+init_fs();
 init_core();
 function requireProject() {
   if (!projectConfigExists()) {
@@ -51570,6 +52424,28 @@ async function runMigration(request, options) {
   }
   const report4 = apply2(planned);
   printOutcome(report4);
+  if (report4.applied) await provisionMadeProjects(request);
+}
+async function provisionMadeProjects(request) {
+  const madeProject = request.verb === "promote" || request.verb === "externalize" && request.as === "project";
+  if (!madeProject) return;
+  const root = nodePath3.resolve(getProjectRoot());
+  let made;
+  if (request.verb === "externalize") made = request.path ? nodePath3.resolve(root, request.path) : void 0;
+  else made = graph().nodes.find((n) => n.parent === "" && n.mountAlias === request.alias)?.directory;
+  for (const dir of made ? [nodePath3.resolve(made)] : []) {
+    if (dir === root || !pathExists(nodePath3.join(dir, ".wai", "project.yaml"))) continue;
+    const shown2 = shownDir(dir);
+    try {
+      await runWithProjectRoot(dir, async () => {
+        await runGenerate({});
+        runMcpInstall({ global: false, backend: "claude" });
+      });
+      logger.success(`Set ${shown2} up for its own sessions (guide, skills, .mcp.json): a teammate opens that folder in their AI tool.`);
+    } catch (e) {
+      logger.warn(`Could not set ${shown2} up for its own sessions (${e instanceof Error ? e.message : String(e)}). Run there: \`wairon generate\` and \`wairon mcp install --backend claude\`.`);
+    }
+  }
 }
 var ownerLabel = (key) => key === "" ? "the top project" : key;
 var SCREENFUL = 20;
@@ -51691,10 +52567,11 @@ async function runInit(options = {}) {
   }
   if (!options.yes && !process.stdin.isTTY) {
     throw new WaironError(
-      "Non-interactive shell: `wairon init` asks questions and there is no terminal to ask them on. Re-run with --yes (-y) to use the defaults (project name from the directory, profile backend, targets claude and agy). Nothing was written."
+      "Non-interactive shell: `wairon init` asks questions and there is no terminal to ask them on. Re-run with --yes (-y) to use the defaults (project name from the directory, profile backend, target claude). Nothing was written."
     );
   }
   if (ancestorRoot) {
+    if (options.yes) throw new WaironError(boundByParentMessage(ancestorRoot, cwd));
     await runInitAsMember(ancestorRoot, cwd, options);
     return;
   }
@@ -51707,23 +52584,35 @@ async function runInit(options = {}) {
 function memberAliasOf(name) {
   return name.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "member";
 }
+function boundByParentCommands(parentRoot, cwd) {
+  const relPath = (path58.relative(parentRoot, cwd) || ".").split(path58.sep).join("/");
+  const alias = memberAliasOf(path58.basename(cwd));
+  return [
+    `make it a member project of that parent: cd "${parentRoot}" && wairon member add ${alias} ${relPath} --project`,
+    "or start an independent project here: make this folder its own repository (`git init`), then re-run `wairon init`"
+  ];
+}
+function boundByParentMessage(parentRoot, cwd) {
+  const [member, independent] = boundByParentCommands(parentRoot, cwd);
+  return `This folder is bound by the wairon project at ${parentRoot}, and --yes cannot answer whether it should join it \u2014 init never edits a project.yaml outside this folder without asking. Nothing was written. To ${member}; ${independent}.`;
+}
 async function runInitAsMember(parentRoot, cwd, options) {
   const relPath = (path58.relative(parentRoot, cwd) || ".").split(path58.sep).join("/");
   const defaultAlias = memberAliasOf(path58.basename(cwd));
-  logger.info(`Detected a parent wairon project at ${parentRoot}`);
+  logger.info(`Detected a parent wairon project at ${parentRoot} \u2014 it binds this folder.`);
   logger.info(`This directory ("${relPath}") is not yet a wairon project.`);
   if (!options.yes) {
     const { proceed } = await import_inquirer4.default.prompt([
       {
         type: "confirm",
         name: "proceed",
-        message: `Create "${relPath}" as a member project of the parent project?`,
-        default: true
+        message: `Create "${relPath}" as a member project of the parent project? (edits ${path58.join(parentRoot, ".wai", "project.yaml")})`,
+        default: false
       }
     ]);
     if (!proceed) {
       logger.info("Cancelled \u2014 no changes made.");
-      logger.info("To add this directory later, run `wairon member add <alias> <path>` from the parent project.");
+      for (const line2 of boundByParentCommands(parentRoot, cwd)) logger.info(`To ${line2}.`);
       return;
     }
   }
@@ -51763,13 +52652,13 @@ async function runInitNonInteractive() {
   const cwd = process.cwd();
   const projectName = path58.basename(cwd);
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const targets = [defaultTargetConfig("claude"), defaultTargetConfig("agy")];
+  const targets = [defaultTargetConfig("claude")];
   const projectConfig = buildProjectConfig(projectName, targets, now, "backend");
   const guidePlan = {
     claudeGlobal: false,
     claudeLocal: true,
     geminiGlobal: false,
-    geminiLocal: true
+    geminiLocal: false
   };
   await executeInit(
     projectName,
@@ -52442,7 +53331,7 @@ function releaseChannelLabel(tag) {
   return version.slice(dash + 1).replace(/\.\d+$/, "") || "stable";
 }
 function fetchReleases(repo) {
-  return new Promise((resolve56, reject) => {
+  return new Promise((resolve57, reject) => {
     const url = `https://api.github.com/repos/${repo}/releases?per_page=100`;
     const options = {
       headers: {
@@ -52462,7 +53351,7 @@ function fetchReleases(repo) {
           return;
         }
         try {
-          resolve56(JSON.parse(data));
+          resolve57(JSON.parse(data));
         } catch {
           reject(new Error("Failed to parse GitHub API response"));
         }
@@ -52634,7 +53523,7 @@ async function filteredCheckbox(config) {
     32,
     Math.max(...items.map((i) => i.label.length))
   );
-  return new Promise((resolve56) => {
+  return new Promise((resolve57) => {
     const checked = /* @__PURE__ */ new Set();
     let cursor = 0;
     let filterIdx = 0;
@@ -52701,7 +53590,7 @@ async function filteredCheckbox(config) {
       );
       teardown();
       const result = items.filter((_, idx) => checked.has(idx)).map((i) => i.value);
-      resolve56(result);
+      resolve57(result);
     }
     function abort() {
       process.stdout.write("\n");
@@ -53398,7 +54287,7 @@ async function runDoctor(options = {}) {
       const lock = readLockState(computeGateStateId());
       if (lock.state === "locked") {
         console.log(import_chalk17.default.bold("Lock"));
-        line(tally, "ok", `frozen at ${lock.record.lockedAt} by ${describeApprover(lock.record.lockedBy)}`);
+        line(tally, "ok", `approved at ${lock.record.lockedAt} by ${describeApprover(lock.record.lockedBy)}`);
         if (!lock.record.specs) {
           line(tally, "warn", "this lock predates per-spec approval \u2014 re-lock so `wairon status` can name what drifts");
         }
@@ -53415,7 +54304,7 @@ async function runDoctor(options = {}) {
         line(
           tally,
           "warn",
-          `stale \u2014 the design or something it was approved under changed since ${lock.record.lockedAt}, so this lock no longer holds. Re-run \`wairon lock\` to freeze the current state.`
+          `stale \u2014 the design or something it was approved under changed since ${lock.record.lockedAt}, so the approval no longer covers it. Run \`wairon lock\` to approve the current design (\`wairon status\` names the specs that moved).`
         );
         logger.blank();
       }
@@ -54068,21 +54957,21 @@ async function runDiagram(options = {}) {
   const formatted = applyFormat(options);
   if (formatted.canvas && !formatted.all) {
     const dest2 = formatted.out ?? path62.join(AI_PATHS.docsDir(), "diagrams", "canvas.html");
-    writeArtifact(dest2, renderDiagram("canvas", canvasRelations(formatted)));
+    writeArtifact(dest2, renderDiagram2("canvas", canvasRelations(formatted)));
     logger.success(`Interactive canvas written to ${dest2}`);
     logger.info("Open it in a browser \u2014 fully self-contained (works offline).");
     return;
   }
   if (formatted.drawio && !formatted.all) {
     const dest2 = formatted.out ?? path62.join(AI_PATHS.docsDir(), "diagrams", "architecture.drawio");
-    writeArtifact(dest2, renderDiagram("drawio"));
+    writeArtifact(dest2, renderDiagram2("drawio"));
     logger.success(`draw.io diagram written to ${dest2}`);
     logger.info("Open with draw.io / diagrams.net (or import into tools that accept the format).");
     return;
   }
   if (formatted.excalidraw && !formatted.all) {
     const dest2 = formatted.out ?? path62.join(AI_PATHS.docsDir(), "diagrams", "architecture.excalidraw");
-    writeArtifact(dest2, renderDiagram("excalidraw"));
+    writeArtifact(dest2, renderDiagram2("excalidraw"));
     logger.success(`Excalidraw scene written to ${dest2}`);
     logger.info("Open with excalidraw.com or the VS Code extension.");
     return;
@@ -54090,7 +54979,7 @@ async function runDiagram(options = {}) {
   const wantsMermaid = formatted.format?.toLowerCase().startsWith("mermaid") || !!formatted.subsystem || !!formatted.sequence;
   if (!formatted.all && !formatted.sequence && !wantsMermaid) {
     const dest2 = formatted.out ?? path62.join(AI_PATHS.docsDir(), "diagrams", "canvas.html");
-    writeArtifact(dest2, renderDiagram("canvas", canvasRelations(formatted)));
+    writeArtifact(dest2, renderDiagram2("canvas", canvasRelations(formatted)));
     logger.success(`Interactive canvas written to ${dest2}`);
     logger.info("Open it in a browser \u2014 fully self-contained (works offline). Other formats: --format mermaid|drawio|excalidraw.");
     return;
@@ -54105,9 +54994,9 @@ async function runDiagram(options = {}) {
     for (const file of files) {
       writeArtifact(path62.join(outDir, file.relPath), toMarkdown(file));
     }
-    writeArtifact(path62.join(outDir, "canvas.html"), renderDiagram("canvas", canvasRelations(formatted)));
-    writeArtifact(path62.join(outDir, "architecture.drawio"), renderDiagram("drawio"));
-    writeArtifact(path62.join(outDir, "architecture.excalidraw"), renderDiagram("excalidraw"));
+    writeArtifact(path62.join(outDir, "canvas.html"), renderDiagram2("canvas", canvasRelations(formatted)));
+    writeArtifact(path62.join(outDir, "architecture.drawio"), renderDiagram2("drawio"));
+    writeArtifact(path62.join(outDir, "architecture.excalidraw"), renderDiagram2("excalidraw"));
     const graph2 = loadSpecGraph();
     const indexPath = path62.join(outDir, "README.md");
     writeArtifact(indexPath, diagramSetIndex(files, graph2.systemName));
@@ -54132,7 +55021,7 @@ async function runDiagram(options = {}) {
     title = `${formatted.subsystem} \u2014 components`;
     defaultDest = path62.join(diagramsDir, "subsystems", `${formatted.subsystem.replace(/::/g, "--")}.md`);
   } else {
-    mermaid = renderDiagram("mermaid");
+    mermaid = renderDiagram2("mermaid");
     title = "Component architecture";
     defaultDest = path62.join(diagramsDir, "system.md");
   }
@@ -54178,7 +55067,7 @@ var path63 = __toESM(require("path"));
 function registryPath(dataDir) {
   return path63.join(dataDir, "projects.json");
 }
-function load4(dataDir) {
+function load5(dataDir) {
   try {
     return JSON.parse(fs40.readFileSync(registryPath(dataDir), "utf8"));
   } catch {
@@ -54198,8 +55087,8 @@ var ID_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
 function isValidProjectId(id) {
   return typeof id === "string" && ID_RE.test(id);
 }
-function load5(dataDir) {
-  return load4(dataDir);
+function load6(dataDir) {
+  return load5(dataDir);
 }
 function save2(dataDir, records) {
   save(dataDir, records.map((r) => r.parentProjectId ? withoutRoot(r) : r));
@@ -54246,7 +55135,7 @@ function familyRootOf(records, record2) {
 }
 function existingProjectRoot(dataDir, id) {
   if (!isValidProjectId(id)) return null;
-  const records = load5(dataDir);
+  const records = load6(dataDir);
   const rec = records.find((r) => r.id === id);
   return rec ? derivedRoot(records, rec) : null;
 }
@@ -54256,7 +55145,7 @@ function declaredSubsystemIds(dataDir, id) {
 }
 function rootOnDisk(dataDir, id) {
   if (!isValidProjectId(id)) return null;
-  const records = load5(dataDir);
+  const records = load6(dataDir);
   const rec = records.find((r) => r.id === id);
   const root = rec ? derivedRoot(records, rec) : null;
   return root && fs41.existsSync(root) ? root : null;
@@ -54275,7 +55164,7 @@ function createProjectRecord(dataDir, id) {
   if (!isValidProjectId(id)) {
     throw new Error(`Invalid project id "${id}" (allowed: lowercase letters, digits, hyphen).`);
   }
-  const records = load5(dataDir);
+  const records = load6(dataDir);
   if (records.some((r) => r.id === id)) {
     throw new Error(`Project "${id}" already exists.`);
   }
@@ -54295,7 +55184,7 @@ function registerProjectRecord(dataDir, id, rootPath) {
   if (!isValidProjectId(id)) {
     throw new Error(`Invalid project id "${id}" (allowed: lowercase letters, digits, hyphen).`);
   }
-  const records = load5(dataDir);
+  const records = load6(dataDir);
   const existing = records.find((r) => r.id === id);
   const record2 = {
     id,
@@ -54309,7 +55198,7 @@ function registerProjectRecord(dataDir, id, rootPath) {
 }
 function registerMemberRecord(dataDir, record2) {
   const memberPath = validMemberShape(record2);
-  const records = load5(dataDir);
+  const records = load6(dataDir);
   refuseParent(records, record2);
   const existing = records.find((r) => r.id === record2.id);
   const member = {
@@ -54363,7 +55252,7 @@ function setProjectRecordStatus(dataDir, id, status2, reason) {
   if (status2 !== "active" && status2 !== "disabled") {
     throw new Error(`Invalid project status "${status2}" (allowed: active, disabled).`);
   }
-  const records = load5(dataDir);
+  const records = load6(dataDir);
   const existing = records.find((r) => r.id === id);
   if (!existing) throw new Error(`Unknown project "${id}".`);
   const { disabledReason: _was, ...rest } = existing;
@@ -54373,11 +55262,11 @@ function setProjectRecordStatus(dataDir, id, status2, reason) {
   return withDerivedRoot(next, record2);
 }
 function listProjectRecords(dataDir) {
-  const records = load5(dataDir);
+  const records = load6(dataDir);
   return records.map((r) => withDerivedRoot(records, r));
 }
 function removeProjectRecord(dataDir, id) {
-  const records = load5(dataDir);
+  const records = load6(dataDir);
   const rec = records.find((r) => r.id === id);
   if (!rec) return;
   if (!rec.parentProjectId) {
@@ -54393,7 +55282,7 @@ function removeProjectRecord(dataDir, id) {
   save2(dataDir, records.filter((r) => r.id !== id));
 }
 function listFamilyRecords(dataDir, id) {
-  const records = load5(dataDir);
+  const records = load6(dataDir);
   const rec = records.find((r) => r.id === id);
   if (!rec) return [];
   const root = familyRootOf(records, rec);
@@ -54408,7 +55297,7 @@ function listFamilyRecords(dataDir, id) {
   return out;
 }
 function projectRepositoryScope(dataDir, id) {
-  const records = load5(dataDir);
+  const records = load6(dataDir);
   const rec = records.find((r) => r.id === id);
   if (!rec) return null;
   const segments = [];
@@ -54495,7 +55384,7 @@ function resolveQualifiedMember(dataDir, qualifier) {
   if (!parsed || parsed.mounts.length === 0) {
     throw new Error(`invalid member qualifier "${qualifier}" (expected projectId::alias, one alias per hop)`);
   }
-  const records = load5(dataDir);
+  const records = load6(dataDir);
   const top = records.find((r) => r.id === parsed.projectId);
   const topRoot = top ? derivedRoot(records, top) : null;
   if (!top || top.status !== "active" || topRoot === null) throw new Error(`unknown project "${parsed.projectId}"`);
@@ -54536,7 +55425,7 @@ function memberIdAt2(dir) {
   return { id };
 }
 function planMemberRecords(dataDir, id) {
-  const records = load5(dataDir);
+  const records = load6(dataDir);
   const rec = records.find((r) => r.id === id);
   if (!rec) return [];
   const root = familyRootOf(records, rec);
@@ -54610,7 +55499,7 @@ function assertMintableNarrowingEntry(dataDir, entry) {
     );
   }
   if (parsed.mounts.length > 0) return resolveQualifiedMember(dataDir, entry).id;
-  if (!load5(dataDir).some((r) => r.id === parsed.projectId)) throw new Error(`unknown project "${parsed.projectId}"`);
+  if (!load6(dataDir).some((r) => r.id === parsed.projectId)) throw new Error(`unknown project "${parsed.projectId}"`);
   return parsed.projectId;
 }
 function entryRecordId(dataDir, entry) {
@@ -54638,7 +55527,7 @@ function indexResolveBinding(dataDir, principal, selector) {
     if (targetId === null) return null;
     via = target;
   }
-  const records = load5(dataDir);
+  const records = load6(dataDir);
   const rec = records.find((r) => r.id === targetId);
   if (!rec || !isValidProjectId(rec.id)) return null;
   if (!wildcard && !authorized.some((e) => {
@@ -54656,7 +55545,7 @@ function indexResolveBinding(dataDir, principal, selector) {
 function indexResolveRoot(dataDir, principal, selector) {
   return indexResolveBinding(dataDir, principal, selector)?.rootPath ?? null;
 }
-function resolveProjectBinding(dataDir, principal, selector) {
+function resolveProjectBinding2(dataDir, principal, selector) {
   return indexResolveBinding(dataDir, principal, selector);
 }
 function resolveProjectRoot(dataDir, principal, selector) {
@@ -55079,7 +55968,7 @@ function storePath2(dataDir) {
 function assignmentKey(a) {
   return [a.subjectKind, a.subjectId ?? "", a.scopeKind, a.scopeId ?? "", a.capability].join("|");
 }
-function load6(dataDir) {
+function load7(dataDir) {
   const p = storePath2(dataDir);
   let raw;
   try {
@@ -55107,7 +55996,7 @@ function replaceAll(dataDir, assignments) {
   fs43.renameSync(tmp, p);
 }
 function registrySet(dataDir, assignment) {
-  const assignments = load6(dataDir);
+  const assignments = load7(dataDir);
   const key = assignmentKey(assignment);
   const idx = assignments.findIndex((a) => assignmentKey(a) === key);
   if (assignment.value === "inherit") {
@@ -55129,7 +56018,7 @@ function registrySet(dataDir, assignment) {
   return stored;
 }
 function registryRemove(dataDir, assignmentId) {
-  const assignments = load6(dataDir);
+  const assignments = load7(dataDir);
   const remaining = assignments.filter((a) => a.id !== assignmentId);
   if (remaining.length === assignments.length) return;
   replaceAll(dataDir, remaining);
@@ -55137,7 +56026,7 @@ function registryRemove(dataDir, assignmentId) {
 function registryRemapScope(dataDir, remap) {
   if (remap.length === 0) return;
   const lookup2 = new Map(remap.map((r) => [r.oldId, r.newId]));
-  const assignments = load6(dataDir);
+  const assignments = load7(dataDir);
   let changed = false;
   const rewritten = assignments.map((a) => {
     const next = a.scopeId ? lookup2.get(a.scopeId) : void 0;
@@ -55151,13 +56040,13 @@ function registryRemapScope(dataDir, remap) {
 function registryRemoveForScopes(dataDir, scopeIds) {
   if (scopeIds.length === 0) return;
   const doomed = new Set(scopeIds);
-  const assignments = load6(dataDir);
+  const assignments = load7(dataDir);
   const remaining = assignments.filter((a) => !(a.scopeId && doomed.has(a.scopeId)));
   if (remaining.length === assignments.length) return;
   replaceAll(dataDir, remaining);
 }
 function indexList(dataDir, scopeIds, subjectKind, subjectId, capability) {
-  let assignments = load6(dataDir);
+  let assignments = load7(dataDir);
   if (scopeIds && scopeIds.length > 0) {
     const wanted = new Set(scopeIds);
     assignments = assignments.filter((a) => a.scopeId !== void 0 && wanted.has(a.scopeId));
@@ -55168,7 +56057,7 @@ function indexList(dataDir, scopeIds, subjectKind, subjectId, capability) {
   return assignments;
 }
 function indexGet(dataDir, assignmentId) {
-  return load6(dataDir).find((a) => a.id === assignmentId) ?? null;
+  return load7(dataDir).find((a) => a.id === assignmentId) ?? null;
 }
 function setAssignment(dataDir, assignment) {
   return registrySet(dataDir, assignment);
@@ -55240,7 +56129,7 @@ function isBuiltinRoleId(roleId) {
 function storePath3(dataDir) {
   return path67.join(dataDir, "roles.json");
 }
-function load7(dataDir) {
+function load8(dataDir) {
   const p = storePath3(dataDir);
   let raw;
   try {
@@ -55271,7 +56160,7 @@ function registryCreate(dataDir, role) {
   if (isBuiltinRoleId(role.id)) {
     throw new Error(`Role "${role.id}" is a reserved built-in role and cannot be created.`);
   }
-  const roles = load7(dataDir);
+  const roles = load8(dataDir);
   if (roles.some((r) => r.id === role.id)) {
     throw new Error(`Role "${role.id}" already exists.`);
   }
@@ -55284,7 +56173,7 @@ function registryUpdate(dataDir, role) {
   if (isBuiltinRoleId(role.id)) {
     throw new Error(`Role "${role.id}" is a reserved built-in role and cannot be modified.`);
   }
-  const roles = load7(dataDir);
+  const roles = load8(dataDir);
   const idx = roles.findIndex((r) => r.id === role.id);
   if (idx === -1) {
     throw new Error(`Role "${role.id}" not found.`);
@@ -55298,7 +56187,7 @@ function registryDelete(dataDir, roleId) {
   if (isBuiltinRoleId(roleId)) {
     throw new Error(`Role "${roleId}" is a reserved built-in role and cannot be deleted.`);
   }
-  const roles = load7(dataDir);
+  const roles = load8(dataDir);
   const remaining = roles.filter((r) => r.id !== roleId);
   if (remaining.length === roles.length) return;
   replaceAll2(dataDir, remaining);
@@ -55307,7 +56196,7 @@ function indexListEffectiveRoles(dataDir) {
   return [...indexListRoles(dataDir).filter((r) => !isBuiltinRoleId(r.id)), ...BUILTIN_ROLES];
 }
 function indexListRoles(dataDir) {
-  return load7(dataDir).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  return load8(dataDir).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
 }
 function createRole(dataDir, role) {
   return registryCreate(dataDir, role);
@@ -55735,7 +56624,7 @@ var path69 = __toESM(require("path"));
 function storePath5(dataDir) {
   return path69.join(dataDir, "auth", "credentials.json");
 }
-function load8(dataDir) {
+function load9(dataDir) {
   try {
     return JSON.parse(fs46.readFileSync(storePath5(dataDir), "utf8"));
   } catch {
@@ -55762,10 +56651,10 @@ function digestEquals(a, b) {
   return crypto13.timingSafeEqual(ab, bb);
 }
 function findByTokenHash(dataDir, tokenHash) {
-  return load8(dataDir).find((r) => digestEquals(r.keyHash, tokenHash)) ?? null;
+  return load9(dataDir).find((r) => digestEquals(r.keyHash, tokenHash)) ?? null;
 }
 function createCredential(dataDir, record2) {
-  const records = load8(dataDir);
+  const records = load9(dataDir);
   if (records.some((r) => r.id === record2.id)) {
     throw new Error(`Credential "${record2.id}" already exists.`);
   }
@@ -55773,10 +56662,10 @@ function createCredential(dataDir, record2) {
   save3(dataDir, records);
 }
 function revokeCredential(dataDir, id) {
-  save3(dataDir, load8(dataDir).filter((r) => r.id !== id));
+  save3(dataDir, load9(dataDir).filter((r) => r.id !== id));
 }
 function revokeAllForOwner(dataDir, ownerUserId) {
-  const records = load8(dataDir);
+  const records = load9(dataDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   let revoked = 0;
   for (const rec of records) {
@@ -55789,16 +56678,16 @@ function revokeAllForOwner(dataDir, ownerUserId) {
   return revoked;
 }
 function listCredentials(dataDir, project2) {
-  return load8(dataDir).filter(
+  return load9(dataDir).filter(
     (r) => project2 === "*" || r.projects.includes("*") || r.projects.includes(project2)
   );
 }
 function listByOwner(dataDir, ownerUserId) {
-  return load8(dataDir).filter((r) => r.ownerSubject?.userId === ownerUserId);
+  return load9(dataDir).filter((r) => r.ownerSubject?.userId === ownerUserId);
 }
 function renarrowCredential(dataDir, id, projects) {
   if (projects.length === 0) throw new Error(`Credential "${id}": a narrowing cannot be empty.`);
-  const records = load8(dataDir);
+  const records = load9(dataDir);
   const rec = records.find((r) => r.id === id);
   if (!rec) throw new Error(`Unknown credential "${id}".`);
   if (rec.revokedAt) throw new Error(`Credential "${id}" is revoked.`);
@@ -57451,7 +58340,7 @@ init_fs();
 function configPath2() {
   return aiDir("producers.json");
 }
-function load9() {
+function load10() {
   try {
     return JSON.parse(fs54.readFileSync(configPath2(), "utf8"));
   } catch {
@@ -57466,18 +58355,18 @@ function save4(configs) {
   fs54.renameSync(tmp, p);
 }
 function readProducerConfig(target) {
-  return load9().find((c) => c.target === target) ?? null;
+  return load10().find((c) => c.target === target) ?? null;
 }
 function writeProducerConfig(config) {
-  const configs = load9().filter((c) => c.target !== config.target);
+  const configs = load10().filter((c) => c.target !== config.target);
   configs.push(config);
   save4(configs);
 }
 function clearProducerConfig(target) {
-  save4(load9().filter((c) => c.target !== target));
+  save4(load10().filter((c) => c.target !== target));
 }
 function listProducerConfigs() {
-  return load9();
+  return load10();
 }
 
 // src/producers/core-adapter.ts
@@ -57493,7 +58382,7 @@ function project(diagramUrl) {
   const types = loadTypeSpecs();
   let mermaid = "";
   try {
-    mermaid = renderDiagram("mermaid");
+    mermaid = renderDiagram2("mermaid");
   } catch {
   }
   return {
@@ -57995,7 +58884,7 @@ function executeApprovedLock(cfg, projectId, approver, expected) {
     const specs = captureApprovedSpecs();
     refuseMovedInputs(captured, computeGateStateId());
     const record2 = lockRecordOf(captured, approver, design, gate, config, specs, members);
-    writeLockRecord(record2);
+    writeLockRecord2(record2);
     return publishLock(record2, scope);
   });
 }
@@ -58056,7 +58945,7 @@ function publishLock(record2, scope) {
   const publish2 = runWithProjectRoot(scope.repositoryRoot, () => publish(message, scope.pathspecs));
   if (!publish2.published) return record2;
   const published = { ...record2, commitSha: publish2.commitSha, compareUrl: publish2.compareUrl };
-  writeLockRecord(published);
+  writeLockRecord2(published);
   return published;
 }
 function projectGitCredentialKey(project2) {
@@ -58221,7 +59110,7 @@ function generateDiagram(cfg, credential, project2, format) {
   const root = existingProjectRoot(cfg.dataDir, project2);
   if (!root) throw new Error(`Unknown project "${project2}".`);
   const relations = format === "canvas" ? instanceRelations(cfg, project2, root) : void 0;
-  return runWithProjectRoot(root, () => renderDiagram(format, relations));
+  return runWithProjectRoot(root, () => renderDiagram2(format, relations));
 }
 function instanceRelations(cfg, project2, root) {
   const familyRoot = listFamilyRecords(cfg.dataDir, project2)[0];
@@ -62006,7 +62895,7 @@ function lockTargetOf(cfg, req) {
       `Approved ${req.kind} request "${req.id}" carries a ${SUBPROJECT_SCOPE_PAYLOAD} payload with no usable member qualifier \u2014 refusing to execute, because falling back to the whole project would widen the scope the requester was confined to.`
     );
   }
-  const member = resolveProjectBinding(cfg.dataDir, RECORD_LOOKUP, `${projectId}::${parsed.subproject}`);
+  const member = resolveProjectBinding2(cfg.dataDir, RECORD_LOOKUP, `${projectId}::${parsed.subproject}`);
   if (!member) {
     throw new Error(
       `Approved ${req.kind} request "${req.id}" names member "${parsed.subproject}" of "${projectId}", which holds no hosted record \u2014 refusing to execute rather than widen to the whole project; run \`wairon host doctor --fix\`.`
@@ -62196,7 +63085,7 @@ async function awaitApproval(cfg, credential, requestId, timeoutSeconds) {
   let current2 = req;
   while (current2.status === "pending" && Date.now() < deadline) {
     const remaining = deadline - Date.now();
-    await new Promise((resolve56) => setTimeout(resolve56, Math.min(AWAIT_POLL_INTERVAL_MS, remaining)));
+    await new Promise((resolve57) => setTimeout(resolve57, Math.min(AWAIT_POLL_INTERVAL_MS, remaining)));
     expirePendingApprovals(cfg.dataDir, (/* @__PURE__ */ new Date()).toISOString());
     current2 = getApprovalRequestById(cfg.dataDir, requestId) ?? current2;
   }
@@ -63608,7 +64497,7 @@ async function handleMcpRequest(cfg, req, res, body, credential) {
       permissionSubject: { subjectId: "anonymous", roleBindings: [], instanceAdmin: true }
     };
   }
-  const binding = resolveProjectBinding(cfg.dataDir, principal, projectSelector(req));
+  const binding = resolveProjectBinding2(cfg.dataDir, principal, projectSelector(req));
   if (!binding) {
     sendJson(res, 403, { error: "project not authorized, unknown, or not specified" });
     return;
@@ -63800,7 +64689,7 @@ function writtenOwners(cfg, binding, response) {
 function familyReachOf(cfg, principal, binding) {
   const family = listFamilyRecords(cfg.dataDir, binding.projectId);
   const reach2 = resolveFamilyReach(cfg.dataDir, principal, family.map((r) => r.id));
-  const covered = (id) => resolveProjectBinding(cfg.dataDir, principal, id) !== null;
+  const covered = (id) => resolveProjectBinding2(cfg.dataDir, principal, id) !== null;
   const topRoot = existingProjectRoot(cfg.dataDir, binding.familyRootId) ?? binding.rootPath;
   const parentReach = reach2.readable.includes(binding.familyRootId) && covered(binding.familyRootId);
   const unwritableRoots = family.filter((r) => r.rootPath && !isRetiredPart(r) && !(reach2.writable.includes(r.id) && covered(r.id))).map((r) => r.rootPath);
@@ -63815,7 +64704,7 @@ function familyReachOf(cfg, principal, binding) {
 }
 function hostedRecordLookup(cfg, principal) {
   return (recordId) => {
-    const bound2 = resolveProjectBinding(cfg.dataDir, principal, recordId);
+    const bound2 = resolveProjectBinding2(cfg.dataDir, principal, recordId);
     if (!bound2 || recordId.includes(SUBPROJECT_SEPARATOR)) return null;
     return authorize(cfg.dataDir, principal, "project:read", "project", bound2.projectId).value === "yes" ? bound2.rootPath : null;
   };
@@ -63841,7 +64730,7 @@ function handleViewDiagram(cfg, req, res) {
     sendJson(res, 404, { error: "project not found" });
     return;
   }
-  const html = runWithProjectRoot(root, () => renderDiagram(grant.format));
+  const html = runWithProjectRoot(root, () => renderDiagram2(grant.format));
   res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
   res.end(html);
 }
@@ -64224,7 +65113,7 @@ function captureSnapshot(dataDir, principal, projectId, view, artifacts) {
       canvasModel: JSON.stringify(buildCanvasDataModel(relations))
     };
     if (artifacts.includes("html")) {
-      snapshot.html = renderDiagram("canvas", relations);
+      snapshot.html = renderDiagram2("canvas", relations);
     }
     if (artifacts.includes("openapi")) {
       const result = exportSurface2("project", "openapi");
@@ -64780,7 +65669,7 @@ function getWebProjectCanvas(cfg, sessionId, projectId) {
   }
   const listed = listProjects2(cfg, sessionId);
   const relations = runWithProjectBinding(root, readReach(cfg, projectId, root, listed), () => familyRelations2());
-  return runWithProjectRoot(root, () => renderDiagram("canvas", relations));
+  return runWithProjectRoot(root, () => renderDiagram2("canvas", relations));
 }
 function getWebProjectCanvasModel(cfg, sessionId, projectId) {
   const principal = authenticateSession(cfg.dataDir, sessionId);
@@ -68551,6 +69440,7 @@ function upgradeMemberRecords(cfg, apply4) {
 
 // src/commands/host.ts
 init_fs();
+init_project();
 
 // src/core/demo-seed.ts
 init_specs2();
@@ -69157,11 +70047,11 @@ async function runServe(options = {}) {
   logger.info(`  data dir:    ${import_chalk18.default.gray(cfg.dataDir)}`);
   logger.blank();
   logger.info("Press Ctrl+C to stop.");
-  await new Promise((resolve56) => {
+  await new Promise((resolve57) => {
     const shutdown = () => {
       logger.info("Shutting down\u2026");
       handle.close();
-      resolve56();
+      resolve57();
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
@@ -69180,12 +70070,19 @@ function openBrowser(url) {
   }
 }
 async function runDev(options = {}) {
-  const cwd = process.cwd();
-  if (!fs68.existsSync(path91.join(cwd, ".wai"))) {
+  const binding = resolveProjectBinding(process.cwd());
+  if (!binding) {
     throw new WaironError(
-      "No .wai/ found in the current directory. Run `wairon dev` from a wairon project root (or run `wairon init` first)."
+      "No wairon project binds this folder. Run `wairon dev` inside a wairon project (or run `wairon init` first)."
     );
   }
+  const cwd = binding.root;
+  let projectId = null;
+  try {
+    const config = runWithProjectRoot(cwd, () => loadProjectConfig());
+    if (config) projectId = effectiveProjectId(config);
+  } catch {
+  }
   const hash = crypto29.createHash("sha256").update(cwd).digest("hex").slice(0, 16);
   const dataDir = path91.join(os14.tmpdir(), "wairon-dev", hash);
   fs68.mkdirSync(dataDir, { recursive: true });
@@ -69221,16 +70118,16 @@ async function runDev(options = {}) {
   const url = `http://127.0.0.1:${port}`;
   logger.success("wairon dev server started (local, single-project, no login).");
   logger.info(`  open:      ${import_chalk18.default.cyan(url)}`);
-  logger.info(`  project:   ${import_chalk18.default.gray(cwd)}  ${import_chalk18.default.gray('(served as "local")')}`);
+  logger.info(`  project:   ${projectId ?? path91.basename(cwd)} at ${import_chalk18.default.gray(cwd)}  ${import_chalk18.default.gray('(served as "local")')}`);
   logger.info(`  data dir:  ${import_chalk18.default.gray(dataDir)}  ${import_chalk18.default.gray("(ephemeral)")}`);
   logger.blank();
   logger.info("An agent edits specs; refresh the page to see the live graph. Press Ctrl+C to stop.");
   if (options.open) openBrowser(url);
-  await new Promise((resolve56) => {
+  await new Promise((resolve57) => {
     const shutdown = () => {
       logger.info("Shutting down\u2026");
       handle.close();
-      resolve56();
+      resolve57();
     };
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
@@ -70002,7 +70899,8 @@ function printStatuses(statuses) {
       s.sourceKind,
       s.pinned ? "pinned" : import_chalk21.default.yellow("not pinned"),
       s.reachable ? "reachable" : import_chalk21.default.yellow("unreachable"),
-      s.stale ? import_chalk21.default.red("stale") : "current",
+      // Never "current" beside "unreachable": nothing was compared.
+      s.stale ? import_chalk21.default.red("stale") : s.reachable ? "current" : import_chalk21.default.yellow("not compared"),
       ...s.drifted ? [import_chalk21.default.yellow("drifted")] : []
     ];
     logger.info(`${import_chalk21.default.cyan(s.alias)} \u2192 ${s.project}: ${flags.join(", ")}${s.detail ? ` \u2014 ${s.detail}` : ""}`);
@@ -70011,6 +70909,9 @@ function printStatuses(statuses) {
       logger.info(`    ${name}: ${u.state}${u.code ? ` ${u.code}` : ""}${u.detail ? ` \u2014 ${u.detail}` : ""}`);
     }
   }
+  logger.info(import_chalk21.default.gray(
+    "Words: stale \u2014 a name this project uses changed or was removed since the pin (adapt the design, then re-pin); current \u2014 every used name matches the pin; not compared \u2014 the producer could not be read; drifted \u2014 the producer moved since the pin (re-pin to record it; alone it means nothing used changed). Per name: unchanged; changed (its signature moved); removed (gone from the producer's export table); unlocked (used but not in the pin yet \u2014 re-pin); unavailable (not compared \u2014 never a pass)."
+  ));
 }
 function printListings(rows) {
   if (!rows.length) {
@@ -70153,10 +71054,15 @@ async function setExecutionTier2(tier) {
 // src/cli/index.ts
 cleanStaleBinary();
 var program = new import_commander.Command();
-program.name("wairon").description("SYW Waffle AIron \u2014 Spec-Driven Development (SDD) & Agent Topology Orchestration").version(WAIRON_VERSION, "-v, --version").option("--verbose", "enable verbose output").option("--silent", "suppress all output except errors").hook("preAction", (thisCommand) => {
+program.name("wairon").description("SYW Waffle AIron \u2014 Spec-Driven Development (SDD) & Agent Topology Orchestration").version(WAIRON_VERSION, "-v, --version").option("--verbose", "enable verbose output").option("--silent", "suppress all output except errors").hook("preAction", (thisCommand, actionCommand) => {
   const opts = thisCommand.opts();
   if (opts.verbose) setLogLevel("verbose");
   else if (opts.silent) setLogLevel("silent");
+  if (!opts.silent) {
+    const names = [];
+    for (let c = actionCommand; c && c.parent; c = c.parent) names.unshift(c.name());
+    announceBinding(names.join(" "));
+  }
 });
 program.command("init").description("Initialize wairon and bootstrap the SDD Spec Tree (.wai/specs/) in the current project").option("-y, --yes", "use defaults without interactive prompts").option("--pack <source>", "vendor + register an extension pack right after init (repeatable)", (v, all) => [...all, v], []).action(async (opts) => {
   await runInit({ yes: opts.yes });
@@ -70187,7 +71093,7 @@ program.command("lock").description("Record human approval of the design: valida
 program.command("validate").description("Validate the project configuration and the SDD Spec Tree").option("--ci", "treat warnings as errors for CI pipelines (notices are printed and counted, never fatal)").option("--subsystem <id>", "only validate the specified subsystem (granular)").option("--no-recursive", "at a project that declares members: run the owner's gate alone instead of the family run").option("--family", "run the family run from here: every member's own gate, and this project's externals composed against their live producers").option("--all", "print every finding (by default the first 100 per severity are printed, followed by per-code totals)").action(async (opts) => {
   await validateCommand(opts);
 });
-program.command("status").description("Show the spec tree with its authoring readiness (how far each spec is written out, from its draft/design/complete status) and, separately, its approval state from .wai/lock.json").option("--subsystem <id>", "only show status for the specified subsystem").option("--no-recursive", "show this project only, without its members").action(async (opts) => {
+program.command("status").description("Show the spec tree with its authoring readiness (how far each spec is written out, from its draft/design/complete status) and, separately, its approval state from .wai/lock.json").option("--subsystem <id>", "only show status for the specified subsystem").option("--no-recursive", "show this project only, without its members").option("--all", "list every spec that moved since the approval, not the first few").action(async (opts) => {
   await statusCommand(opts);
 });
 program.command("doctor").description("Health check: flags stale generated guides/skills, an unregistered MCP server, spec-tree issues and the chaining migration still pending").option("--fix", "regenerate stale in-project guides/context/skills, register the MCP server, then apply the chaining migration once confirmed").option("--report <section>", "print one section's report and nothing else, writing nothing (chaining | composed-validation); never combines with --fix").option("-y, --yes", "answer the chaining migration's confirmation (for a non-interactive --fix); a write outside the project root also needs --global").option("--global", "consent to the --fix writes outside the project root (a machine-wide MCP config, the legacy global plugin); with --yes it answers their confirmation, and each replaced file is backed up beside itself").action(async (opts) => {
@@ -70265,7 +71171,7 @@ var variantsCmd = program.command("variants").description("Component variants \u
 variantsCmd.command("list").alias("ls").description("List the component variants in the registry (global + project) with their base and guidance").action(async () => {
   await runVariants();
 });
-program.command("diagram").description("Generate architecture diagrams from the spec tree \u2014 interactive canvas by default; Mermaid / draw.io / Excalidraw via --format").option("--subsystem <id>", "scope the component diagram to one subsystem (plus its external neighbors)").option("--sequence <component:method>", "emit a sequence diagram derived from the method's L5 narrative").option("--depth <n>", "max call-expansion depth for sequence diagrams (default 3)", (v) => parseInt(v, 10)).option("--all", "write the full diagram set: system, per-subsystem, entrypoint sequences, and the interactive canvas").option("--canvas", "emit the interactive self-contained HTML canvas (pan/zoom, collapse boundaries, detail panel, issue overlay)").option("--drawio", "emit an editable draw.io / diagrams.net file (same layout as the canvas)").option("--excalidraw", "emit an editable Excalidraw scene (same layout as the canvas)").option("--format <fmt>", "alias for the flags above: mermaid | canvas | drawio | excalidraw").option("--out <path>", "write to a file (or directory with --all; default .wai/docs/diagrams) instead of stdout").option("--no-health", "skip comparing each consumption relation with its live producer: the canvas draws those edges as not checked").action(async (opts) => {
+program.command("diagram").description("Generate architecture diagrams from the spec tree \u2014 interactive canvas by default; Mermaid / draw.io / Excalidraw via --format").option("--subsystem <id>", "scope the component diagram to one subsystem (plus its external neighbors)").option("--sequence <component:method>", "emit a sequence diagram derived from the method's L5 narrative").option("--depth <n>", "max call-expansion depth for sequence diagrams (default 3)", (v) => parseInt(v, 10)).option("--all", "write the full diagram set: system, per-subsystem, entrypoint sequences, and the interactive canvas").option("--canvas", "emit the interactive self-contained HTML canvas (pan/zoom, collapse boundaries, detail panel, issue overlay)").option("--drawio", "emit an editable draw.io / diagrams.net file (same layout as the canvas)").option("--excalidraw", "emit an editable Excalidraw scene (same layout as the canvas)").option("--format <fmt>", "alias for the flags above: mermaid | canvas | drawio | excalidraw").option("--out <path>", "the file to write (a directory with --all); every format writes a file \u2014 default under .wai/docs/diagrams/ (system.md for Mermaid, canvas.html for the canvas); a .mmd path writes raw Mermaid").option("--no-health", "skip comparing each consumption relation with its live producer: the canvas draws those edges as not checked").action(async (opts) => {
   await runDiagram({
     subsystem: opts.subsystem,
     sequence: opts.sequence,