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

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, "");
@@ -3709,6 +3709,7 @@ __export(src_exports, {
   keyIn: () => keyIn,
   landReference: () => landReference,
   languageOfSourcePath: () => languageOfSourcePath,
+  lineEndingFor: () => lineEndingFor,
   listDirectChainedSubprojects: () => listDirectChainedSubprojects,
   listExternals: () => listExternals2,
   listFiles: () => listFiles,
@@ -3828,6 +3829,7 @@ __export(src_exports, {
   resolveSubsystemExports: () => resolveSubsystemExports,
   resolveVariantGuidance: () => resolveVariantGuidance,
   retireSpecialists: () => retireSpecialists,
+  returnTypeOf: () => returnTypeOf,
   rewriteReferences: () => rewriteReferences2,
   runWithHostedLookup: () => runWithHostedLookup,
   runWithProjectBinding: () => runWithProjectBinding,
@@ -3866,6 +3868,7 @@ __export(src_exports, {
   typeIsMany: () => typeIsMany,
   typeMatchesRef: () => typeMatchesRef,
   typeNamedRefs: () => typeNamedRefs,
+  typeProblemEnumProposal: () => typeProblemEnumProposal,
   typeProblemIntProposal: () => typeProblemIntProposal,
   typeSourceFiles: () => typeSourceFiles,
   typeSpellingFacts: () => typeSpellingFacts,
@@ -3879,6 +3882,7 @@ __export(src_exports, {
   validateProject: () => validateProject,
   validateProjectConfig: () => validateProjectConfig,
   validateRegistry: () => validateRegistry,
+  withLineEndings: () => withLineEndings,
   withPack: () => withPack,
   writeFile: () => writeFile,
   writeFileIfChanged: () => writeFileIfChanged,
@@ -3893,8 +3897,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");
 
@@ -3907,17 +3911,119 @@ function ensureDir(dirPath) {
 }
 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");
@@ -4063,44 +4169,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.102";
+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 {
@@ -4150,6 +4279,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 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));
+}
+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]+)$/;
@@ -4185,7 +4475,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
@@ -4735,7 +5025,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(),
@@ -4938,7 +5228,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 ?? []
   ])];
@@ -5236,13 +5526,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());
@@ -5256,7 +5546,7 @@ function projectConfigFsAdapterAt(rootDir) {
       writeFile(file(), editDocumentText(text3, document, root));
     },
     documentExists() {
-      return fs2.existsSync(file());
+      return fs3.existsSync(file());
     },
     readText() {
       return readFileOrNull(file());
@@ -5278,8 +5568,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();
@@ -5679,9 +5970,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)}
@@ -6122,15 +6473,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);
@@ -6323,15 +6674,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 {
@@ -6348,12 +6699,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 = {
@@ -6387,8 +6738,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) {
@@ -6427,7 +6778,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() {
@@ -6447,11 +6798,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) } : {},
@@ -6464,8 +6815,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");
 }
@@ -6479,14 +6830,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;
   }
@@ -6497,10 +6848,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) => {
@@ -6520,8 +6871,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);
@@ -6533,136 +6884,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);
   }
 }
 
@@ -8061,7 +8293,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)"],
@@ -8070,7 +8306,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)"],
@@ -8265,9 +8500,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++;
@@ -8294,6 +8529,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(")");
@@ -8402,7 +8641,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) {
@@ -8436,9 +8675,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)) {
@@ -8476,6 +8727,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]);
@@ -8549,6 +8801,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}?`;
@@ -8568,11 +8822,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;
@@ -8763,6 +9018,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: [] };
 }
@@ -8913,6 +9209,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;
@@ -8949,6 +9246,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(", ")}>`;
   }
@@ -8991,6 +9290,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)"
     ];
@@ -9265,7 +9565,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(/^\.\//, "");
 }
@@ -9339,14 +9639,20 @@ 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;
 }
-function resolveImport(fromFile, specifier, knownPaths) {
-  if (!specifier.startsWith(".")) return void 0;
-  const joined = pathKey(path9.posix.normalize(path9.posix.join(path9.posix.dirname(fromFile), specifier)));
+function returnTypeOf(facts, fn) {
+  return ownEntry(facts.returnTypes, fn);
+}
+function resolveImport(fromFile, specifier, knownPaths, packages) {
+  if (!specifier.startsWith(".")) {
+    const mapped = ownEntry(packages, specifier);
+    return mapped !== void 0 && knownPaths.has(mapped) ? mapped : void 0;
+  }
+  const joined = pathKey(path10.posix.normalize(path10.posix.join(path10.posix.dirname(fromFile), specifier)));
   const candidates = [
     joined,
     joined.replace(/\.js$/, ".ts"),
@@ -9493,7 +9799,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)) {
@@ -9555,15 +9861,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;
@@ -9696,7 +10002,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()
@@ -9933,7 +10239,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) {
@@ -10704,9 +11010,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) {
@@ -15089,17 +15395,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) {
@@ -15142,7 +15448,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;
   },
@@ -15275,6 +15581,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) {
@@ -15284,7 +15592,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) {
@@ -15736,61 +16045,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.100";
-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() {
@@ -17285,7 +17539,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
     );
   }
@@ -17666,12 +17920,12 @@ function packFiles(dir, prefix = "") {
 function computePackDigest(packDir) {
   const hash = crypto3.createHash("sha256");
   const abs = path16.resolve(packDir);
-  let isFile = false;
+  let isFile2 = false;
   try {
-    isFile = fs11.statSync(abs).isFile();
+    isFile2 = fs11.statSync(abs).isFile();
   } catch {
   }
-  const entries = isFile ? [[path16.basename(abs), abs]] : packFiles(abs).map((rel2) => [rel2, path16.join(abs, rel2)]);
+  const entries = isFile2 ? [[path16.basename(abs), abs]] : packFiles(abs).map((rel2) => [rel2, path16.join(abs, rel2)]);
   for (const [rel2, full] of entries) {
     hash.update(rel2);
     hash.update("\0");
@@ -18291,6 +18545,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);
@@ -18298,6 +18562,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",
@@ -18355,6 +18620,7 @@ function appendUnique(map, key, value, same) {
   list.push(value);
 }
 function buildCodeIndex(model) {
+  const packages = model.packages ?? {};
   const facts = /* @__PURE__ */ new Map();
   const paths = /* @__PURE__ */ new Set();
   const exactPaths = /* @__PURE__ */ new Set();
@@ -18387,7 +18653,7 @@ function buildCodeIndex(model) {
       const f = facts.get(from);
       if (f?.status !== "analyzed") continue;
       for (const specifier of f.reexports) {
-        const to = resolveImport(from, specifier, paths);
+        const to = resolveImport(from, specifier, paths, packages);
         if (to && !out.has(to)) {
           out.add(to);
           queue.push(to);
@@ -18399,7 +18665,7 @@ function buildCodeIndex(model) {
   };
   const NO_ORIGIN = /* @__PURE__ */ new Set();
   const landingFrom = (scope, specifier) => {
-    const to = resolveImport(scope, specifier, paths);
+    const to = resolveImport(scope, specifier, paths, packages);
     return to ? republishedFrom(to) : NO_ORIGIN;
   };
   const scopeOf2 = (site, from) => {
@@ -18429,7 +18695,7 @@ function buildCodeIndex(model) {
   };
   const possibleOriginsOf = (site, from) => {
     const proven = originOf2(site, from);
-    if (!site.field && !site.constructed && !site.via) return proven;
+    if (!site.field && !site.constructed && !site.via && !site.returnedBy && !site.enclosingClass) return proven;
     const resolved = scopeOf2(site, from);
     if (!resolved) return proven;
     const { path: scope, facts: f } = resolved;
@@ -18442,24 +18708,59 @@ function buildCodeIndex(model) {
     if (site.field) for (const typeName of fieldTypesOf(f, site.field)) widenThroughType(typeName);
     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)) {
+      for (const candidate of republishedFrom(scope)) out.add(candidate);
+    }
+    if (site.returnedBy !== void 0) {
+      for (const fnFile of originOf2({ name: site.returnedBy, member: false }, scope)) {
+        const at = facts.get(fnFile);
+        if (at?.status !== "analyzed" || at.analysisGrade !== "exact") continue;
+        const typeName = returnTypeOf(at, site.returnedBy);
+        if (typeName === void 0) continue;
+        const specifier = typeBindingOf(at, typeName);
+        const landings = specifier !== void 0 ? landingFrom(fnFile, specifier) : declarationsAt(fnFile).has(typeName) ? republishedFrom(fnFile) : NO_ORIGIN;
+        for (const candidate of landings) {
+          const there = facts.get(candidate);
+          if (there && holdsMemberBody(there, site.name, typeName)) out.add(candidate);
+        }
+      }
+    }
     return out;
   };
+  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) => {
+  const forwardsOf = (start, name, container) => {
     const out = [];
+    const listed = /* @__PURE__ */ new Set();
     const seen = /* @__PURE__ */ new Set();
-    const queue = [{ file: pathKey(start), name }];
+    const queue = [{ file: pathKey(start), name, container }];
     while (queue.length) {
       const at = queue.shift();
-      const key = `${at.file}#${at.name}`;
+      const key = `${at.scope ? "s" : "p"}|${at.container ?? ""}|${at.file}#${at.name}`;
       if (seen.has(key)) continue;
       seen.add(key);
-      out.push(at);
-      for (const binding of facts.get(at.file)?.reexportBindings ?? []) {
+      if (!listed.has(`${at.file}#${at.name}`)) {
+        listed.add(`${at.file}#${at.name}`);
+        out.push({ file: at.file, name: at.name });
+      }
+      const f = facts.get(at.file);
+      if (at.scope) {
+        const binding = f ? importBindingOf(f, at.name) : void 0;
+        if (!binding || binding.namespace) continue;
+        const to = resolveImport(at.file, binding.from, paths, packages);
+        if (to) queue.push({ file: to, name: binding.imported ?? at.name });
+        continue;
+      }
+      for (const alias of f?.exportAliases ?? []) {
+        if (alias.exported !== at.name || alias.container !== at.container) continue;
+        queue.push({ file: at.file, name: alias.local, scope: true });
+      }
+      if (at.container !== void 0) continue;
+      for (const binding of f?.reexportBindings ?? []) {
         const star = binding.exported === "*";
         if (!star && binding.exported !== at.name) continue;
         if (star && at.name === "default") continue;
-        const to = resolveImport(at.file, binding.from, paths);
+        const to = resolveImport(at.file, binding.from, paths, packages);
         if (!to) continue;
         if (star && !facts.get(to)?.exportedNames.includes(at.name)) continue;
         queue.push({ file: to, name: star ? at.name : binding.local });
@@ -18470,6 +18771,7 @@ function buildCodeIndex(model) {
   return {
     paths,
     exactPaths,
+    packages,
     factsAt: (path49) => facts.get(pathKey(path49)),
     declarationsAt,
     anchorsAt: (path49) => namesAt(anchors, pathKey(path49), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames, ...f.anchoredNames])),
@@ -18523,7 +18825,7 @@ function buildImportGraph(index, universe) {
   const traces = /* @__PURE__ */ new Map();
   const resolveAll = (from, specifiers, into) => {
     for (const specifier of specifiers) {
-      const to = resolveImport(from, specifier, universe);
+      const to = resolveImport(from, specifier, universe, index.packages);
       if (to && to !== from) into.add(to);
     }
   };
@@ -18819,7 +19121,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" },
@@ -18837,7 +19139,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");
@@ -19226,10 +19528,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" }
@@ -19239,9 +19541,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,
@@ -19575,7 +19876,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)" },
@@ -19737,7 +20038,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" }
   ],
@@ -19768,9 +20069,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." }
   ],
@@ -19808,7 +20109,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) {
@@ -19845,7 +20146,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" },
@@ -22391,7 +22692,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.`
         );
       }
     }
@@ -23378,10 +23679,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" }
   ],
@@ -23396,7 +23709,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
             );
@@ -23741,13 +24054,13 @@ function invokedAs(code, site, file) {
   if (!site.member) {
     const binding = importBindingOf(facts, site.name);
     if (!binding || binding.namespace) return [];
-    const module3 = resolveImport(scope, binding.from, code.paths);
+    const module3 = resolveImport(scope, binding.from, code.paths, code.packages);
     return module3 ? code.forwardsOf(module3, binding.imported ?? site.name) : [];
   }
   if (!site.via) return [];
   const receiver = importBindingOf(facts, site.via);
   if (!receiver?.namespace) return [];
-  const module2 = resolveImport(scope, receiver.from, code.paths);
+  const module2 = resolveImport(scope, receiver.from, code.paths, code.packages);
   return module2 ? code.forwardsOf(module2, site.name) : [];
 }
 function claimsOf(implMethod) {
@@ -23769,6 +24082,8 @@ function describeSite(site) {
   if (site.via) return `${site.via}.${site.name}(\u2026)`;
   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.enclosingClass) return `this.${site.name}(\u2026)`;
   return `<receiver>.${site.name}(\u2026)`;
 }
 function describeMiss(m) {
@@ -23781,7 +24096,7 @@ 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, and 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. 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 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; 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.",
   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 },
@@ -23824,7 +24139,7 @@ var callConformanceRule = {
         if (!ctx.componentMap.has(claim.component)) continue;
         const target = resolveCallTarget(ctx, claim.component, claim.method);
         if (target.accepted.has(fnSymbol)) continue;
-        if (isTarget(code.forwardsOf(file, fnSymbol), target)) continue;
+        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}`;
         if (target.files.size === 0) {
@@ -23867,7 +24182,7 @@ 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 \`this.<field>\` receiver whose declared type names one, a \`new Class(\u2026)\` receiver whose class does, and a receiver NAME the file annotates with a type that does. What does not: an import from a PACKAGE specifier, 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.`,
+          `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.`,
           impl.id,
           entry.draftContext,
           void 0,
@@ -23889,7 +24204,9 @@ var callConformanceRule = {
         reached.set(site, owner);
         return owner !== void 0;
       };
-      for (const site of closedCallSites(code, file, fnSymbol, stopAtModelled, implMethod.exportedVia) ?? []) {
+      const forwardsToModelled = code.forwardsOf(file, fnSymbol, implMethod.exportedVia).some((p) => p.file !== here && modelledAt.get(p.file)?.byName.has(p.name));
+      const conversed = forwardsToModelled ? [] : closedCallSites(code, file, fnSymbol, stopAtModelled, implMethod.exportedVia) ?? [];
+      for (const site of conversed) {
         const owner = reached.get(site);
         if (!owner || owner.component === component.id) continue;
         const ref = `${owner.component}.${owner.method}`;
@@ -25077,7 +25394,7 @@ var exportConformanceRule = {
       const facts = code.factsAt(file);
       if (!facts || facts.status !== "analyzed" || facts.analysisGrade !== "exact") continue;
       for (const binding of facts.reexportBindings ?? []) {
-        const target = resolveImport(file, binding.from, code.paths);
+        const target = resolveImport(file, binding.from, code.paths, code.packages);
         const methods = target ? typeMethodsAt.get(target) : void 0;
         if (!methods) continue;
         if (binding.local === "*") {
@@ -25089,7 +25406,7 @@ var exportConformanceRule = {
     }
     const takenFrom = /* @__PURE__ */ new Map();
     const take = (consumer, writtenIn, specifier, names) => {
-      const target = resolveImport(writtenIn, specifier, code.paths);
+      const target = resolveImport(writtenIn, specifier, code.paths, code.packages);
       if (!target) return;
       let byName = takenFrom.get(target);
       if (!byName) takenFrom.set(target, byName = /* @__PURE__ */ new Map());
@@ -26823,6 +27140,9 @@ function walkExact(ts, sourceText, fileName) {
   const reexports = /* @__PURE__ */ new Set();
   const starExports = [];
   const namedReexports = [];
+  const exportAliases = [];
+  const propertyAliases = [];
+  const returnTypes = /* @__PURE__ */ new Map();
   const complexity = /* @__PURE__ */ new Map();
   const calls = /* @__PURE__ */ new Map();
   const bodies = /* @__PURE__ */ new Map();
@@ -26839,7 +27159,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}` : "");
+  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 siteKey = (site) => `${site.member ? "m" : "b"}:${receiverKey(site)}:${site.name}`;
   const addBindingNames = (name) => {
     if (ts.isIdentifier(name)) declared.add(name.text);
@@ -26947,6 +27267,44 @@ function walkExact(ts, sourceText, fileName) {
     }
     return void 0;
   };
+  const enclosingClassOf = (node) => {
+    let at = node.parent;
+    while (at) {
+      if (ts.isFunctionExpression(at) || ts.isFunctionDeclaration(at) || ts.isClassExpression(at)) return void 0;
+      if ((ts.isMethodDeclaration(at) || ts.isGetAccessorDeclaration(at) || ts.isSetAccessorDeclaration(at)) && at.parent && ts.isObjectLiteralExpression(at.parent)) return void 0;
+      if (ts.isClassDeclaration(at)) {
+        return at.name && at.parent && ts.isSourceFile(at.parent) ? at.name.text : void 0;
+      }
+      at = at.parent;
+    }
+    return void 0;
+  };
+  const returnedTypeOf = (fn) => {
+    const annotated = fn.type;
+    if (annotated) {
+      if (!ts.isTypeReferenceNode(annotated)) return void 0;
+      if (ts.isIdentifier(annotated.typeName) && annotated.typeName.text === "Promise" && annotated.typeArguments?.length === 1) {
+        const inner2 = annotated.typeArguments[0];
+        return ts.isTypeReferenceNode(inner2) && !inner2.typeArguments ? typeReferenceName(inner2) : void 0;
+      }
+      return annotated.typeArguments ? void 0 : typeReferenceName(annotated);
+    }
+    const constructedClass = (expression) => {
+      let node = expression;
+      while (node && (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isSatisfiesExpression(node))) node = node.expression;
+      return node && ts.isNewExpression(node) && ts.isIdentifier(node.expression) ? node.expression.text : void 0;
+    };
+    if (!fn.body) return void 0;
+    if (!ts.isBlock(fn.body)) return constructedClass(fn.body);
+    const returns = [];
+    const collect = (node) => {
+      if (ts.isFunctionLike(node)) return;
+      if (ts.isReturnStatement(node)) returns.push(node);
+      ts.forEachChild(node, collect);
+    };
+    ts.forEachChild(fn.body, collect);
+    return returns.length === 1 ? constructedClass(returns[0].expression) : void 0;
+  };
   const isTopLevelVariable = (decl) => ts.isVariableDeclaration(decl) && ts.isIdentifier(decl.name) && !!decl.parent && ts.isVariableDeclarationList(decl.parent) && !!decl.parent.parent && ts.isVariableStatement(decl.parent.parent) && !!decl.parent.parent.parent && ts.isSourceFile(decl.parent.parent.parent);
   const containerOf = (owner) => {
     if (!owner) return void 0;
@@ -27008,6 +27366,11 @@ function walkExact(ts, sourceText, fileName) {
             addSite({ name, member: true, field: receiver.name.text });
           } else if (ts.isNewExpression(receiver) && ts.isIdentifier(receiver.expression)) {
             addSite({ name, member: true, constructed: receiver.expression.text });
+          } else if (ts.isCallExpression(receiver) && ts.isIdentifier(receiver.expression)) {
+            addSite({ name, member: true, returnedBy: receiver.expression.text });
+          } 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 });
         }
       }
@@ -27134,6 +27497,8 @@ function walkExact(ts, sourceText, fileName) {
       signatures.push(declaredParameters(node));
       functionParams.set(fnName, signatures);
       if (completesLater(node)) asyncFunctions.push(fnName);
+      const returned = returnedTypeOf(node) ?? null;
+      returnTypes.set(fnName, returnTypes.has(fnName) && returnTypes.get(fnName) !== returned ? null : returned);
       const routes = collectRoutes(node);
       if (routes.size > 0) {
         const known = functionRoutes.get(fnName) ?? /* @__PURE__ */ new Map();
@@ -27170,6 +27535,23 @@ function walkExact(ts, sourceText, fileName) {
     if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && !schemaConstants.has(node.name.text)) {
       schemaConstants.set(node.name.text, node.initializer);
     }
+    if (isTopLevelVariable(node) && node.initializer) {
+      let literal = node.initializer;
+      while (ts.isAsExpression(literal) || ts.isSatisfiesExpression(literal) || ts.isParenthesizedExpression(literal)) {
+        literal = literal.expression;
+      }
+      if (ts.isObjectLiteralExpression(literal)) {
+        const container = node.name.text;
+        for (const property of literal.properties) {
+          if (ts.isShorthandPropertyAssignment(property)) {
+            propertyAliases.push({ exported: property.name.text, local: property.name.text, container });
+          } else if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.initializer)) {
+            const key = propertyNameText(property.name);
+            if (key) propertyAliases.push({ exported: key, local: property.initializer.text, container });
+          }
+        }
+      }
+    }
     if (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isModuleDeclaration(node)) {
       const name = node.name && ts.isIdentifier(node.name) ? node.name.text : void 0;
       if (name) {
@@ -27221,9 +27603,10 @@ function walkExact(ts, sourceText, fileName) {
         for (const el of node.exportClause.elements) {
           declared.add(el.name.text);
           exported.add(el.name.text);
-          if (spec && !node.isTypeOnly && !el.isTypeOnly) {
-            namedReexports.push({ exported: el.name.text, local: (el.propertyName ?? el.name).text, from: spec });
-          }
+          if (node.isTypeOnly || el.isTypeOnly) continue;
+          const local = (el.propertyName ?? el.name).text;
+          if (spec) namedReexports.push({ exported: el.name.text, local, from: spec });
+          else exportAliases.push({ exported: el.name.text, local });
         }
       } else if (!node.exportClause && spec) {
         starExports.push(spec);
@@ -27298,7 +27681,13 @@ function walkExact(ts, sourceText, fileName) {
     if (values && schemaConstants.has(alias.constant)) enumValues.set(alias.name, values);
   }
   const reexportOnly = sf.statements.length > 0 && sf.statements.every((st) => ts.isExportDeclaration(st) && !!st.moduleSpecifier);
-  return { declared, anchors, exported, imports, reexports, starExports, namedReexports, complexity, calls, bodies, importBindings, typeOnlyBindings, fieldTypes, localTypes, typeShapes, functionParams, functionRoutes, asyncFunctions, enumValues, aliasTypes, mutableBindings, reexportOnly };
+  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 };
+}
+var NO_PACKAGES = /* @__PURE__ */ new Map();
+function resolveModule(fromFile, specifier, packages) {
+  if (!specifier.startsWith(".")) return packages.get(specifier) ?? null;
+  return resolveRelativeModule(fromFile, specifier);
 }
 function resolveRelativeModule(fromFile, specifier) {
   if (!specifier.startsWith(".")) return null;
@@ -27321,8 +27710,8 @@ function resolveRelativeModule(fromFile, specifier) {
   }
   return null;
 }
-function reexportTarget(ts, filePath, specifier, projectRoot, visited, exactCache) {
-  const target = resolveRelativeModule(filePath, specifier);
+function reexportTarget(ts, filePath, specifier, projectRoot, visited, exactCache, packages) {
+  const target = resolveModule(filePath, specifier, packages);
   if (!target || path18.relative(projectRoot, target).startsWith("..")) return null;
   let targetFacts = exactCache.get(target);
   if (targetFacts === void 0) {
@@ -27336,7 +27725,7 @@ function reexportTarget(ts, filePath, specifier, projectRoot, visited, exactCach
   if (!targetFacts) return null;
   if (!visited.has(target)) {
     visited.add(target);
-    chaseReexports(ts, targetFacts, target, projectRoot, visited, exactCache);
+    chaseReexports(ts, targetFacts, target, projectRoot, visited, exactCache, packages);
   }
   return { path: target, facts: targetFacts };
 }
@@ -27359,13 +27748,33 @@ function carryBody(facts, target, targetPath, local, exported, projectRoot) {
   }
   facts.bodies.set(exported, carried);
 }
-function chaseReexports(ts, facts, filePath, projectRoot, visited, exactCache) {
+function carryAliasBody(facts, source, from, local, alias) {
+  const sourceBodies = source.bodies.get(local) ?? [];
+  if (!sourceBodies.length || sourceBodies.some((b) => b.nested)) return;
+  const moduleScope = sourceBodies.filter((b) => b.container === void 0);
+  if (!moduleScope.length) return;
+  const score = source.complexity.get(local);
+  if (score !== void 0) {
+    facts.complexity.set(alias.exported, Math.max(facts.complexity.get(alias.exported) ?? 0, score));
+  }
+  const relocate2 = (site) => from !== void 0 ? { ...site, from: site.from ?? from } : site;
+  const sites = facts.calls.get(alias.exported) ?? /* @__PURE__ */ new Map();
+  const carried = facts.bodies.get(alias.exported) ?? [];
+  for (const body of moduleScope) {
+    const moved = body.sites.map(relocate2);
+    for (const site of moved) sites.set(`${from ?? ""}|${alias.container ?? ""}|${JSON.stringify(site)}`, site);
+    carried.push(alias.container !== void 0 ? { container: alias.container, sites: moved } : { sites: moved });
+  }
+  facts.calls.set(alias.exported, sites);
+  facts.bodies.set(alias.exported, carried);
+}
+function chaseReexports(ts, facts, filePath, projectRoot, visited, exactCache, packages = NO_PACKAGES) {
   for (const re of facts.namedReexports) {
-    const target = reexportTarget(ts, filePath, re.from, projectRoot, visited, exactCache);
+    const target = reexportTarget(ts, filePath, re.from, projectRoot, visited, exactCache, packages);
     if (target) carryBody(facts, target.facts, target.path, re.local, re.exported, projectRoot);
   }
   for (const spec of facts.starExports) {
-    const target = reexportTarget(ts, filePath, spec, projectRoot, visited, exactCache);
+    const target = reexportTarget(ts, filePath, spec, projectRoot, visited, exactCache, packages);
     if (!target) continue;
     for (const name of target.facts.exported) {
       facts.exported.add(name);
@@ -27373,6 +27782,150 @@ function chaseReexports(ts, facts, filePath, projectRoot, visited, exactCache) {
       carryBody(facts, target.facts, target.path, name, name, projectRoot);
     }
   }
+  for (const alias of facts.exportAliases) {
+    const binding = facts.importBindings.get(alias.local);
+    if (binding) {
+      if (binding.namespace) continue;
+      const target = reexportTarget(ts, filePath, binding.from, projectRoot, visited, exactCache, packages);
+      if (!target) continue;
+      const from = pathKey(path18.relative(projectRoot, target.path));
+      carryAliasBody(facts, target.facts, from, binding.imported ?? alias.local, alias);
+    } else if (alias.container !== void 0 || alias.local !== alias.exported) {
+      carryAliasBody(facts, facts, void 0, alias.local, alias);
+    }
+  }
+}
+var BUILD_EXTENSIONS = [".d.mts", ".d.cts", ".d.ts", ".mjs", ".cjs", ".jsx", ".js"];
+var SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var ENTRY_CONDITIONS = ["types", "import", "require", "default"];
+function isOwnFile(projectRoot, absolute) {
+  const rel2 = path18.relative(projectRoot, absolute);
+  if (rel2.startsWith("..") || path18.isAbsolute(rel2)) return false;
+  return !pathKey(rel2).split("/").includes("node_modules");
+}
+function isFile(absolute) {
+  try {
+    return fs13.statSync(absolute).isFile();
+  } catch {
+    return false;
+  }
+}
+function readJsonFile2(file, ts) {
+  let text3;
+  try {
+    text3 = fs13.readFileSync(file, "utf8");
+  } catch {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text3);
+  } catch {
+    if (!ts) return void 0;
+    const parsed = ts.parseConfigFileTextToJson(file, text3);
+    return parsed.error ? void 0 : parsed.config;
+  }
+}
+function conditionTargets(value) {
+  if (typeof value === "string") return [value];
+  if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+  const record = value;
+  const keys = [...ENTRY_CONDITIONS.filter((k) => k in record), ...Object.keys(record).filter((k) => !ENTRY_CONDITIONS.includes(k))];
+  return keys.flatMap((k) => conditionTargets(record[k]));
+}
+function packageEntries(pkg) {
+  const entries = /* @__PURE__ */ new Map();
+  const exportsField = pkg.exports;
+  if (exportsField !== void 0 && exportsField !== null) {
+    const isSubpathMap = typeof exportsField === "object" && !Array.isArray(exportsField) && Object.keys(exportsField).some((k) => k.startsWith("."));
+    if (isSubpathMap) {
+      for (const [subpath, value] of Object.entries(exportsField)) {
+        if (!subpath.startsWith(".") || subpath.includes("*")) continue;
+        const targets = conditionTargets(value);
+        if (targets.length) entries.set(subpath, targets);
+      }
+    } else {
+      const targets = conditionTargets(exportsField);
+      if (targets.length) entries.set(".", targets);
+    }
+    return entries;
+  }
+  const fallbacks = ["module", "main", "types"].map((k) => pkg[k]).filter((v) => typeof v === "string");
+  if (fallbacks.length) entries.set(".", fallbacks);
+  return entries;
+}
+function entrySource(packageDir, target, compiler, projectRoot) {
+  const absolute = path18.resolve(packageDir, target);
+  if (!isOwnFile(projectRoot, absolute)) return null;
+  const isDeclaration = /\.d\.[cm]?ts$/.test(absolute);
+  if (!isDeclaration && languageOfSourcePath(absolute) && isFile(absolute) && !(compiler.outDir && !path18.relative(compiler.outDir, absolute).startsWith(".."))) {
+    return absolute;
+  }
+  if (!compiler.outDir || !compiler.rootDir) return null;
+  const inOut = path18.relative(compiler.outDir, absolute);
+  if (inOut.startsWith("..") || path18.isAbsolute(inOut)) return null;
+  const extension = BUILD_EXTENSIONS.find((ext) => inOut.endsWith(ext));
+  const stem = extension ? inOut.slice(0, -extension.length) : inOut;
+  for (const ext of SOURCE_EXTENSIONS) {
+    const candidate = path18.join(compiler.rootDir, stem + ext);
+    if (isOwnFile(projectRoot, candidate) && isFile(candidate)) return candidate;
+  }
+  return null;
+}
+function readLocalPackages(projectRoot) {
+  const out = /* @__PURE__ */ new Map();
+  const ts = resolveTypeScript(projectRoot);
+  const root = readJsonFile2(path18.join(projectRoot, "package.json"), null);
+  if (!root || typeof root !== "object" || Array.isArray(root)) return out;
+  const rootPkg = root;
+  const declared = Array.isArray(rootPkg.workspaces) ? rootPkg.workspaces : rootPkg.workspaces && typeof rootPkg.workspaces === "object" && Array.isArray(rootPkg.workspaces.packages) ? rootPkg.workspaces.packages : [];
+  const dirs = [projectRoot];
+  for (const entry of declared) {
+    if (typeof entry !== "string") continue;
+    const key = pathKey(entry).replace(/\/+$/, "");
+    if (!key || path18.isAbsolute(key)) continue;
+    if (key.endsWith("/*")) {
+      const base = path18.resolve(projectRoot, key.slice(0, -2));
+      if (base.includes("*") || !isOwnFile(projectRoot, base)) continue;
+      let children;
+      try {
+        children = fs13.readdirSync(base, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const child of children.slice().sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
+        if (child.isDirectory() && child.name !== "node_modules" && !child.name.startsWith(".")) {
+          dirs.push(path18.join(base, child.name));
+        }
+      }
+    } else if (!key.includes("*")) {
+      const dir = path18.resolve(projectRoot, key);
+      if (isOwnFile(projectRoot, dir)) dirs.push(dir);
+    }
+  }
+  for (const dir of dirs) {
+    const pkg = dir === projectRoot ? rootPkg : readJsonFile2(path18.join(dir, "package.json"), null);
+    if (!pkg || typeof pkg !== "object" || Array.isArray(pkg)) continue;
+    const name = pkg.name;
+    if (typeof name !== "string" || !name) continue;
+    const tsconfig = readJsonFile2(path18.join(dir, "tsconfig.json"), ts);
+    const options = tsconfig?.compilerOptions ?? {};
+    const compiler = {
+      outDir: typeof options.outDir === "string" ? path18.resolve(dir, options.outDir) : void 0,
+      rootDir: typeof options.rootDir === "string" ? path18.resolve(dir, options.rootDir) : void 0
+    };
+    for (const [subpath, targets] of packageEntries(pkg)) {
+      const specifier = subpath === "." ? name : `${name}/${subpath.replace(/^\.\//, "")}`;
+      if (out.has(specifier)) continue;
+      for (const target of targets) {
+        const source = entrySource(dir, target, compiler, projectRoot);
+        if (source) {
+          out.set(specifier, source);
+          break;
+        }
+      }
+    }
+  }
+  return out;
 }
 function looksBinary(buffer) {
   const probe = buffer.subarray(0, Math.min(buffer.length, 4096));
@@ -27430,6 +27983,9 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
   const seen = /* @__PURE__ */ new Set();
   const exactCache = /* @__PURE__ */ new Map();
   const rootFiles = walkDeclaredRoots(sourceRoots, exclude, projectRoot);
+  const localPackages = readLocalPackages(projectRoot);
+  const packages = {};
+  for (const [specifier, absolute] of localPackages) packages[specifier] = pathKey(path18.relative(projectRoot, absolute));
   const declaredPaths = [];
   for (const impl of implementations) {
     declaredPaths.push(...implementationSourceFiles(impl));
@@ -27475,7 +28031,7 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
       if (ts) {
         try {
           const facts = walkExact(ts, text3, absolute);
-          chaseReexports(ts, facts, absolute, projectRoot, /* @__PURE__ */ new Set([absolute]), exactCache);
+          chaseReexports(ts, facts, absolute, projectRoot, /* @__PURE__ */ new Set([absolute]), exactCache, localPackages);
           analyzed = {
             analysisGrade: "exact",
             declaredNames: [...facts.declared],
@@ -27487,6 +28043,10 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
               ...facts.namedReexports.map(({ exported, local, from }) => ({ exported, local, from })),
               ...facts.starExports.map((from) => ({ exported: "*", local: "*", from }))
             ],
+            exportAliases: facts.exportAliases.map((alias) => ({ ...alias })),
+            returnTypes: Object.fromEntries(
+              [...facts.returnTypes].filter((entry) => entry[1] !== null)
+            ),
             functionComplexity: Object.fromEntries(facts.complexity),
             functionCallSites: Object.fromEntries([...facts.calls].map(([k, v]) => [k, [...v.values()]])),
             functionBodies: Object.fromEntries(facts.bodies),
@@ -27516,7 +28076,7 @@ function buildCodeModel(implementations, types, projectRoot, sourceRoots = [], e
     }
     files.push({ path: sourcePath, status: "analyzed", language, ...analyzed });
   }
-  return { files, projectRoot, rootFiles };
+  return { files, projectRoot, rootFiles, packages };
 }
 var IMPORT_FROM_RE = /(?:^|;)[ \t]*import\s+(?!\()([^'";]*?)\s*from\s*['"]([^'"]+)['"]/gm;
 var DYNAMIC_IMPORT_RE = /\{([^{}]*)\}\s*=\s*await\s+import\(\s*['"]([^'"]+)['"]\s*\)/g;
@@ -29483,8 +30043,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":
@@ -30214,6 +30774,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) {
@@ -30285,7 +30854,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) {
@@ -30311,7 +30881,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);
@@ -30904,6 +31474,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) => {
@@ -30926,6 +31506,7 @@ 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;
@@ -31045,6 +31626,9 @@ function respellStoredReferences(kind, doc, map) {
       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))}`;
@@ -31104,7 +31688,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;
@@ -33200,12 +33785,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
@@ -35756,7 +36341,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) {
@@ -36185,7 +36770,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) {
@@ -37145,7 +37730,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();
@@ -38686,17 +39271,17 @@ 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.readPaths ? { readPaths: brief.readPaths.map(under) } : {},
-    root: brief.root ? under(brief.root) : relative19
+    root: brief.root ? under(brief.root) : relative20
   };
 }
 function loadRegistry() {
@@ -38975,19 +39560,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);
@@ -39266,7 +39851,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;
@@ -39281,7 +39866,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()];
@@ -39428,7 +40015,7 @@ ${headline} \u2014 approved ${approval.lockedAt} by ${by}:
     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");
@@ -39510,16 +40097,16 @@ 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.
@@ -39536,7 +40123,8 @@ This project uses **wairon**. System specs live under \`.wai/specs/\` (L0 System
   - **\`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\`)
@@ -40005,7 +40593,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 && (own.state !== "never" || hasMembers)) output += `${mark.layer("system", "Approval:")} this project is ${own.state}${own.upgraded ? " (locked under an earlier gate identity \u2014 re-lock once)" : ""}
 `;
   return { text: output, failed: false };
 }
@@ -41187,7 +41775,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"];
@@ -42267,7 +42855,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 });
 };
@@ -42345,7 +42933,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)) {
@@ -42392,8 +42980,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;
 }
@@ -42433,7 +43021,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 };
@@ -42507,7 +43095,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 } : {}
   };
@@ -42618,7 +43206,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"];
@@ -42819,7 +43407,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 });
@@ -42850,7 +43438,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"];
@@ -43029,7 +43617,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;
@@ -43065,8 +43653,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;
@@ -43075,7 +43663,7 @@ function planExternalize(family, bound2, request) {
   crossingsBack(plan6, family, bound2, subKey);
   checkSiblings(plan6, family, bound2, id, subKey, table);
   if (plan6.refusals.length > 0) return plan6;
-  edit3(plan6, bound2, "move", `externalize ${id} as a project: its specs into a member at ${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: [[]] });
   plan6.notes.push("Source code is not moved: move the subsystem's code into the member yourself.");
   return plan6;
@@ -44204,7 +44792,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 };
 }
@@ -44304,6 +44892,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."),
@@ -44446,7 +45056,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
@@ -45028,7 +45638,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>`)"),
@@ -45098,7 +45708,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)"),
@@ -45112,7 +45722,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)"),
@@ -45125,7 +45735,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({
@@ -45468,7 +46078,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"),
@@ -45491,8 +46101,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":
@@ -45516,13 +46128,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(
@@ -45783,14 +46401,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) {
@@ -46343,6 +46971,7 @@ function loadProjectConfig3() {
   keyIn,
   landReference,
   languageOfSourcePath,
+  lineEndingFor,
   listDirectChainedSubprojects,
   listExternals,
   listFiles,
@@ -46462,6 +47091,7 @@ function loadProjectConfig3() {
   resolveSubsystemExports,
   resolveVariantGuidance,
   retireSpecialists,
+  returnTypeOf,
   rewriteReferences,
   runWithHostedLookup,
   runWithProjectBinding,
@@ -46500,6 +47130,7 @@ function loadProjectConfig3() {
   typeIsMany,
   typeMatchesRef,
   typeNamedRefs,
+  typeProblemEnumProposal,
   typeProblemIntProposal,
   typeSourceFiles,
   typeSpellingFacts,
@@ -46513,6 +47144,7 @@ function loadProjectConfig3() {
   validateProject,
   validateProjectConfig,
   validateRegistry,
+  withLineEndings,
   withPack,
   writeFile,
   writeFileIfChanged,