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

package/dist/index.js

@@ -3316,8 +3316,8 @@ var require_dist = __commonJS({
       return normalized === "." ? ".wai/" : `${normalized}/.wai/`;
     }
     function normalizeRootPath(relativePath) {
-      const posix5 = relativePath.split(path210.sep).join("/").replace(/^\.\//, "").replace(/\/+$/, "");
-      return posix5 === "" || posix5 === "." ? "." : posix5;
+      const posix7 = relativePath.split(path210.sep).join("/").replace(/^\.\//, "").replace(/\/+$/, "");
+      return posix7 === "" || posix7 === "." ? "." : posix7;
     }
     function slugify(projectName) {
       const slug2 = projectName.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -3566,6 +3566,7 @@ __export(src_exports, {
   aiDir: () => aiDir,
   aiDirAt: () => aiDirAt,
   aiPathsAt: () => aiPathsAt,
+  aliasTargetOf: () => aliasTargetOf,
   ambiguityMessage: () => ambiguityMessage,
   approvalKeyIn: () => approvalKeyIn,
   approvalRecord: () => approvalRecord,
@@ -3709,6 +3710,7 @@ __export(src_exports, {
   keyIn: () => keyIn,
   landReference: () => landReference,
   languageOfSourcePath: () => languageOfSourcePath,
+  lineEndingFor: () => lineEndingFor,
   listDirectChainedSubprojects: () => listDirectChainedSubprojects,
   listExternals: () => listExternals2,
   listFiles: () => listFiles,
@@ -3750,6 +3752,7 @@ __export(src_exports, {
   memberDeclarationOf: () => memberDeclarationOf,
   memberDigest: () => memberDigest,
   memberLocationOf: () => memberLocationOf,
+  memberTypesOf: () => memberTypesOf,
   methodGenericParameters: () => methodGenericParameters,
   methodSourceFile: () => methodSourceFile,
   methodTypeRefs: () => methodTypeRefs,
@@ -3808,7 +3811,7 @@ __export(src_exports, {
   renameId: () => renameProjectId,
   renameMethod: () => renameMethod,
   renameType: () => renameType,
-  renderDiagram: () => renderDiagram,
+  renderDiagram: () => renderDiagram2,
   repairForeignStepFields: () => repairForeignStepFields,
   repairSignatures: () => repairSignatures,
   repairTypeSpellings: () => repairTypeSpellings,
@@ -3822,6 +3825,7 @@ __export(src_exports, {
   resolveExternals: () => resolveDeclared,
   resolveImport: () => resolveImport,
   resolveInstalledPack: () => resolveInstalledPack,
+  resolveProjectBinding: () => resolveProjectBinding,
   resolveProjectExports: () => resolveProjectExports,
   resolveSignatures: () => resolveSignatures,
   resolveSubprojectForNamespace: () => resolveSubprojectForNamespace,
@@ -3867,6 +3871,7 @@ __export(src_exports, {
   typeIsMany: () => typeIsMany,
   typeMatchesRef: () => typeMatchesRef,
   typeNamedRefs: () => typeNamedRefs,
+  typeProblemEnumProposal: () => typeProblemEnumProposal,
   typeProblemIntProposal: () => typeProblemIntProposal,
   typeSourceFiles: () => typeSourceFiles,
   typeSpellingFacts: () => typeSpellingFacts,
@@ -3880,11 +3885,12 @@ __export(src_exports, {
   validateProject: () => validateProject,
   validateProjectConfig: () => validateProjectConfig,
   validateRegistry: () => validateRegistry,
+  withLineEndings: () => withLineEndings,
   withPack: () => withPack,
   writeFile: () => writeFile,
   writeFileIfChanged: () => writeFileIfChanged,
   writeJsonFile: () => writeJsonFile,
-  writeLockRecord: () => writeLockRecord,
+  writeLockRecord: () => writeLockRecord2,
   writeReachDenials: () => writeReachDenials,
   writeReachPermits: () => writeReachPermits,
   writeRootGuideDelegator: () => writeRootGuideDelegator,
@@ -3894,8 +3900,8 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/config/project-config.ts
-var fs2 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
+var fs3 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
 var YAML = __toESM(require("yaml"));
 var import_zod4 = require("zod");
 
@@ -3903,22 +3909,125 @@ var import_zod4 = require("zod");
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var import_node_async_hooks = require("async_hooks");
+var yaml = __toESM(require("js-yaml"));
 function ensureDir(dirPath) {
   fs.mkdirSync(dirPath, { recursive: true });
 }
 function writeFile(filePath, content) {
   ensureDir(path.dirname(filePath));
-  fs.writeFileSync(filePath, content, "utf-8");
+  fs.writeFileSync(filePath, withLineEndings(filePath, content), "utf-8");
 }
 function writeFileIfChanged(filePath, content) {
+  const text3 = withLineEndings(filePath, content);
   if (fs.existsSync(filePath)) {
     const existing = fs.readFileSync(filePath, "utf-8");
-    if (existing === content) return false;
+    if (existing === text3) return false;
   }
   ensureDir(path.dirname(filePath));
-  fs.writeFileSync(filePath, content, "utf-8");
+  fs.writeFileSync(filePath, text3, "utf-8");
   return true;
 }
+var EOL_SAMPLE_BYTES = 64 * 1024;
+function endingsOf(text3) {
+  const crlf = text3.split("\r\n").length - 1;
+  const lf = text3.split("\n").length - 1 - crlf;
+  if (crlf === 0 && lf === 0) return null;
+  return crlf > lf ? "\r\n" : "\n";
+}
+function sampleOf(file) {
+  let fd;
+  try {
+    fd = fs.openSync(file, "r");
+    const buffer = Buffer.alloc(EOL_SAMPLE_BYTES);
+    const read2 = fs.readSync(fd, buffer, 0, EOL_SAMPLE_BYTES, 0);
+    return buffer.subarray(0, read2).toString("utf-8");
+  } catch {
+    return null;
+  } finally {
+    if (fd !== void 0) fs.closeSync(fd);
+  }
+}
+function attributeMatches(pattern, relative20) {
+  const glob = pattern.replace(/^\//, "");
+  const target = glob.includes("/") ? relative20 : path.posix.basename(relative20);
+  const source = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\//g, "\0").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\u0000/g, "(?:.*/)?");
+  return new RegExp(`^${source}$`).test(target);
+}
+function attributeEol(attributesFile, file) {
+  const text3 = readFileOrNull(attributesFile);
+  if (text3 === null) return null;
+  const relative20 = path.relative(path.dirname(attributesFile), file).split(path.sep).join("/");
+  let eol = null;
+  for (const raw of text3.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line === "" || line.startsWith("#")) continue;
+    const [pattern, ...attrs] = line.split(/\s+/);
+    if (!attributeMatches(pattern, relative20)) continue;
+    for (const attr of attrs) {
+      if (attr === "eol=crlf") eol = "\r\n";
+      else if (attr === "eol=lf") eol = "\n";
+      else if (attr === "-text" || attr === "binary") eol = null;
+    }
+  }
+  return eol;
+}
+function conventionFolders(dir) {
+  const folders = [];
+  let at = path.resolve(dir);
+  for (let depth = 0; depth < 8; depth++) {
+    folders.push(at);
+    if (fs.existsSync(path.join(at, ".git")) || fs.existsSync(path.join(at, ".wai"))) return folders;
+    const parent = path.dirname(at);
+    if (parent === at) break;
+    at = parent;
+  }
+  return folders.slice(0, 1);
+}
+function folderEndings(folder, ext, exclude) {
+  let names;
+  try {
+    names = fs.readdirSync(folder);
+  } catch {
+    return null;
+  }
+  const candidates = names.filter((n) => path.join(folder, n) !== exclude && /\.(ya?ml|json|md|ts|js|txt)$/i.test(n)).sort((a, b) => Number(path.extname(b) === ext) - Number(path.extname(a) === ext)).slice(0, 24);
+  let crlf = 0;
+  let lf = 0;
+  for (const name of candidates) {
+    const full = path.join(folder, name);
+    try {
+      if (!fs.statSync(full).isFile()) continue;
+    } catch {
+      continue;
+    }
+    const sample = sampleOf(full);
+    const endings = sample === null ? null : endingsOf(sample);
+    if (endings === "\r\n") crlf++;
+    else if (endings === "\n") lf++;
+  }
+  if (crlf === lf) return null;
+  return crlf > lf ? "\r\n" : "\n";
+}
+function lineEndingFor(filePath) {
+  const own = sampleOf(filePath);
+  const existing = own === null ? null : endingsOf(own);
+  if (existing) return existing;
+  const folders = conventionFolders(path.dirname(filePath));
+  for (const folder of folders) {
+    const eol = attributeEol(path.join(folder, ".gitattributes"), filePath);
+    if (eol) return eol;
+  }
+  const ext = path.extname(filePath);
+  for (const folder of folders) {
+    const endings = folderEndings(folder, ext, path.resolve(filePath));
+    if (endings) return endings;
+  }
+  return "\n";
+}
+function withLineEndings(filePath, content) {
+  const normalised = content.replace(/\r\n/g, "\n");
+  return lineEndingFor(filePath) === "\r\n" ? normalised.replace(/\n/g, "\r\n") : normalised;
+}
 function readFileOrNull(filePath) {
   try {
     return fs.readFileSync(filePath, "utf-8");
@@ -4017,22 +4126,74 @@ function setProjectRoot(dir) {
 function getProjectRootOverride() {
   return projectRootOverride;
 }
-function findSystemRoot(startDir) {
+function holdsSystemSpec(dir) {
+  for (const base of [".wai", ".wairon"]) {
+    const specs = path.join(dir, base, "specs");
+    if (fs.existsSync(path.join(specs, ".index.yaml")) || fs.existsSync(path.join(specs, "system.yaml"))) return true;
+    if (base === ".wai" && fs.existsSync(path.join(dir, ".wai"))) break;
+  }
+  return false;
+}
+function findRepositoryRoot(startDir) {
   let dir = path.resolve(startDir);
   while (true) {
-    const isWai = fs.existsSync(path.join(dir, ".wai"));
-    const isWairon = !isWai && fs.existsSync(path.join(dir, ".wairon"));
-    const base = isWai ? ".wai" : isWairon ? ".wairon" : null;
-    if (base) {
-      if (fs.existsSync(path.join(dir, base, "specs", ".index.yaml")) || fs.existsSync(path.join(dir, base, "specs", "system.yaml"))) {
-        return dir;
-      }
+    if (fs.existsSync(path.join(dir, ".git"))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function isAtOrBelow(outer, inner2) {
+  const rel2 = path.relative(outer, inner2);
+  return rel2 === "" || !rel2.startsWith("..") && !path.isAbsolute(rel2);
+}
+function declaredMemberDirs(projectRoot) {
+  let parsed;
+  try {
+    const text3 = fs.readFileSync(path.join(projectRoot, ".wai", "project.yaml"), "utf-8");
+    parsed = yaml.load(text3);
+  } catch {
+    return [];
+  }
+  const members = parsed?.members;
+  if (!members || typeof members !== "object") return [];
+  const dirs = [];
+  for (const value of Object.values(members)) {
+    const declaration2 = value;
+    const source = typeof declaration2 === "string" ? declaration2 : typeof declaration2?.source === "string" ? declaration2.source : typeof declaration2?.path === "string" ? declaration2.path : void 0;
+    if (!source) continue;
+    const text3 = source.trim();
+    if (text3.startsWith("hosted:") || /^[a-z][a-z0-9+.-]*:\/\//i.test(text3) || /^[\w.-]+@[\w.-]+:/.test(text3) || path.isAbsolute(text3)) continue;
+    dirs.push(path.resolve(projectRoot, text3));
+  }
+  return dirs;
+}
+function resolveProjectBinding(startDir) {
+  const start = path.resolve(startDir);
+  const repositoryRoot2 = findRepositoryRoot(start) ?? void 0;
+  const withRepo = (b) => repositoryRoot2 ? { ...b, repositoryRoot: repositoryRoot2 } : b;
+  let dir = start;
+  while (true) {
+    if (holdsSystemSpec(dir)) return withRepo({ root: dir, via: dir === start ? "here" : "ancestor" });
+    if (repositoryRoot2 && dir === repositoryRoot2) break;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  dir = path.dirname(repositoryRoot2);
+  while (true) {
+    if (holdsSystemSpec(dir)) {
+      const declares2 = declaredMemberDirs(dir).some((member) => isAtOrBelow(repositoryRoot2, member) && isAtOrBelow(member, start));
+      if (declares2) return withRepo({ root: dir, via: "declared-member" });
     }
     const parent = path.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
+function findSystemRoot(startDir) {
+  return resolveProjectBinding(startDir)?.root ?? null;
+}
 function getProjectRoot() {
   const scoped = requestRootStore.getStore()?.root;
   if (scoped) return scoped;
@@ -4064,44 +4225,67 @@ function aiDirAt(root, ...segments) {
   return path.join(base, ...segments);
 }
 
-// src/utils/yaml.ts
-var yaml = __toESM(require("js-yaml"));
-function parseYaml(content, sourcePath) {
-  try {
-    return yaml.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, {
-    indent: 2,
-    lineWidth: 100,
-    noRefs: true,
-    sortKeys: false
-  });
-}
-function readYamlFile(filePath) {
-  const content = readFileOrNull(filePath);
-  if (content === null) return null;
-  return parseYaml(content, filePath);
-}
-function writeYamlFile(filePath, value) {
-  writeFile(filePath, serializeYaml(value));
+// src/config/defaults.ts
+var os = __toESM(require("os"));
+var path2 = __toESM(require("path"));
+var DEFAULT_TARGET_DIRS = {
+  claude: ".claude/agents",
+  gemini: ".gemini/agents",
+  agy: ".gemini/agents",
+  cursor: ".cursor/rules",
+  copilot: ".github/prompts",
+  codex: ".codex/agents"
+};
+function defaultTargetConfig(type) {
+  return {
+    type,
+    outputDir: DEFAULT_TARGET_DIRS[type],
+    enabled: true
+  };
 }
-function readJsonFile(filePath) {
-  const content = readFileOrNull(filePath);
-  if (content === null) return null;
-  try {
-    return JSON.parse(content);
-  } catch (err) {
-    throw new Error(`Failed to parse JSON (${filePath}): ${String(err)}`);
+var WAIRON_VERSION = "5.1.1-dev.103";
+var GITHUB_REPO = "SYW-Apps/Waffle-AIron";
+var ARCHITECT_AGENT_ID = "agent-architect";
+var ARCHITECT_TEMPLATE_ID = "architect";
+function globalTemplatesDir(projectOverride) {
+  if (process.env.WAIRON_TEMPLATES_DIR) {
+    return process.env.WAIRON_TEMPLATES_DIR;
   }
+  if (projectOverride) {
+    return projectOverride;
+  }
+  return path2.join(os.homedir(), ".wairon", "templates");
 }
-function writeJsonFile(filePath, value) {
-  writeFile(filePath, JSON.stringify(value, null, 2) + "\n");
+var BACKEND_COMMANDS = {
+  claude: "claude",
+  gemini: "gemini"
+};
+function backendCommand(backend) {
+  return BACKEND_COMMANDS[backend] ?? backend;
 }
+var SUPPORTED_ALIASES = ["wai"];
+var SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  ".git",
+  ".cache",
+  "coverage",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "target",
+  // Rust
+  "vendor"
+]);
+
+// src/core/adapters/git-source.ts
+var import_child_process = require("child_process");
+var crypto = __toESM(require("crypto"));
+var fs2 = __toESM(require("fs"));
+var os2 = __toESM(require("os"));
+var path3 = __toESM(require("path"));
 
 // src/utils/errors.ts
 var WaironError = class extends Error {
@@ -4151,6 +4335,167 @@ ${reasons.map((r) => `  - ${r}`).join("\n")}`);
   }
 };
 
+// src/core/adapters/git-source.ts
+var SourceUnavailable = class extends WaironError {
+  constructor(message) {
+    super(message);
+    this.name = "SourceUnavailable";
+  }
+};
+function osUserCache() {
+  if (process.platform === "win32") return process.env.LOCALAPPDATA ?? path3.join(os2.homedir(), "AppData", "Local");
+  if (process.platform === "darwin") return path3.join(os2.homedir(), "Library", "Caches");
+  return process.env.XDG_CACHE_HOME ?? path3.join(os2.homedir(), ".cache");
+}
+var cacheRoots = /* @__PURE__ */ new Map();
+function cacheRoot() {
+  const setting = process.env.WAIRON_CACHE_DIR ?? "";
+  let root = cacheRoots.get(setting);
+  if (root === void 0) {
+    root = setting !== "" ? path3.resolve(setting) : path3.join(osUserCache(), "wairon");
+    cacheRoots.set(setting, root);
+  }
+  return root;
+}
+function git(args, cwd) {
+  return (0, import_child_process.execFileSync)("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_ASKPASS: "echo" }
+  });
+}
+function reasonOf(e) {
+  const stderr = e?.stderr;
+  const text3 = typeof stderr === "string" && stderr.trim() !== "" ? stderr : e instanceof Error ? e.message : String(e);
+  return text3.trim().split(/\r?\n/).filter((l) => l.trim() !== "").slice(-1)[0] ?? "git failed";
+}
+function cacheEntryOf(url, commit2) {
+  const repo = crypto.createHash("sha256").update(url).digest("hex");
+  return path3.join(cacheRoot(), "git", repo, commit2);
+}
+function within(entry, url, commit2, dir) {
+  const at = dir ? path3.join(entry, dir) : entry;
+  if (!fs2.existsSync(at)) {
+    throw new SourceUnavailable(`the commit ${commit2} of ${url} holds no "${dir}"`);
+  }
+  return at;
+}
+function fetchInto(tmp, url, commit2) {
+  git(["init", "-q"], tmp);
+  try {
+    git(["fetch", "-q", "--depth", "1", url, commit2], tmp);
+  } catch {
+    git(["fetch", "-q", url, "+refs/heads/*:refs/remotes/source/*", "+refs/tags/*:refs/tags/*"], tmp);
+  }
+  git(["-c", "advice.detachedHead=false", "checkout", "-q", commit2], tmp);
+  fs2.rmSync(path3.join(tmp, ".git"), { recursive: true, force: true });
+}
+function fetch(url, commit2, dir) {
+  const entry = cacheEntryOf(url, commit2);
+  if (fs2.existsSync(entry)) return within(entry, url, commit2, dir);
+  fs2.mkdirSync(path3.dirname(entry), { recursive: true });
+  const tmp = `${entry}.tmp-${process.pid}-${crypto.randomBytes(4).toString("hex")}`;
+  fs2.mkdirSync(tmp, { recursive: true });
+  try {
+    fetchInto(tmp, url, commit2);
+    try {
+      fs2.renameSync(tmp, entry);
+    } catch (e) {
+      if (!fs2.existsSync(entry)) throw e;
+      fs2.rmSync(tmp, { recursive: true, force: true });
+    }
+  } catch (e) {
+    fs2.rmSync(tmp, { recursive: true, force: true });
+    if (fs2.readdirSync(path3.dirname(entry)).length === 0) fs2.rmdirSync(path3.dirname(entry));
+    throw e instanceof SourceUnavailable ? e : new SourceUnavailable(`cannot fetch ${commit2} of ${url}: ${reasonOf(e)}`);
+  }
+  return within(entry, url, commit2, dir);
+}
+function resolve3(url, ref) {
+  let listed;
+  try {
+    listed = git(["ls-remote", url, ref ?? "HEAD"]);
+  } catch (e) {
+    throw new SourceUnavailable(`cannot reach ${url}: ${reasonOf(e)}`);
+  }
+  const wanted = commitListed(listed, ref ?? "HEAD");
+  if (!wanted) throw new SourceUnavailable(`${url} lists no ref "${ref ?? "HEAD"}"`);
+  return wanted;
+}
+function commitListed(listed, ref) {
+  const lines = listed.split(/\r?\n/).filter((l) => l.trim() !== "").map((l) => l.split(/\s+/));
+  const names = [ref, `refs/heads/${ref}`, `refs/tags/${ref}^{}`, `refs/tags/${ref}`];
+  for (const name of names) {
+    const line = lines.find(([, listedName]) => listedName === name);
+    if (line) return line[0];
+  }
+  return void 0;
+}
+function trackedFiles(directory, pathspecs) {
+  if (pathspecs.length === 0) return [];
+  try {
+    return git(["ls-files", "-z", "--", ...pathspecs], directory).split("\0").filter((p) => p !== "");
+  } catch {
+    return null;
+  }
+}
+function head(directory) {
+  try {
+    return git(["rev-parse", "HEAD"], directory).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function repositoryRoot(directory) {
+  let at = path3.resolve(directory);
+  for (; ; ) {
+    if (fs2.existsSync(path3.join(at, ".git"))) return at;
+    const up = path3.dirname(at);
+    if (up === at) return null;
+    at = up;
+  }
+}
+
+// src/utils/yaml.ts
+var yaml2 = __toESM(require("js-yaml"));
+function parseYaml(content, sourcePath) {
+  try {
+    return yaml2.load(content);
+  } catch (err) {
+    const loc = sourcePath ? ` (${sourcePath})` : "";
+    throw new Error(`Failed to parse YAML${loc}: ${String(err)}`);
+  }
+}
+function serializeYaml(value) {
+  return yaml2.dump(value, {
+    indent: 2,
+    lineWidth: 100,
+    noRefs: true,
+    sortKeys: false
+  });
+}
+function readYamlFile(filePath) {
+  const content = readFileOrNull(filePath);
+  if (content === null) return null;
+  return parseYaml(content, filePath);
+}
+function writeYamlFile(filePath, value) {
+  writeFile(filePath, serializeYaml(value));
+}
+function readJsonFile(filePath) {
+  const content = readFileOrNull(filePath);
+  if (content === null) return null;
+  try {
+    return JSON.parse(content);
+  } catch (err) {
+    throw new Error(`Failed to parse JSON (${filePath}): ${String(err)}`);
+  }
+}
+function writeJsonFile(filePath, value) {
+  writeFile(filePath, JSON.stringify(value, null, 2) + "\n");
+}
+
 // src/models/identity-rename.ts
 var EDGE = " -> ";
 var QUALIFIED_UNIT = /^(\d+:)?([^.\s]+)\.([^.\s]+)$/;
@@ -4186,7 +4531,7 @@ function rekeyAnchor(rename, anchor) {
 }
 
 // src/models/project.ts
-var path2 = __toESM(require("path"));
+var path4 = __toESM(require("path"));
 var import_zod3 = require("zod");
 
 // src/models/agent.ts
@@ -4346,6 +4691,14 @@ var AgentBriefSchema = import_zod2.z.object({
    * agent implements nothing.
    */
   typeMapping: import_zod2.z.array(import_zod2.z.string()).optional(),
+  /**
+   * Where an implementing agent may write CODE: each source file its
+   * implementations name, plus the folder they share below the project root as
+   * `<folder>/**`. Empty when nothing names a file yet (the instructions then
+   * ask the spawning session to name the planned files); absent for an agent
+   * that implements nothing.
+   */
+  codeFence: import_zod2.z.array(import_zod2.z.string()).optional(),
   /**
    * Set only on a brief for a member's agent (an id qualified `<alias>::`): the
    * member's directory relative to the root the brief was asked from. The
@@ -4736,7 +5089,7 @@ var ExternalDeclarationSchema = import_zod3.z.object({
   /**
    * The producer's public names this project imports, so its specs may name
    * them bare: `['*']` imports every public name the producer exports to this
-   * project, `[waffler-error]` only those. Plain strings: a malformed entry is
+   * project, `[shared-error]` only those. Plain strings: a malformed entry is
    * REPORTED (the declaration's problem), never unreadable.
    */
   use: import_zod3.z.array(import_zod3.z.string()).optional(),
@@ -4939,7 +5292,7 @@ var PACK_EXT_RE = /\.(ya?ml|cjs|js)$/i;
 function declaredPackNames(config) {
   const selection = config.profileSelection;
   return [.../* @__PURE__ */ new Set([
-    ...(config.extensions?.packs ?? []).map((entry) => typeof entry === "string" ? path2.basename(entry).replace(PACK_EXT_RE, "") : entry.name),
+    ...(config.extensions?.packs ?? []).map((entry) => typeof entry === "string" ? path4.basename(entry).replace(PACK_EXT_RE, "") : entry.name),
     ...selection?.requiredPackNames ?? [],
     ...selection?.defaultPackNames ?? []
   ])];
@@ -5237,13 +5590,13 @@ function isPart(config) {
 
 // src/config/project-config.ts
 function waiDirAt(root) {
-  const wai = path3.join(root, ".wai");
-  const legacy = path3.join(root, ".wairon");
-  return !fs2.existsSync(wai) && fs2.existsSync(legacy) ? legacy : wai;
+  const wai = path5.join(root, ".wai");
+  const legacy = path5.join(root, ".wairon");
+  return !fs3.existsSync(wai) && fs3.existsSync(legacy) ? legacy : wai;
 }
 function projectConfigFsAdapterAt(rootDir) {
-  const root = path3.resolve(rootDir);
-  const file = () => path3.join(waiDirAt(root), "project.yaml");
+  const root = path5.resolve(rootDir);
+  const file = () => path5.join(waiDirAt(root), "project.yaml");
   return {
     readDocument() {
       return readYamlFile(file());
@@ -5257,7 +5610,7 @@ function projectConfigFsAdapterAt(rootDir) {
       writeFile(file(), editDocumentText(text3, document, root));
     },
     documentExists() {
-      return fs2.existsSync(file());
+      return fs3.existsSync(file());
     },
     readText() {
       return readFileOrNull(file());
@@ -5279,8 +5632,9 @@ function storeOver(adapter, root) {
       if (!checked.success) {
         throw new WaironError(`Refusing to write an invalid .wai/project.yaml at ${root}: ${checked.error.message}`);
       }
-      const document = config.partOf !== void 0 ? { schemaVersion: config.schemaVersion, partOf: config.partOf } : config;
-      adapter.writeDocument(overlayKnownFields(ProjectConfigSchema, document, currentDocument()));
+      const onDisk = currentDocument();
+      const document = config.partOf !== void 0 ? { schemaVersion: config.schemaVersion, partOf: config.partOf } : withoutDefaultedMaterialization(config, onDisk);
+      adapter.writeDocument(overlayKnownFields(ProjectConfigSchema, document, onDisk));
     },
     exists() {
       return adapter.documentExists();
@@ -5680,9 +6034,69 @@ function asReadable(document) {
   if (!isPlainObject(document) || document.partOf === void 0) return document;
   return { name: "", createdAt: PART_EPOCH, updatedAt: PART_EPOCH, ...document };
 }
+var MANAGED_AGENT_MARKER = "wairon:managed";
+var MANAGED_AGENT_NAME = /-(owner|implementer|architect)\.(md|ya?ml)$/;
+function holdsMaterializedAgentFiles(document, root) {
+  const dirs = new Set(Object.values(DEFAULT_TARGET_DIRS));
+  for (const target of Array.isArray(document.targets) ? document.targets : []) {
+    const outputDir = isPlainObject(target) ? target.outputDir : void 0;
+    if (typeof outputDir === "string") dirs.add(outputDir);
+  }
+  const base = path5.resolve(root);
+  const inside = [];
+  for (const dir of dirs) {
+    const rel2 = path5.relative(base, path5.resolve(base, dir));
+    if (rel2.startsWith("..") || path5.isAbsolute(rel2)) continue;
+    let present = false;
+    try {
+      present = fs3.statSync(path5.join(base, rel2)).isDirectory();
+    } catch {
+      present = false;
+    }
+    if (present) inside.push(rel2 === "" ? "." : rel2.split(path5.sep).join("/"));
+  }
+  if (inside.length === 0) return false;
+  const tracked = trackedFiles(base, inside);
+  const candidates = [];
+  if (tracked === null) {
+    for (const dir of inside) {
+      let names;
+      try {
+        names = fs3.readdirSync(path5.join(base, dir));
+      } catch {
+        continue;
+      }
+      for (const name of names) candidates.push(path5.posix.join(dir, name));
+    }
+  } else {
+    const folders = new Set(inside.map((dir) => path5.posix.normalize(dir)));
+    for (const file of tracked) if (folders.has(path5.posix.dirname(file))) candidates.push(file);
+  }
+  for (const file of candidates) {
+    const head2 = readFileOrNull(path5.join(base, file));
+    if (head2 === null) continue;
+    if (MANAGED_AGENT_NAME.test(path5.posix.basename(file))) return true;
+    if (head2.slice(0, 4096).includes(MANAGED_AGENT_MARKER)) return true;
+  }
+  return false;
+}
+function withInferredMaterialization(document, root) {
+  if (!isPlainObject(document) || document.partOf !== void 0) return document;
+  const rules = isPlainObject(document.rules) ? document.rules : void 0;
+  if (rules !== void 0 && hasOwn(rules, "materializeAgentFiles")) return document;
+  if (!holdsMaterializedAgentFiles(document, root)) return document;
+  return { ...document, rules: { ...rules ?? {}, materializeAgentFiles: true } };
+}
+function withoutDefaultedMaterialization(config, onDisk) {
+  if (!isPlainObject(onDisk) || config.rules?.materializeAgentFiles !== false) return config;
+  const stated = isPlainObject(onDisk.rules) && hasOwn(onDisk.rules, "materializeAgentFiles");
+  if (stated) return config;
+  const { materializeAgentFiles: _defaulted, ...rules } = config.rules;
+  return { ...config, rules };
+}
 function parseConfig(document, root) {
   try {
-    return ProjectConfigSchema.parse(asReadable(document));
+    return ProjectConfigSchema.parse(asReadable(withInferredMaterialization(document, root)));
   } catch (e) {
     throw new WaironError(
       `Invalid .wai/project.yaml: ${e instanceof Error ? e.message : String(e)}
@@ -6123,15 +6537,15 @@ function indexOver(store, root) {
     specsDir() {
       try {
         const declared = store.readField("paths.specsDir");
-        if (declared) return path3.resolve(root, declared);
+        if (declared) return path5.resolve(root, declared);
       } catch {
       }
-      return path3.join(waiDirAt(root), "specs");
+      return path5.join(waiDirAt(root), "specs");
     }
   };
 }
 function projectConfigRepositoryOver(adapter, rootDir) {
-  const root = path3.resolve(rootDir);
+  const root = path5.resolve(rootDir);
   const store = storeOver(adapter, root);
   const index = indexOver(store, root);
   const registry = registryOver(store, root);
@@ -6324,15 +6738,15 @@ var fs14 = __toESM(require("fs"));
 var path21 = __toESM(require("path"));
 
 // src/config/paths.ts
-var fs3 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
+var fs4 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
 function aiPathsAt(rootDir) {
-  const resolvedRoot = path4.resolve(rootDir);
+  const resolvedRoot = path6.resolve(rootDir);
   const aiDirAt2 = (...segments) => {
-    const waiPath = path4.join(resolvedRoot, ".wai");
-    const waironPath = path4.join(resolvedRoot, ".wairon");
-    const base = !fs3.existsSync(waiPath) && fs3.existsSync(waironPath) ? waironPath : waiPath;
-    return path4.join(base, ...segments);
+    const waiPath = path6.join(resolvedRoot, ".wai");
+    const waironPath = path6.join(resolvedRoot, ".wairon");
+    const base = !fs4.existsSync(waiPath) && fs4.existsSync(waironPath) ? waironPath : waiPath;
+    return path6.join(base, ...segments);
   };
   const specsDir = () => projectConfigRepositoryAt(resolvedRoot).specsDir();
   return {
@@ -6349,12 +6763,12 @@ function aiPathsAt(rootDir) {
     contextDomainsMd: () => aiDirAt2("context", "domains.md"),
     contextWaironGuideMd: () => aiDirAt2("context", "wairon-guide.md"),
     specsDir,
-    specsSystem: () => path4.join(specsDir(), ".index.yaml"),
-    specsSubsystemsDir: () => path4.join(specsDir(), "subsystems"),
-    specsComponentsDir: () => path4.join(specsDir(), "components"),
-    specsInterfacesDir: () => path4.join(specsDir(), "interfaces"),
-    specsImplementationsDir: () => path4.join(specsDir(), "implementations"),
-    specsTypesDir: () => path4.join(specsDir(), "types")
+    specsSystem: () => path6.join(specsDir(), ".index.yaml"),
+    specsSubsystemsDir: () => path6.join(specsDir(), "subsystems"),
+    specsComponentsDir: () => path6.join(specsDir(), "components"),
+    specsInterfacesDir: () => path6.join(specsDir(), "interfaces"),
+    specsImplementationsDir: () => path6.join(specsDir(), "implementations"),
+    specsTypesDir: () => path6.join(specsDir(), "types")
   };
 }
 var AI_PATHS = {
@@ -6388,8 +6802,8 @@ function assertProjectInitialized() {
 }
 
 // src/core/statehash.ts
-var crypto = __toESM(require("crypto"));
-var path5 = __toESM(require("path"));
+var crypto2 = __toESM(require("crypto"));
+var path7 = __toESM(require("path"));
 
 // src/utils/canonical-json.ts
 function canonicalize(value) {
@@ -6428,7 +6842,7 @@ function digestTree(keep, asStored = (impl) => impl) {
     implementations: kind(loadImplementationSpecs().map(asStored)),
     types: kind(loadTypeSpecs())
   };
-  const digest3 = crypto.createHash("sha256").update(canonicalize(tree)).digest("hex");
+  const digest3 = crypto2.createHash("sha256").update(canonicalize(tree)).digest("hex");
   return { algorithm: CONTENT_ALGORITHM, digest: digest3 };
 }
 function computeStateId() {
@@ -6448,11 +6862,11 @@ function computeOwnStateId() {
   return digestTree((id) => (owners.get(id) ?? "") === "", asStored);
 }
 function isInside(dir, file) {
-  const rel2 = path5.relative(dir, file);
-  return rel2 !== "" && !rel2.startsWith("..") && !path5.isAbsolute(rel2);
+  const rel2 = path7.relative(dir, file);
+  return rel2 !== "" && !rel2.startsWith("..") && !path7.isAbsolute(rel2);
 }
 function fromPartRoot(impl, root, partDir) {
-  const from = (p) => path5.isAbsolute(p) ? p : path5.relative(partDir, path5.resolve(root, p)).split(path5.sep).join("/");
+  const from = (p) => path7.isAbsolute(p) ? p : path7.relative(partDir, path7.resolve(root, p)).split(path7.sep).join("/");
   return {
     ...impl,
     ...impl.sourcePath ? { sourcePath: from(impl.sourcePath) } : {},
@@ -6465,8 +6879,8 @@ function stateIdEquals(a, b) {
 }
 
 // src/core/lockfile.ts
-var fs4 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 function lockPath() {
   return aiDir("lock.json");
 }
@@ -6480,14 +6894,14 @@ function normalizeApprover(value) {
 }
 function readLockRecord() {
   try {
-    return normalizeRecord(JSON.parse(fs4.readFileSync(lockPath(), "utf8")));
+    return normalizeRecord(JSON.parse(fs5.readFileSync(lockPath(), "utf8")));
   } catch {
     return null;
   }
 }
 function readLockRecordAt(root) {
   try {
-    return normalizeRecord(JSON.parse(fs4.readFileSync(aiDirAt(root, "lock.json"), "utf8")));
+    return normalizeRecord(JSON.parse(fs5.readFileSync(aiDirAt(root, "lock.json"), "utf8")));
   } catch {
     return null;
   }
@@ -6498,10 +6912,10 @@ function normalizeRecord(raw) {
 }
 function writeLockRecord(record) {
   const p = lockPath();
-  fs4.mkdirSync(path6.dirname(p), { recursive: true });
+  fs5.mkdirSync(path8.dirname(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  fs4.writeFileSync(tmp, JSON.stringify(withSortedMaps(record), null, 2) + "\n");
-  fs4.renameSync(tmp, p);
+  fs5.writeFileSync(tmp, withLineEndings(p, JSON.stringify(withSortedMaps(record), null, 2) + "\n"));
+  fs5.renameSync(tmp, p);
 }
 function withSortedMaps(record) {
   const sorted = (m) => {
@@ -6521,8 +6935,8 @@ function withSortedMaps(record) {
 }
 
 // src/core/spec-files.ts
-var fs5 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
 var SPEC_FILE_EXTENSION = ".yaml";
 function readSpecFile(specPath) {
   return readYamlFile(specPath);
@@ -6534,136 +6948,17 @@ function listSpecFiles(specsDir) {
   return listFilesRecursive(specsDir, SPEC_FILE_EXTENSION);
 }
 function removeSpecFile(specPath, specsRoot) {
-  if (!fs5.existsSync(specPath)) return false;
-  fs5.unlinkSync(specPath);
-  pruneEmptyDirs(path7.dirname(specPath), path7.resolve(specsRoot));
+  if (!fs6.existsSync(specPath)) return false;
+  fs6.unlinkSync(specPath);
+  pruneEmptyDirs(path9.dirname(specPath), path9.resolve(specsRoot));
   return true;
 }
 function pruneEmptyDirs(dir, specsRoot) {
   let at = dir;
   while (at !== specsRoot && at.startsWith(specsRoot)) {
-    if (!fs5.existsSync(at) || fs5.readdirSync(at).length > 0) return;
-    fs5.rmdirSync(at);
-    at = path7.dirname(at);
-  }
-}
-
-// src/core/adapters/git-source.ts
-var import_child_process = require("child_process");
-var crypto2 = __toESM(require("crypto"));
-var fs6 = __toESM(require("fs"));
-var os = __toESM(require("os"));
-var path8 = __toESM(require("path"));
-var SourceUnavailable = class extends WaironError {
-  constructor(message) {
-    super(message);
-    this.name = "SourceUnavailable";
-  }
-};
-function osUserCache() {
-  if (process.platform === "win32") return process.env.LOCALAPPDATA ?? path8.join(os.homedir(), "AppData", "Local");
-  if (process.platform === "darwin") return path8.join(os.homedir(), "Library", "Caches");
-  return process.env.XDG_CACHE_HOME ?? path8.join(os.homedir(), ".cache");
-}
-var cacheRoots = /* @__PURE__ */ new Map();
-function cacheRoot() {
-  const setting = process.env.WAIRON_CACHE_DIR ?? "";
-  let root = cacheRoots.get(setting);
-  if (root === void 0) {
-    root = setting !== "" ? path8.resolve(setting) : path8.join(osUserCache(), "wairon");
-    cacheRoots.set(setting, root);
-  }
-  return root;
-}
-function git(args, cwd) {
-  return (0, import_child_process.execFileSync)("git", args, {
-    cwd,
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-    env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_ASKPASS: "echo" }
-  });
-}
-function reasonOf(e) {
-  const stderr = e?.stderr;
-  const text3 = typeof stderr === "string" && stderr.trim() !== "" ? stderr : e instanceof Error ? e.message : String(e);
-  return text3.trim().split(/\r?\n/).filter((l) => l.trim() !== "").slice(-1)[0] ?? "git failed";
-}
-function cacheEntryOf(url, commit2) {
-  const repo = crypto2.createHash("sha256").update(url).digest("hex");
-  return path8.join(cacheRoot(), "git", repo, commit2);
-}
-function within(entry, url, commit2, dir) {
-  const at = dir ? path8.join(entry, dir) : entry;
-  if (!fs6.existsSync(at)) {
-    throw new SourceUnavailable(`the commit ${commit2} of ${url} holds no "${dir}"`);
-  }
-  return at;
-}
-function fetchInto(tmp, url, commit2) {
-  git(["init", "-q"], tmp);
-  try {
-    git(["fetch", "-q", "--depth", "1", url, commit2], tmp);
-  } catch {
-    git(["fetch", "-q", url, "+refs/heads/*:refs/remotes/source/*", "+refs/tags/*:refs/tags/*"], tmp);
-  }
-  git(["-c", "advice.detachedHead=false", "checkout", "-q", commit2], tmp);
-  fs6.rmSync(path8.join(tmp, ".git"), { recursive: true, force: true });
-}
-function fetch(url, commit2, dir) {
-  const entry = cacheEntryOf(url, commit2);
-  if (fs6.existsSync(entry)) return within(entry, url, commit2, dir);
-  fs6.mkdirSync(path8.dirname(entry), { recursive: true });
-  const tmp = `${entry}.tmp-${process.pid}-${crypto2.randomBytes(4).toString("hex")}`;
-  fs6.mkdirSync(tmp, { recursive: true });
-  try {
-    fetchInto(tmp, url, commit2);
-    try {
-      fs6.renameSync(tmp, entry);
-    } catch (e) {
-      if (!fs6.existsSync(entry)) throw e;
-      fs6.rmSync(tmp, { recursive: true, force: true });
-    }
-  } catch (e) {
-    fs6.rmSync(tmp, { recursive: true, force: true });
-    if (fs6.readdirSync(path8.dirname(entry)).length === 0) fs6.rmdirSync(path8.dirname(entry));
-    throw e instanceof SourceUnavailable ? e : new SourceUnavailable(`cannot fetch ${commit2} of ${url}: ${reasonOf(e)}`);
-  }
-  return within(entry, url, commit2, dir);
-}
-function resolve7(url, ref) {
-  let listed;
-  try {
-    listed = git(["ls-remote", url, ref ?? "HEAD"]);
-  } catch (e) {
-    throw new SourceUnavailable(`cannot reach ${url}: ${reasonOf(e)}`);
-  }
-  const wanted = commitListed(listed, ref ?? "HEAD");
-  if (!wanted) throw new SourceUnavailable(`${url} lists no ref "${ref ?? "HEAD"}"`);
-  return wanted;
-}
-function commitListed(listed, ref) {
-  const lines = listed.split(/\r?\n/).filter((l) => l.trim() !== "").map((l) => l.split(/\s+/));
-  const names = [ref, `refs/heads/${ref}`, `refs/tags/${ref}^{}`, `refs/tags/${ref}`];
-  for (const name of names) {
-    const line = lines.find(([, listedName]) => listedName === name);
-    if (line) return line[0];
-  }
-  return void 0;
-}
-function head(directory) {
-  try {
-    return git(["rev-parse", "HEAD"], directory).trim() || null;
-  } catch {
-    return null;
-  }
-}
-function repositoryRoot(directory) {
-  let at = path8.resolve(directory);
-  for (; ; ) {
-    if (fs6.existsSync(path8.join(at, ".git"))) return at;
-    const up = path8.dirname(at);
-    if (up === at) return null;
-    at = up;
+    if (!fs6.existsSync(at) || fs6.readdirSync(at).length > 0) return;
+    fs6.rmdirSync(at);
+    at = path9.dirname(at);
   }
 }
 
@@ -8062,7 +8357,11 @@ var GENERIC_ALIASES = /* @__PURE__ */ new Map([
   ["HashMap", { form: "map", arity: 2 }],
   ["Option", { form: "optional", arity: 1 }],
   ["Optional", { form: "optional", arity: 1 }],
-  ["Promise", { form: "async", arity: 1 }]
+  ["Promise", { form: "async", arity: 1 }],
+  // The success-or-failure type the mainstream languages with typed failures
+  // share (Rust, Swift, Kotlin, F#); Rust's spelling is its alias.
+  ["result", { form: "result", arity: 2 }],
+  ["Result", { form: "result", arity: 2 }]
 ]);
 var NOT_NEUTRAL = /* @__PURE__ */ new Map([
   ["uuid", "a named value-object holding a string (e.g. order_id)"],
@@ -8071,7 +8370,6 @@ var NOT_NEUTRAL = /* @__PURE__ */ new Map([
   ["byte", "int, or bytes for binary data"],
   ["time", "datetime for an instant, or duration for an elapsed time"],
   ["tuple", "a named value-object"],
-  ["result", "the success type as the returns (failures as findings or throws), or a named value-object"],
   ["error", "a named value-object"],
   ["never", "void"],
   ["box", "the inner type (ownership is an implementation detail)"],
@@ -8266,9 +8564,9 @@ var RawParser = class {
     }
     name += this.ident();
     while (this.isP("::") || this.isP(".")) {
-      const sep14 = this.peek().v;
+      const sep15 = this.peek().v;
       this.at++;
-      name += sep14 + this.ident();
+      name += sep15 + this.ident();
     }
     if (!this.isP("<")) return { k: "name", name };
     this.at++;
@@ -8295,6 +8593,10 @@ var RawParser = class {
     const close2 = this.closingParen();
     const after = close2 === -1 ? void 0 : this.tokens[close2 + 1];
     if (!after || after.t !== "p" || after.v !== "=>") {
+      if (this.isP(")", 1)) {
+        this.at += 2;
+        return { k: "name", name: "void" };
+      }
       this.expect("(");
       const inner2 = this.type();
       this.expect(")");
@@ -8403,7 +8705,7 @@ function optionalOf(inner2) {
   return { form: "optional", args: [inner2] };
 }
 function inner(ctx) {
-  return { ...ctx, top: false, voidAllowed: false, omittable: false };
+  return { ...ctx, top: false, voidAllowed: false, resultAllowed: false, omittable: false };
 }
 function normalise(node, ctx, notes) {
   switch (node.k) {
@@ -8437,9 +8739,21 @@ function asyncOf(innerNode, ctx, notes, spelled) {
   if (!ctx.top || !RETURNS_POSITIONS.has(ctx.position)) {
     throw new TypeProblemError("TYPE_POSITION_INVALID", `${spelled} may stand only at the top of a returns, not in a ${ctx.position}`);
   }
-  const read2 = normalise(innerNode, { ...inner(ctx), voidAllowed: true }, notes);
+  const read2 = normalise(innerNode, { ...inner(ctx), voidAllowed: true, resultAllowed: true }, notes);
   return { form: "async", args: [read2] };
 }
+function resultOf(args, ctx, notes, spelled) {
+  if (!ctx.resultAllowed) {
+    throw new TypeProblemError(
+      "TYPE_POSITION_INVALID",
+      `${spelled} may stand only as a whole returns (or under its async), not in a ${ctx.top ? ctx.position : "collection, union, optional or argument"}`,
+      "the success type here (a failure belongs to a method's returns)"
+    );
+  }
+  const ok = normalise(args[0], { ...inner(ctx), voidAllowed: true }, notes);
+  const err = normalise(args[1], inner(ctx), notes);
+  return { form: "result", args: [ok, err] };
+}
 function bareName(name, ctx, notes) {
   const lower = name.toLowerCase();
   if (NONES.has(name)) {
@@ -8477,6 +8791,7 @@ function appliedName(name, args, ctx, notes) {
       throw new TypeProblemError("TYPE_EXPRESSION_INVALID", `"${name}" takes ${alias.arity} type argument${alias.arity === 1 ? "" : "s"}, ${args.length} given`);
     }
     if (alias.form === "async") return asyncOf(args[0], ctx, notes, `${name}<...>`);
+    if (alias.form === "result") return resultOf(args, ctx, notes, `${name}<...>`);
     if (alias.form === "optional") return optionalOf(normalise(args[0], inner(ctx), notes));
     const read2 = args.map((a) => normalise(a, inner(ctx), notes));
     if (alias.form === "map") assertMapKey(read2[0], args[0]);
@@ -8550,6 +8865,8 @@ function canonicalTypeText(expr) {
       return `${expr.form}<${canonicalTypeText(expr.args[0])}>`;
     case "map":
       return `map<${canonicalTypeText(expr.args[0])}, ${canonicalTypeText(expr.args[1])}>`;
+    case "result":
+      return `result<${canonicalTypeText(expr.args[0])}, ${canonicalTypeText(expr.args[1])}>`;
     case "optional": {
       const innerText = canonicalTypeText(expr.args[0]);
       return expr.args[0].form === "union" ? `(${innerText})?` : `${innerText}?`;
@@ -8569,11 +8886,12 @@ function typeNamedRefs(expr) {
 }
 function typeIsMany(expr) {
   if (expr.form === "list" || expr.form === "set" || expr.form === "map") return true;
-  if (expr.form === "optional" || expr.form === "async") return typeIsMany(expr.args[0]);
+  if (expr.form === "optional" || expr.form === "async" || expr.form === "result") return typeIsMany(expr.args[0]);
   return false;
 }
 function contextFor(position, omittable2, looseNumber = false) {
-  return { position, top: true, voidAllowed: RETURNS_POSITIONS.has(position), omittable: omittable2, looseNumber };
+  const returns = RETURNS_POSITIONS.has(position);
+  return { position, top: true, voidAllowed: returns, resultAllowed: returns, omittable: omittable2, looseNumber };
 }
 function parseTypePosition(text3, position, omittable2 = false) {
   let raw;
@@ -8764,6 +9082,47 @@ function typeProblemIntProposal(problem) {
   if (!parse.expression || parse.problem) return null;
   return { specId: problem.specId, kind: problem.kind, path: problem.path, written: problem.written, stored: parse.canonical };
 }
+function stringLiteralValue(text3) {
+  const quote = text3[0];
+  if (quote !== "'" && quote !== '"' && quote !== "`" || text3[text3.length - 1] !== quote) return null;
+  return text3.slice(1, -1).replace(/\\(.)/g, "$1");
+}
+function kebabOf(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[\s_.]+/g, "-").toLowerCase();
+}
+function typeProblemEnumProposal(problem) {
+  if (problem.code !== "TYPE_FORM_UNSUPPORTED") return null;
+  if (problem.specId === void 0 || problem.kind === void 0 || problem.path === void 0) return null;
+  let raw;
+  try {
+    raw = readRaw(problem.written);
+  } catch (e) {
+    if (e instanceof TypeSyntaxError) return null;
+    throw e;
+  }
+  const members = raw.k === "union" ? raw.members : [raw];
+  const values = [];
+  let optional = false;
+  for (const member of members) {
+    if (member.k === "name" && member.args === void 0 && NONES.has(member.name)) {
+      optional = true;
+      continue;
+    }
+    const value = member.k === "literal" ? stringLiteralValue(member.text) : null;
+    if (value === null) return null;
+    if (!values.includes(value)) values.push(value);
+  }
+  if (values.length === 0) return null;
+  return {
+    specId: problem.specId,
+    kind: problem.kind,
+    path: problem.path,
+    written: problem.written,
+    enumId: kebabOf(positionNameOf(problem.path)),
+    values,
+    optional
+  };
+}
 function emptyTypeSpellingFacts() {
   return { respellings: [], problems: [] };
 }
@@ -8814,7 +9173,7 @@ function extractTypesFromSignature(signature, returns) {
   let sigCleaned = signature.replace(/\/\/.*$/gm, "").replace(/#.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
   sigCleaned = sigCleaned.replace(/(?<=\S)\s*\([^)]*\)\s*$/, "");
   sigCleaned = sigCleaned.replace(/(?<=\S)\s+[-—:]\s+[a-z\s_-]+$/, "");
-  const returnsCleaned = returns.replace(/\/\/.*$/gm, "").replace(/#.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/[a-zA-Z0-9_-]+\s*\??\s*:/g, "");
+  const returnsCleaned = returns.replace(/\/\/.*$/gm, "").replace(/#.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/(?<![:\w-])[a-zA-Z0-9_-]+\s*\??\s*:(?!:)/g, "");
   types.push(...extractTypeIdentifiers(returnsCleaned));
   const openParen = sigCleaned.indexOf("(");
   const closeParen = sigCleaned.lastIndexOf(")");
@@ -8845,7 +9204,7 @@ function extractTypesFromSignature(signature, returns) {
       const colonIndex = param.indexOf(":");
       if (colonIndex !== -1) {
         const paramType = param.slice(colonIndex + 1).trim();
-        const paramTypeCleaned = paramType.replace(/[a-zA-Z0-9_-]+\s*\??\s*:/g, "");
+        const paramTypeCleaned = paramType.replace(/(?<![:\w-])[a-zA-Z0-9_-]+\s*\??\s*:(?!:)/g, "");
         types.push(...extractTypeIdentifiers(paramTypeCleaned));
       }
     }
@@ -8914,6 +9273,7 @@ function lastSegment(name) {
   return name.split(/::|\./).filter(Boolean).pop() ?? name;
 }
 function sameType(code, spec, codeNames) {
+  if (spec.form === "result" && code.form !== "result") return sameType(code, spec.args[0], codeNames);
   if (code.form === "primitive" && code.name === "number") return spec.form === "primitive" && (spec.name === "int" || spec.name === "float");
   if (code.form === "named" && (spec.form === "named" || spec.form === "applied")) {
     if (spec.form === "applied") return false;
@@ -8950,6 +9310,8 @@ function writeTypeScript(expr) {
       return expr.args.map(writeTypeScript).join(" | ");
     case "async":
       return `Promise<${writeTypeScript(expr.args[0])}>`;
+    case "result":
+      return writeTypeScript(expr.args[0]);
     case "applied":
       return `${expr.name}<${expr.args.map(writeTypeScript).join(", ")}>`;
   }
@@ -8992,6 +9354,7 @@ var typescriptDialect = {
       "T? \u2192 T | null",
       "A | B \u2192 A | B",
       "async T \u2192 Promise<T>",
+      "result<T, E> \u2192 T, throwing E on failure (result<void, E> \u2192 void)",
       "an enum E \u2192 type E = 'a' | 'b' (a string-literal union alias)",
       "a named scalar E holding P \u2192 type E = P (an alias of the primitive)"
     ];
@@ -9266,7 +9629,7 @@ function jumpFieldsOf(s) {
 }
 
 // src/models/code-model.ts
-var path9 = __toESM(require("path"));
+var path10 = __toESM(require("path"));
 function pathKey(sourcePath) {
   return sourcePath.replace(/\\/g, "/").replace(/^\.\//, "");
 }
@@ -9290,6 +9653,12 @@ function fieldTypesOf(facts, field) {
 function localTypesOf(facts, name) {
   return ownEntry(facts.localTypes, name) ?? NO_DECLARED_TYPES;
 }
+function memberTypesOf(facts, shape, property) {
+  return ownEntry(facts.memberTypes, `${shape}.${property}`) ?? NO_DECLARED_TYPES;
+}
+function aliasTargetOf(facts, name) {
+  return ownEntry(facts.aliasTargets, name);
+}
 function typeBindingOf(facts, name) {
   return ownEntry(facts.typeOnlyBindings, name) ?? ownEntry(facts.importBindings, name)?.from;
 }
@@ -9340,7 +9709,7 @@ var EXTENSION_LANGUAGE = {
   ".swift": "swift"
 };
 function languageOfSourcePath(sourcePath) {
-  return EXTENSION_LANGUAGE[path9.extname(sourcePath).toLowerCase()];
+  return EXTENSION_LANGUAGE[path10.extname(sourcePath).toLowerCase()];
 }
 function dialectOf(facts) {
   return facts.language ? typeDialectFor(facts.language) : null;
@@ -9353,7 +9722,7 @@ function resolveImport(fromFile, specifier, knownPaths, packages) {
     const mapped = ownEntry(packages, specifier);
     return mapped !== void 0 && knownPaths.has(mapped) ? mapped : void 0;
   }
-  const joined = pathKey(path9.posix.normalize(path9.posix.join(path9.posix.dirname(fromFile), specifier)));
+  const joined = pathKey(path10.posix.normalize(path10.posix.join(path10.posix.dirname(fromFile), specifier)));
   const candidates = [
     joined,
     joined.replace(/\.js$/, ".ts"),
@@ -9500,7 +9869,7 @@ function exportTargetKey(e) {
 }
 
 // src/models/project-family.ts
-var path10 = __toESM(require("path"));
+var path11 = __toESM(require("path"));
 function walkMemberPath(byKey3, start, segments) {
   let node = start;
   for (const segment of segments.slice(0, -1)) {
@@ -9562,15 +9931,15 @@ function keyIn(project, localId) {
   return project ? `${project}::${localId}` : localId;
 }
 function approvalKeyIn(file, root, parts) {
-  const resolved = path10.resolve(file);
+  const resolved = path11.resolve(file);
   for (const part of parts) {
     if (part.directory === void 0) continue;
-    const rel2 = path10.relative(part.directory, resolved);
-    if (rel2 !== "" && !rel2.startsWith("..") && !path10.isAbsolute(rel2)) {
-      return `members/${part.alias}/${rel2.split(path10.sep).join("/")}`;
+    const rel2 = path11.relative(part.directory, resolved);
+    if (rel2 !== "" && !rel2.startsWith("..") && !path11.isAbsolute(rel2)) {
+      return `members/${part.alias}/${rel2.split(path11.sep).join("/")}`;
     }
   }
-  return path10.relative(root, resolved).split(path10.sep).join("/");
+  return path11.relative(root, resolved).split(path11.sep).join("/");
 }
 function familyNode(family, namespace) {
   return family.nodes.find((n) => n.namespace === namespace) ?? null;
@@ -9703,7 +10072,7 @@ var DesignDependencyRoleSchema = import_zod9.z.enum(DESIGN_DEPENDENCY_ROLES);
 var ExtSchema = import_zod9.z.record(import_zod9.z.unknown());
 var TypeExpressionSchema = import_zod9.z.lazy(
   () => import_zod9.z.object({
-    form: import_zod9.z.enum(["primitive", "named", "list", "set", "map", "optional", "union", "async", "applied"]),
+    form: import_zod9.z.enum(["primitive", "named", "list", "set", "map", "optional", "union", "async", "applied", "result"]),
     name: import_zod9.z.string().optional(),
     args: import_zod9.z.array(TypeExpressionSchema)
   }).passthrough()
@@ -9940,7 +10309,7 @@ function resolveNarrativeLabels(methodName, steps) {
 
 // src/core/canvas.ts
 var fs7 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var path12 = __toESM(require("path"));
 
 // src/core/canvas-layout.ts
 function computeLayout(model, collapsed) {
@@ -10711,9 +11080,9 @@ function embedJson(value) {
 }
 function loadCytoscapeLib() {
   const candidates = [
-    path11.resolve(__dirname, "..", "templates", "canvas", "cytoscape.min.js"),
+    path12.resolve(__dirname, "..", "templates", "canvas", "cytoscape.min.js"),
     // src/core & dist/cli
-    path11.resolve(__dirname, "templates", "canvas", "cytoscape.min.js")
+    path12.resolve(__dirname, "templates", "canvas", "cytoscape.min.js")
     // dist (library entry)
   ];
   for (const p of candidates) {
@@ -15096,17 +15465,17 @@ function safeFilenamePart(value) {
 
 // src/core/externals.ts
 var fs8 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var path13 = __toESM(require("path"));
 function lockPath2(root) {
-  return path12.join(root, ".wai", "externals.lock.yaml");
+  return path13.join(root, ".wai", "externals.lock.yaml");
 }
 function snapshotPath(root, alias) {
-  return path12.join(root, ".wai", "externals", `${alias}.yaml`);
+  return path13.join(root, ".wai", "externals", `${alias}.yaml`);
 }
 function writeAtomically(file, text3) {
-  fs8.mkdirSync(path12.dirname(file), { recursive: true });
+  fs8.mkdirSync(path13.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
-  fs8.writeFileSync(tmp, text3);
+  fs8.writeFileSync(tmp, withLineEndings(file, text3));
   fs8.renameSync(tmp, file);
 }
 function sortedLock(lock) {
@@ -15149,7 +15518,7 @@ var externalsFileAdapter = {
     const file = snapshotPath(getProjectRoot(), alias);
     if (!fs8.existsSync(file)) return false;
     fs8.unlinkSync(file);
-    const dir = path12.dirname(file);
+    const dir = path13.dirname(file);
     if (fs8.existsSync(dir) && fs8.readdirSync(dir).length === 0) fs8.rmdirSync(dir);
     return true;
   },
@@ -15233,7 +15602,7 @@ function unpin(alias) {
 }
 
 // src/core/openapi.ts
-var yaml2 = __toESM(require("js-yaml"));
+var yaml3 = __toESM(require("js-yaml"));
 var PRIMITIVE_SCHEMAS = {
   string: { type: "string" },
   int: { type: "integer" },
@@ -15282,6 +15651,8 @@ function schemaOfExpression(expr, closureIds) {
       return { oneOf: expr.args.map((member) => schemaOfExpression(member, closureIds)) };
     case "async":
       return schemaOfExpression(expr.args[0], closureIds);
+    case "result":
+      return schemaOfExpression(expr.args[0], closureIds);
   }
 }
 function schemaFor(typeRef2, closureIds) {
@@ -15291,7 +15662,8 @@ function schemaFor(typeRef2, closureIds) {
 }
 function returnsNothing(returns) {
   const expr = expressionOf(returns);
-  const inner2 = expr?.form === "async" ? expr.args[0] : expr;
+  const awaited = expr?.form === "async" ? expr.args[0] : expr;
+  const inner2 = awaited?.form === "result" ? awaited.args[0] : awaited;
   return inner2?.form === "primitive" && inner2.name === "void";
 }
 function enumDescription(values) {
@@ -15515,7 +15887,7 @@ function toOpenApiSet(snapshot) {
 }
 function isOpenApiDocument(body) {
   try {
-    const parsed = yaml2.load(body);
+    const parsed = yaml3.load(body);
     return !!parsed && typeof parsed === "object" && typeof parsed.openapi === "string";
   } catch {
     return false;
@@ -15626,7 +15998,7 @@ function authFromSecurityScheme(scheme) {
 function fromOpenApi(document, projectName) {
   let parsed;
   try {
-    parsed = yaml2.load(document);
+    parsed = yaml3.load(document);
   } catch (e) {
     throw new Error(`Invalid surface document: not parseable as JSON/YAML (${e instanceof Error ? e.message : String(e)})`);
   }
@@ -15743,61 +16115,6 @@ function fromOpenApi(document, projectName) {
   });
 }
 
-// src/config/defaults.ts
-var os2 = __toESM(require("os"));
-var path13 = __toESM(require("path"));
-var DEFAULT_TARGET_DIRS = {
-  claude: ".claude/agents",
-  gemini: ".gemini/agents",
-  agy: ".gemini/agents",
-  cursor: ".cursor/rules",
-  copilot: ".github/prompts",
-  codex: ".codex/agents"
-};
-function defaultTargetConfig(type) {
-  return {
-    type,
-    outputDir: DEFAULT_TARGET_DIRS[type],
-    enabled: true
-  };
-}
-var WAIRON_VERSION = "5.1.1-dev.101";
-var GITHUB_REPO = "SYW-Apps/Waffle-AIron";
-var ARCHITECT_AGENT_ID = "agent-architect";
-var ARCHITECT_TEMPLATE_ID = "architect";
-function globalTemplatesDir(projectOverride) {
-  if (process.env.WAIRON_TEMPLATES_DIR) {
-    return process.env.WAIRON_TEMPLATES_DIR;
-  }
-  if (projectOverride) {
-    return projectOverride;
-  }
-  return path13.join(os2.homedir(), ".wairon", "templates");
-}
-var BACKEND_COMMANDS = {
-  claude: "claude",
-  gemini: "gemini"
-};
-function backendCommand(backend) {
-  return BACKEND_COMMANDS[backend] ?? backend;
-}
-var SUPPORTED_ALIASES = ["wai"];
-var SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  "dist",
-  "build",
-  "out",
-  ".git",
-  ".cache",
-  "coverage",
-  "__pycache__",
-  ".venv",
-  "venv",
-  "target",
-  // Rust
-  "vendor"
-]);
-
 // src/core/design-export.ts
 var NoSystemSpecError = class extends Error {
   constructor() {
@@ -16511,7 +16828,9 @@ function writeSurfaceFile(targetPath, snapshot, renderedSet) {
   const resolved = path14.resolve(targetPath);
   fs9.mkdirSync(path14.dirname(resolved), { recursive: true });
   if (!renderedSet || renderedSet.length === 0) {
-    writeYamlFile(resolved, snapshot);
+    if (path14.extname(resolved).toLowerCase() === ".json") fs9.writeFileSync(resolved, `${JSON.stringify(snapshot, null, 2)}
+`);
+    else writeYamlFile(resolved, snapshot);
     return [resolved];
   }
   if (renderedSet.length === 1) {
@@ -17292,7 +17611,7 @@ function approvalFinding(entry, config) {
     return finding(
       config,
       "MEMBER_DRIFTED",
-      `The member ${named(entry.key)} was approved under an earlier gate identity \u2014 the gate identity gained inputs in stage 5 (members' composition subjects, \`composition\`; code conformance moved beside the claim), which says nothing about its design. Re-lock it once at its own root (\`wairon lock\`).`,
+      `The member ${named(entry.key)} was approved under an earlier gate identity \u2014 the gate identity gained inputs in this release (members' composition subjects, \`composition\`; code conformance moved beside the claim), which says nothing about its design. Re-lock it once at its own root (\`wairon lock\`).`,
       entry.key
     );
   }
@@ -18298,6 +18617,16 @@ function verifyIntegrity(selection, packDir, where) {
     message: `Pack "${wanted}" resolved to content that does not match the pinned integrity: expected ${selection.integrity}, found ${actual} (${where}). The pack was modified after it was pinned \u2014 reinstall or re-bundle the pinned version, or update the pin with \`wairon pack use ${selection.name} --pin\` if the change is intended.`
   };
 }
+function bundlesSingleFile(bundleDir, storePath) {
+  try {
+    if (!fs12.statSync(storePath).isFile()) return false;
+    const entry = packDirEntry(bundleDir);
+    if (!entry || fs12.readdirSync(bundleDir).length !== 1) return false;
+    return fs12.readFileSync(entry).equals(fs12.readFileSync(storePath));
+  } catch {
+    return false;
+  }
+}
 function detectBundleStoreDrift(selection, bundleDir) {
   const bundledVersion = path17.basename(bundleDir);
   const installed = resolveInstalledPack(selection.name, bundledVersion);
@@ -18305,6 +18634,7 @@ function detectBundleStoreDrift(selection, bundleDir) {
   const bundleDigest = computePackDigest(bundleDir);
   const storeDigest = computePackDigest(installed.path);
   if (bundleDigest === storeDigest) return void 0;
+  if (bundlesSingleFile(bundleDir, installed.path)) return void 0;
   return {
     code: "PACK_STORE_DRIFT",
     severity: "warning",
@@ -18437,17 +18767,47 @@ function buildCodeIndex(model) {
   };
   const possibleOriginsOf = (site, from) => {
     const proven = originOf2(site, from);
-    if (!site.field && !site.constructed && !site.via && !site.returnedBy && !site.enclosingClass) return proven;
+    if (!site.field && !site.constructed && !site.via && !site.returnedBy && !site.enclosingClass && !site.receiverPath) {
+      return proven;
+    }
     const resolved = scopeOf2(site, from);
     if (!resolved) return proven;
     const { path: scope, facts: f } = resolved;
     const out = new Set(proven);
-    const widenThrough = (name, specifier) => {
-      const landings = specifier !== void 0 ? landingFrom(scope, specifier) : declarationsAt(scope).has(name) ? republishedFrom(scope) : NO_ORIGIN;
+    const widenThroughAt = (at, name, specifier) => {
+      const landings = specifier !== void 0 ? landingFrom(at, specifier) : declarationsAt(at).has(name) ? republishedFrom(at) : NO_ORIGIN;
       for (const candidate of landings) out.add(candidate);
     };
-    const widenThroughType = (typeName) => widenThrough(typeName, typeBindingOf(f, typeName));
+    const widenThrough = (name, specifier) => widenThroughAt(scope, name, specifier);
+    const widenThroughType = (typeName, at = scope, atFacts = f) => {
+      widenThroughAt(at, typeName, typeBindingOf(atFacts, typeName));
+      for (const decl of typeDeclarationsOf(at, atFacts, typeName)) {
+        const target = aliasTargetOf(decl.facts, decl.name);
+        if (target !== void 0) widenThroughAt(decl.path, target, typeBindingOf(decl.facts, target));
+      }
+    };
     if (site.field) for (const typeName of fieldTypesOf(f, site.field)) widenThroughType(typeName);
+    if (site.receiverPath && site.receiverPath.length >= 2) {
+      const [root, ...rest] = site.receiverPath;
+      const links = [...rest];
+      let current2 = [];
+      if (root === "this") {
+        const field = links.shift();
+        if (field !== void 0) current2 = fieldTypesOf(f, field).map((type) => ({ at: scope, facts: f, type }));
+      } else {
+        current2 = localTypesOf(f, root).map((type) => ({ at: scope, facts: f, type }));
+      }
+      for (const link of links) {
+        const next = [];
+        for (const c of current2) {
+          for (const decl of typeDeclarationsOf(c.at, c.facts, c.type, true)) {
+            for (const type of memberTypesOf(decl.facts, decl.name, link)) next.push({ at: decl.path, facts: decl.facts, type });
+          }
+        }
+        current2 = next;
+      }
+      for (const c of current2) widenThroughType(c.type, c.at, c.facts);
+    }
     if (site.constructed) widenThrough(site.constructed, importBindingOf(f, site.constructed)?.from);
     if (site.via) for (const typeName of localTypesOf(f, site.via)) widenThroughType(typeName);
     if (site.enclosingClass !== void 0 && holdsMemberBody(f, site.name, site.enclosingClass)) {
@@ -18469,6 +18829,34 @@ function buildCodeIndex(model) {
     }
     return out;
   };
+  const typeDeclarationsOf = (at, atFacts, typeName, throughAlias2 = false) => {
+    const found = [];
+    const exactFacts = (p) => {
+      const x = facts.get(p);
+      return x?.status === "analyzed" && x.analysisGrade === "exact" ? x : void 0;
+    };
+    const direct = (where, whereFacts, name) => {
+      if (whereFacts.declaredNames.includes(name) && typeBindingOf(whereFacts, name) === void 0) {
+        return [{ path: where, facts: whereFacts, name }];
+      }
+      const specifier = typeBindingOf(whereFacts, name);
+      if (specifier === void 0) return [];
+      const published = importBindingOf(whereFacts, name)?.imported ?? name;
+      const out = [];
+      for (const candidate of landingFrom(where, specifier)) {
+        const there = exactFacts(candidate);
+        if (there && there.declaredNames.includes(published)) out.push({ path: candidate, facts: there, name: published });
+      }
+      return out;
+    };
+    for (const decl of direct(at, atFacts, typeName)) {
+      found.push(decl);
+      if (!throughAlias2) continue;
+      const target = aliasTargetOf(decl.facts, decl.name);
+      if (target !== void 0) found.push(...direct(decl.path, decl.facts, target));
+    }
+    return found;
+  };
   const holdsMemberBody = (f, name, container) => f.status === "analyzed" && f.analysisGrade === "exact" && !!f.functionBodies && Object.prototype.hasOwnProperty.call(f.functionBodies, name) && f.functionBodies[name].some((b) => b.container === container);
   const declarationsAt = (path49) => namesAt(declarations, pathKey(path49), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames]));
   const forwardsOf = (start, name, container) => {
@@ -18863,7 +19251,7 @@ var localIdsRule = {
 var projectIdentityRule = {
   name: "project-identity",
   judges: "design",
-  description: "The bound project is keyed on its id, so the id must be declared, well-formed, stable and its own: a project that declares none answers to its display name slugified until it writes one (PROJECT_ID_DEFAULTED), a project whose name yields no id or whose declared id breaks the grammar has nothing reliable to key on (PROJECT_ID_AMBIGUOUS), an id the rename migration moved from the one the lock approved is owed a re-lock and nothing more (PROJECT_ID_RENAMED: the approved id is one of the configuration's previousIds), and any other id that differs from the one the lock approved has moved under everything that keyed on it (PROJECT_ID_CHANGED). It judges the bound project's own identity only. The family half \u2014 a member with a defaulted id (named with its alias as the id to declare), a member with no id, and two members resolving to one id \u2014 is a family check since stage 4 (family_validator.checkMembers), which reads the family root's graph.",
+  description: "The bound project is keyed on its id, so the id must be declared, well-formed, stable and its own: a project that declares none answers to its display name slugified until it writes one (PROJECT_ID_DEFAULTED), a project whose name yields no id or whose declared id breaks the grammar has nothing reliable to key on (PROJECT_ID_AMBIGUOUS), an id the rename migration moved from the one the lock approved is owed a re-lock and nothing more (PROJECT_ID_RENAMED: the approved id is one of the configuration's previousIds), and any other id that differs from the one the lock approved has moved under everything that keyed on it (PROJECT_ID_CHANGED). It judges the bound project's own identity only. The family half \u2014 a member with a defaulted id (named with its alias as the id to declare), a member with no id, and two members resolving to one id \u2014 is a family check (family_validator.checkMembers), which reads the family root's graph.",
   codes: [
     { code: "PROJECT_ID_AMBIGUOUS", defaultSeverity: "warning", summary: "Project has no usable id: its name yields no slug, or its declared id breaks the grammar" },
     { code: "PROJECT_ID_CHANGED", defaultSeverity: "error", summary: "Project id differs from the id the lock approved" },
@@ -18881,7 +19269,7 @@ function judgeOwnIdentity(ctx, identity2) {
     ctx.addIssue(
       "notice",
       "PROJECT_ID_DEFAULTED",
-      `Project "${identity2.name}" declares no id in .wai/project.yaml, so it answers to "${identity2.id}", derived from its display name \u2014 renaming the project would move it. No save writes it for you; declare it with \`id: ${identity2.id}\` (stage 3 requires an explicit id).`
+      `Project "${identity2.name}" declares no id in .wai/project.yaml, so it answers to "${identity2.id}", derived from its display name \u2014 renaming the project would move it. No save writes it for you; declare it with \`id: ${identity2.id}\` (a project is keyed on an explicit id).`
     );
   }
   const ambiguous = problem("ambiguous");
@@ -18978,10 +19366,11 @@ var fieldTypeReferencesRule = {
         for (const ref of refs) {
           if (!ctx.isTypeResolved(ref, /* @__PURE__ */ new Set())) {
             const hint = ctx.importHint(ref);
+            const spelled = ctx.aliasSpelling(ref);
             ctx.addIssue(
               "error",
               "UNDEFINED_TYPE_REFERENCE",
-              `Type "${t.id}" field "${field.name}" references undefined type "${ref}" in "${field.type}".${hint ? ` A declared dependency exports it without this project importing it \u2014 add \`${hint}\`.` : ""}`,
+              `Type "${t.id}" field "${field.name}" references undefined type "${ref}" in "${field.type}".${hint ? ` A declared dependency exports it without this project importing it \u2014 add \`${hint}\`.` : ""}${spelled ? ` "${ref.split(".")[0]}" is another project here, not a subsystem of this one \u2014 write \`${spelled}\`.` : ""}`,
               t.id,
               isDraftCtx
             );
@@ -19016,10 +19405,11 @@ var signatureTypeReferencesRule = {
         for (const ref of refs) {
           if (!ctx.isTypeResolved(ref, allGenerics)) {
             const hint = ctx.importHint(ref);
+            const spelled = ctx.aliasSpelling(ref);
             ctx.addIssue(
               "error",
               "UNDEFINED_TYPE_REFERENCE",
-              `Method "${m.name}" on interface "${intf.id}" references undefined type "${ref}" in signature.${hint ? ` A declared dependency exports it without this project importing it \u2014 add \`${hint}\`.` : ""}`,
+              `Method "${m.name}" on interface "${intf.id}" references undefined type "${ref}" in signature.${hint ? ` A declared dependency exports it without this project importing it \u2014 add \`${hint}\`.` : ""}${spelled ? ` "${ref.split(".")[0]}" is another project here, not a subsystem of this one \u2014 write \`${spelled}\`.` : ""}`,
               intf.id,
               isDraftCtx
             );
@@ -19038,10 +19428,11 @@ var signatureTypeReferencesRule = {
       for (const { ref, by } of named2) {
         if (ctx.isTypeResolved(ref, typeGenerics)) continue;
         const hint = ctx.importHint(ref);
+        const spelled = ctx.aliasSpelling(ref);
         ctx.addIssue(
           "error",
           "UNDEFINED_TYPE_REFERENCE",
-          `${by} references undefined type "${ref}" in signature.${hint ? ` A declared dependency exports it without this project importing it \u2014 add \`${hint}\`.` : ""}`,
+          `${by} references undefined type "${ref}" in signature.${hint ? ` A declared dependency exports it without this project importing it \u2014 add \`${hint}\`.` : ""}${spelled ? ` "${ref.split(".")[0]}" is another project here, not a subsystem of this one \u2014 write \`${spelled}\`.` : ""}`,
           t.id,
           isDraftCtx
         );
@@ -19270,10 +19661,10 @@ function problemMessage(problem, specId) {
 var typeExpressionsRule = {
   name: "type-expressions",
   judges: "design",
-  description: "Reports what the scan's type canonicalisation recorded (ctx.typeSpellingFacts), one finding per position, located by spec and path: a stored text that does not parse (TYPE_EXPRESSION_INVALID); one that breaks a position rule \u2014 void or async out of place, a map key that is not string, int or an enum, a named scalar's holds that is not one primitive other than void and any, `T??` (TYPE_POSITION_INVALID); one using a form the grammar leaves out \u2014 an inline object shape, an inline function type, a string-literal union, a union mixing in a primitive or a collection, an intersection, a utility type or a tuple (TYPE_FORM_UNSUPPORTED); one naming `number` or a legacy builtin with no neutral meaning (TYPE_NOT_NEUTRAL); and one that is an alias of its canonical spelling (TYPE_SPELLING_STALE, which any save or doctor --fix repairs). Every message names the replacement: `number` asks \"int or float?\" (and says when the doctor repair proposes int), a function type names a signature type, a literal union an enum, an inline object or a mixed union a named value-object. The writer refuses all but the stale spelling at write time; these findings are how a tree that held them before the grammar existed is told, while it still loads and its consumers read the position as opaque any \u2014 which is why only what no real tree holds (a text that does not parse, a broken position rule) is an error. No finding when the run carries no facts (a candidate run).",
+  description: "Reports what the scan's type canonicalisation recorded (ctx.typeSpellingFacts), one finding per position, located by spec and path: a stored text that does not parse (TYPE_EXPRESSION_INVALID); one that breaks a position rule \u2014 void, async or result out of place, a map key that is not string, int or an enum, a named scalar's holds that is not one primitive other than void and any, `T??` (TYPE_POSITION_INVALID); one using a form the grammar leaves out \u2014 an inline object shape, an inline function type, a string-literal union, a union mixing in a primitive or a collection, an intersection, a utility type or a tuple (TYPE_FORM_UNSUPPORTED); one naming `number` or a legacy builtin with no neutral meaning (TYPE_NOT_NEUTRAL); and one that is an alias of its canonical spelling (TYPE_SPELLING_STALE, which any save or doctor --fix repairs). Every message names the replacement: `number` asks \"int or float?\" (and says when the doctor repair proposes int), a function type names a signature type, a literal union an enum (which the doctor repair proposes), an inline object or a mixed union a named value-object. The writer refuses all but the stale spelling at write time; on load every one of them is a warning \u2014 these findings are how a tree that held them before the grammar existed is told, while it still loads, stays lockable with its debt in view, and its consumers read the position as opaque any, which never invents a shape. No finding when the run carries no facts (a candidate run).",
   codes: [
-    { code: "TYPE_EXPRESSION_INVALID", defaultSeverity: "error", summary: "A structured type position does not parse under the type grammar" },
-    { code: "TYPE_POSITION_INVALID", defaultSeverity: "error", summary: "A type position breaks a position rule: void or async out of place, a non-scalar map key, or T??" },
+    { code: "TYPE_EXPRESSION_INVALID", defaultSeverity: "warning", summary: "A structured type position does not parse under the type grammar" },
+    { code: "TYPE_POSITION_INVALID", defaultSeverity: "warning", summary: "A type position breaks a position rule: void, async or result out of place, a non-scalar map key, or T??" },
     { code: "TYPE_FORM_UNSUPPORTED", defaultSeverity: "warning", summary: "A type position uses a form the grammar leaves out \u2014 inline object, inline function type, string-literal union, union mixing in a primitive or collection, intersection, utility type or tuple \u2014 and the message names its named replacement" },
     { code: "TYPE_NOT_NEUTRAL", defaultSeverity: "warning", summary: "A type position names number (int or float?) or a legacy builtin with no neutral meaning, and the message names the replacement" },
     { code: "TYPE_SPELLING_STALE", defaultSeverity: "warning", summary: "A stored type position is an alias of its canonical spelling; any save or doctor --fix rewrites it" }
@@ -19283,9 +19674,8 @@ var typeExpressionsRule = {
     if (!facts) return;
     for (const problem of facts.problems) {
       if (problem.specId === void 0 || !ctx.isSpecInScope(problem.specId)) continue;
-      const severity = problem.code === "TYPE_EXPRESSION_INVALID" || problem.code === "TYPE_POSITION_INVALID" ? "error" : "warning";
       ctx.addIssue(
-        severity,
+        "warning",
         problem.code,
         problemMessage(problem, problem.specId),
         problem.specId,
@@ -19619,7 +20009,7 @@ var publicSurfaceBoundContractRule = {
 var exportTablesRule = {
   name: "export-tables",
   judges: "design",
-  description: "Every level's export table must resolve the way a module resolver resolves `export \u2026 from`: one public name binds one target (EXPORT_ID_DUPLICATE when two wildcards \u2014 or two explicit entries \u2014 bind a name to different targets, or two public names share one nameKey, since a bare import could not tell them apart; the name is left out), no chain leads back to itself (EXPORT_CYCLE \u2014 an error for a named chain that never reaches a component or type, a warning for a wildcard cycle, which resolves to its union), every entry names a source and an item that exist, that the source exports and, for an own type, that the level owns \u2014 a subsystem-owned type at L1, a project-level type (no subsystem) for an L0 `{ typeDef }` without `from` \u2014 under a public name of [a-z0-9-_]+ (EXPORT_INVALID), every re-exported component can serve a boundary caller \u2014 a Portal, a gateway being a Portal variant, or an Observer for events (EXPORT_UNCONSUMABLE, at L0 and for L1 re-exports; an error since stage 4), and an L0 entry that re-exports a member's or an external's export never declares a wider audience than that export has (EXPORT_WIDENS_AUDIENCE): a re-export can narrow reach, never widen it. The rule judges the facts the export resolver recorded in the scan \u2014 for the bound root's table and every contained member's \u2014 and resolves nothing itself.",
+  description: "Every level's export table must resolve the way a module resolver resolves `export \u2026 from`: one public name binds one target (EXPORT_ID_DUPLICATE when two wildcards \u2014 or two explicit entries \u2014 bind a name to different targets, or two public names share one nameKey, since a bare import could not tell them apart; the name is left out), no chain leads back to itself (EXPORT_CYCLE \u2014 an error for a named chain that never reaches a component or type, a warning for a wildcard cycle, which resolves to its union), every entry names a source and an item that exist, that the source exports and, for an own type, that the level owns \u2014 a subsystem-owned type at L1, a project-level type (no subsystem) for an L0 `{ typeDef }` without `from` \u2014 under a public name of [a-z0-9-_]+ (EXPORT_INVALID), every re-exported component can serve a boundary caller \u2014 a Portal, a gateway being a Portal variant, or an Observer for events (EXPORT_UNCONSUMABLE, at L0 and for L1 re-exports), and an L0 entry that re-exports a member's or an external's export never declares a wider audience than that export has (EXPORT_WIDENS_AUDIENCE): a re-export can narrow reach, never widen it. The rule judges the facts the export resolver recorded in the scan \u2014 for the bound root's table and every contained member's \u2014 and resolves nothing itself.",
   codes: [
     { code: "EXPORT_ID_DUPLICATE", defaultSeverity: "error", summary: "One public name bound to different targets by two wildcard re-exports or two explicit entries" },
     { code: "EXPORT_CYCLE", defaultSeverity: "error", summary: "A re-export chain leads back to itself (a warning for a wildcard cycle, which resolves to its union)" },
@@ -19781,7 +20171,7 @@ function whyNoRewrite(ref) {
 var referenceFormsRule = {
   name: "reference-forms",
   judges: "design",
-  description: "A cross-project reference is `alias::name` (or a bare name a `use` imports): the alias is one of the referring project's members or externals, the name a public name of that project's L0 table. The older forms still bind for one release and are reported (DEPRECATED_REFERENCE_FORM), each naming the spec, where in it, the form as written and the text to write instead (the scan's rewrite: a bare local id, or `alias::publicName`): a leading `::`, which escapes to the root of whatever checkout loads it; `super::`, which climbs the containing projects \u2014 a place in one family, not a name; a member path (`desktop::shell` written inside desktop, `waffler_core::transpiler::x` written inside transpiler), a first segment the referring project does not declare, read from the bound root; and a self-prefix \u2014 the referring project's own id as the first segment, with `::` or `.` (`registry.advisory-channel` inside registry), which stage 3's migration did not rewrite and stage 4's positional step does. Wairon's own writer emits none of them. A form with no rewrite (its target is out of reach) is reported with the reason. It reads the project graph's authored references, which the scan records before binding erases the form.",
+  description: "A cross-project reference is `alias::name` (or a bare name a `use` imports): the alias is one of the referring project's members or externals, the name a public name of that project's L0 table. The older forms still bind for one release and are reported (DEPRECATED_REFERENCE_FORM), each naming the spec, where in it, the form as written and the text to write instead (the scan's rewrite: a bare local id, or `alias::publicName`): a leading `::`, which escapes to the root of whatever checkout loads it; `super::`, which climbs the containing projects \u2014 a place in one family, not a name; a member path (`desktop::shell` written inside desktop, `app_core::engine::x` written inside engine), a first segment the referring project does not declare, read from the bound root; and a self-prefix \u2014 the referring project's own id as the first segment, with `::` or `.` (`registry.advisory-channel` inside registry), which `wairon doctor --fix` rewrites to the bare local id. Wairon's own writer emits none of them. A form with no rewrite (its target is out of reach) is reported with the reason. It reads the project graph's authored references, which the scan records before binding erases the form.",
   codes: [
     { code: "DEPRECATED_REFERENCE_FORM", defaultSeverity: "notice", summary: "A reference written with a leading ::, super:: or a member path where a local id or alias::name belongs" }
   ],
@@ -19812,9 +20202,9 @@ function carriedFields(mount) {
 var memberDeclarationsRule = {
   name: "member-declarations",
   judges: "design",
-  description: "A project declares its members in project.yaml `members`, each by one source in one grammar. A deprecated declaration form loads for one release and is reported (DEPRECATED_MOUNT_FORM, notice): the L1 form \u2014 a subsystem carrying projectPath \u2014 naming the mount, its path, the `members` entry that replaces it, and every field it carries that `doctor --fix` will move into the member (or stop on); a mount whose alias `members` also declares is reported as ignored; and (stage 8) the long-form `path` key, naming the `source` (or shorthand) `doctor --fix` rewrites it to. Since stage 8 it also judges what each member of the bound project IS against what is declared or written about it, from the scan's problems at the bound root (a member's own members are that member's gate's): what a member is follows from its content \u2014 an id, an L0 or a lock make it a project, anything else a part \u2014 and every contradiction is ONE finding, MEMBER_KIND_MISMATCH (error), naming the alias and the contradiction: an asserted `as` the content contradicts; a part whose configuration declares project fields (members, externals, rules, extensions, composition, targets) without the id that would make it a project (add the id, or move them to the parent); a non-contained part with no PartOf, or one naming another project (opened alone it could not say what it belongs to); a contained member declaring PartOf; a `use` on a member whose content is a part (its names are already this project's own). A part whose files could not be read \u2014 its directory absent, or its git commit not cached and not fetchable (offline, refused, unknown) \u2014 is PART_UNAVAILABLE (error): the project's own subsystems are missing, so its verdict cannot be a pass. The member findings name no spec: members live in configuration. It reads the project graph's nodes, their legacy mounts, the bound root's declared members and its problems.",
+  description: "A project declares its members in project.yaml `members`, each by one source in one grammar. A deprecated declaration form loads for one release and is reported (DEPRECATED_MOUNT_FORM, notice): the L1 form \u2014 a subsystem carrying projectPath \u2014 naming the mount, its path, the `members` entry that replaces it, and every field it carries that `doctor --fix` will move into the member (or stop on); a mount whose alias `members` also declares is reported as ignored; and the deprecated long-form `path` key, naming the `source` (or shorthand) `doctor --fix` rewrites it to. It also judges what each member of the bound project IS against what is declared or written about it, from the scan's problems at the bound root (a member's own members are that member's gate's): what a member is follows from its content \u2014 an id, an L0 or a lock make it a project, anything else a part \u2014 and every contradiction is ONE finding, MEMBER_KIND_MISMATCH (error), naming the alias and the contradiction: an asserted `as` the content contradicts; a part whose configuration declares project fields (members, externals, rules, extensions, composition, targets) without the id that would make it a project (add the id, or move them to the parent); a non-contained part with no PartOf, or one naming another project (opened alone it could not say what it belongs to); a contained member declaring PartOf; a `use` on a member whose content is a part (its names are already this project's own). A part whose files could not be read \u2014 its directory absent, or its git commit not cached and not fetchable (offline, refused, unknown) \u2014 is PART_UNAVAILABLE (error): the project's own subsystems are missing, so its verdict cannot be a pass. The member findings name no spec: members live in configuration. It reads the project graph's nodes, their legacy mounts, the bound root's declared members and its problems.",
   codes: [
-    { code: "DEPRECATED_MOUNT_FORM", defaultSeverity: "notice", summary: "A member declared in a deprecated form \u2014 an L1 subsystem carrying projectPath, or (stage 8) the long-form `path` key \u2014 which doctor --fix rewrites to a `members` entry with one `source`." },
+    { code: "DEPRECATED_MOUNT_FORM", defaultSeverity: "notice", summary: "A member declared in a deprecated form \u2014 an L1 subsystem carrying projectPath, or the long-form `path` key \u2014 which doctor --fix rewrites to a `members` entry with one `source`." },
     { code: "MEMBER_KIND_MISMATCH", defaultSeverity: "error", summary: "What a member's content makes it (an id, L0 or lock: a project; else a part) contradicts what is declared or written about it: an asserted `as`, project fields in a part, a missing or wrong PartOf, a `use` on a part." },
     { code: "PART_UNAVAILABLE", defaultSeverity: "error", summary: "A part's files could not be read (absent directory, unpinned or unfetchable git commit): the project's own subsystems are missing." }
   ],
@@ -19852,7 +20242,7 @@ var memberDeclarationsRule = {
       ctx.addIssue(
         "notice",
         "DEPRECATED_MOUNT_FORM",
-        `This project declares the member "${member.alias}" with the long-form \`path\` key, which stage 8 replaced by the one location key \`source\`. \`doctor --fix\` rewrites it to ${rest ? `\`source: ${written}\` in its long form` : `the shorthand \`${member.alias}: ${written}\``} \u2014 its meaning unchanged.`
+        `This project declares the member "${member.alias}" with the long-form \`path\` key, which the one location key replaced: \`source\`. \`doctor --fix\` rewrites it to ${rest ? `\`source: ${written}\` in its long form` : `the shorthand \`${member.alias}: ${written}\``} \u2014 its meaning unchanged.`
       );
     }
     for (const problem of family.problems) {
@@ -19889,7 +20279,7 @@ function declaration(producer) {
 var projectBoundariesRule = {
   name: "project-boundaries",
   judges: "design",
-  description: "The one judge of every cross-project reference the bound project writes (decision 9 \u2014 every project is a crate of its own, reached only through its L0 exports and only as a dependency it declared). It reads each of the project's own references from the project graph \u2014 `::` forms and bare names bound through `use` imports alike \u2014 takes its resolution from resolveCrossProject, decided before any severity from the project's own files alone, and reports every outcome but resolved once, carrying the resolution: forbidden is EXTERNAL_UNDECLARED (the reference reaches a project the referrer declares neither as a member nor as an external, or names a first segment that is none of its subsystems, aliases or foreign providers); missing is EXTERNAL_NOT_EXPORTED (the producer's table \u2014 a contained member's live one, or the external's pin \u2014 has no public name covering the referrer, or not the used method, or exports the type only inside a signature's closure); an ambiguous import is IMPORT_AMBIGUOUS (two imports supply one bare name: two explicit `use` names, or two `*` with no explicit one \u2014 name it `alias::name` or narrow a `use`); unavailable is EXTERNAL_CHECK_UNAVAILABLE (no pin, an unreadable pin, a member absent on disk, or a deprecated form naming no alias \u2014 never a pass). A bare name no import supplies is not this rule's: it is the unresolved-reference finding it always was, with rule_context.importHint appended. A trustedLinks entry naming a subsystem of another project (`alias::sub`) is TRUSTED_LINK_CROSSES_PROJECT: a sanctioned fast lane stays inside one project. Stage 4 makes the three stage-2 notices errors now that the owner's gate judges them exactly; a reference is never left to a parent's verdict.",
+  description: "The one judge of every cross-project reference the bound project writes (every project is a crate of its own, reached only through its L0 exports and only as a dependency it declared). It reads each of the project's own references from the project graph \u2014 `::` forms and bare names bound through `use` imports alike \u2014 takes its resolution from resolveCrossProject, decided before any severity from the project's own files alone, and reports every outcome but resolved once, carrying the resolution: forbidden is EXTERNAL_UNDECLARED (the reference reaches a project the referrer declares neither as a member nor as an external, or names a first segment that is none of its subsystems, aliases or foreign providers); missing is EXTERNAL_NOT_EXPORTED (the producer's table \u2014 a contained member's live one, or the external's pin \u2014 has no public name covering the referrer, or not the used method, or exports the type only inside a signature's closure); an ambiguous import is IMPORT_AMBIGUOUS (two imports supply one bare name: two explicit `use` names, or two `*` with no explicit one \u2014 name it `alias::name` or narrow a `use`); unavailable is EXTERNAL_CHECK_UNAVAILABLE (no pin, an unreadable pin, a member absent on disk, or a deprecated form naming no alias \u2014 never a pass). A bare name no import supplies is not this rule's: it is the unresolved-reference finding it always was, with rule_context.importHint appended. A trustedLinks entry naming a subsystem of another project (`alias::sub`) is TRUSTED_LINK_CROSSES_PROJECT: a sanctioned fast lane stays inside one project. An undeclared, unexported or ambiguous reference is an error, since the owner's gate judges it exactly; a reference is never left to a parent's verdict.",
   codes: [
     { code: "EXTERNAL_UNDECLARED", defaultSeverity: "error", summary: "A reference reaches another project the referring project declares neither as a member nor as an external, or names a first segment that is none of its subsystems, aliases or foreign providers" },
     { code: "EXTERNAL_NOT_EXPORTED", defaultSeverity: "error", summary: "A reference reaches another project at anything but a public name, or a member of one, whose audience covers the referrer" },
@@ -22435,7 +22825,7 @@ var reproducibilityRule = {
         ctx.addIssue(
           "warning",
           "PACK_SOURCE_UNFETCHABLE",
-          `Pack selection "${selection.name}" records no source and is not bundled, so a fresh machine or CI runner cannot obtain it \u2014 \`wairon pack sync\` has nothing to fetch. Record a URL (\`wairon pack use ${selection.name} --source <url>\`) or commit a copy (\`wairon pack bundle ${selection.name}\`).`
+          `Pack selection "${selection.name}" records no source and is not bundled, so a fresh machine or CI runner cannot obtain it \u2014 \`wairon pack sync\` has nothing to fetch. Commit a copy the repository carries (\`wairon pack bundle ${selection.name}\`, or \`wairon pack bundle --all\` for every selection), or record a URL \`wairon pack sync\` fetches it from (\`wairon pack use ${selection.name} --source <url>\`). A selection \`wairon doctor --fix\` recorded from a pack installed from a local path has no URL to record: bundle it.`
         );
       }
     }
@@ -23422,10 +23812,22 @@ var invariantBackingRule = {
 };
 
 // src/core/rules/wiring/invariant-references.ts
+function unknownInvariantMessage(where, ref, types, aliases) {
+  const parts = splitInvariantRef(ref);
+  const qualifier = parts ? parts.typeRef.lastIndexOf("::") : -1;
+  if (parts && qualifier > 0) {
+    const bare = `${parts.typeRef.slice(qualifier + 2)}.${parts.invariantId}`;
+    if (resolveInvariantRef(bare, types, aliases)) {
+      const prefix = parts.typeRef.slice(0, qualifier);
+      return `${where} asserts invariant "${ref}", whose qualifier "${prefix}::" names no project this one reaches the type through \u2014 the invariant is declared here, so write "${bare}" (a project's own alias, written from inside it, is not a qualifier it reads as its own; \`wairon doctor --fix\` rewrites it in a migrated family).`;
+    }
+  }
+  return `${where} asserts invariant "${ref}", but no entity declares it (expected "<type-id>.<invariant-id>" naming a declared entry in that entity's invariants).`;
+}
 var invariantReferencesRule = {
   name: "invariant-references",
   judges: "design",
-  description: "Every invariant a narrative step asserts (step.assertsInvariants) must resolve to a declared entity invariant: the reference splits at its last dot into a type reference and an invariant id, and some entity matching that type reference must declare that id. A reference nothing declares is an error \u2014 the step claims a property that exists nowhere.",
+  description: "Every invariant a narrative step asserts (step.assertsInvariants) must resolve to a declared entity invariant: the reference splits at its last dot into a type reference and an invariant id, and some entity matching that type reference must declare that id. A reference nothing declares is an error \u2014 the step claims a property that exists nowhere. The message says which: when the type reference carries a qualifier (`alias::type`) and the bare reference does resolve, the cause is the qualifier \u2014 typically the project's own alias written from inside it \u2014 and the message names it and the bare reference to write instead, never claiming that no entity declares the invariant.",
   codes: [
     { code: "UNKNOWN_INVARIANT_REF", defaultSeverity: "error", summary: "A narrative step asserts an invariant that no entity declares" }
   ],
@@ -23440,7 +23842,7 @@ var invariantReferencesRule = {
             ctx.addIssue(
               "error",
               "UNKNOWN_INVARIANT_REF",
-              `Step ${step.stepNumber} of "${method.name}" in implementation "${impl.id}" asserts invariant "${ref}", but no entity declares it (expected "<type-id>.<invariant-id>" naming a declared entry in that entity's invariants).`,
+              unknownInvariantMessage(`Step ${step.stepNumber} of "${method.name}" in implementation "${impl.id}"`, ref, ctx.types, aliases),
               impl.id,
               isDraftCtx
             );
@@ -23761,19 +24163,40 @@ function closedCallSites(code, file, fn, stopAt, container) {
   return out;
 }
 var anchorKey = (symbol, exportedVia) => exportedVia !== void 0 ? `${exportedVia}.${symbol}` : symbol;
+var bodyKey = (file, symbol, exportedVia) => `${file}|${anchorKey(symbol, exportedVia)}`;
 function resolveCallTarget(ctx, componentId, methodName) {
   const accepted = /* @__PURE__ */ new Set([methodName]);
   const files = /* @__PURE__ */ new Set();
+  const bodies = /* @__PURE__ */ new Set();
+  const anchors = [];
   for (const intf of ctx.interfacesByComponent.get(componentId) ?? []) {
     for (const impl of ctx.implementationsByContract.get(intf.id) ?? []) {
       const method = impl.methods.find((m) => m.name === methodName);
       if (!method && !intf.methods.some((m) => m.name === methodName)) continue;
       if (method?.symbol) accepted.add(method.symbol);
       const file = methodSourceFile(method ?? {}, impl.sourcePath);
-      if (file) files.add(pathKey(file));
+      if (!file) continue;
+      files.add(pathKey(file));
+      bodies.add(bodyKey(pathKey(file), method?.symbol ?? methodName, method?.exportedVia));
+      anchors.push({ file: pathKey(file), symbol: method?.symbol ?? methodName, exportedVia: method?.exportedVia });
     }
   }
-  return { accepted, files };
+  return { accepted, files, bodies, anchors };
+}
+function targetForwards(code, target) {
+  const out = /* @__PURE__ */ new Set();
+  for (const anchor of target.anchors) {
+    for (const p of code.forwardsOf(anchor.file, anchor.symbol, anchor.exportedVia)) out.add(`${p.file}#${p.name}`);
+    if (anchor.exportedVia !== void 0) continue;
+    const facts = code.factsAt(anchor.file);
+    if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
+    const binding = importBindingOf(facts, anchor.symbol);
+    if (!binding || binding.namespace) continue;
+    const module2 = resolveImport(anchor.file, binding.from, code.paths, code.packages);
+    if (!module2) continue;
+    for (const p of code.forwardsOf(module2, binding.imported ?? anchor.symbol)) out.add(`${p.file}#${p.name}`);
+  }
+  return out;
 }
 function isTarget(pairs, target) {
   return pairs.some((p) => target.files.has(p.file) && target.accepted.has(p.name));
@@ -23814,6 +24237,7 @@ function describeSite(site) {
   if (site.field) return `this.${site.field}.${site.name}(\u2026)`;
   if (site.constructed) return `new ${site.constructed}(\u2026).${site.name}(\u2026)`;
   if (site.returnedBy) return `${site.returnedBy}(\u2026).${site.name}(\u2026)`;
+  if (site.receiverPath) return `${site.receiverPath.join(".")}.${site.name}(\u2026)`;
   if (site.enclosingClass) return `this.${site.name}(\u2026)`;
   return `<receiver>.${site.name}(\u2026)`;
 }
@@ -23827,10 +24251,10 @@ function describeMiss(m) {
 var callConformanceRule = {
   name: "call-conformance",
   judges: "code",
-  description: "Code\u2194spec Level 3: the CLAIMED call \u2194 realized call relation, judged both ways against the method's own source file (its sourcePath, else the implementation's), at exact analysis grade only. A method claims a call two ways and they face one check: a narrative `call` step, and an entry of the declared `calls` a narrative-less method reaches its collaborators through. They assert the same thing, and the step number is no part of the claim \u2014 this check never reads order, so it is only how a finding points at one. Forward: every claim must be realized by a call whose callee RESOLVES TO one of the target method's own source files \u2014 the target's contract name or a per-method `symbol` override, closed transitively over the named helpers the realized function calls, and resolved against every file the call CAN have reached: a `this.<field>.<method>()` receiver followed through the field's DECLARED TYPE, a `new Class(...).<method>()` receiver through the module its CLASS NAME came from, a plain `<name>.<method>()` receiver through the type the file ANNOTATES that name with \u2014 a parameter's, or an annotated variable's, which is how a module that wires its collaborators as closures writes every one of its calls \u2014 a `fn(...).<method>()` receiver through the type fn RETURNS where the code settles it, and a `this.<method>()` receiver through the class whose own method it sits in; a package specifier naming a package of this repository resolves like a relative one, and an export alias (`export { a as b }`, an adapter object property `{ b: a }`) forwards by identity like a re-export. A matching call whose origin a pure model cannot resolve is reported apart as CALL_ORIGIN_UNRESOLVED, which NAMES the shape it could not follow and asks for nothing \u2014 a coverage hole in the reader, reported for the reason CONFORMANCE_DEGRADED is: a silently degraded gate is worse than a degraded one. A finding names a landing only from the PROVEN tier so that widening what a call reached can accept a claim but never accuse one, and a target that names no file of its own falls back to name membership. Converse: a call that resolves to a modelled method of ANOTHER component in the SAME file crosses a component boundary while looking local, so the method must claim it \u2014 in a step or in `calls` (UNDECLARED_COLOCATED_CALL) \u2014 judged on the proven tier alone, and a same-file private helper is no modelled method and is never reported; a function forwarding by identity to a modelled method written in another file IS that method, so what it calls is that method's subject. A method that claims nothing at all is judged in neither direction: what it leaves unsaid is UNUSED_*'s subject. Order, arguments and conditions stay unverified, dispatch steps (runtime-table routed) are no claim about a call site, a malformed declared reference is MALFORMED_DECLARED_CALL's finding and names no target here, the conformance dial (off) skips, and weaker analysis grades never guess.",
+  description: "Code\u2194spec Level 3: the CLAIMED call \u2194 realized call relation, judged both ways against the method's own source file (its sourcePath, else the implementation's), at exact analysis grade only. A method claims a call two ways and they face one check: a narrative `call` step, and an entry of the declared `calls` a narrative-less method reaches its collaborators through. They assert the same thing, and the step number is no part of the claim \u2014 this check never reads order, so it is only how a finding points at one. Forward: every claim must be realized by a call whose callee RESOLVES TO one of the target method's own source files \u2014 the target's contract name or a per-method `symbol` override, closed transitively over the named helpers the realized function calls, and resolved against every file the call CAN have reached: a `this.<field>.<method>()` receiver followed through the field's DECLARED TYPE, a `new Class(...).<method>()` receiver through the module its CLASS NAME came from, a plain `<name>.<method>()` receiver through the type the file ANNOTATES that name with \u2014 a parameter's, or an annotated variable's, which is how a module that wires its collaborators as closures writes every one of its calls \u2014 a `fn(...).<method>()` receiver through the type fn RETURNS where the code settles it, and a `this.<method>()` receiver through the class whose own method it sits in, and a receiver CHAIN (`this.<field>.<property>.<method>()`, `<name>.<property>.<method>()`) link by link through each link's declared type \u2014 a declared type read through a member-preserving utility (Pick, Omit, Partial, Required, Readonly) and one alias hop; a package specifier naming a package of this repository resolves like a relative one, and an export alias (`export { a as b }`, an adapter object property `{ b: a }`) forwards by identity like a re-export. A matching call whose origin a pure model cannot resolve is reported apart as CALL_ORIGIN_UNRESOLVED, which NAMES the shape it could not follow and asks for nothing \u2014 a coverage hole in the reader, reported for the reason CONFORMANCE_DEGRADED is: a silently degraded gate is worse than a degraded one. A finding names a landing only from the PROVEN tier so that widening what a call reached can accept a claim but never accuse one, and a target that names no file of its own falls back to name membership. N:1 identity \u2014 a caller that IS the target \u2014 is judged on the body, the same anchor in the same file, never on a shared name: a Portal method forwarding to a same-named Orchestrator method elsewhere must make that call. Converse: a call that resolves to a modelled method of ANOTHER component in the SAME file crosses a component boundary while looking local, so the method must claim it \u2014 in a step or in `calls` (UNDECLARED_COLOCATED_CALL) \u2014 judged on the proven tier alone, and a same-file private helper is no modelled method and is never reported; a function forwarding by identity to a modelled method written in another file IS that method, so what it calls is that method's subject. A method that claims nothing at all is judged in neither direction: what it leaves unsaid is UNUSED_*'s subject. Order, arguments and conditions stay unverified, dispatch steps (runtime-table routed) are no claim about a call site, a malformed declared reference is MALFORMED_DECLARED_CALL's finding and names no target here, the conformance dial (off) skips, and weaker analysis grades never guess.",
   codes: [
     { code: "CALL_STEP_UNREALIZED", defaultSeverity: "warning", summary: "Narrative call step or declared call realized by no call that resolves to the target method's own source file \u2014 the call is absent, or it lands in another module", carryable: true },
-    { code: "CALL_ORIGIN_UNRESOLVED", defaultSeverity: "warning", summary: "Narrative call step or declared call whose target name IS called, but only from call sites written in a shape this analysis cannot resolve to a file \u2014 the claim was not checked, and is neither proven realized nor accused", carryable: true },
+    { code: "CALL_ORIGIN_UNRESOLVED", defaultSeverity: "warning", summary: "Narrative call step or declared call whose target name IS called, but only from call sites written in a shape this analysis cannot resolve to a file \u2014 the claim was not checked, and is neither proven realized nor accused. What resolves is a name bound to a module of THIS project: a bare or namespaced call through such an import binding, a this.<field> receiver whose declared type names one, a receiver chain (this.<field>.<property>, <name>.<property>) each of whose links the code declares a type for, a new Class(\u2026) receiver whose class does, a receiver name the file annotates with such a type, a fn(\u2026) receiver whose return the code settles, and this inside a class's own method \u2014 a declared type read through Pick/Omit/Partial/Required/Readonly and one alias hop. What does not: a third-party package import, a value the module assembled, and a receiver the file declares nothing for", carryable: true },
     { code: "UNDECLARED_COLOCATED_CALL", defaultSeverity: "warning", summary: "The realized function calls a modelled method of another component living in the same source file, and neither a narrative step nor a declared call names it", carryable: true }
   ],
   check(ctx) {
@@ -23858,9 +24282,9 @@ var callConformanceRule = {
       const here = pathKey(file);
       const fnSymbol = implMethod.symbol ?? implMethod.name;
       const colocated = modelledAt.get(here) ?? { byKey: /* @__PURE__ */ new Map(), byName: /* @__PURE__ */ new Map() };
-      const ownerOf4 = (site, bodyKey) => {
+      const ownerOf4 = (site, bodyKey2) => {
         const inHere = pathKey(site.from ?? here) === here;
-        if (inHere && bodyKey !== void 0 && !bodyKey.startsWith("*")) return colocated.byKey.get(bodyKey);
+        if (inHere && bodyKey2 !== void 0 && !bodyKey2.startsWith("*")) return colocated.byKey.get(bodyKey2);
         return colocated.byName.get(site.name);
       };
       const sites = closedCallSites(code, file, fnSymbol, void 0, implMethod.exportedVia);
@@ -23869,7 +24293,9 @@ var callConformanceRule = {
       for (const claim of claimsOf(implMethod)) {
         if (!ctx.componentMap.has(claim.component)) continue;
         const target = resolveCallTarget(ctx, claim.component, claim.method);
-        if (target.accepted.has(fnSymbol)) continue;
+        if (target.bodies.has(bodyKey(here, fnSymbol, implMethod.exportedVia))) continue;
+        const sharedBody = targetForwards(code, target);
+        if (code.forwardsOf(file, fnSymbol, implMethod.exportedVia).some((p) => p.file !== here && sharedBody.has(`${p.file}#${p.name}`))) continue;
         if (isTarget(code.forwardsOf(file, fnSymbol, implMethod.exportedVia), target)) continue;
         const matching = sites.filter((s) => target.accepted.has(s.name));
         const ref = `${claim.component}.${claim.method}`;
@@ -23913,7 +24339,10 @@ var callConformanceRule = {
         ctx.addIssue(
           "warning",
           "CALL_ORIGIN_UNRESOLVED",
-          `Method "${implMethod.name}" in implementation "${impl.id}": ${unresolved.length} ${claimNoun(implMethod)} ARE called by name inside the function "${fnSymbol}" in "${file}", but every site calling them is written in a shape this analysis cannot resolve to a file \u2014 ${unresolved.map(describeMiss).join("; ")}. What resolves is a name bound to a module of THIS project: a bare or namespaced call through such an import binding (a package of this repository included), a \`this.<field>\` receiver whose declared type names one, a \`new Class(\u2026)\` receiver whose class does, a receiver NAME the file annotates with a type that does, a \`fn(\u2026)\` receiver whose function's return the code settles on a type with that method's body, and \`this\` inside a class's own method that has it. What does not: an import from a third-party PACKAGE, a receiver holding a value the module assembled, a receiver this model records no name for, and one the file annotates with nothing. This reports what was not checked, not what is wrong \u2014 the claim is neither proven realized nor accused of being missing, and no working call is asked to be rewritten to suit the reader.`,
+          // The sites, and what the answer means — once. Which receiver
+          // forms resolve is the code's summary and the rule's description
+          // (`wairon rules list`), not prose every finding repeats.
+          `Method "${implMethod.name}" in implementation "${impl.id}": ${unresolved.length} ${claimNoun(implMethod)} not checked \u2014 called by name inside "${fnSymbol}" in "${file}", but only through receivers this analysis cannot resolve to a file: ${unresolved.map(describeMiss).join("; ")}. Neither proven realized nor accused; the receiver forms that do resolve are listed under CALL_ORIGIN_UNRESOLVED in \`wairon rules list\`.`,
           impl.id,
           entry.draftContext,
           void 0,
@@ -23930,8 +24359,8 @@ var callConformanceRule = {
       }
       const crossings = /* @__PURE__ */ new Map();
       const reached = /* @__PURE__ */ new Map();
-      const stopAtModelled = (site, bodyKey) => {
-        const owner = ownerOf4(site, bodyKey);
+      const stopAtModelled = (site, bodyKey2) => {
+        const owner = ownerOf4(site, bodyKey2);
         reached.set(site, owner);
         return owner !== void 0;
       };
@@ -24020,7 +24449,7 @@ var hiddenStateRule = {
 var dependencyConformanceRule = {
   name: "dependency-conformance",
   judges: "code",
-  description: "Code\u2194spec Level 2: runtime import edges between component-mapped source files (a component maps to every file its implementations and their methods name) must be justified by declared relations \u2014 a direct dependsOn/owns pair, a shared component, membership in a depended-on pattern, or (across subsystems) a declared edge to the target subsystem's published surface (UNDECLARED_DEPENDENCY). Conversely, a declared dependsOn/owns edge between components realized in different files should be visible as an import between any file of the source and any file of the target (UNREALIZED_DEPENDENCY \u2014 DI indirection can defeat this, hence warning). Only exact-grade analyzed files participate; type-only imports are exempt; chained subprojects validate standalone.",
+  description: "Code\u2194spec Level 2: runtime import edges between component-mapped source files (a component maps to every file its implementations and their methods name) must be justified by declared relations \u2014 a direct dependsOn/owns pair, a shared component, membership in a depended-on pattern, or (across subsystems) a declared edge to the target subsystem's published surface (UNDECLARED_DEPENDENCY). Conversely, a declared dependsOn/owns edge between components realized in different files should be visible as an import between any file of the source and any file of the target (UNREALIZED_DEPENDENCY \u2014 DI indirection can defeat this, hence warning). A type-only import never accuses, but it does realize a declared edge: a constructor-injected collaborator is reached through its type, and `import type` is what dependency injection writes down. Only exact-grade analyzed files participate; chained subprojects validate standalone.",
   codes: [
     { code: "UNDECLARED_DEPENDENCY", defaultSeverity: "warning", summary: "A runtime import between component-mapped files has no declared dependsOn/owns (or published-surface) justification" },
     { code: "UNREALIZED_DEPENDENCY", defaultSeverity: "warning", summary: "A declared dependsOn/owns edge between components in different files is realized by no import between any of their files" }
@@ -24088,6 +24517,23 @@ var dependencyConformanceRule = {
         );
       }
     }
+    const typeTraces = /* @__PURE__ */ new Map();
+    const typeTracesOf = (path49) => {
+      let out = typeTraces.get(path49);
+      if (out) return out;
+      out = /* @__PURE__ */ new Set();
+      const facts = code.factsAt(path49);
+      for (const specifier of new Set(Object.values(facts?.typeOnlyBindings ?? {}))) {
+        const to = resolveImport(path49, specifier, mappedPaths, code.packages);
+        if (to && to !== path49) out.add(to);
+      }
+      typeTraces.set(path49, out);
+      return out;
+    };
+    const typeConnects = (from, to) => from.some((f) => {
+      const traces = typeTracesOf(f);
+      return to.some((t) => traces.has(t));
+    });
     for (const component of ctx.components) {
       const fromFiles = filesOf(component.id);
       if (fromFiles.length === 0) continue;
@@ -24101,6 +24547,7 @@ var dependencyConformanceRule = {
         if (toFiles.length === 0) continue;
         if (fromFiles.some((f) => toFiles.includes(f))) continue;
         if (graph2.connects(fromFiles, toFiles, isMountingDeclarer)) continue;
+        if (typeConnects(fromFiles, toFiles)) continue;
         const impls = mappedImplsOf(component.id);
         const declaredDependsOn = component.dependsOn.includes(targetId);
         const declaredOwns = (component.owns ?? []).includes(targetId);
@@ -24109,7 +24556,7 @@ var dependencyConformanceRule = {
         ctx.addIssue(
           "warning",
           "UNREALIZED_DEPENDENCY",
-          `Component "${component.id}" declares ${relation} "${targetId}", but no runtime import connects their source files (${fromFiles.join(", ")} \u219B ${crossSubsystem ? `subsystem ${target.subsystem}` : filesOf(targetId).join(", ")}) \u2014 either the collaboration is wired indirectly (DI) or the declared edge is stale.`,
+          `Component "${component.id}" declares ${relation} "${targetId}", but no import \u2014 runtime or type-only \u2014 connects their source files (${fromFiles.join(", ")} \u219B ${crossSubsystem ? `subsystem ${target.subsystem}` : filesOf(targetId).join(", ")}) \u2014 either the collaboration is wired indirectly (DI) or the declared edge is stale.`,
           impls[0]?.id ?? component.id,
           draft,
           void 0,
@@ -24182,11 +24629,13 @@ var portalImportsRule = {
 var integrationSimDeclarationRule = {
   name: "integration-sim-declaration",
   judges: "code",
-  description: "Once a subsystem has adopted integration sims (its first declared L4 simPath), every OTHER complete, non-leaf implementation of that subsystem must declare one too: its unit suite proves contract shape against mocks, not that the wired components run together. A leaf component's unit suite IS its sim, and a subsystem that has adopted nothing is never flooded.",
+  description: "Once a subsystem has adopted integration sims (its first declared L4 simPath), every OTHER complete, non-leaf implementation of that subsystem must declare one too: its unit suite proves contract shape against mocks, not that the wired components run together. A leaf component's unit suite IS its sim, a subsystem that has adopted nothing is never flooded, and an implementation with no code yet \u2014 no source file named, or only files that are missing \u2014 has nothing to wire and is not asked for a harness.",
   codes: [
     { code: "MISSING_INTEGRATION_SIM", defaultSeverity: "warning", summary: "Complete non-leaf implementation in a sim-adopting subsystem declares no simPath" }
   ],
   check(ctx) {
+    const code = ctx.codeIndex();
+    const hasCode = (files) => files.some((file) => code.factsAt(pathKey(file))?.status !== "missing");
     const adopted = /* @__PURE__ */ new Set();
     for (const impl of ctx.implementations) {
       if (!impl.simPath) continue;
@@ -24205,6 +24654,7 @@ var integrationSimDeclarationRule = {
       if (ctx.isImplementationDraft(impl)) continue;
       const deps = [.../* @__PURE__ */ new Set([...comp.dependsOn, ...comp.owns])].filter((d) => ctx.componentMap.has(d));
       if (deps.length === 0) continue;
+      if (!hasCode(implementationSourceFiles(impl))) continue;
       ctx.addIssue(
         "warning",
         "MISSING_INTEGRATION_SIM",
@@ -25025,7 +25475,7 @@ var NOTHING_PROMISED = /* @__PURE__ */ new Set();
 var exportConformanceRule = {
   name: "export-conformance",
   judges: "code",
-  description: "Code-to-contract for the SURFACE: does this file publish anything the components it realizes never promised, that another component then takes? The rest of the conformance set reads contract-to-code \u2014 it asks whether the code holds what a spec claims \u2014 so a file could export whatever it liked under a component's name and nothing looked. That is one half of the same hole as a contract promising a parameter it never passes. A method's `exportedVia` names the export a consumer imports to REACH it \u2014 the value that composes it, which `symbol` cannot name because `symbol` names the function inside \u2014 and a listener's mount names the router entry it calls to hand a portal its requests; both are declared publication, and a declared handle the file does not actually export is itself a finding, so naming one can never become a free-text suppression. Both questions are asked only of a file read at exact grade, and a taker counts only when its own import specifier resolves to the file it is accused of taking from: below that nothing separates an export from a mention, or a shared word from a shared module.",
+  description: "Code-to-contract for the SURFACE: does this file publish anything the components it realizes never promised, that another component then takes? The rest of the conformance set reads contract-to-code \u2014 it asks whether the code holds what a spec claims \u2014 so a file could export whatever it liked under a component's name and nothing looked. That is one half of the same hole as a contract promising a parameter it never passes. A method's `exportedVia` names the export a consumer imports to REACH it \u2014 the value that composes it, which `symbol` cannot name because `symbol` names the function inside \u2014 and a listener's mount names the router entry it calls to hand a portal its requests; both are declared publication, and a declared handle the file does not actually export is itself a finding, so naming one can never become a free-text suppression. Both questions are asked only of a file read at exact grade, and a taker counts only when its own import specifier resolves to the file it is accused of taking from: below that nothing separates an export from a mention, or a shared word from a shared module. A taker inside the owns fence is no crossing: a pattern constructs the blocks it owns, so the owner's file, or another member of the same pattern, importing a member's class is the owns relation made real.",
   codes: [
     {
       code: "UNDECLARED_EXPORT",
@@ -25047,6 +25497,7 @@ var exportConformanceRule = {
   check(ctx) {
     const code = ctx.codeIndex();
     const realization = ctx.realizationIndex();
+    const ownership = ctx.ownershipIndex();
     const promised = /* @__PURE__ */ new Map();
     const promise = (file, name) => {
       if (!name) return;
@@ -25173,13 +25624,20 @@ var exportConformanceRule = {
       const declared = promised.get(file) ?? NOTHING_PROMISED;
       const taken = takenFrom.get(file);
       const owners = new Set(realization.componentsAt(file).map((c) => c.id));
+      const fence = new Set(owners);
+      for (const id of owners) {
+        const pattern = ownership.ownerOf(id);
+        if (pattern === void 0) continue;
+        fence.add(pattern);
+        for (const member of ownership.ownedMembers) if (ownership.ownerOf(member) === pattern) fence.add(member);
+      }
       const crossed = [];
       for (const name of [...new Set(facts.exportedNames)].sort()) {
         if (declared.has(name)) continue;
         const takers = taken?.get(name);
         if (!takers) continue;
         const crossing = [...takers].some(
-          (taker) => taker !== file && !realization.componentsAt(taker).some((c) => owners.has(c.id))
+          (taker) => taker !== file && !realization.componentsAt(taker).some((c) => fence.has(c.id))
         );
         if (crossing) crossed.push(name);
       }
@@ -26881,6 +27339,8 @@ function walkExact(ts, sourceText, fileName) {
   const typeOnlyBindings = /* @__PURE__ */ new Map();
   const fieldTypes = /* @__PURE__ */ new Map();
   const localTypes = /* @__PURE__ */ new Map();
+  const memberTypes = /* @__PURE__ */ new Map();
+  const aliasTargets = /* @__PURE__ */ new Map();
   const typeShapes = /* @__PURE__ */ new Map();
   const functionParams = /* @__PURE__ */ new Map();
   const functionRoutes = /* @__PURE__ */ new Map();
@@ -26890,7 +27350,7 @@ function walkExact(ts, sourceText, fileName) {
   const mutableBindings = /* @__PURE__ */ new Set();
   const schemaConstants = /* @__PURE__ */ new Map();
   const derivedAliases = [];
-  const receiverKey = (site) => site.via ?? (site.field ? `this.${site.field}` : site.constructed ? `new ${site.constructed}` : site.returnedBy ? `${site.returnedBy}()` : site.enclosingClass ? `this:${site.enclosingClass}` : "");
+  const receiverKey = (site) => site.via ?? (site.field ? `this.${site.field}` : site.constructed ? `new ${site.constructed}` : site.returnedBy ? `${site.returnedBy}()` : site.enclosingClass ? `this:${site.enclosingClass}` : site.receiverPath ? site.receiverPath.join(".") : "");
   const siteKey = (site) => `${site.member ? "m" : "b"}:${receiverKey(site)}:${site.name}`;
   const addBindingNames = (name) => {
     if (ts.isIdentifier(name)) declared.add(name.text);
@@ -26905,7 +27365,34 @@ function walkExact(ts, sourceText, fileName) {
     if (ts.isPrivateIdentifier(name)) return name.text;
     return void 0;
   };
-  const typeReferenceName = (type) => type && ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName) ? type.typeName.text : void 0;
+  const MEMBER_PRESERVING = /* @__PURE__ */ new Set(["Pick", "Omit", "Partial", "Required", "Readonly"]);
+  const typeReferenceName = (type) => {
+    let at = type;
+    for (let depth = 0; at && depth < 4; depth++) {
+      if (!ts.isTypeReferenceNode(at) || !ts.isIdentifier(at.typeName)) return void 0;
+      const name = at.typeName.text;
+      if (!MEMBER_PRESERVING.has(name) || !at.typeArguments?.length) return name;
+      at = at.typeArguments[0];
+    }
+    return void 0;
+  };
+  const recordMemberType = (shape, name, type) => {
+    if (!shape) return;
+    const typeName = typeReferenceName(type);
+    if (!typeName) return;
+    const property = propertyNameText(name);
+    if (!property) return;
+    const key = `${shape}.${property}`;
+    const named2 = memberTypes.get(key) ?? /* @__PURE__ */ new Set();
+    named2.add(typeName);
+    memberTypes.set(key, named2);
+  };
+  const shapeNameOf = (holder) => {
+    if (!holder) return void 0;
+    if ((ts.isClassDeclaration(holder) || ts.isInterfaceDeclaration(holder)) && holder.name) return holder.name.text;
+    if (ts.isTypeLiteralNode(holder) && holder.parent && ts.isTypeAliasDeclaration(holder.parent)) return holder.parent.name.text;
+    return void 0;
+  };
   const isParameterProperty = (node) => !!node.modifiers?.some((m) => m.kind === ts.SyntaxKind.PublicKeyword || m.kind === ts.SyntaxKind.PrivateKeyword || m.kind === ts.SyntaxKind.ProtectedKeyword || m.kind === ts.SyntaxKind.ReadonlyKeyword);
   const recordFieldType = (name, type) => {
     const typeName = typeReferenceName(type);
@@ -27102,7 +27589,18 @@ function walkExact(ts, sourceText, fileName) {
           } else if (receiver.kind === ts.SyntaxKind.ThisKeyword) {
             const owner = enclosingClassOf(node);
             addSite(owner !== void 0 ? { name, member: true, enclosingClass: owner } : { name, member: true });
-          } else addSite({ name, member: true });
+          } else {
+            const chain = [];
+            let at = receiver;
+            while (ts.isPropertyAccessExpression(at) && !at.questionDotToken && ts.isIdentifier(at.name)) {
+              chain.unshift(at.name.text);
+              at = at.expression;
+            }
+            if (ts.isIdentifier(at)) chain.unshift(at.text);
+            else if (at.kind === ts.SyntaxKind.ThisKeyword) chain.unshift("this");
+            else chain.length = 0;
+            addSite(chain.length >= 2 ? { name, member: true, receiverPath: chain } : { name, member: true });
+          }
         }
       }
       ts.forEachChild(node, count);
@@ -27237,9 +27735,14 @@ function walkExact(ts, sourceText, fileName) {
         functionRoutes.set(fnName, known);
       }
     }
-    if (ts.isPropertyDeclaration(node)) recordFieldType(node.name, node.type);
-    else if (ts.isParameter(node) && node.parent && ts.isConstructorDeclaration(node.parent) && isParameterProperty(node)) {
+    if (ts.isPropertyDeclaration(node)) {
+      recordFieldType(node.name, node.type);
+      recordMemberType(shapeNameOf(node.parent), node.name, node.type);
+    } else if (ts.isParameter(node) && node.parent && ts.isConstructorDeclaration(node.parent) && isParameterProperty(node)) {
       recordFieldType(node.name, node.type);
+      recordMemberType(shapeNameOf(node.parent.parent), node.name, node.type);
+    } else if (ts.isPropertySignature(node)) {
+      recordMemberType(shapeNameOf(node.parent), node.name, node.type);
     }
     if (ts.isParameter(node) || ts.isVariableDeclaration(node)) recordLocalType(node.name, node.type);
     if (ts.isInterfaceDeclaration(node)) {
@@ -27253,6 +27756,10 @@ function walkExact(ts, sourceText, fileName) {
       if (ts.isTypeLiteralNode(node.type)) recordDeclaredShape(node.name.text, node.type.members, false);
       else {
         if (!aliasTypes.has(node.name.text)) aliasTypes.set(node.name.text, node.type.getText(sf));
+        const named2 = typeReferenceName(node.type);
+        if (named2 !== void 0 && named2 !== node.name.text && !aliasTargets.has(node.name.text)) {
+          aliasTargets.set(node.name.text, named2);
+        }
         const constant = inferredSchemaConstant(node.type);
         if (constant) derivedAliases.push({ name: node.name.text, constant });
         const literals = stringLiteralUnion(node.type);
@@ -27413,7 +27920,7 @@ function walkExact(ts, sourceText, fileName) {
   }
   const reexportOnly = sf.statements.length > 0 && sf.statements.every((st) => ts.isExportDeclaration(st) && !!st.moduleSpecifier);
   for (const alias of propertyAliases) if (exported.has(alias.container)) exportAliases.push(alias);
-  return { declared, anchors, exported, imports, reexports, starExports, namedReexports, exportAliases, returnTypes, complexity, calls, bodies, importBindings, typeOnlyBindings, fieldTypes, localTypes, typeShapes, functionParams, functionRoutes, asyncFunctions, enumValues, aliasTypes, mutableBindings, reexportOnly };
+  return { declared, anchors, exported, imports, reexports, starExports, namedReexports, exportAliases, returnTypes, complexity, calls, bodies, importBindings, typeOnlyBindings, fieldTypes, localTypes, memberTypes, aliasTargets, typeShapes, functionParams, functionRoutes, asyncFunctions, enumValues, aliasTypes, mutableBindings, reexportOnly };
 }
 var NO_PACKAGES = /* @__PURE__ */ new Map();
 function resolveModule(fromFile, specifier, packages) {
@@ -27785,6 +28292,8 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
             typeOnlyBindings: Object.fromEntries(facts.typeOnlyBindings),
             fieldTypes: Object.fromEntries([...facts.fieldTypes].map(([k, v]) => [k, [...v]])),
             localTypes: Object.fromEntries([...facts.localTypes].map(([k, v]) => [k, [...v]])),
+            memberTypes: Object.fromEntries([...facts.memberTypes].map(([k, v]) => [k, [...v]])),
+            aliasTargets: Object.fromEntries(facts.aliasTargets),
             typeShapes: Object.fromEntries(facts.typeShapes),
             functionParams: Object.fromEntries(facts.functionParams),
             functionRoutes: Object.fromEntries([...facts.functionRoutes].map(([k, v]) => [k, [...v.values()]])),
@@ -28229,8 +28738,16 @@ function buildRuleContext(opts) {
     }
     if (ownerId && nameKey(first) === nameKey(ownerId)) return ownTypes.some((spec) => typeMatchesRef(spec, rest.join("::")));
     if (ref.includes("::") && authoredTypeRefs.has(ref)) return true;
+    return false;
+  };
+  const aliasSpelling = (ref) => {
+    const segments = ref.split(".");
+    if (segments.length !== 2 || ref.includes("::")) return null;
+    const [first, name] = segments;
+    if (subsystems.some((s) => nameKey(s.id.split("::").pop()) === nameKey(first) && memberOf(s.id) === void 0)) return null;
     const via = aliasOf(first);
-    return via !== void 0 && rest.length === 1 && exportedBy(via, nameKey(rest[0]), "type") !== void 0;
+    const publicName = via ? exportedBy(via, nameKey(name), "type") : void 0;
+    return via && publicName ? `${via.alias}::${publicName}` : null;
   };
   const foreignSurfaceRef = (ref) => {
     const segments = ref.split("::").filter((seg) => seg && seg !== "super");
@@ -28604,6 +29121,7 @@ function buildRuleContext(opts) {
     isImplementationDraft,
     getComponentProfile,
     isTypeResolved,
+    aliasSpelling,
     targetLanguageFor,
     isSpecInScope,
     isInChainedSubproject,
@@ -29774,8 +30292,8 @@ function generateSequenceDiagram(componentId, methodName, options) {
     const steps = [...methodImpl.narrative].sort((a, b) => a.stepNumber - b.stepNumber);
     for (const step of steps) {
       for (const par of parallelArms) {
-        const sep14 = par.sepByStep.get(step.stepNumber);
-        if (sep14 !== void 0) lines.push(`  and ${escapeLabel(sep14)}`);
+        const sep15 = par.sepByStep.get(step.stepNumber);
+        if (sep15 !== void 0) lines.push(`  and ${escapeLabel(sep15)}`);
       }
       switch (step.type) {
         case "local":
@@ -30505,6 +31023,15 @@ function classifySource(world, sourceId, label7, sources) {
     detail: `"${label7}" re-exports from "${sourceId}", which is neither a subsystem of this project, a member nor a declared external the scan read \u2014 a project re-exports only from its subsystems, members and externals of its family`
   };
 }
+function duplicateDetail(entries, index) {
+  const e = entries[index];
+  if (e.from !== void 0 || e.component !== void 0 || e.interface !== void 0 || e.typeDef !== void 0) return null;
+  const name = e.as ?? e.id;
+  if (name === void 0) return null;
+  const other = entries.findIndex((x, i) => i !== index && (x.as ?? x.id) === name);
+  if (other === -1) return null;
+  return `has a duplicate entry "${name}": entry #${index + 1} names no source and no item, while entry #${other + 1} declares the same id \u2014 delete the copy (entry #${index + 1}), or give it a source and an item under an id of its own`;
+}
 function bindOwnType(world, owner, e, problems) {
   const type = (world.types.get(e.typeDef) ?? []).find((t) => !t.subsystem);
   if (!type) {
@@ -30576,7 +31103,8 @@ function resolveProjectTable(system, subsystems, components, interfaces, types,
   const owner = sources.namespace ? sources.namespace : system.name;
   const problems = [];
   const candidates = [];
-  (system.publicInterfaces ?? []).forEach((e, index) => {
+  const entries = system.publicInterfaces ?? [];
+  entries.forEach((e, index) => {
     const label7 = e.as ?? e.id ?? e.interface ?? e.component ?? e.typeDef ?? `#${index + 1}`;
     const source = classifySource(world, sourceOf(world, e), label7, sources);
     switch (source.kind) {
@@ -30602,7 +31130,7 @@ function resolveProjectTable(system, subsystems, components, interfaces, types,
         return;
       }
       default:
-        problems.push({ kind: "invalid", owner, publicName: label7, detail: source.detail });
+        problems.push({ kind: "invalid", owner, publicName: label7, detail: duplicateDetail(entries, index) ?? source.detail });
     }
   });
   return settle(owner, "project", candidates, problems);
@@ -31125,6 +31653,28 @@ function mapSignatureSource(value, map) {
   const head2 = map("signatureFrom", parts.head);
   return head2 === parts.head ? value : `${head2}.${parts.tail}`;
 }
+var TYPE_EXPRESSION_PATHS = {
+  interface: ["methods.params.type", "methods.returns", "methods.signature", "methods.signatureFrom"],
+  type: ["fields.type", "params.type", "returns", "methods.params.type", "methods.returns", "methods.signature"]
+};
+function typeExpressionSlots(kind, doc) {
+  const out = [];
+  const paths = kind === "interface" || kind === "type" ? TYPE_EXPRESSION_PATHS[kind] : [];
+  const walk2 = (node, segments, at, method) => {
+    if (!node || typeof node !== "object") return;
+    const holder = node;
+    const [head2, ...rest] = segments;
+    if (rest.length === 0) {
+      if (typeof holder[head2] === "string") out.push({ holder, key: head2, path: at, ...method ? { method } : {} });
+      return;
+    }
+    const next = holder[head2];
+    const items = Array.isArray(next) ? next : next && typeof next === "object" ? [next] : [];
+    for (const item of items) walk2(item, rest, at, head2 === "methods" ? item : method);
+  };
+  for (const at of paths) walk2(doc, at.split("."), at, void 0);
+  return out;
+}
 function mapSpecReferences(kind, spec, map) {
   switch (kind) {
     case "subsystem": {
@@ -31195,6 +31745,16 @@ function qualifiedTypeNames(typeStr) {
   }
   return out;
 }
+function invariantTypeRef(ref) {
+  const at = ref.lastIndexOf(".");
+  return at > 0 && at < ref.length - 1 ? ref.slice(0, at) : void 0;
+}
+function mapInvariantRef(ref, map) {
+  const typeRef2 = invariantTypeRef(ref);
+  if (typeRef2 === void 0 || !typeRef2.includes("::")) return ref;
+  const next = map("type", typeRef2);
+  return next === typeRef2 ? ref : `${next}${ref.slice(typeRef2.length)}`;
+}
 function rawReferences(kind, spec) {
   const out = [];
   const add2 = (position, value) => {
@@ -31205,11 +31765,8 @@ function rawReferences(kind, spec) {
       for (const link of spec.trustedLinks ?? []) add2("trustedLinks", link.subsystem);
       break;
     case "interface":
-      for (const m of spec.methods) {
-        qualifiedTypeNames(m.returns).forEach((t) => add2("type", t));
-        m.params?.forEach((p) => qualifiedTypeNames(p.type).forEach((t) => add2("type", t)));
-        if (m.signatureFrom !== void 0 && !signatureSourceParts(m.signatureFrom)) add2("type", m.signatureFrom);
-      }
+    case "type":
+      typeSlotReferences(kind, spec).forEach((t) => add2("type", t));
       break;
     case "implementation":
       for (const m of spec.methods) {
@@ -31217,22 +31774,40 @@ function rawReferences(kind, spec) {
         for (const step of m.narrative) {
           const source = step.auth?.from;
           if (typeof source === "string" && source.startsWith(COMPONENT_AUTH_SOURCE)) add2("auth", source.slice(COMPONENT_AUTH_SOURCE.length));
+          for (const ref of step.assertsInvariants ?? []) add2("type", invariantTypeRef(ref));
         }
       }
       break;
-    case "type": {
-      const t = spec;
-      for (const f of t.fields) qualifiedTypeNames(f.type).forEach((n) => add2("type", n));
-      t.params?.forEach((p) => qualifiedTypeNames(p.type).forEach((n) => add2("type", n)));
-      qualifiedTypeNames(t.returns).forEach((n) => add2("type", n));
-      for (const m of t.methods ?? []) m.params?.forEach((p) => qualifiedTypeNames(p.type).forEach((n) => add2("type", n)));
-      break;
-    }
     default:
       break;
   }
   return out;
 }
+function typeSlotReferences(kind, spec) {
+  const out = [];
+  const structured2 = /* @__PURE__ */ new Set();
+  const slots = typeExpressionSlots(kind, spec);
+  for (const slot of slots) {
+    const value = slot.holder[slot.key];
+    if (slot.path === "methods.signature") continue;
+    if (slot.path === "methods.signatureFrom") {
+      if (!signatureSourceParts(value)) out.push(value);
+      continue;
+    }
+    for (const name of qualifiedTypeNames(value)) {
+      out.push(name);
+      structured2.add(name);
+    }
+  }
+  for (const slot of slots.filter((s) => s.path === "methods.signature")) {
+    for (const name of qualifiedTypeNames(slot.holder[slot.key])) {
+      if (structured2.has(name)) continue;
+      structured2.add(name);
+      out.push(name);
+    }
+  }
+  return out;
+}
 var IMPORTABLE_POSITIONS = /* @__PURE__ */ new Set(["dependsOn", "dispatch", "mounts", "narrative"]);
 function bareRawReferences(kind, spec) {
   const out = [];
@@ -31259,7 +31834,11 @@ function bareRawReferences(kind, spec) {
       const t = spec;
       for (const f of t.fields) for (const ref of fieldTypeRefs(t, f.type)) add2("type", ref);
       for (const ref of signatureTypeRefs(t)) add2("type", ref);
-      for (const m of t.methods ?? []) for (const p of m.params ?? []) for (const ref of fieldTypeRefs(t, p.type)) add2("type", ref);
+      const own = lower(typeGenericParameters(t));
+      for (const m of t.methods ?? []) {
+        const generics = /* @__PURE__ */ new Set([...own, ...lower(methodGenericParameters(m))]);
+        for (const ref of methodTypeRefs(m)) add2("type", ref, generics);
+      }
       break;
     }
     case "implementation":
@@ -31272,6 +31851,9 @@ function bareRawReferences(kind, spec) {
   }
   return out;
 }
+function respellTypeNames(typeStr, map) {
+  return mapTypeNames(typeStr, (_position, name) => map(name));
+}
 function mapTypeNames(typeStr, map) {
   if (typeStr === void 0) return void 0;
   return typeStr.replace(
@@ -31295,12 +31877,9 @@ function respellStoredReferences(kind, doc, map) {
     const values = holder[key];
     if (Array.isArray(values)) holder[key] = values.map((v) => typeof v === "string" ? map(position, v) : v);
   };
-  const typed = (holder, key) => {
-    if (typeof holder[key] === "string") holder[key] = mapTypeNames(holder[key], map);
-  };
   const published = (entries) => {
     for (const e of list(entries)) {
-      for (const key of ["from", "component", "interface", "typeDef"]) at(e, key, "publicInterfaces");
+      for (const key of ["from", "subsystem", "component", "interface", "typeDef"]) at(e, key, "publicInterfaces");
       each(e, "consumers", "publicInterfaces");
     }
   };
@@ -31322,20 +31901,16 @@ function respellStoredReferences(kind, doc, map) {
       break;
     case "interface":
       at(doc, "component", "contract");
-      for (const m of list(doc.methods)) {
-        typed(m, "signature");
-        typed(m, "returns");
-        for (const p of list(m.params)) typed(p, "type");
-        if (typeof m.signatureFrom === "string") {
-          m.signatureFrom = signatureSourceParts(m.signatureFrom) ? mapSignatureSource(m.signatureFrom, map) : mapTypeNames(m.signatureFrom, map);
-        }
-      }
+      typedSlots("interface", doc, map);
       break;
     case "implementation":
       at(doc, "contract", "contract");
       for (const m of list(doc.methods)) {
         for (const step of list(m.narrative)) {
           at(step, "targetComponent", "narrative");
+          if (Array.isArray(step.assertsInvariants)) {
+            step.assertsInvariants = step.assertsInvariants.map((ref) => typeof ref === "string" ? mapInvariantRef(ref, map) : ref);
+          }
           const auth = step.auth;
           if (auth && typeof auth.from === "string" && auth.from.startsWith(COMPONENT_AUTH_SOURCE)) {
             auth.from = `${COMPONENT_AUTH_SOURCE}${map("auth", auth.from.slice(COMPONENT_AUTH_SOURCE.length))}`;
@@ -31353,34 +31928,33 @@ function respellStoredReferences(kind, doc, map) {
     case "type":
       at(doc, "subsystem", "subsystem");
       at(doc, "group", "group");
-      for (const f of list(doc.fields)) typed(f, "type");
-      for (const p of list(doc.params)) typed(p, "type");
-      typed(doc, "returns");
-      for (const m of list(doc.methods)) for (const p of list(m.params)) typed(p, "type");
+      typedSlots("type", doc, map);
       break;
     default:
       break;
   }
 }
+function typedSlots(kind, doc, map) {
+  for (const slot of typeExpressionSlots(kind, doc)) {
+    const value = slot.holder[slot.key];
+    slot.holder[slot.key] = slot.path === "methods.signatureFrom" && signatureSourceParts(value) ? mapSignatureSource(value, map) : mapTypeNames(value, map);
+  }
+}
 function mapRawReferences(kind, spec, map) {
   switch (kind) {
     case "subsystem": {
       const s = spec;
       return { ...s, trustedLinks: (s.trustedLinks ?? []).map((l) => ({ ...l, subsystem: map("trustedLinks", l.subsystem) })) };
     }
-    case "interface": {
-      const i = spec;
-      return {
-        ...i,
-        methods: i.methods.map((m) => ({
-          ...m,
-          ...m.signature !== void 0 ? { signature: mapTypeNames(m.signature, map) } : {},
-          ...m.returns !== void 0 ? { returns: mapTypeNames(m.returns, map) } : {},
-          ...m.params ? { params: m.params.map((p) => ({ ...p, type: mapTypeNames(p.type, map) })) } : {},
-          // A type source is a raw type position; a method source's head is bound, never raw.
-          ...m.signatureFrom !== void 0 && !signatureSourceParts(m.signatureFrom) ? { signatureFrom: mapTypeNames(m.signatureFrom, map) } : {}
-        }))
-      };
+    case "interface":
+    case "type": {
+      const copy = JSON.parse(JSON.stringify(spec));
+      for (const slot of typeExpressionSlots(kind, copy)) {
+        const value = slot.holder[slot.key];
+        if (slot.path === "methods.signatureFrom" && signatureSourceParts(value)) continue;
+        slot.holder[slot.key] = mapTypeNames(value, map);
+      }
+      return copy;
     }
     case "implementation": {
       const impl = spec;
@@ -31395,7 +31969,8 @@ function mapRawReferences(kind, spec, map) {
               return call && next !== call.compId ? `${next}.${call.methodName}` : entry;
             })
           } : {},
-          narrative: m.narrative.map((step) => {
+          narrative: m.narrative.map((authored) => {
+            const step = authored.assertsInvariants ? { ...authored, assertsInvariants: authored.assertsInvariants.map((ref) => mapInvariantRef(ref, map)) } : authored;
             const source = step.auth?.from;
             if (typeof source !== "string" || !source.startsWith(COMPONENT_AUTH_SOURCE)) return step;
             const auth = step.auth;
@@ -31404,17 +31979,6 @@ function mapRawReferences(kind, spec, map) {
         }))
       };
     }
-    case "type": {
-      const t = spec;
-      const typedParams = (params) => params ? { params: params.map((p) => ({ ...p, type: mapTypeNames(p.type, map) })) } : {};
-      return {
-        ...t,
-        fields: t.fields.map((f) => ({ ...f, type: mapTypeNames(f.type, map) })),
-        ...typedParams(t.params),
-        ...t.returns !== void 0 ? { returns: mapTypeNames(t.returns, map) } : {},
-        methods: (t.methods ?? []).map((m) => ({ ...m, ...typedParams(m.params) }))
-      };
-    }
     default:
       return spec;
   }
@@ -33491,12 +34055,12 @@ var SpecWorkspace = class {
     return this.relativizeSpec("interface", stored);
   }
   prepareImplementationForWrite(spec, carry = true) {
-    const relative19 = this.relativizeSpec("implementation", spec, carry);
+    const relative20 = this.relativizeSpec("implementation", spec, carry);
     const member = this.getSubprojectPrefix(spec.id);
     const memberRoot = member ? this.resolveSubprojectForNamespace(member) : null;
-    if (memberRoot) return childRelativeFilePaths(relative19, this.rootDir, memberRoot);
+    if (memberRoot) return childRelativeFilePaths(relative20, this.rootDir, memberRoot);
     const partDir = this.partHolding(this.getImplementationPath(spec.id, spec.contract))?.part.directory;
-    return partDir ? partRelativeFilePaths(relative19, this.rootDir, partDir) : relative19;
+    return partDir ? partRelativeFilePaths(relative20, this.rootDir, partDir) : relative20;
   }
   /**
    * A type written in its stored form — every type position canonical (one
@@ -35801,6 +36365,12 @@ function readLockState(current2) {
   if (!record) return { state: "unlocked", record: null, current: current2 };
   return { state: stateIdEquals(record.stateId, current2) ? "locked" : "stale", record, current: current2 };
 }
+function writeLockRecord2(record) {
+  writeLockRecord(record);
+}
+function renderDiagram2(format, relations) {
+  return renderDiagram(format, relations);
+}
 function createProjectConfig(config) {
   projectConfigRepository.create(config);
 }
@@ -36047,7 +36617,7 @@ function resolveGit(external, config) {
   const declared = gitDeclarationOf(config, external);
   if (!declared) return { ...external, problem: "git producer unavailable: its declaration names no repository" };
   try {
-    const commit2 = external.role === "member" && declared.commit ? declared.commit : resolve7(declared.url, declared.ref);
+    const commit2 = external.role === "member" && declared.commit ? declared.commit : resolve3(declared.url, declared.ref);
     const directory = fetch(declared.url, commit2, declared.dir);
     return { ...external, directory: path23.resolve(directory), commit: commit2, problem: void 0 };
   } catch (e) {
@@ -36476,7 +37046,7 @@ function scaffoldPart(alias, memberDir, contained) {
 }
 function createGitMember(alias, source, description, as) {
   const url = source.git;
-  const commit2 = source.commit ?? resolve7(url, source.ref);
+  const commit2 = source.commit ?? resolve3(url, source.ref);
   const dir = fetch(url, commit2, source.dir);
   const kind = holdsProjectContent(dir) ? "project" : "part";
   if (as !== void 0 && as !== kind) {
@@ -36634,7 +37204,7 @@ function isWithinDir2(dir, file) {
 var MOVED_REF_POSITIONS = /* @__PURE__ */ new Set(["component", "interface"]);
 var INTO_MEMBER_POSITIONS = /* @__PURE__ */ new Set([...MOVED_REF_POSITIONS, "type"]);
 function externalizeSubsystem(subsystemId, path49, as) {
-  externalizeInto(subsystemId, path49, as);
+  return externalizeInto(subsystemId, path49, as);
 }
 function externalizeInto(subsystemId, partPath, as) {
   if (subsystemId.includes("::")) {
@@ -36653,7 +37223,8 @@ function externalizeInto(subsystemId, partPath, as) {
   const parentRoot = getProjectRoot();
   const parentSpecsDir = aiPathsAt(parentRoot).specsDir();
   const fooDir = path25.join(parentSpecsDir, subsystemId);
-  if (!fs16.existsSync(fooDir)) throw new WaironError(`subsystem specs directory not found: ${fooDir}`);
+  const owned = subsystemFiles(subsystemId, parentSpecsDir);
+  if (owned.files.length === 0) throw new WaironError(`subsystem specs not found for "${subsystemId}" under ${parentSpecsDir}`);
   const relPath = toPosixPath(partPath);
   const partDir = assertContainedProjectPath(parentRoot, relPath);
   if (path25.resolve(partDir) === path25.resolve(parentRoot)) throw new WaironError(`cannot externalize "${subsystemId}": the path "${relPath}" is the project root itself.`);
@@ -36666,19 +37237,74 @@ function externalizeInto(subsystemId, partPath, as) {
   if (!joined && (declaredMembers(projectConfigRepository.load() ?? {}).some((m) => m.alias === alias) || projectConfigRepository.load()?.externals?.[alias] !== void 0)) {
     throw new WaironError(`cannot externalize "${subsystemId}": this project already declares the alias "${alias}".`);
   }
-  const targetDir = path25.join(aiPathsAt(partDir).specsDir(), subsystemId);
-  if (fs16.existsSync(targetDir)) throw new WaironError(`target already contains a "${subsystemId}" subsystem: ${targetDir}`);
+  const partSpecsDir = aiPathsAt(partDir).specsDir();
+  const targetDir = path25.join(partSpecsDir, subsystemId);
+  if (owned.home !== void 0 && fs16.existsSync(targetDir)) throw new WaironError(`target already contains a "${subsystemId}" subsystem: ${targetDir}`);
+  const destinationOf = (file) => path25.join(partSpecsDir, path25.relative(parentSpecsDir, file));
+  const strays = owned.files.filter((f) => !(owned.home !== void 0 && isWithinDir2(owned.home, f)));
+  const taken = strays.filter((f) => fs16.existsSync(destinationOf(f)));
+  if (taken.length > 0) throw new WaironError(`cannot externalize "${subsystemId}": the part already holds ${taken.map((f) => toPosixPath(path25.relative(partDir, destinationOf(f)))).join(", ")}.`);
   if (as === "project") {
     if (joined) throw new WaironError(`cannot externalize "${subsystemId}" as a project into the existing part "${joined.alias}": externalize it into the part, then promote the part (\`wairon member promote ${joined.alias}\`).`);
-    const refusals = promoteRefusals(family, specFilesUnder(fooDir), ownSpecFiles(family, fooDir), alias);
+    const inside = new Set(owned.files.map((f) => path25.resolve(f)));
+    const refusals = promoteRefusals(family, owned.files, ownSpecFiles(family, fooDir).filter((f) => !inside.has(path25.resolve(f))), alias);
     if (refusals.length > 0) throw new WaironError(`cannot externalize "${subsystemId}" as a project: ${refusals.join("; ")}.`);
   }
-  ensureDir(path25.dirname(targetDir));
-  fs16.renameSync(fooDir, targetDir);
-  rebaseImplementationPaths(targetDir, parentRoot, partDir);
+  const moved = [];
+  if (owned.home !== void 0) {
+    ensureDir(path25.dirname(targetDir));
+    fs16.renameSync(owned.home, targetDir);
+    moved.push(...specFilesUnder(targetDir));
+  }
+  for (const file of strays) {
+    const to = destinationOf(file);
+    ensureDir(path25.dirname(to));
+    fs16.renameSync(file, to);
+    moved.push(to);
+    removeEmptyDirsUpTo(path25.dirname(file), parentSpecsDir);
+  }
+  rebaseImplementationPaths(partSpecsDir, parentRoot, partDir, moved);
   if (!joined) projectConfigRepository.declareMember(alias, { source: relPath });
   invalidateSpecCache();
-  if (as === "project") promoteMember(alias);
+  return as === "project" ? promoteMember(alias) : void 0;
+}
+function subsystemFiles(subsystemId, specsDir) {
+  const subPath = getSubsystemPath(subsystemId);
+  const nested = subPath.endsWith(".index.yaml") && path25.resolve(path25.dirname(subPath)) === path25.resolve(path25.join(specsDir, subsystemId)) && fs16.existsSync(subPath);
+  const home = nested ? path25.dirname(subPath) : void 0;
+  const files = new Set(home !== void 0 ? specFilesUnder(home).map((f) => path25.resolve(f)) : []);
+  if (!nested && fs16.existsSync(subPath)) files.add(path25.resolve(subPath));
+  const l0 = path25.resolve(aiPathsAt(getProjectRoot()).specsSystem());
+  const others = () => specFilesUnder(specsDir).filter((f) => path25.resolve(f) !== l0 && !files.has(path25.resolve(f)));
+  const add2 = (file) => {
+    if (path25.basename(file) === ".index.yaml") for (const f of specFilesUnder(path25.dirname(file))) files.add(path25.resolve(f));
+    else files.add(path25.resolve(file));
+  };
+  for (const file of others()) {
+    let raw;
+    try {
+      raw = readYamlFile(file);
+    } catch {
+      continue;
+    }
+    const kind = raw && typeof raw === "object" ? specKind(raw) : void 0;
+    if (kind === "subsystem" || kind === "system" || raw?.subsystem !== subsystemId) continue;
+    add2(file);
+  }
+  const owned = () => rawSpecs([...files]);
+  const components = new Set(owned().filter((x) => x.kind === "component").map((x) => x.id));
+  for (const spec of rawSpecs(others())) if (spec.kind === "interface" && components.has(spec.raw?.component)) add2(spec.file);
+  const contracts = new Set(owned().filter((x) => x.kind === "interface").map((x) => x.id));
+  for (const spec of rawSpecs(others())) if (spec.kind === "implementation" && contracts.has(spec.raw?.contract)) add2(spec.file);
+  return { home, files: [...files] };
+}
+function removeEmptyDirsUpTo(dir, stop) {
+  let at = path25.resolve(dir);
+  const end = path25.resolve(stop);
+  while (at !== end && isWithinDir2(end, at) && fs16.existsSync(at) && fs16.readdirSync(at).length === 0) {
+    fs16.rmdirSync(at);
+    at = path25.dirname(at);
+  }
 }
 function specFilesUnder(dir) {
   return fs16.existsSync(dir) ? listFilesRecursive(dir, ".yaml") : [];
@@ -36704,7 +37330,8 @@ function rawSpecs(files) {
   return out;
 }
 function typeTokens(expression) {
-  return typeof expression === "string" ? [...expression.matchAll(/[A-Za-z_][A-Za-z0-9_-]*/g)].map((m) => m[0]) : [];
+  if (typeof expression !== "string") return [];
+  return [...expression.matchAll(/(?:::)?[A-Za-z_][A-Za-z0-9_-]*(?:(?:::|\.)[A-Za-z_][A-Za-z0-9_-]*)*/g)].map((m) => m[0]).filter((t) => !t.includes(".") && !t.includes("::"));
 }
 function referencesOf(spec, wholeParams) {
   const out = [];
@@ -36713,13 +37340,13 @@ function referencesOf(spec, wholeParams) {
     return ref;
   });
   const expressions = [];
-  if (spec.kind === "interface") {
-    for (const m of spec.raw.methods ?? []) {
-      expressions.push(m?.returns);
-      for (const p of m?.params ?? []) if (wholeParams || !(typeof p?.type === "string" && /^[A-Za-z_][A-Za-z0-9_-]*$/.test(p.type))) expressions.push(p?.type);
-    }
+  for (const slot of typeExpressionSlots(spec.kind, spec.raw)) {
+    const value = slot.holder[slot.key];
+    if (slot.path === "methods.signatureFrom") continue;
+    if (slot.path === "methods.signature" && Array.isArray(slot.method?.params)) continue;
+    if (slot.path === "methods.params.type" && spec.kind === "interface" && !wholeParams && /^[A-Za-z_][A-Za-z0-9_-]*$/.test(String(value))) continue;
+    expressions.push(slot.path === "methods.signature" ? String(value).replace(/^\s*[A-Za-z_][\w-]*\s*(?:<[^>]*>)?\s*\(/, "(").replace(/(?<![:\w-])[A-Za-z_][\w-]*\s*\??\s*:(?!:)/g, "") : value);
   }
-  if (spec.kind === "type") for (const f of spec.raw.fields ?? []) expressions.push(f?.type);
   for (const token of expressions.flatMap(typeTokens)) out.push({ ref: token, position: "bare-type" });
   return out;
 }
@@ -36727,6 +37354,9 @@ function crossingsOf(inside, outside) {
   const idsOf = (specs) => new Set(specs.filter((s) => s.kind !== "system").map((s) => s.id));
   const insideIds = idsOf(inside);
   const outsideIds = idsOf(outside);
+  const targetsOf2 = (specs) => new Set(specs.filter((s) => s.kind === "component" || s.kind === "interface" || s.kind === "type").map((s) => s.id));
+  const insideTargets = targetsOf2(inside);
+  const outsideTargets = targetsOf2(outside);
   const typeIds = (specs) => new Map(specs.filter((s) => s.kind === "type").map((s) => [nameKey(s.id), s.id]));
   const insideTypes = typeIds(inside);
   const outsideTypes = typeIds(outside);
@@ -36744,13 +37374,14 @@ function crossingsOf(inside, outside) {
     }
     return found;
   };
-  return { out: collect(inside, outsideIds, outsideTypes, true), in: collect(outside, insideIds, insideTypes, false), insideIds, outsideIds };
+  return { out: collect(inside, outsideTargets, outsideTypes, true), in: collect(outside, insideTargets, insideTypes, false), insideIds, outsideIds, insideTargets, outsideTargets };
 }
 function promoteRefusals(family, insideFiles, outsideFiles, id) {
   const out = [];
   const inside = rawSpecs(insideFiles);
   const outside = rawSpecs(outsideFiles);
   const crossing = crossingsOf(inside, outside);
+  out.push(...unreachableUpward(inside, outside));
   const subsystemsIn = new Set(inside.filter((s) => s.kind === "subsystem").map((s) => s.id));
   for (const s of [...inside, ...outside].filter((x) => x.kind === "subsystem")) {
     for (const link of s.raw.trustedLinks ?? []) {
@@ -36792,13 +37423,19 @@ function climbsOf(family, ids, parentId) {
   return { map, refused: [...new Set(refused2)] };
 }
 var PROJECT_ID_RE_LOCAL = /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/;
-function rewriteRefsIn(specs, remap) {
+function rewriteRefsIn(specs, remap, record) {
   const rewritten = [];
   for (const spec of specs) {
     const raw = readYamlFile(spec.file);
-    if (!rewriteSpecRefs(raw, (ref, position) => remap(ref, position))) continue;
+    const edits = [];
+    if (!rewriteSpecRefs(raw, (ref, position) => {
+      const to = remap(ref, position);
+      if (to !== ref) edits.push({ kind: spec.kind, specId: spec.id, position, from: ref, to });
+      return to;
+    })) continue;
     writeYamlFile(spec.file, raw);
     rewritten.push({ kind: spec.kind, id: spec.id });
+    if (record) for (const e of edits) recordRespelling(record.result, e, record.member);
   }
   return rewritten;
 }
@@ -36848,15 +37485,19 @@ function promoteMember(alias, id) {
     patchKeepingStamp(s.file, (raw) => raw.parentSystem === projectName ? false : (raw.parentSystem = projectName, true));
   }
   if (declaration2?.as === "part") projectConfigRepository.updateMember(alias, { as: "" });
-  const parentSide = rewriteRefsIn(crossing.in.map((c) => c.spec).filter(unique), (ref, position) => INTO_MEMBER_POSITIONS.has(position) && crossing.insideIds.has(ref) ? `${alias}::${ref}` : ref);
+  const result = { respelled: [], memberRespelled: [], exported: [], imported: [], consumersDropped: [] };
+  const parentSide = rewriteRefsIn(crossing.in.map((c) => c.spec).filter(unique), (ref, position) => INTO_MEMBER_POSITIONS.has(position) && crossing.insideTargets.has(ref) ? `${alias}::${ref}` : ref, { result, member: false });
   const climbs = climbsOf(family, crossing.insideIds, parentId).map;
   const climbing = inside.filter((s) => family.authoredReferences.some((r) => r.form === "super" && r.specId === s.id));
-  const memberSide = rewriteRefsIn([...crossing.out.map((c) => c.spec), ...climbing].filter(unique), (ref, position) => climbs.get(ref) ?? (MOVED_REF_POSITIONS.has(position) && crossing.outsideIds.has(ref) ? `${parentId}::${ref}` : ref));
+  const memberSide = rewriteRefsIn([...crossing.out.map((c) => c.spec), ...climbing].filter(unique), (ref, position) => climbs.get(ref) ?? (MOVED_REF_POSITIONS.has(position) && crossing.outsideTargets.has(ref) ? `${parentId}::${ref}` : ref), { result, member: true });
+  const qualified = respellQualified(inside, outside, { alias, parentId, newId }, result);
   invalidateSpecCache();
-  if (crossing.out.length > 0 || [...climbs.values()].some((t) => t.startsWith(`${parentId}::`))) runWithProjectRoot(dir, () => projectConfigRepository.declareExternal(parentId, {}));
+  dropCrossingConsumers(inside, outside, result);
+  if (crossing.out.length > 0 || qualified.out.length > 0 || [...climbs.values()].some((t) => t.startsWith(`${parentId}::`))) runWithProjectRoot(dir, () => projectConfigRepository.declareExternal(parentId, {}));
   for (const s of inside.filter((x) => x.kind === "subsystem")) restateReExports(s.id, alias);
-  exportCrossings(crossing.out, dir, alias, parentId, "out");
-  exportCrossings(crossing.in, dir, alias, parentId, "in");
+  exportCrossings([...crossing.out, ...qualified.out], dir, alias, parentId, "out", result);
+  exportCrossings([...crossing.in, ...qualified.in], dir, alias, parentId, "in", result);
+  exportReExported(inside, dir, alias, result);
   invalidateSpecCache();
   for (const spec of parentSide) if (spec.kind !== "system") normalizeReferences(spec.kind, spec.id);
   const memberKey = graph().nodes.find((n) => n.parent === "" && n.mountAlias === alias)?.namespace;
@@ -36875,6 +37516,165 @@ function promoteMember(alias, id) {
     });
   }
   invalidateSpecCache();
+  return result;
+}
+function recordRespelling(result, edit4, member) {
+  if (edit4.from === edit4.to) return;
+  const list = member ? result.memberRespelled : result.respelled;
+  if (list.some((e) => e.kind === edit4.kind && e.specId === edit4.specId && e.position === edit4.position && e.from === edit4.from)) return;
+  list.push(edit4);
+}
+function assertedTypeRef(ref) {
+  const at = ref.lastIndexOf(".");
+  return at > 0 && at < ref.length - 1 ? ref.slice(0, at) : void 0;
+}
+function sidedTypes(inside, outside) {
+  const types = [
+    ...inside.filter((s) => s.kind === "type").map((s) => ({ spec: s, side: "inside" })),
+    ...outside.filter((s) => s.kind === "type").map((s) => ({ spec: s, side: "outside" }))
+  ];
+  const subsystems = new Set([...inside, ...outside].filter((s) => s.kind === "subsystem").map((s) => nameKey(s.id)));
+  return {
+    qualified: (token) => {
+      const segments = token.split(/::|\./);
+      if (segments.length !== 2 || segments.some((x) => x === "") || !subsystems.has(nameKey(segments[0]))) return void 0;
+      const found = types.filter((t) => typeof t.spec.raw.subsystem === "string" && nameKey(t.spec.raw.subsystem) === nameKey(segments[0]) && nameKey(t.spec.id) === nameKey(segments[1]));
+      return found.length === 1 ? found[0] : void 0;
+    },
+    bare: (token) => {
+      const found = types.filter((t) => nameKey(t.spec.id) === nameKey(token));
+      return found.length === 1 ? found[0] : void 0;
+    }
+  };
+}
+function unreachableUpward(inside, outside) {
+  const out = [];
+  const types = sidedTypes(inside, outside);
+  const outsideComponents = new Set(outside.filter((x) => x.kind === "component").map((x) => x.id));
+  const target = (ref) => ref.includes(".") || ref.includes("::") ? types.qualified(ref) : types.bare(ref);
+  for (const spec of inside) {
+    if (spec.kind === "interface") {
+      for (const m of spec.raw.methods ?? []) {
+        const source = m?.signatureFrom;
+        if (typeof source !== "string") continue;
+        const head2 = source.includes(".") ? source.slice(0, source.lastIndexOf(".")) : void 0;
+        if (target(source)?.side === "outside" || head2 !== void 0 && outsideComponents.has(head2)) {
+          out.push(`"${spec.id}" method "${m.name}" takes its signature from "${source}", which stays in this project: a signatureFrom is not read across a project boundary \u2014 state its params and returns first`);
+        }
+      }
+    }
+    if (spec.kind === "implementation") {
+      for (const m of spec.raw.methods ?? []) {
+        for (const step of m?.narrative ?? []) {
+          for (const ref of step?.assertsInvariants ?? []) {
+            const typeRef2 = typeof ref === "string" ? assertedTypeRef(ref) : void 0;
+            if (typeRef2 !== void 0 && !typeRef2.includes("::") && target(typeRef2)?.side === "outside") {
+              out.push(`"${spec.id}" asserts the invariant "${ref}" of an entity that stays in this project: an invariant is asserted by its own project's write paths \u2014 move the assertion first`);
+            }
+          }
+        }
+      }
+    }
+  }
+  return out;
+}
+function respellQualified(inside, outside, names, result) {
+  const crossings = { out: [], in: [] };
+  const { qualified: qualifiedTarget, bare: bareTarget } = sidedTypes(inside, outside);
+  const respell = (spec, side, token, target, selfPrefix2) => {
+    if (!target) return token;
+    if (target.side !== side) {
+      const to = `${side === "outside" ? names.alias : names.parentId}::${target.spec.id}`;
+      (side === "inside" ? crossings.out : crossings.in).push({ spec, target: target.spec.id, position: "type" });
+      return to;
+    }
+    return side === "inside" && selfPrefix2 ? target.spec.id : token;
+  };
+  for (const [specs, side] of [[inside, "inside"], [outside, "outside"]]) {
+    for (const spec of specs) {
+      if (!fs16.existsSync(spec.file)) continue;
+      const raw = readYamlFile(spec.file);
+      if (!raw || typeof raw !== "object") continue;
+      const edits = [];
+      const record = (from, to) => {
+        if (from !== to) edits.push({ kind: spec.kind, specId: spec.id, position: "type", from, to });
+      };
+      const mapToken = (token) => {
+        const target = qualifiedTarget(token);
+        const to = respell(spec, side, token, target, nameKey(token.split(/::|\./)[0]) === nameKey(names.newId));
+        record(token, to);
+        return to;
+      };
+      for (const slot of typeExpressionSlots(spec.kind, raw)) {
+        const value = slot.holder[slot.key];
+        if (slot.path === "methods.signatureFrom" && !qualifiedTarget(value)) continue;
+        slot.holder[slot.key] = respellTypeNames(value, mapToken);
+      }
+      if (spec.kind === "implementation") {
+        for (const m of raw.methods ?? []) {
+          for (const step of m?.narrative ?? []) {
+            if (!Array.isArray(step?.assertsInvariants)) continue;
+            step.assertsInvariants = step.assertsInvariants.map((ref) => {
+              const typeRef2 = typeof ref === "string" ? assertedTypeRef(ref) : void 0;
+              if (typeRef2 === void 0 || typeRef2.includes("::") && !qualifiedTarget(typeRef2)) return ref;
+              const target = typeRef2.includes(".") || typeRef2.includes("::") ? qualifiedTarget(typeRef2) : bareTarget(typeRef2);
+              const to = respell(spec, side, typeRef2, target, typeRef2.includes(".") && nameKey(typeRef2.split(".")[0]) === nameKey(names.newId));
+              if (to === typeRef2) return ref;
+              record(ref, `${to}${ref.slice(typeRef2.length)}`);
+              return `${to}${ref.slice(typeRef2.length)}`;
+            });
+          }
+        }
+      }
+      if (edits.length === 0) continue;
+      writeYamlFile(spec.file, raw);
+      for (const e of edits) recordRespelling(result, e, side === "inside");
+    }
+  }
+  return crossings;
+}
+function dropCrossingConsumers(inside, outside, result) {
+  const idsOf = (specs) => new Set(specs.filter((s) => s.kind === "subsystem").map((s) => s.id));
+  const sides = [[inside, idsOf(outside)], [outside, idsOf(inside)]];
+  for (const [specs, across] of sides) {
+    for (const spec of specs.filter((s) => s.kind === "subsystem")) {
+      patchKeepingStamp(spec.file, (raw) => {
+        let changed = false;
+        for (const entry of raw.publicInterfaces ?? []) {
+          if (!Array.isArray(entry?.consumers)) continue;
+          const dropped = entry.consumers.filter((c) => typeof c === "string" && across.has(c));
+          if (dropped.length === 0) continue;
+          const kept = entry.consumers.filter((c) => !dropped.includes(c));
+          if (kept.length > 0) entry.consumers = kept;
+          else delete entry.consumers;
+          changed = true;
+          const what = entry.component ?? entry.typeDef ?? entry.interface ?? entry.from ?? "(entry)";
+          result.consumersDropped.push(`${spec.id} ${what}: ${dropped.join(", ")}${kept.length === 0 ? " (the list is gone: the L0 export table governs who outside may use it)" : ""}`);
+        }
+        return changed;
+      });
+    }
+  }
+}
+function exportReExported(inside, memberDir, alias, result) {
+  invalidateSpecCache();
+  const entries = (loadSystemSpec()?.publicInterfaces ?? []).filter((e) => e.from === alias);
+  if (entries.length === 0) return;
+  const targets = entries.map((e) => e.component ?? e.typeDef).filter((t) => t !== void 0);
+  const whole = entries.some((e) => e.component === void 0 && e.typeDef === void 0);
+  runWithProjectRoot(memberDir, () => {
+    for (const name of exportItems(targets)) result.exported.push(`${alias} L0: ${name} (re-exported by the parent)`);
+    if (!whole) return;
+    invalidateSpecCache();
+    const system = loadSystemSpec();
+    if (!system) return;
+    const own = system.publicInterfaces ?? [];
+    const added = inside.filter((s) => s.kind === "subsystem" && !own.some((e) => e.from === s.id && e.component === void 0 && e.typeDef === void 0)).map((s) => ({ from: s.id, audience: "project" }));
+    if (added.length === 0) return;
+    saveSystemSpec({ ...system, publicInterfaces: [...own, ...added] });
+    for (const e of added) result.exported.push(`${alias} L0: everything ${e.from} exports (re-exported whole by the parent)`);
+  });
+  invalidateSpecCache();
 }
 function promotedVision(id, parentName) {
   return `Project ${id}, promoted from a part of ${parentName}`;
@@ -36882,43 +37682,57 @@ function promotedVision(id, parentName) {
 function unique(value, index, all) {
   return all.indexOf(value) === index;
 }
-function exportCrossings(crossings, memberDir, alias, parentId, direction) {
+function exportCrossings(crossings, memberDir, alias, parentId, direction, result) {
   const targets = [...new Set(crossings.map((c) => c.target))];
   const bare = [...new Set(crossings.filter((c) => c.position === "bare-type").map((c) => c.target))];
   if (direction === "out") {
-    exportItems(targets);
-    if (bare.length > 0) projectConfigRepositoryAt(memberDir).importNames(parentId, bare);
+    for (const name of exportItems(targets)) result.exported.push(`${parentId} L0: ${name}`);
+    if (bare.length > 0) {
+      projectConfigRepositoryAt(memberDir).importNames(parentId, bare);
+      result.imported.push(`${alias}: externals.${parentId}.use gains ${bare.join(", ")}`);
+    }
   } else {
-    runWithProjectRoot(memberDir, () => exportItems(targets));
-    if (bare.length > 0) projectConfigRepository.importNames(alias, bare);
+    for (const name of runWithProjectRoot(memberDir, () => exportItems(targets))) result.exported.push(`${alias} L0: ${name}`);
+    if (bare.length > 0) {
+      projectConfigRepository.importNames(alias, bare);
+      result.imported.push(`${parentId}: members.${alias}.use gains ${bare.join(", ")}`);
+    }
   }
 }
 function localIn(key, project) {
   return project && key.startsWith(`${project}::`) ? key.slice(project.length + 2) : key;
 }
 function exportItems(ids) {
-  if (ids.length === 0) return;
+  if (ids.length === 0) return [];
   invalidateSpecCache();
   const system = loadSystemSpec();
-  if (!system) return;
+  if (!system) return [];
   const entries = [...system.publicInterfaces ?? []];
   const types = loadTypeSpecs();
+  const added = [];
   for (const id of ids) {
     if (!PUBLIC_NAME_RE.test(id)) continue;
     const type = types.find((t) => t.id === id);
     if (type) {
       if (type.subsystem) exportTypeFromSubsystem(type.subsystem, id);
-      if (!entries.some((e) => e.typeDef === id && e.from === void 0)) entries.push({ typeDef: id, audience: "project" });
+      if (!entries.some((e) => e.typeDef === id && (e.from === void 0 || e.from === type.subsystem))) {
+        entries.push({ ...type.subsystem ? { from: type.subsystem } : {}, typeDef: id, audience: "project" });
+        added.push(type.subsystem ? `${id} (from ${type.subsystem})` : id);
+      }
       continue;
     }
     const component = loadComponentSpec(id);
     if (!component) continue;
     const exported = resolveSubsystemExports(component.subsystem).entries.some((e) => e.kind === "component" && e.component === id);
-    if (exported && !entries.some((e) => e.component === id)) entries.push({ from: component.subsystem, component: id, audience: "project" });
+    if (exported && !entries.some((e) => e.component === id)) {
+      entries.push({ from: component.subsystem, component: id, audience: "project" });
+      added.push(`${id} (from ${component.subsystem})`);
+    }
   }
   if (entries.length !== (system.publicInterfaces ?? []).length) {
     saveSystemSpec({ ...system, publicInterfaces: entries });
   }
+  return added;
 }
 function exportTypeFromSubsystem(subsystemId, typeId) {
   const sub = loadSubsystemSpec(subsystemId);
@@ -36962,7 +37776,7 @@ function internalizeMember(alias, destination) {
   if (refusals.length > 0) {
     throw new WaironError(`cannot internalize "${alias}": the member cannot be taken in whole \u2014 ${refusals.join("; ")}.`);
   }
-  const result = { subsystems: scan.subsystems, types: scan.types, placed: [], externals: [], deleted: [], notCarried: [] };
+  const result = { subsystems: scan.subsystems, types: scan.types, placed: [], externals: [], deleted: [], notCarried: [], consumersRestored: [] };
   const intoMember = crossingReferences(family, "", member.namespace);
   const backOut = crossingReferences(family, member.namespace, "");
   deleteMount(alias);
@@ -36992,7 +37806,7 @@ function internalizePart(alias, part) {
   projectConfigRepository.removeMember(alias);
   const deleted = deleteMemberWai(partDir);
   invalidateSpecCache();
-  return { subsystems: part.subsystems, types, placed: [], externals: [], deleted, notCarried: [] };
+  return { subsystems: part.subsystems, types, placed: [], externals: [], deleted, notCarried: [], consumersRestored: [] };
 }
 function scanMember(family, alias, member, destination) {
   const root = getProjectRoot();
@@ -37341,7 +38155,7 @@ function demoteMember(alias, destination) {
     refusals.push(`its metadata needs a home subsystem (--home) \u2014 ${home === "" ? "none was named" : `"${home}" is no subsystem of the member or of this project`}; its subsystems are ${subsystems.join(", ") || "none"}`);
   }
   if (refusals.length > 0) throw new WaironError(`demote refused: "${alias}" cannot become a part \u2014 ${refusals.join("; ")}.`);
-  const result = { subsystems, types, placed: [], externals: [], deleted: [], notCarried: [] };
+  const result = { subsystems, types, placed: [], externals: [], deleted: [], notCarried: [], consumersRestored: [] };
   const intoMember = localsOf(dir);
   const backOut = localsOf(root);
   invalidateSpecCache();
@@ -37358,6 +38172,10 @@ function demoteMember(alias, destination) {
   const parentSide = rewriteRefsIn(ownSpecs, across(/* @__PURE__ */ new Set([alias]), intoMember, false));
   const memberSide = rewriteRefsIn(memberSpecs, across(parentAliases, backOut, true));
   for (const pa of parentAliases) for (const name of config?.externals?.[pa]?.use ?? []) if (name !== "*") crossed.add(backOut.get(name) ?? name);
+  const memberNow = rawSpecs(specFilesUnder(aiPathsAt(dir).specsDir()).filter((f) => path25.resolve(f) !== path25.resolve(aiPathsAt(dir).specsSystem())));
+  const parentNow = rawSpecs(ownSpecFiles(family, aiPathsAt(dir).specsDir()));
+  respellQualifiedBack(parentNow, memberNow, { intoMember: (a) => a === alias, backOut: (a) => parentAliases.has(a) }, { intoMember, backOut }, crossed);
+  restoreCrossingConsumers(memberNow, parentNow, result);
   const parentName = loadSystemSpec()?.name;
   if (parentName) {
     for (const s of memberSpecs.filter((x) => x.kind === "subsystem")) {
@@ -37382,6 +38200,79 @@ function demoteMember(alias, destination) {
   invalidateSpecCache();
   return result;
 }
+function respellQualifiedBack(parentSide, memberSide, aliases, tables, crossed) {
+  const types = [...parentSide, ...memberSide].filter((s) => s.kind === "type");
+  const localForm = (id) => {
+    const found = types.filter((t) => t.id === id);
+    if (found.length !== 1) return void 0;
+    const sub = found[0].raw?.subsystem;
+    return typeof sub === "string" && sub !== "" ? `${sub}.${id}` : id;
+  };
+  for (const [specs, across, table, record] of [
+    [parentSide, aliases.intoMember, tables.intoMember, false],
+    [memberSide, aliases.backOut, tables.backOut, true]
+  ]) {
+    const local = (token) => {
+      const segments = token.split("::");
+      if (segments.length !== 2 || !across(segments[0])) return token;
+      const id = table.get(segments[1]) ?? segments[1];
+      const to = localForm(id);
+      if (to === void 0) return token;
+      if (record) crossed.add(id);
+      return to;
+    };
+    for (const spec of specs) {
+      if (!fs16.existsSync(spec.file)) continue;
+      const raw = readYamlFile(spec.file);
+      if (!raw || typeof raw !== "object") continue;
+      let changed = false;
+      for (const slot of typeExpressionSlots(spec.kind, raw)) {
+        const value = slot.holder[slot.key];
+        const next = respellTypeNames(value, local);
+        if (next !== value) {
+          slot.holder[slot.key] = next;
+          changed = true;
+        }
+      }
+      if (spec.kind === "implementation") {
+        for (const m of raw.methods ?? []) {
+          for (const step of m?.narrative ?? []) {
+            if (!Array.isArray(step?.assertsInvariants)) continue;
+            step.assertsInvariants = step.assertsInvariants.map((ref) => {
+              const typeRef2 = typeof ref === "string" ? assertedTypeRef(ref) : void 0;
+              if (typeRef2 === void 0 || !typeRef2.includes("::")) return ref;
+              const to = local(typeRef2);
+              if (to === typeRef2) return ref;
+              changed = true;
+              return `${to}${ref.slice(typeRef2.length)}`;
+            });
+          }
+        }
+      }
+      if (changed) writeYamlFile(spec.file, raw);
+    }
+  }
+}
+function restoreCrossingConsumers(memberSide, parentSide, result) {
+  const sides = [[memberSide, parentSide], [parentSide, memberSide]];
+  for (const [providers, consumers] of sides) {
+    const dependents = consumers.filter((c) => c.kind === "component" && typeof c.raw?.subsystem === "string" && Array.isArray(c.raw?.dependsOn));
+    for (const spec of providers.filter((x) => x.kind === "subsystem")) {
+      patchKeepingStamp(spec.file, (raw) => {
+        let changed = false;
+        for (const entry of raw.publicInterfaces ?? []) {
+          if (!Array.isArray(entry?.consumers) || entry.consumers.length === 0 || typeof entry.component !== "string") continue;
+          const users = [...new Set(dependents.filter((c) => c.raw.dependsOn.includes(entry.component)).map((c) => c.raw.subsystem))].filter((sub) => sub !== spec.id && !entry.consumers.includes(sub));
+          if (users.length === 0) continue;
+          entry.consumers = [...entry.consumers, ...users];
+          changed = true;
+          result.consumersRestored.push(`${spec.id} ${entry.component}: ${users.join(", ")}`);
+        }
+        return changed;
+      });
+    }
+  }
+}
 function deleteProjectContent(memberDir) {
   const wai = path25.join(memberDir, ".wai");
   const deleted = [];
@@ -37411,9 +38302,9 @@ function retireBoundaryExports(family, used, memberKey) {
   const { publicInterfaces: _dropped, ...rest } = system;
   saveSystemSpec(kept.length > 0 ? { ...rest, publicInterfaces: kept } : rest);
   invalidateSpecCache();
-  for (const e of retired.filter((x) => x.typeDef !== void 0 && x.from === void 0)) {
+  for (const e of retired.filter((x) => x.typeDef !== void 0)) {
     const type = loadTypeSpecs().find((t) => t.id === e.typeDef);
-    if (!type?.subsystem) continue;
+    if (!type?.subsystem || e.from !== void 0 && e.from !== type.subsystem) continue;
     patchKeepingStamp(getSubsystemPath(type.subsystem), (raw) => {
       const before = (raw.publicInterfaces ?? []).length;
       raw.publicInterfaces = (raw.publicInterfaces ?? []).filter((pi) => !(pi?.typeDef === e.typeDef && pi?.from === void 0 && Object.keys(pi).length === 1));
@@ -37436,7 +38327,7 @@ function advanceMember(alias, ref, commit2, dryRun) {
   const url = member.source.git;
   const from = member.source.commit ?? "";
   const followed = commit2 === void 0 ? ref ?? member.source.ref : void 0;
-  const to = commit2 ?? resolve7(url, followed);
+  const to = commit2 ?? resolve3(url, followed);
   const after = specContents(fetch(url, to, member.source.dir));
   const before = specContents(from !== "" ? fetch(url, from, member.source.dir) : null);
   const added = [...after.keys()].filter((f) => !before.has(f)).sort();
@@ -37582,7 +38473,7 @@ function renameComponent(componentId, newId) {
   }
   if (componentId.includes("::")) {
     throw new WaironError(
-      `chained-component: "${componentId}" lives in a chained subproject; rename it from that project's own root.`
+      `chained-component: "${componentId}" lives in another project; rename it from that project's own root. ${memberRootWay(componentId, `sdd_rename_component ${componentId.slice(componentId.lastIndexOf("::") + 2)} <new id>`)}`
     );
   }
   if (!SpecIdSchema.safeParse(newId).success) {
@@ -37745,7 +38636,7 @@ function renameMethod(componentId, methodName, newName, pinSymbol) {
   }
   if (componentId.includes("::")) {
     throw new WaironError(
-      `chained-component: "${componentId}" lives in a chained subproject; rename its method from that project's own root.`
+      `chained-component: "${componentId}" lives in another project; rename its method from that project's own root. ${memberRootWay(componentId, `sdd_rename_method ${componentId.slice(componentId.lastIndexOf("::") + 2)} <method> <new name>`)}`
     );
   }
   if (!METHOD_NAME.test(newName)) {
@@ -37903,18 +38794,29 @@ function respellLike(written, oldId, newId) {
   if (written.includes("-")) return kebab(newId);
   return /^[A-Z]/.test(written) ? pascal(newId) : newId;
 }
+function memberRootWay(qualifiedId, call) {
+  const alias = qualifiedId.slice(0, qualifiedId.indexOf("::"));
+  let folder;
+  try {
+    const node = graph().nodes.find((n) => n.namespace === alias || n.parent === "" && n.mountAlias === alias);
+    if (node) folder = path25.relative(getProjectRoot(), node.directory).split(path25.sep).join("/") || ".";
+  } catch {
+  }
+  const where = folder ? `the member project "${alias}" at ${folder}` : `the member project "${alias}"`;
+  return `It belongs to ${where}: open a session in that folder (its own guide and .mcp.json \u2014 run \`wairon generate\` and \`wairon mcp install --backend claude\` there first if it has none) and call ${call} there.`;
+}
 function renameType(typeId, newId) {
   const all = loadTypeSpecs();
   const cut = typeId.lastIndexOf("::");
   const qualifier = cut >= 0 ? typeId.slice(0, cut) : void 0;
   const ownSubsystem = qualifier !== void 0 && loadSubsystemSpecs().some((s) => s.id === qualifier);
   if (qualifier !== void 0 && !ownSubsystem) {
-    throw new WaironError(`chained-type: "${typeId}" lives in another project; rename it from that project's own root.`);
+    throw new WaironError(`chained-type: "${typeId}" lives in another project; rename it from that project's own root. ${memberRootWay(typeId, `sdd_rename_type ${typeId.slice(cut + 2)} <new id>`)} An exported type keeps its public name through \`as\`, so this project's references do not break.`);
   }
   const type = qualifier !== void 0 ? all.find((t) => t.id === typeId.slice(cut + 2) && t.subsystem === qualifier) ?? null : loadTypeSpec(typeId);
   if (!type) throw new WaironError(`type-missing: no type has the id "${typeId}".`);
   if (type.id.includes("::")) {
-    throw new WaironError(`chained-type: "${type.id}" lives in another project; rename it from that project's own root.`);
+    throw new WaironError(`chained-type: "${type.id}" lives in another project; rename it from that project's own root. ${memberRootWay(type.id, `sdd_rename_type ${type.id.slice(type.id.lastIndexOf("::") + 2)} <new id>`)}`);
   }
   const oldId = type.id;
   if (!SpecIdSchema.safeParse(newId).success) {
@@ -38202,8 +39104,8 @@ function walkForPackages(projectRoot, currentDir, depth, results) {
   }
 }
 function pathToId(relPath) {
-  const basename12 = path26.basename(relPath);
-  return basename12.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const basename13 = path26.basename(relPath);
+  return basename13.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
 function pathToName(relPath) {
   const id = pathToId(relPath);
@@ -38687,7 +39589,7 @@ function isWithinDir3(dir, target) {
   const rel2 = path29.relative(path29.resolve(dir), path29.resolve(target));
   return rel2 === "" || !rel2.startsWith("..") && !path29.isAbsolute(rel2);
 }
-function resolveLayer(delegate) {
+function resolveLayer(delegate, implementers = false) {
   projectFilesCache.clear();
   const system = loadSystemSpec();
   if (!system) return [];
@@ -38818,7 +39720,7 @@ function resolveLayer(delegate) {
       updatedAt: sub.updatedAt
     });
   }
-  if (config.rules.generateComponentImplementers) {
+  if (config.rules.generateComponentImplementers || implementers) {
     for (const comp of components) {
       const compInterfaces = interfaces.filter((i) => i.component === comp.id);
       const compInterfaceIds = compInterfaces.map((i) => i.id);
@@ -38886,7 +39788,7 @@ function resolveLayer(delegate) {
 }
 var UnknownAgentError = class extends WaironError {
   constructor(agentId, knownIds) {
-    super(`Unknown agent id: "${agentId}". Known agent ids: ${knownIds.join(", ")}`);
+    super(`Unknown agent id: "${agentId}". Known agent ids: ${knownIds.join(", ")} \u2014 or any component id of this project, which composes that component's implementer brief.`);
     this.name = "UnknownAgentError";
   }
 };
@@ -38897,7 +39799,7 @@ function composeAgentBrief(agentId) {
     return throughMount(brief, hop.alias, hop.relative);
   }
   const records = resolveAgentTopology();
-  const record = records.find((r) => r.id === agentId);
+  const record = records.find((r) => r.id === agentId) ?? componentImplementer(agentId);
   if (!record) {
     throw new UnknownAgentError(agentId, records.map((r) => r.id));
   }
@@ -38916,6 +39818,17 @@ function composeAgentBrief(agentId) {
     domainName: "",
     variantGuidance: record.variantGuidance ?? ""
   });
+  const codeFence = codeFenceOf(record);
+  if (codeFence) {
+    instructions = `${instructions.trimEnd()}
+
+## Code write fence
+
+${codeFence.length > 0 ? `Write code only here (and tests beside it, as the project lays tests out):
+
+${codeFence.map((p) => `- \`${p}\``).join("\n")}
+` : "No implementation names a source file yet, so no code location is declared. The spawning session must name the file(s) this agent may create (the planned sourcePath); set `sourcePath` on the implementation once the file exists.\n"}`;
+  }
   const guidance = loadAgentOverride(agentId);
   if (guidance !== null) {
     instructions = `${instructions.trimEnd()}
@@ -38950,10 +39863,34 @@ ${typeMapping.map((line) => `- ${line}`).join("\n")}
     instructions,
     variantGuidance: record.variantGuidance || void 0,
     ...typeMapping ? { typeMapping } : {},
+    ...codeFence ? { codeFence } : {},
     profile: budget ? profile : void 0,
     budget
   };
 }
+function componentImplementer(agentId) {
+  const componentId = agentId.endsWith("-implementer") ? agentId.slice(0, -"-implementer".length) : agentId;
+  if (componentId === "" || componentId.includes("::")) return null;
+  return resolveLayer(true, true).find((r) => r.id === `${componentId}-implementer`) ?? null;
+}
+function codeFenceOf(record) {
+  const implementsComponents = record.template === "implementer" || record.template === "domain-owner" && record.creationReason.startsWith("Automatically inferred from L1");
+  if (!implementsComponents) return null;
+  const files = record.ownedPaths.filter((p) => !p.startsWith(".wai/") && !p.includes("/.wai/") && !/[*?]/.test(p));
+  if (files.length === 0) return [];
+  const dirs = files.map((f) => path29.posix.dirname(f.replace(/\\/g, "/")));
+  let shared = dirs[0].split("/");
+  for (const dir of dirs.slice(1)) {
+    const parts = dir.split("/");
+    let i = 0;
+    while (i < shared.length && i < parts.length && shared[i] === parts[i]) i++;
+    shared = shared.slice(0, i);
+  }
+  const folder = shared.join("/");
+  const fence = [...files];
+  if (folder !== "" && folder !== ".") fence.push(`${folder}/**`);
+  return fence;
+}
 function implementationLanguage(record) {
   const owned = new Set(record.ownedPaths);
   const implementations = loadImplementationSpecs().filter((impl) => implementationSourceFiles(impl).some((file) => owned.has(file)));
@@ -38977,17 +39914,18 @@ function memberHop(agentId) {
   const alias = agentId.slice(0, at);
   const member = graph().nodes.find((n) => n.parent === "" && n.mountAlias === alias);
   if (!member) return null;
-  const relative19 = path29.relative(getProjectRoot(), member.directory).split(path29.sep).join("/");
-  return { alias, rest: agentId.slice(at + 2), directory: member.directory, relative: relative19 };
+  const relative20 = path29.relative(getProjectRoot(), member.directory).split(path29.sep).join("/");
+  return { alias, rest: agentId.slice(at + 2), directory: member.directory, relative: relative20 };
 }
-function throughMount(brief, alias, relative19) {
-  const under = (p) => path29.posix.join(relative19, p);
+function throughMount(brief, alias, relative20) {
+  const under = (p) => path29.posix.join(relative20, p);
   return {
     ...brief,
     agentId: `${alias}::${brief.agentId}`,
     ownedPaths: brief.ownedPaths.map(under),
+    ...brief.codeFence ? { codeFence: brief.codeFence.map(under) } : {},
     ...brief.readPaths ? { readPaths: brief.readPaths.map(under) } : {},
-    root: brief.root ? under(brief.root) : relative19
+    root: brief.root ? under(brief.root) : relative20
   };
 }
 function loadRegistry() {
@@ -39266,19 +40204,19 @@ function commitStagedTree(stagingDir, destDir, roots, backupExisting) {
   const backupDir = path34.join(root, BACKUP_DIR, timestampSlug());
   let backedUp = false;
   for (const rootRel of roots) {
-    const relative19 = rootRel === "." ? "" : rootRel;
-    const stagedSpecDir = path34.join(stagingDir, relative19, ".wai");
+    const relative20 = rootRel === "." ? "" : rootRel;
+    const stagedSpecDir = path34.join(stagingDir, relative20, ".wai");
     if (!fs20.existsSync(stagedSpecDir)) continue;
-    const liveSpecDir = liveSpecDirFor(path34.join(root, relative19));
+    const liveSpecDir = liveSpecDirFor(path34.join(root, relative20));
     if (backupExisting && liveSpecDir && fs20.existsSync(liveSpecDir)) {
-      const backupTarget = path34.join(backupDir, relative19, path34.basename(liveSpecDir));
+      const backupTarget = path34.join(backupDir, relative20, path34.basename(liveSpecDir));
       fs20.mkdirSync(path34.dirname(backupTarget), { recursive: true });
       fs20.renameSync(liveSpecDir, backupTarget);
       backedUp = true;
     } else if (liveSpecDir && fs20.existsSync(liveSpecDir)) {
       fs20.rmSync(liveSpecDir, { recursive: true, force: true });
     }
-    const target = path34.join(root, relative19, ".wai");
+    const target = path34.join(root, relative20, ".wai");
     fs20.mkdirSync(path34.dirname(target), { recursive: true });
     if (fs20.existsSync(target)) fs20.rmSync(target, { recursive: true, force: true });
     fs20.renameSync(stagedSpecDir, target);
@@ -39557,7 +40495,7 @@ function repairTypeSpellings(apply3) {
     const key = `${kind}:${specId}`;
     let repair = repairs.get(key);
     if (!repair) {
-      repair = { specId, kind, rewritten: [], proposals: [], authorNeeded: [] };
+      repair = { specId, kind, rewritten: [], proposals: [], enumProposals: [], authorNeeded: [] };
       repairs.set(key, repair);
     }
     return repair;
@@ -39572,7 +40510,9 @@ function repairTypeSpellings(apply3) {
     if (problem.specId === void 0 || problem.kind === void 0 || !own(problem.specId)) continue;
     const repair = repairOf(problem.specId, problem.kind);
     const proposal = typeProblemIntProposal(problem);
+    const enumProposal = proposal ? null : typeProblemEnumProposal(problem);
     if (proposal) repair.proposals.push(proposal);
+    else if (enumProposal) repair.enumProposals.push(enumProposal);
     else repair.authorNeeded.push(problem);
   }
   const planned = [...repairs.values()];
@@ -39713,13 +40653,14 @@ Approved: ${approval.lockedAt} by ${by} \u2014 no spec has changed since.${child
 ${headline} \u2014 approved ${approval.lockedAt} by ${by}:
 ` + named2.map((p) => `  ${p}`).join("\n") + (rest > 0 ? `
   \u2026 and ${rest} more` : "") + childNote + "\n",
-      drifted: true
+      drifted: true,
+      moved: [...diff2.changed.map((p) => `~ ${p}`), ...diff2.added.map((p) => `+ ${p}`), ...diff2.removed.map((p) => `- ${p}`)]
     };
   } catch {
     return quiet;
   }
 }
-var GATE_UPGRADE_NOTE = "the gate identity gained inputs in stage 5 (members' composition subjects, `composition`; code conformance moved beside the claim)";
+var GATE_UPGRADE_NOTE = "the gate identity gained inputs in this release (members' composition subjects, `composition`; code conformance moved beside the claim)";
 function memberNotes(approvals) {
   const own = approvals.find((a) => a.key === "");
   const direct = approvals.filter((a) => a.parent === "" && a.as !== "part");
@@ -39801,33 +40742,34 @@ var GLOBAL_GUIDE_BODY = `## wairon \u2014 Spec-Driven Development (optional)
 If \`.wai/specs/\` exists, the wairon SDD workflow is active; otherwise ignore it. wairon does not orchestrate sessions \u2014 it equips yours.
 
 ### In SDD Projects:
-- **Source of Truth**: All architecture lives in the spec tree under \`.wai/specs/\` (L0 System \u2192 L1 Subsystem \u2192 L2 Component \u2192 L3 Interface \u2192 L4 Implementation \u2192 L5 Narrative). Do not edit generated agent config files under \`.claude/agents/\` (rebuilt via \`wairon generate\`).
+- **Source of Truth**: All architecture lives in the spec tree under \`.wai/specs/\` (L0 System \u2192 L1 Subsystem \u2192 L2 Component \u2192 L3 Interface \u2192 L4 Implementation \u2192 L5 Narrative). Agent files under \`.claude/agents/\` are an opt-in generated view (\`rules.materializeAgentFiles\`) \u2014 never edit them; agents are served as live briefs.
 - **Validation**: Conformance checks (stereotype rules, cycle checks, reference integrity) are run via the \`sdd_validate_tree\` MCP tool.
 - **Operating Rules**:
   1. **Skills**: Use \`sdd-architect\` to design (and \`sdd-implement\`, \`sdd-narrative\`, \`sdd-auditor\`). Refer to project's local guide file for detailed constraints.
   2. **MCP Tools Only**: Author/validate specs *only* via \`sdd_*\` tools (e.g. \`sdd_initialize_system\`, \`sdd_validate_tree\`).
   3. **No CLI Exec**: Do not run the \`wairon\` CLI (human tool). Use MCP tools \`sdd_validate_tree\` and \`sdd_get_status\` instead.
   4. **Delegation**: Delegate implementation via the \`sdd-delegate\` skill \u2014 live agent briefs (\`sdd_get_agent_brief\` MCP tool / \`wairon-agent://\` resource) are composed per call and always current; no session restart. Generated agent files are an optional materialized view of the same topology. User-owned per-agent guidance may live in \`.wai/agents/<agent-id>.md\` (folded into every brief; scaffold via \`wairon agent customize <id>\`).
-  5. **Design First**: Complete spec and pass \`sdd_validate_tree\` before writing code.
+  5. **Design First, then approval**: Complete the spec and pass \`sdd_validate_tree\`, then ask the human to approve it with \`wairon lock\` before writing code. Approval is the lock record (\`.wai/lock.json\`), not a spec's \`status\` \u2014 the lock does not rewrite statuses; \`sdd_get_status\` reports the approval state.
   6. **Consistency**: Code must match L3 interfaces and L5 narratives exactly. If the spec is wrong, stop and update the spec.
-  7. **Members & References**: A project may contain other wairon projects as **members**, declared in its \`.wai/project.yaml\` \`members\` (create one with \`sdd_add_member\`); each member has its own spec tree, designed from its own root. Reference what another project exports as \`alias::name\` (the alias is a member or a declared external, the name a public name of its L0 export table); an id without \`::\` is local. A leading \`::\`, \`super::\`, member paths and an L1 subsystem carrying \`projectPath\` are deprecated: they still resolve for one release, are reported, and \`wairon doctor --fix\` rewrites them.`;
+  7. **Members & References**: A project may declare **members** in its \`.wai/project.yaml\` \`members\` (create one with \`sdd_add_member\`). A **part** (the default) stores some of this project's subsystems in another folder or repository: local ids, this project's lock. A **project** member is an independent boundary with its own spec tree and lock, designed from its own root. Reference what another project exports as \`alias::name\` (the alias is a member or a declared external, the name a public name of its L0 export table); an id without \`::\` is local. A leading \`::\`, \`super::\`, member paths and an L1 subsystem carrying \`projectPath\` are deprecated: they still resolve for one release, are reported, and \`wairon doctor --fix\` rewrites them.`;
 var LOCAL_GUIDE_BODY = `## Wairon \u2014 Spec-Driven Development (you are operating inside it)
 
 This project uses **wairon**. System specs live under \`.wai/specs/\` (L0 System \u2192 L1 Subsystem \u2192 L2 Component \u2192 L3 Interface \u2192 L4 Implementation \u2192 Narrative); agent topology and code are derived from it.
 
 **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.
-- **Handoff to implementation**: Once design is complete and validates cleanly, tell the human: *"The specs are complete and validate. Please run \`wairon lock\` to confirm and freeze them."* No session restart is needed after the lock \u2014 delegate implementation right away via the \`sdd-delegate\` skill.
+- **Handoff to implementation**: Once design is complete and validates cleanly, tell the human: *"The specs are complete and validate. Please run \`wairon lock\` to approve them, and commit \`.wai/lock.json\`."* The lock records the approval; it does not rewrite spec files or their \`status\`. No session restart is needed after the lock \u2014 delegate implementation right away via the \`sdd-delegate\` skill.
+- **Approval, not status**: a design is ready to implement when it is APPROVED \u2014 \`sdd_get_status\` reports the approval state (approved, or which specs changed since), and \`wairon lock-check\` gives the same verdict in CI. A spec's \`status\` (draft/design/complete) is authoring readiness only; never wait for it to become \`complete\`.
 - **To implement code**: Delegate via the \`sdd-delegate\` skill: fetch the component's live brief with the \`sdd_get_agent_brief\` MCP tool (or the \`wairon-agent://\` resource) and spawn a subagent from it. Briefs are composed per call from the current spec tree, so they are always current \u2014 never wait for a restart. Implementations must match L3 interfaces and L5 narratives exactly. Generated agent files under \`.claude/agents/\` are an optional materialized view of the same topology \u2014 the live briefs are canonical.
 
 ### Rules (enforced by \`sdd_validate_tree\`)
@@ -39867,7 +40809,7 @@ ${GUIDE_MARKER_END}
   const stripped = stripGuideSection(existing);
   const newContent = stripped.trimEnd() + section;
   fs21.mkdirSync(path36.dirname(filePath), { recursive: true });
-  fs21.writeFileSync(filePath, newContent, "utf-8");
+  writeFile(filePath, newContent);
 }
 function stripGuideSection(content) {
   const start = content.indexOf(GUIDE_MARKER_START);
@@ -39890,7 +40832,7 @@ To design or modify the system, invoke the **\`sdd-architect\`** skill
 (in \`.claude/skills/\`). Author and validate specs with the \`sdd_*\` MCP tools;
 the \`wairon\` CLI is the human developer's tool, not yours.
 `;
-    fs21.writeFileSync(filePath, content, "utf-8");
+    writeFile(filePath, content);
   } else if (targetType === "gemini" || targetType === "agy") {
     const filePath = path36.join(projectRoot, "GEMINI.md");
     const content = `# Wairon SDD Project
@@ -39899,7 +40841,7 @@ ${versionStamp()}
 ${LOCAL_GUIDE_BODY}
 ${GUIDE_MARKER_END}
 `;
-    fs21.writeFileSync(filePath, content, "utf-8");
+    writeFile(filePath, content);
   } else if (targetType === "cursor") {
     const filePath = path36.join(projectRoot, ".cursorrules");
     const content = `# Wairon SDD Project
@@ -39908,7 +40850,7 @@ This project uses the Wairon Spec-Driven Development (SDD) framework.
 
 Refer to the rules in [.cursor/rules/](.cursor/rules/) for full instructions.
 `;
-    fs21.writeFileSync(filePath, content, "utf-8");
+    writeFile(filePath, content);
   } else if (targetType === "copilot") {
     const filePath = path36.join(projectRoot, ".github", "copilot-instructions.md");
     fs21.mkdirSync(path36.dirname(filePath), { recursive: true });
@@ -39918,14 +40860,14 @@ This project uses the Wairon Spec-Driven Development (SDD) framework.
 
 Refer to the prompts in [.github/prompts/](.github/prompts/) for instructions.
 `;
-    fs21.writeFileSync(filePath, content, "utf-8");
+    writeFile(filePath, content);
   } else if (targetType === "codex") {
     const filePath = path36.join(projectRoot, ".codexrules");
     const content = `# Wairon SDD Project
 
 Refer to [.codex/agents/](.codex/agents/) for full instructions.
 `;
-    fs21.writeFileSync(filePath, content, "utf-8");
+    writeFile(filePath, content);
   }
 }
 var GUIDE_TARGETS = ["claude", "gemini", "agy", "cursor", "copilot", "codex"];
@@ -40080,9 +41022,17 @@ function syncContextFiles() {
 var path37 = __toESM(require("path"));
 function approvalTag(entry) {
   if (!entry) return "";
-  const state = entry.upgraded ? `${entry.state}, re-lock once` : entry.state;
-  return entry.pinned ? ` [${state} \xB7 pin ${entry.pinned}]` : ` [${state}]`;
-}
+  const words2 = APPROVAL_WORDS[entry.state];
+  const state = entry.upgraded ? `${words2}, re-lock once` : words2;
+  return entry.pinned ? ` [${state} \xB7 ${PIN_WORDS[entry.pinned]}]` : ` [${state}]`;
+}
+var APPROVAL_WORDS = { approved: "approved", drifted: "drifted", never: "never approved" };
+var PIN_WORDS = { matches: "pinned", moved: "pin moved", unpinned: "not pinned" };
+var OWN_APPROVAL_WORDS = {
+  approved: "approved",
+  drifted: "drifted \u2014 its approval no longer covers this tree (`wairon lock` re-approves)",
+  never: "never approved (`wairon lock` approves the design)"
+};
 var asWritten = (text3) => text3;
 function fillDecor(decor) {
   return {
@@ -40168,11 +41118,15 @@ function getStatusReport(options = {}, decor) {
     }
     componentScores.set(comp.id, score);
   }
+  const typeOwners = new Set(loadTypeSpecs().map((t) => t.subsystem).filter((id) => typeof id === "string"));
   const getSubsystemScore = (subId) => {
     const sub = subsystems.find((s) => s.id === subId);
     if (!sub) return 0;
     const subComps = components.filter((c) => c.subsystem === subId);
-    if (subComps.length === 0) return 0;
+    if (subComps.length === 0) {
+      if (!typeOwners.has(subId)) return 0;
+      return sub.status === "complete" ? 100 : 50;
+    }
     const totalScore = subComps.reduce((acc, c) => acc + (componentScores.get(c.id) ?? 0), 0);
     let avg = Math.round(totalScore / subComps.length);
     if (sub.status === "draft" || sub.status === "design") {
@@ -40295,8 +41249,7 @@ function getStatusReport(options = {}, decor) {
 `;
   }
   const own = options.approvals?.find((a) => a.key === "");
-  const hasMembers = (options.approvals ?? []).some((a) => a.key !== "" && a.as !== "part");
-  if (own && (own.state !== "never" || hasMembers)) output += `${mark.layer("system", "Approval:")} this project is ${own.state}${own.upgraded ? " (locked under the pre-stage-5 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 };
 }
@@ -41478,7 +42431,7 @@ var KINDS_AT = {
   auth: ["implementation"],
   subsystem: ["component", "type"],
   group: ["type"],
-  type: ["interface", "type"]
+  type: ["interface", "type", "implementation"]
 };
 function kindOf(ref) {
   const kinds = KINDS_AT[ref.position] ?? ["component", "interface", "implementation", "type", "subsystem"];
@@ -42558,7 +43511,7 @@ function emptyPlan(family, request) {
   const whole = !(reach2 !== null && !reach2.parentReach);
   return { request, familyRoot: familyNode(family, "").directory, whole, edits: [], refusals: [], changes: [], relock: [], notes: [] };
 }
-var posix3 = (p) => p.split(path43.sep).join("/");
+var posix5 = (p) => p.split(path43.sep).join("/");
 var refuse = (plan6, code, project, detail) => {
   plan6.refusals.push({ code, project, detail });
 };
@@ -42636,7 +43589,7 @@ function attachEdits(plan6, family, bound2, dir, alias, bindingConfig) {
     edit(plan6, key, "id", `id: ${id} (declared${approved !== void 0 ? ", the id its lock approved" : ""})`, { root: dir, call: "setId", args: [id] });
   }
   if (!attached) plan6.notes.push(`${dir} has no project.yaml of its own \u2014 \`wairon doctor --fix\` writes one declaring "${alias}" as its id`);
-  const relPath = posix3(path43.relative(familyNode(family, bound2).directory, dir));
+  const relPath = posix5(path43.relative(familyNode(family, bound2).directory, dir));
   const declaration2 = { path: relPath, ...plan6.request.description !== void 0 ? { description: plan6.request.description } : {} };
   edit(plan6, bound2, "member", `members: ${alias} \u2192 ${relPath} (an existing project, kept as it is)`, { root: familyNode(family, bound2).directory, call: "declareMember", args: [alias, declaration2] });
   for (const requirement of requiredPolicies(bindingConfig)) {
@@ -42683,8 +43636,8 @@ function planDetach(family, bound2, request) {
   if (plan6.request.widen) planWidening(plan6, member, narrow);
   if (plan6.refusals.length > 0) return plan6;
   const boundDir = familyNode(family, bound2).directory;
-  const held = memberDeclarationOf(configAt3(boundDir)?.members?.[alias] ?? posix3(path43.relative(boundDir, member.directory)));
-  const declared = { ...held, path: memberLocationOf(held) ?? posix3(path43.relative(boundDir, member.directory)) };
+  const held = memberDeclarationOf(configAt3(boundDir)?.members?.[alias] ?? posix5(path43.relative(boundDir, member.directory)));
+  const declared = { ...held, path: memberLocationOf(held) ?? posix5(path43.relative(boundDir, member.directory)) };
   detachEdits(plan6, family, bound2, member, alias, declared, consumers, outward);
   return plan6;
 }
@@ -42724,7 +43677,7 @@ function planWidening(plan6, member, narrow) {
 function detachEdits(plan6, family, bound2, member, alias, declared, consumers, outward) {
   const boundDir = familyNode(family, bound2).directory;
   const relocation = plan6.request.relocation;
-  const sourceTo = (from, producer) => relocation ? { hosted: producer.id ?? producer.mountAlias ?? producer.namespace } : { path: posix3(path43.relative(from, producer.directory)) };
+  const sourceTo = (from, producer) => relocation ? { hosted: producer.id ?? producer.mountAlias ?? producer.namespace } : { path: posix5(path43.relative(from, producer.directory)) };
   const where = (source) => source.hosted !== void 0 ? `hosted record ${source.hosted}` : source.path;
   edit(plan6, bound2, "member", `members: ${alias} removed (${declared.path} ${relocation ? `moves to ${relocation.to}` : "stays as it is"})`, { root: boundDir, call: "removeMember", args: [alias] });
   const boundSource = relocation ? sourceTo(boundDir, member) : { path: declared.path };
@@ -42798,7 +43751,7 @@ function adoptEdits(plan6, family, bound2, alias, external, dir, at = dir) {
   edit(plan6, bound2, "pin", `pin ${alias} removed (the family supplies it now)`, { root: boundDir, call: "unpin", args: [alias] });
   edit(plan6, bound2, "external", `externals: ${alias} removed`, { root: boundDir, call: "removeExternal", args: [alias] });
   const declaration2 = {
-    path: posix3(path43.relative(boundDir, at)),
+    path: posix5(path43.relative(boundDir, at)),
     ...external.description !== void 0 ? { description: external.description } : {},
     ...external.use && external.use.length > 0 ? { use: external.use } : {}
   };
@@ -42909,7 +43862,7 @@ var KINDS_AT2 = {
   auth: ["implementation"],
   subsystem: ["component", "type"],
   group: ["type"],
-  type: ["interface", "type"]
+  type: ["interface", "type", "implementation"]
 };
 function kindOf2(ref) {
   const kinds = KINDS_AT2[ref.position] ?? ["component", "interface", "implementation", "type", "subsystem"];
@@ -43057,9 +44010,33 @@ function planAliasRename(family, bound2, request) {
   if ([...family.owners].some(([key, owner]) => owner === bound2 && key.split("::").pop() === next)) {
     plan6.notes.push(`${label5(bound2)} has a spec whose id is "${next}" \u2014 a local id equal to an alias (LOCAL_ID_SHADOWS_PROJECT reports it)`);
   }
+  repinIntactConsumers(plan6, family, bound2);
   return plan6;
 }
-var PHASES = ["rewriteReferences", "renameAlias", "repointExternal", "renameId", "renamePin"];
+function repinIntactConsumers(plan6, family, bound2) {
+  const boundNode2 = familyNode(family, bound2);
+  for (const node of family.nodes) {
+    if (path44.resolve(node.directory) === path44.resolve(boundNode2.directory)) continue;
+    let statuses = [];
+    try {
+      statuses = runWithProjectRoot(node.directory, () => getExternalsStatus2());
+    } catch {
+      continue;
+    }
+    for (const status of statuses) {
+      const producer = node.aliases.get(status.alias);
+      const pinsBound = producer !== void 0 ? producer === bound2 : boundNode2.id !== void 0 && status.project === boundNode2.id;
+      if (!status.pinned || status.outOfReach || !pinsBound) continue;
+      const broken = status.uses.filter((u) => u.state === "changed" || u.state === "removed");
+      if (broken.length > 0) {
+        plan6.notes.push(`${label5(node.namespace)}'s pin of "${status.alias}" is already incompatible (${broken.map((u) => u.publicName ?? u.member ?? "?").join(", ")}): not re-pinned \u2014 adapt its uses, then run \`wairon externals pin ${status.alias}\` there.`);
+        continue;
+      }
+      edit2(plan6, node.namespace, "pin", `pin ${status.alias} taken again: the names it uses of ${label5(bound2)} are unchanged`, { root: node.directory, call: "pinExternals", args: [[status.alias]] });
+    }
+  }
+}
+var PHASES = ["rewriteReferences", "renameAlias", "repointExternal", "renameId", "renamePin", "pinExternals"];
 function write4(plan6, rehearsal) {
   const planned = plan6.edits.filter((e) => e.write !== void 0);
   const unknown = planned.find((x) => !PHASES.includes(x.write.call));
@@ -43074,6 +44051,7 @@ function write4(plan6, rehearsal) {
     for (const e of planned.filter((x) => x.write.call === "renameId")) writeOne2(rehearsal, e.write);
   }
   for (const e of planned.filter((x) => x.write.call === "renamePin")) writeOne2(rehearsal, e.write);
+  for (const e of planned.filter((x) => x.write.call === "pinExternals")) writeOne2(rehearsal, e.write);
 }
 function referencesBySpec(planned) {
   const out = /* @__PURE__ */ new Map();
@@ -43097,6 +44075,8 @@ function writeOne2(rehearsal, w) {
         return renameProjectId(args[0], args[1]);
       case "renamePin":
         return renamePin2(args[0], args[1], args[2]);
+      case "pinExternals":
+        return pinExternals2(args[0]);
       default:
         throw new Error(`identity_migration makes no "${w.call}" write`);
     }
@@ -43110,7 +44090,7 @@ function emptyPlan3(family, request) {
   const whole = !(reach2 !== null && !reach2.parentReach);
   return { request, familyRoot: familyNode(family, "").directory, whole, edits: [], refusals: [], changes: [], relock: [], notes: [] };
 }
-var posix4 = (p) => p.split(path45.sep).join("/");
+var posix6 = (p) => p.split(path45.sep).join("/");
 var label6 = (key) => key === "" ? "the top project" : `"${key}"`;
 var refuse3 = (plan6, code, project, detail) => {
   plan6.refusals.push({ code, project, detail });
@@ -43141,7 +44121,7 @@ var KINDS_AT3 = {
   auth: ["implementation"],
   subsystem: ["component", "type"],
   group: ["type"],
-  type: ["interface", "type"]
+  type: ["interface", "type", "implementation"]
 };
 function kindOf3(ref) {
   const kinds = KINDS_AT3[ref.position] ?? ["component", "interface", "implementation", "type", "subsystem"];
@@ -43320,7 +44300,7 @@ function respellConsumer(plan6, family, c, own) {
 function repointConsumer(plan6, c, boundNode2) {
   const declared = configAt5(c.node.directory)?.externals?.[c.alias];
   const project = boundNode2.id !== void 0 && boundNode2.id !== c.alias ? boundNode2.id : null;
-  const source = declared?.source ? { path: posix4(path45.relative(c.node.directory, boundNode2.directory)) } : null;
+  const source = declared?.source ? { path: posix6(path45.relative(c.node.directory, boundNode2.directory)) } : null;
   edit3(plan6, c.node.namespace, "external", `externals: ${c.alias} names ${boundNode2.id ?? "the top project"}${source ? ` at ${source.path}` : ""}`, { root: c.node.directory, call: "repointExternal", args: [c.alias, project, source] });
   plan6.notes.push(`${label6(c.node.namespace)}'s pin of "${c.alias}" is taken again against ${boundNode2.id ?? "the top project"}: the producer changed, so its lock reads drifted until it is re-locked.`);
   return c;
@@ -43356,8 +44336,8 @@ function planExternalize(family, bound2, request) {
       plan6,
       bound2,
       "move",
-      `externalize ${id}: its specs into ${joined ? `the part "${joined.alias}"` : `a part at ${posix4(path45.relative(node.directory, dir))}, declared as "${id}"`} \u2014 a storage move; no reference, export or pin changes`,
-      { root: node.directory, call: "externalizeSubsystem", args: [id, posix4(path45.relative(node.directory, dir))] }
+      `externalize ${id}: its specs into ${joined ? `the part "${joined.alias}"` : `a part at ${posix6(path45.relative(node.directory, dir))}, declared as "${id}"`} \u2014 a storage move; no reference, export or pin changes`,
+      { root: node.directory, call: "externalizeSubsystem", args: [id, posix6(path45.relative(node.directory, dir))] }
     );
     plan6.notes.push("Source code is not moved: move the subsystem's code yourself if it should live beside its specs.");
     return plan6;
@@ -43366,8 +44346,9 @@ function planExternalize(family, bound2, request) {
   crossingsBack(plan6, family, bound2, subKey);
   checkSiblings(plan6, family, bound2, id, subKey, table);
   if (plan6.refusals.length > 0) return plan6;
-  edit3(plan6, bound2, "move", `externalize ${id} as a project: its specs into a member at ${posix4(path45.relative(node.directory, dir))}, declared as "${id}", then promoted`, { root: node.directory, call: "externalizeSubsystem", args: [id, posix4(path45.relative(node.directory, dir)), "project"] });
+  edit3(plan6, bound2, "move", `externalize ${id} as a project: its specs into a member at ${posix6(path45.relative(node.directory, dir))}, declared as "${id}", then promoted`, { root: node.directory, call: "externalizeSubsystem", args: [id, posix6(path45.relative(node.directory, dir)), "project"] });
   edit3(plan6, id, "pin", `pin the new member's externals (its external for ${node.id ?? "this project"}, when its specs reference it)`, { root: dir, call: "pinExternals", args: [[]] });
+  repinIntactConsumers2(plan6, family, bound2, [dir]);
   plan6.notes.push("Source code is not moved: move the subsystem's code into the member yourself.");
   return plan6;
 }
@@ -43496,6 +44477,7 @@ function planPromote(family, bound2, request) {
   );
   edit3(plan6, newId, "pin", `pin the new project's external for ${node.id ?? "this project"} (when its specs reference it)`, { root: part.directory, call: "pinExternals", args: [[]] });
   if (part.storage !== "contained") edit3(plan6, bound2, "pin", `pin ${alias} (a project stored outside ${label6(bound2)} is judged against its pin)`, { root: node.directory, call: "pinExternals", args: [[alias]] });
+  repinIntactConsumers2(plan6, family, bound2, [part.directory]);
   plan6.notes.push(`"${newId}" has no lock yet: lock it at its own root (\`wairon lock\`) once it validates.`);
   return plan6;
 }
@@ -43562,16 +44544,19 @@ function write5(plan6, rehearsal) {
     return;
   }
   if (plan6.request.verb === "externalize") {
-    for (const e of planned.filter((x) => x.write.call === "externalizeSubsystem")) writeOne3(rehearsal, e.write);
+    for (const e of planned.filter((x) => x.write.call === "externalizeSubsystem")) recordCrossing(plan6, e.project, e.write.args[0], writeOne3(rehearsal, e.write));
     for (const e of planned.filter((x) => x.write.call === "pinExternals")) writeOne3(rehearsal, e.write);
     return;
   }
   if (plan6.request.verb === "promote") {
-    for (const e of planned.filter((x) => x.write.call === "promoteMember")) writeOne3(rehearsal, e.write);
+    for (const e of planned.filter((x) => x.write.call === "promoteMember")) recordCrossing(plan6, e.project, e.write.args[1] ?? e.write.args[0], writeOne3(rehearsal, e.write));
     for (const e of planned.filter((x) => x.write.call === "pinExternals")) writeOne3(rehearsal, e.write);
     return;
   }
-  for (const e of planned.filter((x) => x.write.call === "demoteMember")) writeOne3(rehearsal, e.write);
+  for (const e of planned.filter((x) => x.write.call === "demoteMember")) {
+    const demoted = writeOne3(rehearsal, e.write);
+    for (const line of demoted?.consumersRestored ?? []) plan6.edits.push({ project: e.project, kind: "reference", detail: `consumers across the old boundary restored: ${line}` });
+  }
   for (const e of planned.filter((x) => x.write.call === "unpin")) writeOne3(rehearsal, e.write);
 }
 function referencesBySpec2(planned) {
@@ -43584,9 +44569,46 @@ ${id}`) ?? [], ...edits]);
   }
   return out;
 }
+function repinIntactConsumers2(plan6, family, bound2, created) {
+  const boundNode2 = familyNode(family, bound2);
+  const skip = new Set([boundNode2.directory, ...created].map((d) => path45.resolve(d)));
+  for (const node of family.nodes) {
+    if (skip.has(path45.resolve(node.directory))) continue;
+    let statuses = [];
+    try {
+      statuses = runWithProjectRoot(node.directory, () => getExternalsStatus2());
+    } catch {
+      continue;
+    }
+    for (const status of statuses) {
+      const producer = node.aliases.get(status.alias);
+      const pinsBound = producer !== void 0 ? producer === bound2 : boundNode2.id !== void 0 && status.project === boundNode2.id;
+      if (!status.pinned || status.outOfReach || !pinsBound) continue;
+      const broken = status.uses.filter((u) => u.state === "changed" || u.state === "removed");
+      if (broken.length > 0) {
+        plan6.notes.push(`${label6(node.namespace)}'s pin of "${status.alias}" is already incompatible (${broken.map((u) => u.publicName ?? u.member ?? "?").join(", ")}): not re-pinned \u2014 adapt its uses, then run \`wairon externals pin ${status.alias}\` there.`);
+        continue;
+      }
+      edit3(plan6, node.namespace, "pin", `pin ${status.alias} taken again: the names it uses of ${label6(bound2)} only move with the boundary`, { root: node.directory, call: "pinExternals", args: [[status.alias]] });
+    }
+  }
+}
+function recordCrossing(plan6, bound2, member, result) {
+  const crossed = result;
+  if (!crossed) return;
+  for (const r of crossed.respelled) {
+    plan6.edits.push({ project: bound2, kind: "reference", detail: `${r.specId} (${r.position}): ${r.from} \u2192 ${r.to}`, reference: r });
+  }
+  for (const r of crossed.memberRespelled) {
+    plan6.edits.push({ project: member, kind: "reference", detail: `${r.specId} (${r.position}): ${r.from} \u2192 ${r.to}`, reference: r });
+  }
+  for (const line of crossed.exported) plan6.edits.push({ project: bound2, kind: "export", detail: `export ${line}` });
+  for (const line of crossed.imported) plan6.edits.push({ project: bound2, kind: "external", detail: `import: ${line}` });
+  for (const line of crossed.consumersDropped) plan6.edits.push({ project: bound2, kind: "reference", detail: `consumers across the boundary to ${member} dropped: ${line}` });
+}
 function writeOne3(rehearsal, w) {
   const args = w.args;
-  runWithProjectRoot(rehearsalRoot(rehearsal, w.root), () => {
+  return runWithProjectRoot(rehearsalRoot(rehearsal, w.root), () => {
     switch (w.call) {
       case "internalizeMember":
         return internalizeMember(args[0], args[1]);
@@ -43621,7 +44643,7 @@ var path46 = __toESM(require("path"));
 var fs26 = __toESM(require("fs"));
 var os7 = __toESM(require("os"));
 var nodePath2 = __toESM(require("path"));
-var yaml3 = __toESM(require("js-yaml"));
+var yaml4 = __toESM(require("js-yaml"));
 var TRANSACTIONS2 = nodePath2.join(".wai", "transactions");
 var transactionsDir = (owner) => nodePath2.join(owner, TRANSACTIONS2);
 var transactionDir = (owner, id) => nodePath2.join(transactionsDir(owner), id);
@@ -43688,7 +44710,7 @@ function dropRehearsal(id) {
 function saveJournal(journal) {
   const ignore = nodePath2.join(transactionsDir(journal.owner), ".gitignore");
   if (!fs26.existsSync(ignore)) writeDurably(ignore, "*\n");
-  writeDurably(nodePath2.join(transactionDir(journal.owner, journal.id), "journal.yaml"), yaml3.dump(journal, { noRefs: true, lineWidth: 200 }));
+  writeDurably(nodePath2.join(transactionDir(journal.owner, journal.id), "journal.yaml"), yaml4.dump(journal, { noRefs: true, lineWidth: 200 }));
 }
 function readJournal(owner, id) {
   const file = nodePath2.join(transactionDir(owner, id), "journal.yaml");
@@ -43700,7 +44722,7 @@ function readJournal(owner, id) {
     throw e;
   }
   try {
-    return yaml3.load(text3);
+    return yaml4.load(text3);
   } catch (e) {
     throw new Error(`${file} is not a readable transaction journal: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -44495,7 +45517,7 @@ function errText(message) {
 function errMessage(e) {
   return errText(e instanceof Error ? e.message : String(e));
 }
-var TYPE_REF_GRAMMAR = (what) => `${what}, in the neutral type grammar: a primitive (string, int, float, bool, bytes, date, datetime, duration, any; void only as a whole returns), a defined type id ("billing.Invoice", "alias::name"), list<T>, set<T>, map<K, V> (K is string, int or an enum), T? (T or no value), a union of NAMED types ("Invoice | Receipt"), and on a returns only, async T ("async void"). Every named type must resolve. TypeScript spellings are accepted and respelled \u2014 "Invoice[]" \u2192 list<Invoice>, "Invoice | null" \u2192 Invoice?, boolean \u2192 bool, Record<string, V> \u2192 map<string, V>, Promise<T> \u2192 async T \u2014 and the answer lists each respelling. Refused, naming the replacement: number ("int or float?"), inline object or function types (name a value-object or a signature type), string-literal unions (name an enum), and unions mixing in a primitive or a collection.`;
+var TYPE_REF_GRAMMAR = (what) => `${what}, in the neutral type grammar: a primitive (string, int, float, bool, bytes, date, datetime, duration, any; void only as a whole returns), a defined type id ("billing.Invoice", "alias::name"), list<T>, set<T>, map<K, V> (K is string, int or an enum), T? (T or no value), a union of NAMED types ("Invoice | Receipt"), and on a returns only, async T ("async void") and result<T, E> (completes with T or fails with E; "async result<void, E>"). Every named type must resolve. TypeScript and Rust spellings are accepted and respelled \u2014 "Invoice[]" \u2192 list<Invoice>, "Invoice | null" \u2192 Invoice?, boolean \u2192 bool, Record<string, V> \u2192 map<string, V>, Promise<T> \u2192 async T, Result<(), E> \u2192 result<void, E> \u2014 and the answer lists each respelling. Refused, naming the replacement: number ("int or float?"), inline object or function types (name a value-object or a signature type), string-literal unions (name an enum), and unions mixing in a primitive or a collection.`;
 function structured(content, data) {
   return { content: [{ type: "text", text: content }], structuredContent: data };
 }
@@ -44519,10 +45541,19 @@ ${body}`);
 }
 function migrationView(report3, dryRun) {
   const plan6 = report3.plan;
+  const request = plan6.request;
+  const madeProject = request.verb === "promote" || request.verb === "externalize" && request.as === "project";
+  const madeAt = madeProject && report3.applied ? plan6.changes.find((c) => c.action === "create" && c.path.replace(/\\/g, "/") === ".wai/project.yaml")?.project : void 0;
   return {
     dryRun,
     applied: report3.applied,
     relock: report3.applied ? report3.relock : plan6.relock,
+    ...madeAt ? {
+      newProject: {
+        root: madeAt,
+        next: `The new project at ${madeAt} has no guide, skills or MCP registration of its own yet. The human runs, in that folder: \`wairon generate\` and \`wairon mcp install --backend claude\` (the CLI's \`wairon member promote\` / \`subsystem externalize --as project\` do this themselves). Its own session then designs it \u2014 its specs, L0 export table and project.yaml are written from its own root.`
+      }
+    } : {},
     ...report3.outcome ? { outcome: { committed: report3.outcome.committed, restored: report3.outcome.restored, unrestored: report3.outcome.unrestored, ...report3.outcome.failure ? { failure: report3.outcome.failure } : {} } } : {},
     plan: {
       verb: plan6.request.verb,
@@ -44595,6 +45626,28 @@ function renderChangeReport(report3) {
   return lines.join("\n");
 }
 var SPEC_KINDS = ["system", "subsystem", "component", "interface", "implementation", "type"];
+function specKindsHolding(id) {
+  const system = loadSystemSpec();
+  const held = {
+    system: !!system && (id === "system" || id === system.name),
+    subsystem: !!loadSubsystemSpec(id),
+    component: !!loadComponentSpec(id),
+    interface: !!loadInterfaceSpec(id),
+    implementation: !!loadImplementationSpec(id),
+    type: !!loadTypeSpec(id)
+  };
+  return SPEC_KINDS.filter((k) => held[k]);
+}
+var PORTAL_TYPE_TRANSPORT = {
+  HTTP_API: "HTTP",
+  gRPC: "gRPC",
+  GraphQL: "GraphQL",
+  MessageBus: "MessageBus",
+  NamedPipe: "NamedPipe",
+  IPC: "IPC",
+  CLI: "CLI",
+  Custom: void 0
+};
 var STATUS_VALUES = ["draft", "design", "complete"];
 var testsToRevisitOutput = import_zod12.z.array(import_zod12.z.object({
   method: import_zod12.z.string().describe("The contract method this write changed or deleted."),
@@ -44737,7 +45790,7 @@ var memberCreationOutput = {
     profile: import_zod12.z.string().optional()
   })).describe("Requirements no installed version satisfies: nothing was written for them, and the next family run reports each as POLICY_NOT_ADOPTED."),
   projectType: import_zod12.z.string().optional().describe("The profile written as the new member's projectType, when exactly one adopted requirement names one."),
-  as: import_zod12.z.string().describe("part | project: what was created (stage 8; a part by default)."),
+  as: import_zod12.z.string().describe("part | project: what was created (a part by default)."),
   storage: import_zod12.z.string().describe("contained | path | git: where its files live."),
   commit: import_zod12.z.string().optional().describe("git: the commit the member was pinned at."),
   ...staleServerOutput
@@ -45319,7 +46372,7 @@ ${renderChangeReport(report3)}`,
     server,
     "sdd_add_member",
     {
-      description: "Create a member of the bound project at `source`, in the one members grammar: `services/scheduler` (contained), `../admin` (a sibling checkout), `git@host:acme/payments.git` (a git repository, pinned at its default branch head unless `#<commit>` is given). By default a PART (stage 8): a piece of this project stored in another folder or repository, whose subsystems are this project's own (local ids, the ordinary subsystem rules, this project's lock); it gets only a specs folder, plus a configuration naming this project when it is not contained. With `as: project` an independent PROJECT instead: its project content is created \u2014 a project.yaml declaring the alias as its id, its L0, and the bound project's required packs (composition.requirePolicies) once \u2014 and it is reached only as `alias::name` through its L0 exports. What a member is follows from that content. A git member is not scaffolded; the repository's content decides what it is. Boundaries are earned: create a part unless the piece needs its own team, release, approval or public surface; sdd_promote_member makes one later. Idempotent \u2014 the same call again writes nothing; a different member under the alias is refused.",
+      description: "Create a member of the bound project at `source`, in the one members grammar: `services/scheduler` (contained), `../admin` (a sibling checkout), `git@host:acme/payments.git` (a git repository, pinned at its default branch head unless `#<commit>` is given). By default a PART: a piece of this project stored in another folder or repository, whose subsystems are this project's own (local ids, the ordinary subsystem rules, this project's lock); it gets only a specs folder, plus a configuration naming this project when it is not contained. With `as: project` an independent PROJECT instead: its project content is created \u2014 a project.yaml declaring the alias as its id, its L0, and the bound project's required packs (composition.requirePolicies) once \u2014 and it is reached only as `alias::name` through its L0 exports. What a member is follows from that content. A git member is not scaffolded; the repository's content decides what it is. Boundaries are earned: create a part unless the piece needs its own team, release, approval or public surface; sdd_promote_member makes one later. Idempotent \u2014 the same call again writes nothing; a different member under the alias is refused.",
       inputSchema: {
         alias: import_zod12.z.string().describe("The member's alias ([a-z0-9-_]+); a project's new id"),
         source: import_zod12.z.string().describe("A contained path, a `../` sibling path, or a git URL (optionally `#<commit>`)"),
@@ -45389,7 +46442,7 @@ ${renderChangeReport(report3)}`,
     server,
     "sdd_externalize_subsystem",
     {
-      description: "Move an internal subsystem out to the path. By default (stage 8) into a PART \u2014 a storage move: the subsystem's specs move to that directory (a new part, or the existing part there), and nothing else changes: no reference, export, external or lock entry, the same verdict. With `as: project`, into a member PROJECT instead, family-wide and all-or-nothing \u2014 the move followed by a promote: what crosses the new boundary exported and imported, references respelled `alias::name`, the new member's external for this project pinned, and every other family project's references checked to still resolve (a reference that would need a component made public refuses the plan). Source code is not moved. dryRun answers the plan and writes nothing; run it first and show the plan. Never locks: the answer names the projects to re-lock.",
+      description: "Move an internal subsystem out to the path. By default into a PART \u2014 a storage move: the subsystem's specs move to that directory (a new part, or the existing part there), and nothing else changes: no reference, export, external or lock entry, the same verdict. With `as: project`, into a member PROJECT instead, family-wide and all-or-nothing \u2014 the move followed by a promote: what crosses the new boundary exported and imported, references respelled `alias::name`, the new member's external for this project pinned, and every other family project's references checked to still resolve (a reference that would need a component made public refuses the plan). Source code is not moved. dryRun answers the plan and writes nothing; run it first and show the plan. Never locks: the answer names the projects to re-lock.",
       inputSchema: {
         subsystem: import_zod12.z.string().describe("The subsystem to move out"),
         path: import_zod12.z.string().describe("The part's root, relative to the bound project (a new directory, or an existing part's)"),
@@ -45403,7 +46456,7 @@ ${renderChangeReport(report3)}`,
     server,
     "sdd_promote_member",
     {
-      description: "Promote a part of the bound project to an independent project in place (stage 8) \u2014 its files stay where they are; it gets an id, an L0 exporting exactly what the rest of the project uses of it, its references across the new boundary respelled `alias::name`, the parent declared as its external, and pins on both sides. Refused (each reason listed) for a part fetched from git, a trusted link that would cross the new boundary, a used component its subsystem does not publish, or an id already taken. All-or-nothing; dryRun answers the plan and writes nothing \u2014 run it first and show the plan. Never locks: the answer names the project to re-lock and the new one to lock.",
+      description: "Promote a part of the bound project to an independent project in place \u2014 its files stay where they are; it gets an id, an L0 exporting exactly what the rest of the project uses of it, its references across the new boundary respelled `alias::name`, the parent declared as its external, and pins on both sides. Refused (each reason listed) for a part fetched from git, a trusted link that would cross the new boundary, a used component its subsystem does not publish, or an id already taken. All-or-nothing; dryRun answers the plan and writes nothing \u2014 run it first and show the plan. Never locks: the answer names the project to re-lock and the new one to lock.",
       inputSchema: {
         alias: import_zod12.z.string().describe("The part's alias"),
         id: import_zod12.z.string().optional().describe("The new project's id (default: the alias)"),
@@ -45416,7 +46469,7 @@ ${renderChangeReport(report3)}`,
     server,
     "sdd_demote_member",
     {
-      description: "Demote a project member of the bound project to a part in place (stage 8) \u2014 sdd_promote_member's inverse: its files stay where they are; its own metadata goes to the homes the destination names (as sdd_internalize_member sends it), its L0, lock and pins end, its references across the old boundary become local ids, and its configuration is reduced to naming its parent. Refused while another family project consumes it (a part has no exports \u2014 each consumer listed), for a member fetched from git, or for internalize's reasons. All-or-nothing; dryRun answers the plan and writes nothing \u2014 run it first and show the plan. Never locks.",
+      description: "Demote a project member of the bound project to a part in place \u2014 sdd_promote_member's inverse: its files stay where they are; its own metadata goes to the homes the destination names (as sdd_internalize_member sends it), its L0, lock and pins end, its references across the old boundary become local ids, and its configuration is reduced to naming its parent. Refused while another family project consumes it (a part has no exports \u2014 each consumer listed), for a member fetched from git, or for internalize's reasons. All-or-nothing; dryRun answers the plan and writes nothing \u2014 run it first and show the plan. Never locks.",
       inputSchema: {
         alias: import_zod12.z.string().describe("The project member's alias"),
         destination: import_zod12.z.object({
@@ -45759,7 +46812,7 @@ ${renderChangeReport(report3)}`,
         interface: import_zod12.z.string().describe('The L3 interface ID (e.g. "ibilling-gateway")'),
         endpoints: import_zod12.z.array(import_zod12.z.object({
           method: import_zod12.z.string().describe("The NAME of the interface method to bind (not the HTTP verb)"),
-          transport: import_zod12.z.enum(["HTTP", "gRPC", "GraphQL", "MessageBus", "NamedPipe", "IPC", "CLI", "Custom"]).describe("Wire protocol; must match the Portal's portalType"),
+          transport: import_zod12.z.enum(["HTTP", "HTTP_API", "gRPC", "GraphQL", "MessageBus", "NamedPipe", "IPC", "CLI", "Custom"]).describe("Wire protocol; must be the one the Portal's portalType implies. Either vocabulary is accepted: the endpoint's (HTTP) or the portalType's (HTTP_API), stored as HTTP; any other transport is refused, naming the one the portalType implies"),
           httpMethod: import_zod12.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]).optional().describe("HTTP: verb"),
           path: import_zod12.z.string().optional().describe('HTTP: route path, e.g. "/v1/checkout"'),
           service: import_zod12.z.string().optional().describe("gRPC: service name"),
@@ -45782,8 +46835,10 @@ ${renderChangeReport(report3)}`,
       try {
         const intf = loadInterfaceSpec(interfaceId);
         if (!intf) return errText(`Interface "${interfaceId}" does not exist.`);
-        const buildRaw = (e) => {
-          switch (e.transport) {
+        const owner = intf.component ? loadComponentSpec(intf.component) : null;
+        const implied = owner?.componentType === "Portal" && owner.portalType ? PORTAL_TYPE_TRANSPORT[owner.portalType] : void 0;
+        const buildRaw = (e, transport) => {
+          switch (transport) {
             case "HTTP":
               return { transport: "HTTP", method: e.httpMethod, path: e.path };
             case "gRPC":
@@ -45807,13 +46862,19 @@ ${renderChangeReport(report3)}`,
         for (const e of endpoints) {
           const m = intf.methods.find((x) => x.name === e.method);
           if (!m) return errText(`Method "${e.method}" not found on interface "${interfaceId}". Define it via sdd_define_interface first.`);
-          const parsed = EndpointSchema.safeParse(buildRaw(e));
+          const transport = e.transport === "HTTP_API" ? "HTTP" : e.transport;
+          if (implied && transport !== implied) {
+            return errText(
+              `Method "${e.method}": transport "${e.transport}" does not match ${owner.id}'s portalType ${owner.portalType}, which implies transport "${implied}". Bind it as "${implied}", or change the Portal's portalType.`
+            );
+          }
+          const parsed = EndpointSchema.safeParse(buildRaw(e, transport));
           if (!parsed.success) {
             const detail = parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
-            return errText(`Invalid ${e.transport} endpoint for method "${e.method}": ${detail}`);
+            return errText(`Invalid ${transport} endpoint for method "${e.method}": ${detail}`);
           }
           methods.push({ name: e.method, endpoint: parsed.data });
-          bound2.push(`${e.method}\u2192${e.transport}`);
+          bound2.push(`${e.method}\u2192${transport}`);
         }
         const report3 = updateSpecGated("interface", interfaceId, { methods });
         return structured(
@@ -46074,14 +47135,24 @@ ${renderChangeReport(report3)}`,
     {
       description: `Get/read the parsed JSON contents of a specific spec from the spec tree. Returns structural contents without file system path searching. Pass "methods" to read only the named methods of a contract, an implementation or a type \u2014 a 45-method spec fetched whole to look at one of them is the read side of the same waste a restatement is on the write side; the answer then carries a "partialResult" marker naming what was left out, and must never be re-authored from. For a variant-tagged COMPONENT the result also carries a derived, read-only "variantGuidance" (the variant's base, its implementation guidance, and the same-variant sibling components to implement alike) \u2014 it is resolved from the variant registry, not part of the spec, so never write it back. A contract's methods come back in their STORED form \u2014 a method that takes its signature from a source carries its signatureFrom, not the params the loader resolves into it \u2014 so the answer can be re-authored from as it is; the resolved params, returns and text of each such method come back as a derived, read-only "resolvedSignatures" marker. The structured content carries the same answer with the derived markers KEPT SEPARATE from the stored spec ({kind, id, spec, partialResult?, variantGuidance?, resolvedSignatures?}), so nothing derived can be mistaken for something stored; the text block folds them in as it always has.`,
       inputSchema: {
-        kind: import_zod12.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).describe("The kind of specification"),
+        kind: import_zod12.z.enum(["system", "subsystem", "component", "interface", "implementation", "type"]).optional().describe("The kind of specification. Omit it to infer the kind from the id: the read is refused, naming the candidate kinds, when the id names specs at more than one level (an interface and an implementation sharing an id, say), or at none"),
         id: import_zod12.z.string().describe('The identifier of the spec to fetch (the L0 system spec is a singleton \u2014 pass the system name or "system")'),
         methods: import_zod12.z.array(import_zod12.z.string().min(1)).optional().describe("Return only these methods by name; every other field of the spec comes back unchanged. Only an interface, an implementation or a type declares methods \u2014 asking for one elsewhere is refused, as is a name the spec does not declare (the answer names the ones it does). Omit it for the whole spec.")
       },
       outputSchema: getSpecOutput
     },
-    ({ kind, id, methods }) => {
+    ({ kind: askedKind, id, methods }) => {
       try {
+        let kind;
+        if (askedKind) {
+          kind = askedKind;
+        } else {
+          const holders = specKindsHolding(id);
+          if (holders.length !== 1) {
+            return errText(holders.length === 0 ? `No spec of any kind has the ID "${id}".` : `The ID "${id}" names specs of more than one kind (${holders.join(", ")}). Pass "kind" to choose one.`);
+          }
+          kind = holders[0];
+        }
         let result = null;
         let partial2 = null;
         switch (kind) {
@@ -46275,9 +47346,9 @@ ${testsBlock}` : ""}`, deletion);
     server,
     "sdd_get_agent_brief",
     {
-      description: "Compose the LIVE delegation brief for one resolved agent: the fully rendered instruction body plus the ownedPaths/readPaths scope fence \u2014 the dynamic replacement for generated per-component agent files. Fetch a brief and spawn a generic subagent with it: always fresh after a re-lock, no session restart needed. List agent ids via listAgents or resources/list (the wairon-agent:// entries).",
+      description: "Compose the LIVE delegation brief for one resolved agent: the fully rendered instruction body plus the ownedPaths/readPaths scope fence and the codeFence (where the agent may write CODE: its source files and their shared folder; empty when no file is named yet \u2014 then name the planned files when spawning) \u2014 the dynamic replacement for generated per-component agent files. A COMPONENT id (or `<component>-implementer`) composes that one component's implementer brief, with no agent files and no setting needed. Fetch a brief and spawn a generic subagent with it: always fresh after a re-lock, no session restart needed. List agent ids via listAgents or resources/list (the wairon-agent:// entries).",
       inputSchema: {
-        agentId: import_zod12.z.string().describe("The resolved agent id (list via listAgents or resources/list)")
+        agentId: import_zod12.z.string().describe("The resolved agent id (list via listAgents or resources/list), or a component id for that component's implementer brief")
       }
     },
     ({ agentId }) => {
@@ -46491,6 +47562,7 @@ function loadProjectConfig3() {
   aiDir,
   aiDirAt,
   aiPathsAt,
+  aliasTargetOf,
   ambiguityMessage,
   approvalKeyIn,
   approvalRecord,
@@ -46634,6 +47706,7 @@ function loadProjectConfig3() {
   keyIn,
   landReference,
   languageOfSourcePath,
+  lineEndingFor,
   listDirectChainedSubprojects,
   listExternals,
   listFiles,
@@ -46675,6 +47748,7 @@ function loadProjectConfig3() {
   memberDeclarationOf,
   memberDigest,
   memberLocationOf,
+  memberTypesOf,
   methodGenericParameters,
   methodSourceFile,
   methodTypeRefs,
@@ -46747,6 +47821,7 @@ function loadProjectConfig3() {
   resolveExternals,
   resolveImport,
   resolveInstalledPack,
+  resolveProjectBinding,
   resolveProjectExports,
   resolveSignatures,
   resolveSubprojectForNamespace,
@@ -46792,6 +47867,7 @@ function loadProjectConfig3() {
   typeIsMany,
   typeMatchesRef,
   typeNamedRefs,
+  typeProblemEnumProposal,
   typeProblemIntProposal,
   typeSourceFiles,
   typeSpellingFacts,
@@ -46805,6 +47881,7 @@ function loadProjectConfig3() {
   validateProject,
   validateProjectConfig,
   validateRegistry,
+  withLineEndings,
   withPack,
   writeFile,
   writeFileIfChanged,